sequel 4.47.0 → 4.48.0

data/spec/integration/dataset_test.rb

@@ -15,8 +15,8 @@ describe "Simple Dataset operations" do
   end
 
   it "should support sequential primary keys" do
-    @ds << {:number=>20}
-    @ds << {:number=>30}
+    @ds.insert(:number=>20)
+    @ds.insert(:number=>30)
     @ds.order(:number).all.must_equal [
       {:id => 1, :number=>10},
       {:id => 2, :number=>20},
@@ -28,8 +28,8 @@ describe "Simple Dataset operations" do
       primary_key :id, :type=>:Bignum
       Integer :number
     end
-    @ds << {:number=>20}
-    @ds << {:number=>30}
+    @ds.insert(:number=>20)
+    @ds.insert(:number=>30)
     @ds.order(:number).all.must_equal [{:id => 1, :number=>20}, {:id => 2, :number=>30}]   
   end 
 
@@ -49,7 +49,7 @@ describe "Simple Dataset operations" do
     @ds.filter(:id=>2).first[:number].must_equal 20
   end
 
-  it "should have insert_multiple return primary key values" do
+  deprecated "should have insert_multiple return primary key values" do
     @ds.extension(:sequel_3_dataset_methods).insert_multiple([{:number=>20}, {:number=>30}]).must_equal [2, 3]
     @ds.filter(:id=>2).get(:number).must_equal 20
     @ds.filter(:id=>3).get(:number).must_equal 30
@@ -60,7 +60,7 @@ describe "Simple Dataset operations" do
   end
 
   it "should handle LATERAL subqueries correctly" do
-    @ds << {:number=>20}
+    @ds.insert(:number=>20)
     @ds.from(Sequel[:items].as(:i), @ds.where(Sequel[:items][:number]=>Sequel[:i][:number]).lateral).select_order_map([Sequel[:i][:number].as(:n), Sequel[:t1][:number]]).must_equal [[10, 10], [20, 20]]
     @ds.from(Sequel[:items].as(:i)).cross_join(@ds.where(Sequel[:items][:number]=>Sequel[:i][:number]).lateral).select_order_map([Sequel[:i][:number].as(:n), Sequel[:t1][:number]]).must_equal [[10, 10], [20, 20]]
     @ds.from(Sequel[:items].as(:i)).join(@ds.where(Sequel[:items][:number]=>Sequel[:i][:number]).lateral, 1=>1).select_order_map([Sequel[:i][:number].as(:n), Sequel[:t1][:number]]).must_equal [[10, 10], [20, 20]]
@@ -389,9 +389,9 @@ describe Sequel::Dataset do
 
   it "should return the correct record count" do
     @d.count.must_equal 0
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => nil}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => nil)
     5.times do
       @d.count.must_equal 3
       @d.count(:name).must_equal 3
@@ -400,14 +400,14 @@ describe Sequel::Dataset do
   end
 
   it "should handle functions with identifier names correctly" do
-    @d << {:name => 'abc', :value => 6}
+    @d.insert(:name => 'abc', :value => 6)
     @d.get{sum.function(:value)}.must_equal 6
   end
 
   it "should handle aggregate methods on limited datasets correctly" do
-    @d << {:name => 'abc', :value => 6}
-    @d << {:name => 'bcd', :value => 12}
-    @d << {:name => 'def', :value => 18}
+    @d.insert(:name => 'abc', :value => 6)
+    @d.insert(:name => 'bcd', :value => 12)
+    @d.insert(:name => 'def', :value => 18)
     @d = @d.order(:name).limit(2)
     @d.count.must_equal 2
     @d.avg(:value).to_i.must_equal 9
@@ -415,14 +415,14 @@ describe Sequel::Dataset do
     @d.reverse.min(:value).to_i.must_equal 12
     @d.max(:value).to_i.must_equal 12
     @d.sum(:value).to_i.must_equal 18
