sequel 0.2.1.1 → 0.3.0

data/spec/adapters/postgres_spec.rb

@@ -11,7 +11,20 @@ PGSQL_DB.create_table :test do
   index :value
 end
 
-context "A MySQL dataset" do
+context "A PostgreSQL database" do
+  setup do
+    @db = PGSQL_DB
+  end
+  
+  specify "should provide disconnect functionality" do
+    @db.tables
+    @db.pool.size.should == 1
+    @db.disconnect
+    @db.pool.size.should == 0
+  end
+end
+
+context "A PostgreSQL dataset" do
   setup do
     @d = PGSQL_DB[:test]
     @d.delete # remove all records
@@ -25,24 +38,19 @@ context "A MySQL dataset" do
     @d.count.should == 3
   end
   
-  # specify "should return the last inserted id when inserting records" do
-  #   id = @d << {:name => 'abc', :value => 1.23}
-  #   id.should == @d.first[:id]
-  # end
-  #
-  
-  specify "should return all records" do
+  specify "should return the correct records" do
+    @d.to_a.should == []
     @d << {:name => 'abc', :value => 123}
     @d << {:name => 'abc', :value => 456}
     @d << {:name => 'def', :value => 789}
-    
-    @d.order(:value).all.should == [
+
+    @d.order(:value).to_a.should == [
       {:name => 'abc', :value => 123},
       {:name => 'abc', :value => 456},
       {:name => 'def', :value => 789}
     ]
   end
-   
+  
   specify "should update records correctly" do
     @d << {:name => 'abc', :value => 123}
     @d << {:name => 'abc', :value => 456}
@@ -84,4 +92,50 @@ context "A MySQL dataset" do
     @d.filter(:name => /bc/).count.should == 2
     @d.filter(:name => /^bc/).count.should == 1
   end
-end
+end
+
+context "A PostgreSQL dataset in array tuples mode" do
+  setup do
+    @d = PGSQL_DB[:test]
+    @d.delete # remove all records
+    Sequel.use_array_tuples
+  end
+  
+  teardown do
+    Sequel.use_hash_tuples
+  end
+  
+  specify "should return the correct records" do
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+
+    @d.order(:value).select(:name, :value).to_a.should == [
+      ['abc', 123],
+      ['abc', 456],
+      ['def', 789]
+    ]
+  end
+  
+  specify "should work correctly with transforms" do
+    @d.transform(:value => [proc {|v| v.to_s}, proc {|v| v.to_i}])
+
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 123}
+    @d << {:name => 'abc', :value => 456}
+    @d << {:name => 'def', :value => 789}
+
+    @d.order(:value).select(:name, :value).to_a.should == [
+      ['abc', '123'],
+      ['abc', '456'],
+      ['def', '789']
+    ]
+    
+    a = @d.order(:value).first
+    a.values.should == ['abc', '123']
+    a.keys.should == [:name, :value]
+    a[:name].should == 'abc'
+    a[:value].should == '123'
+  end
+end

data/spec/adapters/sqlite_spec.rb

@@ -72,6 +72,54 @@ context "An SQLite database" do
     
     @db[:t].order(:name).map(:name).should == ['abc', 'def']
   end
+  
+  specify "should be able to execute transactions" do
+    @db.transaction do
+      @db.create_table(:t) {text :name}
+    end
+    
+    @db.tables.should == [:t]
+
+    proc {@db.transaction do
+      @db.create_table(:u) {text :name}
+      raise ArgumentError
+    end}.should raise_error(ArgumentError)
+    # no commit
+    @db.tables.should == [:t]
+
+    proc {@db.transaction do
+      @db.create_table(:v) {text :name}
+      rollback!
+    end}.should_not raise_error
+    # no commit
+    @db.tables.should == [:t]
+  end
+
+  specify "should support nested transactions" do
+    @db.transaction do
+      @db.transaction do
+        @db.create_table(:t) {text :name}
+      end
+    end
+    
+    @db.tables.should == [:t]
+
+    proc {@db.transaction do
+      @db.create_table(:v) {text :name}
+      @db.transaction do
+        rollback! # should roll back the top-level transaction
+      end
+    end}.should_not raise_error
+    # no commit
+    @db.tables.should == [:t]
+  end
+  
+  specify "should provide disconnect functionality" do
+    @db.tables
+    @db.pool.size.should == 1
+    @db.disconnect
+    @db.pool.size.should == 0
+  end
 end
 
 context "An SQLite dataset" do