-    @d.interval(:value).to_i.must_equal 6
+    @d.extension(:sequel_4_dataset_methods).interval(:value).to_i.must_equal 6
   end
 
   it "should return the correct records" do
     @d.to_a.must_equal []
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
 
     @d.order(:value).to_a.must_equal [
       {:name => 'abc', :value => 123},
@@ -432,27 +432,27 @@ describe Sequel::Dataset do
   end
 
   it "should update records correctly" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.filter(:name => 'abc').update(:value => 530)
     @d[:name => 'def'][:value].must_equal 789
     @d.filter(:value => 530).count.must_equal 2
   end
 
   it "should delete records correctly" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.filter(:name => 'abc').delete
     @d.count.must_equal 1
     @d.first[:name].must_equal 'def'
   end
   
   it "should be able to truncate the table" do
-    @d << {:name => 'abc', :value => 123}
-    @d << {:name => 'abc', :value => 456}
-    @d << {:name => 'def', :value => 789}
+    @d.insert(:name => 'abc', :value => 123)
+    @d.insert(:name => 'abc', :value => 456)
+    @d.insert(:name => 'def', :value => 789)
     @d.count.must_equal 3
     @d.truncate.must_be_nil
     @d.count.must_equal 0
@@ -517,9 +517,9 @@ describe Sequel::Dataset do
       Integer :value
     end 
     @d = DB[:items]
-    @d << {:value => 123}
-    @d << {:value => 456}
-    @d << {:value => 789}
+    @d.insert(:value => 123)
+    @d.insert(:value => 456)
+    @d.insert(:value => 789)
   end 
   after do
     DB.drop_table?(:items)
@@ -1055,7 +1055,7 @@ describe "Sequel::Dataset convenience methods" do
     @db.drop_table?(:a)
   end
   
-  it "#[]= should update matching rows" do
+  deprecated "#[]= should update matching rows" do
     @ds.insert(20, 10)
     @ds.extension(:sequel_3_dataset_methods)[:a=>20] = {:b=>30}
     @ds.all.must_equal [{:a=>20, :b=>30}]
@@ -1104,7 +1104,7 @@ describe "Sequel::Dataset convenience methods" do
   end
   
   it "#range should return the range between the maximum and minimum values" do
-    @ds = @ds.unordered
+    @ds = @ds.unordered.extension(:sequel_4_dataset_methods)
     @ds.insert(20, 10)
     @ds.insert(30, 10)
     @ds.range(:a).must_equal(20..30)
@@ -1112,7 +1112,7 @@ describe "Sequel::Dataset convenience methods" do
   end
   
   it "#interval should return the different between the maximum and minimum values" do
-    @ds = @ds.unordered
+    @ds = @ds.unordered.extension(:sequel_4_dataset_methods)
     @ds.insert(20, 10)
     @ds.insert(30, 10)
     @ds.interval(:a).to_i.must_equal 10
@@ -1147,10 +1147,10 @@ describe "Sequel::Dataset main SQL methods" do
     @ds.filter(Sequel.lit("b < ?", 15)).invert.all.must_equal [{:a=>20, :b=>30}]
   end
   
-  it "#and and #or should work correctly" do
+  it "#where and #or should work correctly" do
     @ds.insert(20, 30)
-    @ds.filter(:a=>20).and(:b=>30).all.must_equal [{:a=>20, :b=>30}]
-    @ds.filter(:a=>20).and(:b=>15).all.must_equal []
+    @ds.filter(:a=>20).where(:b=>30).all.must_equal [{:a=>20, :b=>30}]
+    @ds.filter(:a=>20).where(:b=>15).all.must_equal []
     @ds.filter(:a=>20).or(:b=>15).all.must_equal [{:a=>20, :b=>30}]
     @ds.filter(:a=>10).or(:b=>15).all.must_equal []
   end
@@ -1212,17 +1212,18 @@ describe "Sequel::Dataset convenience methods" do
     @ds.map([:a, :b]).must_equal [[1, 2], [5, 6]]
   end
   
-  it "should have working #to_hash" do
+  it "should have working #as_hash" do
     @ds.to_hash(:a).must_equal(1=>{:a=>1, :b=>2, :c=>3, :d=>4}, 5=>{:a=>5, :b=>6, :c=>7, :d=>8})
-    @ds.to_hash(:b).must_equal(2=>{:a=>1, :b=>2, :c=>3, :d=>4}, 6=>{:a=>5, :b=>6, :c=>7, :d=>8})
-    @ds.to_hash([:a, :b]).must_equal([1, 2]=>{:a=>1, :b=>2, :c=>3, :d=>4}, [5, 6]=>{:a=>5, :b=>6, :c=>7, :d=>8})
+    @ds.as_hash(:a).must_equal(1=>{:a=>1, :b=>2, :c=>3, :d=>4}, 5=>{:a=>5, :b=>6, :c=>7, :d=>8})
+    @ds.as_hash(:b).must_equal(2=>{:a=>1, :b=>2, :c=>3, :d=>4}, 6=>{:a=>5, :b=>6, :c=>7, :d=>8})
+    @ds.as_hash([:a, :b]).must_equal([1, 2]=>{:a=>1, :b=>2, :c=>3, :d=>4}, [5, 6]=>{:a=>5, :b=>6, :c=>7, :d=>8})
 
-    @ds.to_hash(:a, :b).must_equal(1=>2, 5=>6)
-    @ds.to_hash([:a, :c], :b).must_equal([1, 3]=>2, [5, 7]=>6)
-    @ds.to_hash(:a, [:b, :c]).must_equal(1=>[2, 3], 5=>[6, 7])
-    @ds.to_hash([:a, :c], [:b, :d]).must_equal([1, 3]=>[2, 4], [5, 7]=>[6, 8])
+    @ds.as_hash(:a, :b).must_equal(1=>2, 5=>6)
+    @ds.as_hash([:a, :c], :b).must_equal([1, 3]=>2, [5, 7]=>6)
+    @ds.as_hash(:a, [:b, :c]).must_equal(1=>[2, 3], 5=>[6, 7])
+    @ds.as_hash([:a, :c], [:b, :d]).must_equal([1, 3]=>[2, 4], [5, 7]=>[6, 8])
 
-    @ds.to_hash(:a, :b, :hash => (tmp = {})).must_be_same_as(tmp)
+    @ds.as_hash(:a, :b, :hash => (tmp = {})).must_be_same_as(tmp)
   end
 
   it "should have working #to_hash_groups" do
@@ -1874,7 +1875,7 @@ describe "Dataset replace" do
   end
 
   it "should update a record if the condition is met" do
-    @d << {:id => 111}
+    @d.insert(:id => 111)
     @d.all.must_equal [{:id => 111, :value => nil}]
     @d.replace(:id => 111, :value => 333)
     @d.all.must_equal [{:id => 111, :value => 333}]

data/spec/integration/plugin_test.rb

@@ -1195,6 +1195,7 @@ describe "AssociationPks plugin" do
     class ::Album < Sequel::Model
       plugin :association_pks
       many_to_many :tags, :order=>:id, :delay_pks=>false
+      many_to_many :uat_tags, :order=>Sequel[:tags][:id], :delay_pks=>false, :class=>:Tag, :right_key=>:tag_id, :association_pks_use_associated_table=>true
     end 
     class ::Tag < Sequel::Model
     end 
@@ -1260,6 +1261,10 @@ describe "AssociationPks plugin" do
     Album.order(:id).all.map{|a| a.tag_pks.sort}.must_equal [[@t1, @t2, @t3], [@t2], []]
   end
 
+  it "should return correct associated pks for many_to_many associations using :association_pks_use_associated_table" do
+    Album.order(:id).all.map{|a| a.uat_tag_pks.sort}.must_equal [[@t1, @t2, @t3], [@t2], []]
+  end
+
   it "should return correct associated right-side cpks for one_to_many associations" do
     Album.one_to_many :vocalists, :order=>:first
     Album.order(:id).all.map{|a| a.vocalist_pks.sort}.must_equal [[@v1, @v2, @v3], [], []]
@@ -1270,6 +1275,11 @@ describe "AssociationPks plugin" do
     Album.order(:id).all.map{|a| a.vocalist_pks.sort}.must_equal [[@v1, @v2, @v3], [@v2], []]
   end
 
+  it "should return correct associated right-side cpks for many_to_many associations when using :association_pks_use_associated_table" do
+    Album.many_to_many :vocalists, :join_table=>:albums_vocalists, :right_key=>[:first, :last], :order=>Sequel[:vocalists][:first], :association_pks_use_associated_table=>true
+    Album.order(:id).all.map{|a| a.vocalist_pks.sort}.must_equal [[@v1, @v2, @v3], [@v2], []]
+  end
+
   it "should return correct associated pks for left-side cpks for one_to_many associations" do
     Vocalist.one_to_many :instruments, :key=>[:first, :last], :order=>:id
     Vocalist.order(:first, :last).all.map{|a| a.instrument_pks.sort}.must_equal [[@i1, @i2, @i3], [], []]
@@ -1280,6 +1290,11 @@ describe "AssociationPks plugin" do
     Vocalist.order(:first, :last).all.map{|a| a.instrument_pks.sort}.must_equal [[@i1, @i2, @i3], [@i2], []]
   end
 
+  it "should return correct associated pks for left-side cpks for many_to_many associations when using :association_pks_use_associated_table" do
+    Vocalist.many_to_many :instruments, :join_table=>:vocalists_instruments, :left_key=>[:first, :last], :order=>:id, :association_pks_use_associated_table=>true
+    Vocalist.order(:first, :last).all.map{|a| a.instrument_pks.sort}.must_equal [[@i1, @i2, @i3], [@i2], []]
+  end
+
   it "should return correct associated right-side cpks for left-side cpks for one_to_many associations" do
     Vocalist.one_to_many :hits, :key=>[:first, :last], :order=>:week
     Vocalist.order(:first, :last).all.map{|a| a.hit_pks.sort}.must_equal [[@h1, @h2, @h3], [], []]
@@ -1290,6 +1305,11 @@ describe "AssociationPks plugin" do
     Vocalist.order(:first, :last).all.map{|a| a.hit_pks.sort}.must_equal [[@h1, @h2, @h3], [@h2], []]
   end
 
+  it "should return correct associated right-side cpks for left-side cpks for many_to_many associations when using :association_pks_use_associated_table" do
+    Vocalist.many_to_many :hits, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week], :order=>Sequel[:vocalists_hits][:week], :association_pks_use_associated_table=>true
+    Vocalist.order(:first, :last).all.map{|a| a.hit_pks.sort}.must_equal [[@h1, @h2, @h3], [@h2], []]
+  end
+
   deprecated "should handle :delay_pks=>true association option for new instances" do
     album_class = Class.new(Album)
     album_class.many_to_many :tags, :clone=>:tags, :delay_pks=>true, :join_table=>:albums_tags, :left_key=>:album_id

data/spec/integration/prepared_statement_test.rb

@@ -22,6 +22,7 @@ describe "Prepared Statements and Bound Arguments" do
     @ds.filter(:numb=>:$n).call(:all, :n=>10).must_equal [{:id=>1, :numb=>10}]
     @ds.filter(:numb=>:$n).call(:first, :n=>10).must_equal(:id=>1, :numb=>10)
     @ds.filter(:numb=>:$n).call([:map, :numb], :n=>10).must_equal [10]
+    @ds.filter(:numb=>:$n).call([:as_hash, :id, :numb], :n=>10).must_equal(1=>10)
     @ds.filter(:numb=>:$n).call([:to_hash, :id, :numb], :n=>10).must_equal(1=>10)
     @ds.filter(:numb=>:$n).call([:to_hash_groups, :id, :numb], :n=>10).must_equal(1=>[10])
   end
@@ -161,6 +162,8 @@ describe "Prepared Statements and Bound Arguments" do
     @db.call(:select_n, :n=>10).must_equal(:id=>1, :numb=>10)
     @ds.filter(:numb=>:$n).prepare([:map, :numb], :select_n)
     @db.call(:select_n, :n=>10).must_equal [10]
+    @ds.filter(:numb=>:$n).prepare([:as_hash, :id, :numb], :select_n)
+    @db.call(:select_n, :n=>10).must_equal(1=>10)
     @ds.filter(:numb=>:$n).prepare([:to_hash, :id, :numb], :select_n)
     @db.call(:select_n, :n=>10).must_equal(1=>10)
   end