@@ -80,6 +128,18 @@ context "An SQLite dataset" do
     @d.delete # remove all records
   end
   
+  specify "should return the correct records" do
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 1.23}
+    @d << {:name => 'abc', :value => 4.56}
+    @d << {:name => 'def', :value => 7.89}
+    @d.select(:name, :value).to_a.sort_by {|h| h[:value]}.should == [
+      {:name => 'abc', :value => 1.23},
+      {:name => 'abc', :value => 4.56},
+      {:name => 'def', :value => 7.89}
+    ]
+  end
+  
   specify "should return the correct record count" do
     @d.count.should == 0
     @d << {:name => 'abc', :value => 1.23}
@@ -87,7 +147,7 @@ context "An SQLite dataset" do
     @d << {:name => 'def', :value => 7.89}
     @d.count.should == 3
   end
-  
+
   specify "should return the last inserted id when inserting records" do
     id = @d << {:name => 'abc', :value => 1.23}
     id.should == @d.first[:id]
@@ -186,3 +246,55 @@ context "SQLite::Dataset#update" do
   end
 end
 
+context "An SQLite dataset in array tuples mode" do
+  setup do
+    @d = SQLITE_DB[:items]
+    @d.delete # remove all records
+    
+    Sequel.use_array_tuples
+  end
+  
+  teardown do
+    Sequel.use_hash_tuples
+  end
+  
+  specify "should return the correct records" do
+    @d.to_a.should == []
+    @d << {:name => 'abc', :value => 1.23}
+    @d << {:name => 'abc', :value => 4.56}
+    @d << {:name => 'def', :value => 7.89}
+    @d.select(:name, :value).to_a.sort_by {|h| h[:value]}.should == [
+      Array.from_hash({:name => 'abc', :value => 1.23}),
+      Array.from_hash({:name => 'abc', :value => 4.56}),
+      Array.from_hash({:name => 'def', :value => 7.89})
+    ]
+  end
+end  
+
+context "SQLite dataset" do
+  setup do
+    SQLITE_DB.create_table :test do
+      integer :id, :primary_key => true, :auto_increment => true
+      text :name
+      float :value
+    end
+
+    @d = SQLITE_DB[:items]
+    @d.delete # remove all records
+    @d << {:name => 'abc', :value => 1.23}
+    @d << {:name => 'def', :value => 4.56}
+    @d << {:name => 'ghi', :value => 7.89}
+  end
+  
+  teardown do
+    SQLITE_DB.drop_table :test
+  end
+  
+  specify "should be able to insert from a subquery" do
+    SQLITE_DB[:test] << @d
+    SQLITE_DB[:test].count.should == 3
+    SQLITE_DB[:test].select(:name, :value).order(:value).to_a.should == \
+      @d.select(:name, :value).order(:value).to_a
+  end
+end
+

data/spec/array_keys_spec.rb