data/spec/integration/schema_test.rb

@@ -215,7 +215,7 @@ describe "Database index parsing" do
     DB.indexes(:items).must_equal({})
   end
 
-  cspecify "should not include partial indexes", :sqlite do
+  it "should not include partial indexes" do
     DB.create_table!(:items){Integer :n; Integer :a; index :n, :where=>proc{n > 10}}
     DB.indexes(:items).must_equal({})
   end if DB.supports_partial_indexes?
@@ -387,6 +387,26 @@ describe "Database schema modifiers" do
     @db.table_exists?(:items).must_equal false
   end if DB.supports_transactional_ddl?
   
+  it "should handle errors creating indexes when ignoring index errors" do
+    @db.drop_table?(:items)
+    @db.transaction do
+      @db.create_table(:items, :ignore_index_errors=>true) do
+        Integer :n1
+        Integer :n2
+        index :n1, :name=>'items_n1'
+        index :foo, :name=>'items_f'
+        index :n2, :name=>'items_n2'
+        index :bar, :name=>'items_g'
+      end
+    end
+    @db.table_exists?(:items).must_equal true
+    indexes = @db.indexes(:items).keys
+    indexes.must_include :items_n1
+    indexes.must_include :items_n2
+    indexes.wont_include :items_f
+    indexes.wont_include :items_g
+  end if DB.supports_transactional_ddl? && DB.database_type != :mssql
+  
   describe "join tables" do
     after do
       @db.drop_join_table(:cat_id=>:cats, :dog_id=>:dogs) if @db.table_exists?(:cats_dogs)

data/spec/integration/transaction_test.rb

@@ -14,7 +14,7 @@ describe "Database transactions" do
   end
 
   it "should support transactions" do
-    @db.transaction{@d << {:name => 'abc', :value => 1}}
+    @db.transaction{@d.insert(:name => 'abc', :value => 1)}
     @d.count.must_equal 1
   end
 
@@ -32,25 +32,25 @@ describe "Database transactions" do
   it "should correctly rollback transactions" do
     proc do
       @db.transaction do
-        @d << {:name => 'abc', :value => 1}
+        @d.insert(:name => 'abc', :value => 1)
         raise Interrupt, 'asdf'
       end
     end.must_raise(Interrupt)
 
     @db.transaction do
-      @d << {:name => 'abc', :value => 1}
+      @d.insert(:name => 'abc', :value => 1)
       raise Sequel::Rollback
     end.must_be_nil
 
     proc do
       @db.transaction(:rollback=>:reraise) do
-        @d << {:name => 'abc', :value => 1}
+        @d.insert(:name => 'abc', :value => 1)
         raise Sequel::Rollback
       end
     end.must_raise(Sequel::Rollback)
 
     @db.transaction(:rollback=>:always) do
-      @d << {:name => 'abc', :value => 1}
+      @d.insert(:name => 'abc', :value => 1)
       2
     end.must_equal 2
 
@@ -60,14 +60,14 @@ describe "Database transactions" do
   it "should support nested transactions" do
     @db.transaction do
       @db.transaction do
-        @d << {:name => 'abc', :value => 1}
+        @d.insert(:name => 'abc', :value => 1)
       end 
     end 
     @d.count.must_equal 1
 
     @d.delete
     @db.transaction do
-      @d << {:name => 'abc', :value => 1}
+      @d.insert(:name => 'abc', :value => 1)
       @db.transaction do
         raise Sequel::Rollback
       end 