@@ -0,0 +1,544 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+context "An array with symbol keys" do
+  setup do
+    @a = [1, 2, 3]
+	  @a.keys = [:a, :b, :c]
+  end
+  
+  specify "should provide subscript access" do
+    @a[0].should == 1
+	  @a[0..1].should == [1, 2]
+	
+	  @a[1] = 4
+	  @a.should == [1, 4, 3]
+  end
+  
+  specify "should provide key access using symbols" do
+    @a[:a].should == 1
+    @a[:b].should == 2
+    @a[:B].should == nil
+ 
+    @a[:a] = 11
+    @a.should == [11, 2, 3]
+    @a[:a].should == 11
+ 
+    @a[:d] = 4
+    @a.should == [11, 2, 3, 4]
+    @a.keys.should == [:a, :b, :c, :d]
+  end
+  
+  specify "should provide key acess using strings" do
+    @a['a'].should == 1
+    @a['A'].should be_nil
+    
+    @a['d'] = 4
+    @a.should == [1, 2, 3, 4]
+    @a.keys.should == [:a, :b, :c, :d]
+  end
+
+  specify "should provide #store functionality" do
+    @a.store(:a, 11)
+    @a.should == [11, 2, 3]
+    
+    @a.store(:d, 4)
+    @a.should == [11, 2, 3, 4]
+
+    @a.store('d', 44)
+    @a.should == [11, 2, 3, 44]
+  end
+
+  specify "should provide #to_hash/#to_h functionality" do
+    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
+    @a.to_h.should == {:a => 1, :b => 2, :c => 3}
+  end
+  
+  specify "should provide #fields as alias to #keys" do
+    @a.fields.should == [:a, :b, :c]
+    @a.fields = [:x, :y, :z]
+    
+    @a[:x].should == 1
+  end
+  
+  specify "should provide #slice functionality with keys" do
+    s = @a.slice(0, 2)
+    s.should == [1, 2]
+    s.keys.should == [:a, :b]
+    
+    s = @a.slice(1..2)
+    s.should == [2, 3]
+    s.keys.should == [:b, :c]
+  end
+  
+  specify "should provide #each_pair iterator" do
+    pairs = []
+    @a.each_pair {|k, v| pairs << [k, v]}
+    pairs.should == [[:a, 1], [:b, 2], [:c, 3]]
+  end
+  
+  specify "should provide stock #delete functionality for arrays without keys" do
+    a = [1, 2, 3]
+    a.delete(2)
+    a.should == [1, 3]
+  end
+  
+  specify "should provide key-based #delete functionality" do
+    @a.delete(:b)
+    @a.should == [1, 3]
+    @a.keys.should == [:a, :c]
+    @a[:a].should == 1
+    @a[:c].should == 3
+  end
+  
+  specify "should separate array keys after #delete/#delete_at" do
+    b = @a.dup
+
+    b.delete(:b)
+
+    @a.keys.should == [:a, :b, :c]
+    b.keys.should == [:a, :c]
+    @a.should == [1, 2, 3]
+    b.should == [1, 3]
+    @a[:b].should == 2
+    b[:b].should == nil
+  end
+  
+  specify "should provide #each_key functionality" do
+    keys = []
+    @a.each_key {|k| keys << k}
+    keys.should == [:a, :b, :c]
+  end
+  
+  specify "should provide #each_value functionality" do
+    values = []
+    @a.each_value {|v| values << v}
+    values.should == [1, 2, 3]
+  end
+  
+  specify "should provide stock #include? functionality for arrays without keys" do
+    [1, 2, 3].include?(2).should be_true
+    [1, 2, 3].include?(4).should be_false
+  end
+
+  specify "should provide #has_key?/#member?/#key?/#include? functionality" do
+    @a.has_key?(:a).should be_true
+    @a.has_key?(:b).should be_true
+    @a.has_key?(:c).should be_true
+    @a.has_key?(:B).should be_false
+    @a.has_key?(:d).should be_false
+
+    @a.has_key?('a').should be_true
+    @a.has_key?('b').should be_true
+    @a.has_key?('c').should be_true
+    @a.has_key?('A').should be_false
+    @a.has_key?('d').should be_false
+
+    @a.key?(:a).should be_true
+    @a.key?(:b).should be_true
+    @a.key?(:c).should be_true
+    @a.key?(:B).should be_false
+    @a.key?(:d).should be_false
+
+    @a.key?('a').should be_true
+    @a.key?('b').should be_true
+    @a.key?('c').should be_true
+    @a.key?('A').should be_false
+    @a.key?('d').should be_false
+
+    @a.member?(:a).should be_true
+    @a.member?(:b).should be_true
+    @a.member?(:c).should be_true
+    @a.member?(:B).should be_false
+    @a.member?(:d).should be_false
+
+    @a.member?('a').should be_true
+    @a.member?('b').should be_true
+    @a.member?('c').should be_true
+    @a.member?('A').should be_false
+    @a.member?('d').should be_false
+
+    @a.include?(:a).should be_true
+    @a.include?(:b).should be_true
+    @a.include?(:c).should be_true
+    @a.include?(:B).should be_false
+    @a.include?(:d).should be_false
+
+    @a.include?('a').should be_true
+    @a.include?('b').should be_true
+    @a.include?('c').should be_true
+    @a.include?('A').should be_false
+    @a.include?('d').should be_false
+  end
+  
+  specify "should provide original #include? functionality for arrays without keys" do
+    [1, 2, 3].include?(:a).should be_false
+    [1, 2, 3].include?(1).should be_true
+  end
+  
+  specify "should provide #has_value?/#value? functionality" do
+    @a.has_value?(1).should be_true
+    @a.has_value?(2).should be_true
+    @a.has_value?(3).should be_true
+    @a.has_value?(4).should be_false
+
+    @a.value?(1).should be_true
+    @a.value?(2).should be_true
+    @a.value?(3).should be_true
+    @a.value?(4).should be_false
+  end
+  
+  specify "should provide #fetch functionality" do
+    @a.fetch(:a).should == 1
+    @a.fetch(:b).should == 2
+    @a.fetch(:c).should == 3
+    proc {@a.fetch(:d)}.should raise_error(IndexError)
+    @a.fetch(:d, 4).should == 4
+    @a.fetch(:d, nil).should == nil
+    
+    @a.fetch(:a) {|v| v.to_s}.should == '1'
+    @a.fetch(:d, 4) {|v| v.to_s}.should == '4'
+  end
+  
+  specify "should provide #values functionality" do
+    @a.values.should == [1, 2, 3]
+  end
+  
+  specify "should provide #dup functionality" do
+    b = @a.dup
+    b.should == [1, 2, 3]
+    b.keys.should == @a.keys
+    
+    b[:a].should == 1
+    b[:b].should == 2
+    b[:c].should == 3
+    b[:d].should be_nil
+    
+    @a.keys << :e
+    @a.keys.should == [:a, :b, :c, :e]
+    b.keys.should == @a.keys
+  end
+  
+  specify "should provide #clone functionality" do
+    b = @a.clone
+    b.should == [1, 2, 3]
+    b.keys.should == @a.keys
+
+    b[:a].should == 1
+    b[:b].should == 2
+    b[:c].should == 3
+    b[:d].should be_nil
+
+    @a.keys << :e
+    @a.keys.should == [:a, :b, :c, :e]
+    b.keys.should_not == @a.keys
+  end
+
+  specify "should provide #merge functionality" do
+    @a.merge(@a).to_hash.should == {:a => 1, :b => 2, :c => 3}
+    
+    @a.merge({:b => 22, :d => 4}).to_hash.should == {:a => 1, :b => 22, :c => 3, :d => 4}
+    
+    b = [1, 2, 3]
+    b.keys = [:b, :c, :d]
+    @a.merge(b).to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
+
+    # call with a block. The block returns the old value passed to it
+    @a.merge(b) {|k, o, n| o}.to_hash.should == {:a => 1, :b => 2, :c => 3, :d => 3}
+  end
+  
+  specify "should provide #merge!/#update!/#update functionality" do
+    @a.merge!(@a)
+    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
+    
+    @a.update(:b => 22)
+    @a.to_hash.should == {:a => 1, :b => 22, :c => 3}
+    
+    b = [1, 2, 3]
+    b.keys = [:b, :c, :d]
+    @a.update!(b)
+    @a.to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
+  end
+end
+
+context "An array with string keys" do
+  setup do
+    @a = [1, 2, 3]
+      @a.keys = ['a', 'b', 'c']
+  end
+
+  specify "should provide key access using symbols" do
+    @a[:a].should == 1
+    @a[:b].should == 2
+    @a[:B].should == nil
+
+    @a[:a] = 11
+    @a.should == [11, 2, 3]
+    @a[:a].should == 11
+
+    @a[:d] = 4
+    @a.should == [11, 2, 3, 4]
+    @a.keys.should == ['a', 'b', 'c', :d]
+  end
+
+  specify "should provide key acess using strings" do
+    @a['a'].should == 1
+    @a['A'].should be_nil
+
+    @a['d'] = 4
+    @a.should == [1, 2, 3, 4]
+    @a.keys.should == ['a', 'b', 'c', :d]
+  end
+
+  specify "should provide #store functionality" do
+    @a.store(:a, 11)
+    @a.should == [11, 2, 3]
+
+    @a.store(:d, 4)
+    @a.should == [11, 2, 3, 4]
+
+    @a.store('d', 44)
+    @a.should == [11, 2, 3, 44]
+  end
+
+  specify "should provide #to_hash/#to_h functionality" do
+    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
+    @a.to_h.should == {:a => 1, :b => 2, :c => 3}
+  end
+
+  specify "should provide #fields as alias to #keys" do
+    @a.fields.should == ['a', 'b', 'c']
+    @a.fields = [:x, :y, :z]
+
+    @a[:x].should == 1
+  end
+
+  specify "should provide #slice functionality with keys" do
+    s = @a.slice(0, 2)
+    s.should == [1, 2]
+    s.keys.should == ['a', 'b']
+
+    s = @a.slice(1..2)
+    s.should == [2, 3]
+    s.keys.should == ['b', 'c']
+  end
+
+  specify "should provide #each_pair iterator" do
+    pairs = []
+    @a.each_pair {|k, v| pairs << [k, v]}
+    pairs.should == [['a', 1], ['b', 2], ['c', 3]]
+  end
+
+  specify "should provide key-based #delete functionality" do
+    @a.delete(:b)
+    @a.should == [1, 3]
+    @a.keys.should == ['a', 'c']
+    @a[:a].should == 1
+    @a[:c].should == 3
+  end
+
+  specify "should provide #each_key functionality" do
+    keys = []
+    @a.each_key {|k| keys << k}
+    keys.should == ['a', 'b', 'c']
+  end
+
+  specify "should provide #each_value functionality" do
+    values = []
+    @a.each_value {|v| values << v}
+    values.should == [1, 2, 3]
+  end
+
+  specify "should provide #has_key?/#member?/#key?/#include? functionality" do
+    @a.has_key?(:a).should be_true
+    @a.has_key?(:b).should be_true
+    @a.has_key?(:c).should be_true
+    @a.has_key?(:B).should be_false
+    @a.has_key?(:d).should be_false
+
+    @a.has_key?('a').should be_true
+    @a.has_key?('b').should be_true
+    @a.has_key?('c').should be_true
+    @a.has_key?('A').should be_false
+    @a.has_key?('d').should be_false
+
+    @a.key?(:a).should be_true
+    @a.key?(:b).should be_true
+    @a.key?(:c).should be_true
+    @a.key?(:B).should be_false
+    @a.key?(:d).should be_false
+
+    @a.key?('a').should be_true
+    @a.key?('b').should be_true
+    @a.key?('c').should be_true
+    @a.key?('A').should be_false
+    @a.key?('d').should be_false
+
+    @a.member?(:a).should be_true
+    @a.member?(:b).should be_true
+    @a.member?(:c).should be_true
+    @a.member?(:B).should be_false
+    @a.member?(:d).should be_false
+
+    @a.member?('a').should be_true
+    @a.member?('b').should be_true
+    @a.member?('c').should be_true
+    @a.member?('A').should be_false
+    @a.member?('d').should be_false
+
+    @a.include?(:a).should be_true
+    @a.include?(:b).should be_true
+    @a.include?(:c).should be_true
+    @a.include?(:B).should be_false
+    @a.include?(:d).should be_false
+
+    @a.include?('a').should be_true
+    @a.include?('b').should be_true
+    @a.include?('c').should be_true
+    @a.include?('A').should be_false
+    @a.include?('d').should be_false
+  end
+
+  specify "should provide original #include? functionality for arrays without keys" do
+    [1, 2, 3].include?(:a).should be_false
+    [1, 2, 3].include?(1).should be_true
+  end
+
+  specify "should provide #has_value?/#value? functionality" do
+    @a.has_value?(1).should be_true
+    @a.has_value?(2).should be_true
+    @a.has_value?(3).should be_true
+    @a.has_value?(4).should be_false
+
+    @a.value?(1).should be_true
+    @a.value?(2).should be_true
+    @a.value?(3).should be_true
+    @a.value?(4).should be_false
+  end
+
+  specify "should provide #fetch functionality" do
+    @a.fetch(:a).should == 1
+    @a.fetch(:b).should == 2
+    @a.fetch(:c).should == 3
+    proc {@a.fetch(:d)}.should raise_error(IndexError)
+    @a.fetch(:d, 4).should == 4
+    @a.fetch(:d, nil).should == nil
+
+    @a.fetch(:a) {|v| v.to_s}.should == '1'
+    @a.fetch(:d, 4) {|v| v.to_s}.should == '4'
+  end
+
+  specify "should provide #values functionality" do
+    @a.values.should == [1, 2, 3]
+  end
+
+  specify "should provide #dup functionality" do
+    b = @a.dup
+    b.should == [1, 2, 3]
+    b.keys.should == @a.keys
+
+    b[:a].should == 1
+    b[:b].should == 2
+    b[:c].should == 3
+    b[:d].should be_nil
+
+    @a.keys << :e
+    @a.keys.should == ['a', 'b', 'c', :e]
+    b.keys.should == @a.keys
+  end
+
+  specify "should provide #clone functionality" do
+    b = @a.clone
+    b.should == [1, 2, 3]
+    b.keys.should == @a.keys
+
+    b[:a].should == 1
+    b[:b].should == 2
+    b[:c].should == 3
+    b[:d].should be_nil
+
+    @a.keys << :e
+    @a.keys.should == ['a', 'b', 'c', :e]
+    b.keys.should_not == @a.keys
+  end
+
+  specify "should provide #merge functionality" do
+    @a.merge(@a).to_hash.should == {:a => 1, :b => 2, :c => 3}
+
+    @a.merge({:b => 22, :d => 4}).to_hash.should == {:a => 1, :b => 22, :c => 3, :d => 4}
+
+    b = [1, 2, 3]
+    b.keys = [:b, :c, :d]
+    @a.merge(b).to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
+
+    # call with a block. The block returns the old value passed to it
+    @a.merge(b) {|k, o, n| o}.to_hash.should == {:a => 1, :b => 2, :c => 3, :d => 3}
+  end
+
+  specify "should provide #merge!/#update!/#update functionality" do
+    @a.merge!(@a)
+    @a.to_hash.should == {:a => 1, :b => 2, :c => 3}
+
+    @a.update(:b => 22)
+    @a.to_hash.should == {:a => 1, :b => 22, :c => 3}
+
+    b = [1, 2, 3]
+    b.keys = [:b, :c, :d]
+    @a.update!(b)
+    @a.to_hash.should == {:a => 1, :b => 1, :c => 2, :d => 3}
+  end
+end
+
+context "Array.from_hash" do
+  specify "should construct an array with keys from a hash" do
+    h = {:x => 1, :y => 2, :z => 3}
+    a = Array.from_hash(h)
+    a.to_hash.should == h
+  end
+end
+
+context "Sequel.use_array_tuples" do
+  setup do
+    @c = Class.new(Sequel::Dataset) do
+      def fetch_rows(sql, &block)
+        block[{:a => 1, :b => 2, :c => 3}]
+      end
+    end
+    
+    @ds = @c.new(nil).from(:items)
+  end
+  
+  teardown do
+    Sequel.use_hash_tuples
+  end
+  
+  specify "should cause the dataset to return array tuples instead of hashes" do
+    @ds.first.should == {:a => 1, :b => 2, :c => 3}
+    Sequel.use_array_tuples
+    a = @ds.first
+    a.class.should == Array
+    a.values.sort.should == [1, 2, 3]
+    a.keys.map {|k| k.to_s}.sort.should == ['a', 'b', 'c']
+    a[:a].should == 1
+    a[:b].should == 2
+    a[:c].should == 3
+    a[:d].should == nil
+    
+    @ds.transform(:a => [proc {|v| v.to_s}, proc {|v| v.to_i}])
+    a = @ds.first
+    a[:a].should == '1'
+    
+    @ds.transform({})
+    a = @ds.first
+    a[:a].should == 1
+
+    @ds.set_model(Hash)
+  end
+  
+  specify "should be reversible using Sequel.use_hash_tuples" do
+    Sequel.use_array_tuples
+    @ds.first.class.should == Array
+    
+    Sequel.use_hash_tuples
+    @ds.first.should == {:a => 1, :b => 2, :c => 3}
+  end
+end