@@ -75,7 +75,7 @@ describe "Database transactions" do
     @d.count.must_equal 0
 
     proc {@db.transaction do
-      @d << {:name => 'abc', :value => 1}
+      @d.insert(:name => 'abc', :value => 1)
       @db.transaction do
         raise Interrupt, 'asdf'
       end 
@@ -86,9 +86,9 @@ describe "Database transactions" do
   if DB.supports_savepoints?
     it "should handle table_exists? failures inside transactions" do
       @db.transaction do
-        @d << {:name => '1'}
+        @d.insert(:name => '1')
         @db.table_exists?(:asadf098asd9asd98sa).must_equal false
-        @d << {:name => '2'}
+        @d.insert(:name => '2')
       end
       @d.select_order_map(:name).must_equal %w'1 2'
     end
@@ -96,7 +96,7 @@ describe "Database transactions" do
     it "should handle :rollback=>:always inside transactions" do
       @db.transaction do
         @db.transaction(:rollback=>:always) do
-          @d << {:name => 'abc', :value => 1}
+          @d.insert(:name => 'abc', :value => 1)
           2
         end.must_equal 2
       end
@@ -105,36 +105,36 @@ describe "Database transactions" do
 
     it "should handle table_exists? failures inside savepoints" do
       @db.transaction do
-        @d << {:name => '1'}
+        @d.insert(:name => '1')
         @db.transaction(:savepoint=>true) do
-          @d << {:name => '2'}
+          @d.insert(:name => '2')
           @db.table_exists?(:asadf098asd9asd98sa).must_equal false
-          @d << {:name => '3'}
+          @d.insert(:name => '3')
         end
-        @d << {:name => '4'}
+        @d.insert(:name => '4')
       end
       @d.select_order_map(:name).must_equal %w'1 2 3 4'
     end
 
     it "should support nested transactions through savepoints using the savepoint option" do
       @db.transaction do
-        @d << {:name => '1'}
+        @d.insert(:name => '1')
         @db.transaction(:savepoint=>true) do
-          @d << {:name => '2'}
+          @d.insert(:name => '2')
           @db.transaction do
-            @d << {:name => '3'}
+            @d.insert(:name => '3')
             raise Sequel::Rollback
           end
         end
-        @d << {:name => '4'}
+        @d.insert(:name => '4')
         @db.transaction do
-          @d << {:name => '6'}
+          @d.insert(:name => '6')
           @db.transaction(:savepoint=>true) do
-            @d << {:name => '7'}
+            @d.insert(:name => '7')
             raise Sequel::Rollback
           end
         end
-        @d << {:name => '5'}
+        @d.insert(:name => '5')
       end
 
       @d.order(:name).map(:name).must_equal %w{1 4 5 6}
@@ -142,23 +142,23 @@ describe "Database transactions" do
 
     it "should support nested transactions through savepoints using the auto_savepoint option" do
       @db.transaction(:auto_savepoint=>true) do
-        @d << {:name => '1'}
+        @d.insert(:name => '1')
         @db.transaction do
-          @d << {:name => '2'}
+          @d.insert(:name => '2')
           @db.transaction do
-            @d << {:name => '3'}
+            @d.insert(:name => '3')
             raise Sequel::Rollback
           end
         end
-        @d << {:name => '4'}
+        @d.insert(:name => '4')
         @db.transaction(:auto_savepoint=>true) do
-          @d << {:name => '6'}
+          @d.insert(:name => '6')
           @db.transaction do
-            @d << {:name => '7'}
+            @d.insert(:name => '7')
             raise Sequel::Rollback
           end
         end
-        @d << {:name => '5'}
+        @d.insert(:name => '5')
       end
 
       @d.order(:name).map(:name).must_equal %w{1 4 5 6}
@@ -168,7 +168,7 @@ describe "Database transactions" do
   it "should handle returning inside of the block by committing" do
     def ret_commit
       @db.transaction do
-        @db[:items] << {:name => 'abc'}
+        @db[:items].insert(:name => 'abc')
         return
       end
     end
@@ -199,20 +199,20 @@ describe "Database transactions" do
     end
 
     it "should commit prepared transactions using commit_prepared_transaction" do
-      @db.transaction(:prepare=>'XYZ'){@d << {:name => '1'}}
+      @db.transaction(:prepare=>'XYZ'){@d.insert(:name => '1')}
       @db.commit_prepared_transaction('XYZ')
       @d.select_order_map(:name).must_equal ['1']
     end
 
     it "should rollback prepared transactions using rollback_prepared_transaction" do
-      @db.transaction(:prepare=>'XYZ'){@d << {:name => '1'}}
+      @db.transaction(:prepare=>'XYZ'){@d.insert(:name => '1')}
       @db.rollback_prepared_transaction('XYZ')
       @d.select_order_map(:name).must_equal []
     end
 
     if DB.supports_savepoints_in_prepared_transactions?
       it "should support savepoints when using prepared transactions" do
-        @db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@d << {:name => '1'}}}
+        @db.transaction(:prepare=>'XYZ'){@db.transaction(:savepoint=>true){@d.insert(:name => '1')}}
         @db.commit_prepared_transaction('XYZ')
         @d.select_order_map(:name).must_equal ['1']
       end
@@ -221,7 +221,7 @@ describe "Database transactions" do
 
   it "should support all transaction isolation levels" do
     [:uncommitted, :committed, :repeatable, :serializable].each_with_index do |l, i|
-      @db.transaction(:isolation=>l){@d << {:name => 'abc', :value => 1}}
+      @db.transaction(:isolation=>l){@d.insert(:name => 'abc', :value => 1)}
       @d.count.must_equal i + 1
     end
   end
@@ -331,10 +331,10 @@ if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby') and RUBY_VERSION < '1.9'
       q1 = Queue.new
       t = Thread.new do
         @db.transaction do
-          @d << {:name => 'abc', :value => 1}
+          @d.insert(:name => 'abc', :value => 1)
           q1.push nil
           q.pop
-          @d << {:name => 'def', :value => 2}
+          @d.insert(:name => 'def', :value => 2)
         end
       end
       q1.pop
@@ -348,14 +348,14 @@ if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby') and RUBY_VERSION < '1.9'
         q1 = Queue.new
         t = Thread.new do
           @db.transaction do
-            @d << {:name => 'abc', :value => 1}
+            @d.insert(:name => 'abc', :value => 1)
             @db.transaction(:savepoint=>true) do
-              @d << {:name => 'def', :value => 2}
+              @d.insert(:name => 'def', :value => 2)
               q1.push nil
               q.pop
-              @d << {:name => 'ghi', :value => 3}
+              @d.insert(:name => 'ghi', :value => 3)
             end
-            @d << {:name => 'jkl', :value => 4}
+            @d.insert(:name => 'jkl', :value => 4)
           end
         end
         q1.pop