sequel 4.49.0 → 5.0.0

data/spec/integration/transaction_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Database transactions" do
   before(:all) do
@@ -192,7 +192,6 @@ describe "Database transactions" do
       c = Class.new(Sequel::Model(@d))
       c.set_primary_key :name
       c.unrestrict_primary_key
-      c.use_after_commit_rollback = false
       @db.transaction(:prepare=>'XYZ'){c.create(:name => '1'); c.create(:name => '2').destroy}
       @db.commit_prepared_transaction('XYZ')
       @d.select_order_map(:name).must_equal ['1']
@@ -315,57 +314,6 @@ describe "Database transactions" do
   end
 end
 
-if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby') and RUBY_VERSION < '1.9'
-  describe "Database transactions and Thread#kill" do
-    before do
-      @db = DB
-      @db.create_table!(:items, :engine=>'InnoDB'){String :name; Integer :value}
-      @d = @db[:items]
-    end
-    after do
-      @db.drop_table?(:items)
-    end
-
-    it "should handle transactions inside threads" do
-      q = Queue.new
-      q1 = Queue.new
-      t = Thread.new do
-        @db.transaction do
-          @d.insert(:name => 'abc', :value => 1)
-          q1.push nil
-          q.pop
-          @d.insert(:name => 'def', :value => 2)
-        end
-      end
-      q1.pop
-      t.kill
-      @d.count.must_equal 0
-    end
-
-    if DB.supports_savepoints?
-      it "should handle transactions with savepoints inside threads" do
-        q = Queue.new
-        q1 = Queue.new
-        t = Thread.new do
-          @db.transaction do
-            @d.insert(:name => 'abc', :value => 1)
-            @db.transaction(:savepoint=>true) do
-              @d.insert(:name => 'def', :value => 2)
-              q1.push nil
-              q.pop
-              @d.insert(:name => 'ghi', :value => 3)
-            end
-            @d.insert(:name => 'jkl', :value => 4)
-          end
-        end
-        q1.pop
-        t.kill
-        @d.count.must_equal 0
-      end
-    end
-  end
-end
-
 describe "Database transaction retrying" do
   before(:all) do
     @db = DB
@@ -379,7 +327,7 @@ describe "Database transaction retrying" do
     @db.drop_table?(:items)
   end
 
-  cspecify "should be supported using the :retry_on option", [:db2] do
+  it "should be supported using the :retry_on option" do
     @d.insert('b')
     @d.insert('c')
     s = 'a'
@@ -390,7 +338,7 @@ describe "Database transaction retrying" do
     @d.select_order_map(:a).must_equal %w'b c d'
   end
 
-  cspecify "should limit number of retries via the :num_retries option", [:db2] do
+  it "should limit number of retries via the :num_retries option" do
     @d.insert('b')
     @d.insert('c')
     s = 'a'

data/spec/integration/type_test.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative "spec_helper"
 
 describe "Supported types" do
   def create_items_table_with_column(name, type, opts={})
@@ -37,13 +37,13 @@ describe "Supported types" do
     ds.all.must_equal [{:number=>2**34}]
   end
   
-  cspecify "should support generic float type", [:swift, :sqlite] do
+  it "should support generic float type" do
     ds = create_items_table_with_column(:number, Float)
     ds.insert(:number => 2.1)
     ds.all.must_equal [{:number=>2.1}]
   end
   
-  cspecify "should support generic numeric type", [:odbc, :mssql], [:swift, :sqlite] do
+  cspecify "should support generic numeric type", [:odbc, :mssql] do
     ds = create_items_table_with_column(:number, Numeric, :size=>[15, 10])
     ds.insert(:number => BigDecimal.new('2.123456789'))
     ds.all.must_equal [{:number=>BigDecimal.new('2.123456789')}]
@@ -67,7 +67,7 @@ describe "Supported types" do
     ds.all.must_equal [{:name=>'Test User'*100}]
   end
   
-  cspecify "should support generic date type", [:do, :sqlite], [:jdbc, :sqlite], [:tinytds], [:jdbc, :mssql], :oracle do
+  cspecify "should support generic date type", [:jdbc, :sqlite], [:tinytds], [:jdbc, :mssql], :oracle do
     ds = create_items_table_with_column(:dat, Date)
     d = Date.today
     ds.insert(:dat => d)
@@ -75,7 +75,7 @@ describe "Supported types" do
     ds.first[:dat].to_s.must_equal d.to_s
   end
   
-  cspecify "should support generic time type", [:do], [:swift], [:odbc], [:jdbc, :mssql], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle, [:ado] do
+  cspecify "should support generic time type", [:odbc], [:jdbc, :mssql], [:jdbc, :sqlite], [:mysql2], [:tinytds], :oracle, [:ado] do
     ds = create_items_table_with_column(:tim, Time, :only_time=>true)
     t = Sequel::SQLTime.now
     ds.insert(:tim => t)
@@ -89,7 +89,7 @@ describe "Supported types" do
     v2.must_be_kind_of(Sequel::SQLTime)
   end
   
-  cspecify "should support generic datetime type", [:do, :sqlite], [:jdbc, :sqlite] do
+  cspecify "should support generic datetime type", [:jdbc, :sqlite] do
     ds = create_items_table_with_column(:tim, DateTime)
     t = DateTime.now
     ds.insert(:tim => t)
@@ -100,14 +100,14 @@ describe "Supported types" do
     ds.first[:tim].strftime('%Y%m%d%H%M%S').must_equal t.strftime('%Y%m%d%H%M%S')
   end
   
-  cspecify "should support generic file type", [:do], [:odbc, :mssql], [:mysql2], [:tinytds] do
+  cspecify "should support generic file type", [:odbc, :mssql], [:mysql2], [:tinytds] do
     ds = create_items_table_with_column(:name, File)
     ds.insert(:name =>Sequel.blob("a\0"*300))
     ds.all.must_equal [{:name=>Sequel.blob("a\0"*300)}]
     ds.first[:name].must_be_kind_of(::Sequel::SQL::Blob)
   end
   
-  cspecify "should support generic boolean type", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
+  cspecify "should support generic boolean type", [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     ds = create_items_table_with_column(:number, TrueClass)
     ds.insert(:number => true)
     ds.all.must_equal [{:number=>true}]
@@ -116,7 +116,7 @@ describe "Supported types" do
     ds.all.must_equal [{:number=>true}]
   end
   
-  cspecify "should support generic boolean type with defaults", [:do, :sqlite], [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
+  cspecify "should support generic boolean type with defaults", [:jdbc, :sqlite], [:jdbc, :db2], :oracle do
     ds = create_items_table_with_column(:number, TrueClass, :default=>true)
     ds.insert
     ds.all.must_equal [{:number=>true}]

data/spec/model/association_reflection_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe Sequel::Model::Associations::AssociationReflection, "#associated_class" do
   before do
@@ -15,14 +15,34 @@ describe Sequel::Model::Associations::AssociationReflection, "#associated_class"
     @c.association_reflection(:c).associated_class.must_equal ParParent
   end
 
+  it "should use the :class value if present" do
+    @c.many_to_one :c, :class=>@c
+    @c.one_to_many :cs, :class=>@c
+    c = @c.association_reflection(:c)
+    cs = @c.association_reflection(:cs)
+
+    c.association_method.must_equal :c
+    c.dataset_method.must_equal :c_dataset
+    c.setter_method.must_equal :c=
+    c._setter_method.must_equal :_c=
+
+    cs.association_method.must_equal :cs
+    cs.dataset_method.must_equal :cs_dataset
+    cs.add_method.must_equal :add_c
+    cs._add_method.must_equal :_add_c
+    cs.remove_method.must_equal :remove_c
+    cs._remove_method.must_equal :_remove_c
+    cs.remove_all_method.must_equal :remove_all_cs
+    cs._remove_all_method.must_equal :_remove_all_cs
+  end
+
   it "should have inspect include association class and representation of association definition " do
     ParParent.many_to_one :c
     ParParent.association_reflection(:c).inspect.must_equal "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c>"
     ParParent.many_to_one :c, :class=>ParParent
     ParParent.association_reflection(:c).inspect.must_equal "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :class=>ParParent>"
     ParParent.many_to_one :c, :class=>ParParent, :key=>:c_id
-    ["#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :key=>:c_id, :class=>ParParent>",
-     "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :class=>ParParent, :key=>:c_id>"].must_include ParParent.association_reflection(:c).inspect
+    ParParent.association_reflection(:c).inspect.must_equal "#<Sequel::Model::Associations::ManyToOneAssociationReflection ParParent.many_to_one :c, :key=>:c_id, :class=>ParParent>"
 
     @c.one_to_many :foos do |ds| ds end
     @c.association_reflection(:foos).inspect.must_equal "#<Sequel::Model::Associations::OneToManyAssociationReflection #{@c.to_s}.one_to_many :foos, :block=>#{@c.association_reflection(:foos)[:block].inspect}>"
@@ -286,11 +306,6 @@ describe Sequel::Model::Associations::AssociationReflection do
     def @c.name() "C" end
   end
 
-  deprecated "#eager_loading_predicate_key should be an alias of predicate_key for backwards compatibility" do
-    @c.one_to_many :cs, :class=>@c
-    @c.dataset.literal(@c.association_reflection(:cs).eager_loading_predicate_key).must_equal 'foo.c_id'
-  end
-
   it "one_to_many #qualified_primary_key should be a qualified version of the primary key" do
     @c.one_to_many :cs, :class=>@c
     @c.dataset.literal(@c.association_reflection(:cs).qualified_primary_key).must_equal 'foo.id'
@@ -516,7 +531,7 @@ describe Sequel::Model, " association reflection methods" do
     c.associate :many_to_one, :parent2, :class => @c1
     @c1.associations.must_equal [:parent]
     c.associations.sort_by{|x| x.to_s}.must_equal [:parent, :parent2]
-    c.instance_methods.map{|x| x.to_s}.must_include('parent')
+    c.instance_methods.must_include(:parent)
   end
 end
 

data/spec/model/associations_spec.rb

@@ -1,4 +1,4 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require_relative "spec_helper"
 
 describe Sequel::Model, "associate" do
   it "should use explicit class if given a class, symbol, or string" do
@@ -449,12 +449,6 @@ describe Sequel::Model, "many_to_one" do
     d.associations[:parent] = 42
     d.parent(:reload=>true).wont_equal 42 
     DB.sqls.must_equal ["SELECT * FROM nodes WHERE id = 234"]
-    deprecated do
-      d.parent(true).wont_equal 42 
-      DB.sqls.must_equal ["SELECT * FROM nodes WHERE id = 234"]
-      d.parent(Object.new).wont_equal 42 
-      DB.sqls.must_equal ["SELECT * FROM nodes WHERE id = 234"]
-    end
   end
   
   it "should use a callback if given one as the argument" do
@@ -571,31 +565,31 @@ describe Sequel::Model, "many_to_one" do
 
   it "should not create the setter method if :read_only option is used" do
     @c2.many_to_one :parent, :class => @c2, :read_only=>true
-    @c2.instance_methods.collect{|x| x.to_s}.must_include('parent')
-    @c2.instance_methods.collect{|x| x.to_s}.wont_include('parent=')
+    @c2.instance_methods.must_include(:parent)
+    @c2.instance_methods.wont_include(:parent=)
   end
 
   it "should not add associations methods directly to class" do
     @c2.many_to_one :parent, :class => @c2
-    @c2.instance_methods.collect{|x| x.to_s}.must_include('parent')
-    @c2.instance_methods.collect{|x| x.to_s}.must_include('parent=')
-    @c2.instance_methods(false).collect{|x| x.to_s}.wont_include('parent')
-    @c2.instance_methods(false).collect{|x| x.to_s}.wont_include('parent=')
+    @c2.instance_methods.must_include(:parent)
+    @c2.instance_methods.must_include(:parent=)
+    @c2.instance_methods(false).wont_include(:parent)
+    @c2.instance_methods(false).wont_include(:parent=)
   end
 
   it "should add associations methods to the :methods_module option" do
     m = Module.new
     @c2.many_to_one :parent, :class => @c2, :methods_module=>m
-    m.instance_methods.collect{|x| x.to_s}.must_include('parent')
-    m.instance_methods.collect{|x| x.to_s}.must_include('parent=')
-    @c2.instance_methods.collect{|x| x.to_s}.wont_include('parent')
-    @c2.instance_methods.collect{|x| x.to_s}.wont_include('parent=')
+    m.instance_methods.must_include(:parent)
+    m.instance_methods.must_include(:parent=)
+    @c2.instance_methods.wont_include(:parent)
+    @c2.instance_methods.wont_include(:parent=)
   end
 
   it "should add associations methods directly to class if :methods_module is the class itself" do
     @c2.many_to_one :parent, :class => @c2, :methods_module=>@c2
-    @c2.instance_methods(false).collect{|x| x.to_s}.must_include('parent')
-    @c2.instance_methods(false).collect{|x| x.to_s}.must_include('parent=')
+    @c2.instance_methods(false).must_include(:parent)
+    @c2.instance_methods(false).must_include(:parent=)
   end
 
   it "should raise an error if trying to set a model object that doesn't have a valid primary key" do
@@ -607,7 +601,7 @@ describe Sequel::Model, "many_to_one" do
 
   it "should make the change to the foreign_key value inside a _association= method" do
     @c2.many_to_one :parent, :class => @c2
-    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_parent=")
+    @c2.private_instance_methods.must_include(:_parent=)
     p = @c2.new
     c = @c2.load(:id=>123)
     def p._parent=(x)
@@ -679,21 +673,6 @@ describe Sequel::Model, "many_to_one" do
     p.associations[:parent].must_equal :foo
   end
 
-  deprecated "should raise error and not call internal add or remove method if before callback returns false, even if raise_on_save_failure is false" do
-    p = @c2.new
-    c = @c2.load(:id=>123)
-    p.raise_on_save_failure = false
-    @c2.many_to_one :parent, :class => @c2, :before_set=>:bs
-    def p.bs(x) false end
-    def p._parent=; raise; end
-    proc{p.parent = c}.must_raise(Sequel::HookFailed)
-    
-    p.parent.must_be_nil
-    p.associations[:parent] = c
-    p.parent.must_equal c
-    proc{p.parent = nil}.must_raise(Sequel::HookFailed)
-  end
-
   it "should raise error and not call internal add or remove method if before callback calls cancel_action, even if raise_on_save_failure is false" do
     p = @c2.new
     c = @c2.load(:id=>123)
@@ -751,9 +730,9 @@ describe Sequel::Model, "one_to_one" do
 
   it "should not add a setter method if the :read_only option is true" do
     @c2.one_to_one :attribute, :class => @c1, :read_only=>true
-    im = @c2.instance_methods.collect{|x| x.to_s}
-    im.must_include('attribute')
-    im.wont_include('attribute=')
+    im = @c2.instance_methods
+    im.must_include(:attribute)
+    im.wont_include(:attribute=)
   end
 
   it "should add a setter method" do
@@ -761,10 +740,9 @@ describe Sequel::Model, "one_to_one" do
     attrib = @c1.new(:id=>3)
     @c1.dataset = @c1.dataset.with_fetch(:id=>3)
     @c2.new(:id => 1234).attribute = attrib
-    sqls = DB.sqls
-    ['INSERT INTO attributes (node_id, id) VALUES (1234, 3)',
-      'INSERT INTO attributes (id, node_id) VALUES (3, 1234)'].must_include(sqls.slice! 1)
-    sqls.must_equal ['UPDATE attributes SET node_id = NULL WHERE (node_id = 1234)', "SELECT * FROM attributes WHERE id = 3"]
+    DB.sqls.must_equal ['UPDATE attributes SET node_id = NULL WHERE (node_id = 1234)',
+      'INSERT INTO attributes (id, node_id) VALUES (3, 1234)',
+      "SELECT * FROM attributes WHERE id = 3"]
 
     @c2.new(:id => 1234).attribute.must_equal attrib
     attrib = @c1.load(:id=>3)
@@ -800,10 +778,9 @@ describe Sequel::Model, "one_to_one" do
     attrib = @c1.new(:id=>3)
     @c1.dataset = @c1.dataset.with_fetch(:id=>3)
     @c2.new(:id => 1234, :xxx=>5).attribute = attrib
-    sqls = DB.sqls
-    ['INSERT INTO attributes (node_id, id) VALUES (5, 3)',
-      'INSERT INTO attributes (id, node_id) VALUES (3, 5)'].must_include(sqls.slice! 1)
-    sqls.must_equal ['UPDATE attributes SET node_id = NULL WHERE (node_id = 5)', "SELECT * FROM attributes WHERE id = 3"]
+    DB.sqls.must_equal ['UPDATE attributes SET node_id = NULL WHERE (node_id = 5)',
+      'INSERT INTO attributes (id, node_id) VALUES (3, 5)',
+      "SELECT * FROM attributes WHERE id = 3"]
 
     @c2.new(:id => 321, :xxx=>5).attribute.must_equal attrib
     attrib = @c1.load(:id=>3)
@@ -818,10 +795,8 @@ describe Sequel::Model, "one_to_one" do
     attrib = @c1.load(:id=>3, :y=>6)
     @c1.dataset = @c1.dataset.with_fetch(:id=>3, :y=>6)
     @c2.load(:id => 1234, :x=>5).attribute = attrib
-    sqls = DB.sqls
-    sqls.last.must_match(/UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 3\)/)
-    sqls.first.must_match(/UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(\(node_id = 1234\) AND \(y = 5\) AND \(id != 3\)\)/)
-    sqls.length.must_equal 2
+    DB.sqls.must_equal ["UPDATE attributes SET node_id = NULL, y = NULL WHERE ((node_id = 1234) AND (y = 5) AND (id != 3))",
+      "UPDATE attributes SET y = 5, node_id = 1234 WHERE (id = 3)"]
   end
 
   it "should use implicit key if omitted" do
@@ -946,10 +921,9 @@ describe Sequel::Model, "one_to_one" do
     @c2.dataset = @c2.dataset.with_fetch(:id => 4321, :blah => 3)
     d.parent = e
     e.values.must_equal(:id => 4321, :blah => 3)
-    sqls = DB.sqls
-    ["INSERT INTO nodes (blah, id) VALUES (3, 4321)",
-     "INSERT INTO nodes (id, blah) VALUES (4321, 3)"].must_include(sqls.slice! 1)
-    sqls.must_equal ["UPDATE nodes SET blah = NULL WHERE (blah = 3)", "SELECT * FROM nodes WHERE id = 4321"]
+    DB.sqls.must_equal ["UPDATE nodes SET blah = NULL WHERE (blah = 3)",
+      "INSERT INTO nodes (id, blah) VALUES (4321, 3)",
+      "SELECT * FROM nodes WHERE id = 4321"]
   end
   
   it "should persist changes to associated object when the setter is called" do
@@ -999,10 +973,6 @@ describe Sequel::Model, "one_to_one" do
     d.associations[:parent] = [42]
     d.parent(:reload=>true).wont_equal 42 
     DB.sqls.must_equal ["SELECT * FROM nodes WHERE (nodes.node_id = 1) LIMIT 1"]
-    deprecated do
-      d.parent(true).wont_equal 42 
-      DB.sqls.must_equal ["SELECT * FROM nodes WHERE (nodes.node_id = 1) LIMIT 1"]
-    end
   end
   
   it "should have the setter set the reciprocal many_to_one cached association" do
@@ -1054,10 +1024,10 @@ describe Sequel::Model, "one_to_one" do
 
   it "should not add associations methods directly to class" do
     @c2.one_to_one :parent, :class => @c2
-    @c2.instance_methods.collect{|x| x.to_s}.must_include('parent')
-    @c2.instance_methods.collect{|x| x.to_s}.must_include('parent=')
-    @c2.instance_methods(false).collect{|x| x.to_s}.wont_include('parent')
-    @c2.instance_methods(false).collect{|x| x.to_s}.wont_include('parent=')
+    @c2.instance_methods.must_include(:parent)
+    @c2.instance_methods.must_include(:parent=)
+    @c2.instance_methods(false).wont_include(:parent)
+    @c2.instance_methods(false).wont_include(:parent=)
   end
 
   it "should raise an error if the current model object that doesn't have a valid primary key" do
@@ -1069,7 +1039,7 @@ describe Sequel::Model, "one_to_one" do
 
   it "should make the change to the foreign_key value inside a _association= method" do
     @c2.one_to_one :parent, :class => @c2
-    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_parent=")
+    @c2.private_instance_methods.must_include(:_parent=)
     c = @c2.new
     p = @c2.load(:id=>123)
     def p._parent=(x)
@@ -1126,21 +1096,6 @@ describe Sequel::Model, "one_to_one" do
     parent.pk.must_equal 20
   end
 
-  deprecated "should raise error and not call internal add or remove method if before callback returns false, even if raise_on_save_failure is false" do
-    p = @c2.load(:id=>321)
-    c = @c2.load(:id=>123)
-    p.raise_on_save_failure = false
-    @c2.one_to_one :parent, :class => @c2, :before_set=>:bs
-    def p.bs(x) false end
-    def p._parent=; raise; end
-    proc{p.parent = c}.must_raise(Sequel::HookFailed)
-    
-    p.associations[:parent].must_be_nil
-    p.associations[:parent] = c
-    p.parent.must_equal c
-    proc{p.parent = nil}.must_raise(Sequel::HookFailed)
-  end
-
   it "should raise error and not call internal add or remove method if before callback calls cancel_action, even if raise_on_save_failure is false" do
     p = @c2.load(:id=>321)
     c = @c2.load(:id=>123)
@@ -1253,15 +1208,6 @@ describe Sequel::Model, "one_to_many" do
     DB.sqls.must_equal ["SELECT * FROM attributes WHERE ((attributes.nodeid = 1234) AND (name > 'M'))"]
   end
   
-  deprecated "should use a callback if given one as the argument" do
-    @c2.one_to_many :attributes, :class => @c1, :key => :nodeid
-    
-    d = @c2.load(:id => 1234)
-    d.associations[:attributes] = []
-    d.attributes(proc{|ds| ds.filter{name > 'M'}}).wont_equal []
-    DB.sqls.must_equal ["SELECT * FROM attributes WHERE ((attributes.nodeid = 1234) AND (name > 'M'))"]
-  end
-  
   it "should use explicit key if given" do
     @c2.one_to_many :attributes, :class => @c1, :key => :nodeid
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT * FROM attributes WHERE (attributes.nodeid = 1234)'
@@ -1303,9 +1249,8 @@ describe Sequel::Model, "one_to_many" do
     a = @c1.new(:id => 234)
     @c1.dataset = @c1.dataset.with_fetch(:id=>234, :node_id=>1234)
     a.must_equal n.add_attribute(a)
-    sqls = DB.sqls
-    sqls.shift.must_match(/INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/)
-    sqls.must_equal ["SELECT * FROM attributes WHERE id = 234"]
+    DB.sqls.must_equal ["INSERT INTO attributes (id, node_id) VALUES (234, 1234)",
+      "SELECT * FROM attributes WHERE id = 234"]
     a.values.must_equal(:node_id => 1234, :id => 234)
   end
 
@@ -1335,9 +1280,8 @@ describe Sequel::Model, "one_to_many" do
     DB.reset
     @c1.dataset = @c1.dataset.with_fetch(:node_id => 1234, :id => 234)
     n.add_attribute(:id => 234).must_equal @c1.load(:node_id => 1234, :id => 234)
-    sqls = DB.sqls
-    sqls.shift.must_match(/INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/)
-    sqls.must_equal ["SELECT * FROM attributes WHERE id = 234"]
+    DB.sqls.must_equal ["INSERT INTO attributes (id, node_id) VALUES (234, 1234)",
+      "SELECT * FROM attributes WHERE id = 234"]
   end
 
   it "should accept a primary key for the add_ method" do
@@ -1403,9 +1347,7 @@ describe Sequel::Model, "one_to_many" do
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345)
     n.add_attribute(a).must_equal a
-    sqls = DB.sqls
-    sqls.shift.must_match(/UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 2345\)/)
-    sqls.must_equal []
+    DB.sqls.must_equal ["UPDATE attributes SET node_id = 1234, y = 5 WHERE (id = 2345)"]
   end
 
   it "should have add_ method accept a composite key" do
@@ -1416,10 +1358,8 @@ describe Sequel::Model, "one_to_many" do
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345, :z => 8, :node_id => 1234, :y=>5)
     n.add_attribute([2345, 8]).must_equal a
-    sqls = DB.sqls
-    sqls.shift.must_match(/SELECT \* FROM attributes WHERE \(\((id|z) = (2345|8)\) AND \((id|z) = (2345|8)\)\) LIMIT 1/)
-    sqls.shift.must_match(/UPDATE attributes SET (node_id|y) = (1234|5), (node_id|y) = (1234|5) WHERE \(\((id|z) = (2345|8)\) AND \((id|z) = (2345|8)\)\)/)
-    sqls.must_equal []
+    DB.sqls.must_equal ["SELECT * FROM attributes WHERE ((id = 2345) AND (z = 8)) LIMIT 1",
+      "UPDATE attributes SET node_id = 1234, y = 5 WHERE ((id = 2345) AND (z = 8))"]
   end
   
   it "should have remove_ method respect composite keys" do
@@ -1428,9 +1368,8 @@ describe Sequel::Model, "one_to_many" do
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345, :node_id=>1234, :y=>5)
     n.remove_attribute(a).must_equal a
-    sqls = DB.sqls
-    sqls.pop.must_match(/UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(id = 2345\)/)
-    sqls.must_equal ["SELECT 1 AS one FROM attributes WHERE ((attributes.node_id = 1234) AND (attributes.y = 5) AND (id = 2345)) LIMIT 1"]
+    DB.sqls.must_equal ["SELECT 1 AS one FROM attributes WHERE ((attributes.node_id = 1234) AND (attributes.y = 5) AND (id = 2345)) LIMIT 1",
+      "UPDATE attributes SET node_id = NULL, y = NULL WHERE (id = 2345)"]
   end
   
   it "should accept a array of composite primary key values for the remove_ method and remove an existing record" do
@@ -1439,10 +1378,8 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1, :key=>:node_id, :primary_key=>:id
     n = @c2.new(:id => 123)
     n.remove_attribute([234, 5]).must_equal @c1.load(:node_id => nil, :y => 5, :id => 234)
-    sqls = DB.sqls
-    sqls.length.must_equal 2
-    sqls.first.must_match(/SELECT \* FROM attributes WHERE \(\(attributes.node_id = 123\) AND \(attributes\.(id|y) = (234|5)\) AND \(attributes\.(id|y) = (234|5)\)\) LIMIT 1/)
-    sqls.last.must_match(/UPDATE attributes SET node_id = NULL WHERE \(\((id|y) = (234|5)\) AND \((id|y) = (234|5)\)\)/)
+    DB.sqls.must_equal ["SELECT * FROM attributes WHERE ((attributes.node_id = 123) AND (attributes.id = 234) AND (attributes.y = 5)) LIMIT 1",
+      "UPDATE attributes SET node_id = NULL WHERE ((id = 234) AND (y = 5))"]
   end
   
   it "should raise an error in add_ and remove_ if the passed object returns false to save (is not valid)" do
@@ -1584,10 +1521,6 @@ describe Sequel::Model, "one_to_many" do
     n.associations[:attributes] = 42
     n.attributes(:reload=>true).wont_equal 42
     DB.sqls.must_equal ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
-    deprecated do
-      n.attributes(true).wont_equal 42
-      DB.sqls.must_equal ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
-    end
   end
 
   it "should add item to cache if it exists when calling add_" do
@@ -1635,28 +1568,28 @@ describe Sequel::Model, "one_to_many" do
 
   it "should not create the add_, remove_, or remove_all_ methods if :read_only option is used" do
     @c2.one_to_many :attributes, :class => @c1, :read_only=>true
-    im = @c2.instance_methods.collect{|x| x.to_s}
-    im.must_include('attributes')
-    im.must_include('attributes_dataset')
-    im.wont_include('add_attribute')
-    im.wont_include('remove_attribute')
-    im.wont_include('remove_all_attributes')
+    im = @c2.instance_methods
+    im.must_include(:attributes)
+    im.must_include(:attributes_dataset)
+    im.wont_include(:add_attribute)
+    im.wont_include(:remove_attribute)
+    im.wont_include(:remove_all_attributes)
   end
 
   it "should not add associations methods directly to class" do
     @c2.one_to_many :attributes, :class => @c1
-    im = @c2.instance_methods.collect{|x| x.to_s}
-    im.must_include('attributes')
-    im.must_include('attributes_dataset')
-    im.must_include('add_attribute')
-    im.must_include('remove_attribute')
-    im.must_include('remove_all_attributes')
-    im2 = @c2.instance_methods(false).collect{|x| x.to_s}
-    im2.wont_include('attributes')
-    im2.wont_include('attributes_dataset')
-    im2.wont_include('add_attribute')
-    im2.wont_include('remove_attribute')
-    im2.wont_include('remove_all_attributes')
+    im = @c2.instance_methods
+    im.must_include(:attributes)
+    im.must_include(:attributes_dataset)
+    im.must_include(:add_attribute)
+    im.must_include(:remove_attribute)
+    im.must_include(:remove_all_attributes)
+    im2 = @c2.instance_methods(false)
+    im2.wont_include(:attributes)
+    im2.wont_include(:attributes_dataset)
+    im2.wont_include(:add_attribute)
+    im2.wont_include(:remove_attribute)
+    im2.wont_include(:remove_all_attributes)
   end
 
   it "should populate the reciprocal many_to_one cache when loading the one_to_many association" do
@@ -1705,9 +1638,7 @@ describe Sequel::Model, "one_to_many" do
   it "should have the remove_all_ method respect composite keys" do
     @c2.one_to_many :attributes, :class => @c1, :key=>[:node_id, :y], :primary_key=>[:id, :x]
     @c2.new(:id => 1234, :x=>5).remove_all_attributes
-    sqls = DB.sqls
-    sqls.pop.must_match(/UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(\(node_id = 1234\) AND \(y = 5\)\)/)
-    sqls.must_equal []
+    DB.sqls.must_equal ["UPDATE attributes SET node_id = NULL, y = NULL WHERE ((node_id = 1234) AND (y = 5))"]
   end
 
   it "remove_all should set the cache to []" do
@@ -1750,7 +1681,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should call an _add_ method internally to add attributes" do
     @c2.one_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_add_attribute")
+    @c2.private_instance_methods.must_include(:_add_attribute)
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
     def p._add_attribute(x)
@@ -1786,7 +1717,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should call a _remove_ method internally to remove attributes" do
     @c2.one_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_remove_attribute")
+    @c2.private_instance_methods.must_include(:_remove_attribute)
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
     def p._remove_attribute(x)
@@ -1834,7 +1765,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should call a _remove_all_ method internally to remove attributes" do
     @c2.one_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_remove_all_attributes")
+    @c2.private_instance_methods.must_include(:_remove_all_attributes)
     p = @c2.load(:id=>10)
     def p._remove_all_attributes
       @x = :foo
@@ -1893,39 +1824,6 @@ describe Sequel::Model, "one_to_many" do
     attributes.collect{|a| a.pk}.must_equal [20, 30]
   end
 
-  deprecated "should raise error and not call internal add or remove method if before callback returns false if raise_on_save_failure is true" do
-    p = @c2.load(:id=>10)
-    c = @c1.load(:id=>123)
-    @c2.one_to_many :attributes, :class => @c1, :before_add=>:ba, :before_remove=>:br
-    def p.ba(c) false end
-    def p._add_attribute; raise; end
-    def p._remove_attribute; raise; end
-    p.associations[:attributes] = []
-    proc{p.add_attribute(c)}.must_raise(Sequel::HookFailed)
-    p.attributes.must_equal []
-    p.associations[:attributes] = [c]
-    def p.br(c) false end
-    proc{p.remove_attribute(c)}.must_raise(Sequel::HookFailed)
-    p.attributes.must_equal [c]
-  end
-
-  deprecated "should return nil and not call internal add or remove method if before callback returns false if raise_on_save_failure is false" do
-    p = @c2.load(:id=>10)
-    c = @c1.load(:id=>123)
-    p.raise_on_save_failure = false
-    @c2.one_to_many :attributes, :class => @c1, :before_add=>:ba, :before_remove=>:br
-    def p.ba(c) false end
-    def p._add_attribute; raise; end
-    def p._remove_attribute; raise; end
-    p.associations[:attributes] = []
-    p.add_attribute(c).must_be_nil
-    p.attributes.must_equal []
-    p.associations[:attributes] = [c]
-    def p.br(c) false end
-    p.remove_attribute(c).must_be_nil
-    p.attributes.must_equal [c]
-  end
-
   it "should raise error and not call internal add or remove method if before callback calls cancel_action if raise_on_save_failure is true" do
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
@@ -2066,11 +1964,6 @@ describe Sequel::Model, "many_to_many" do
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)'
   end
   
-  deprecated "should respect :eager_loading_predicate_key when lazily loading" do
-    @c2.many_to_many :attributes, :class => @c1, :eager_loading_predicate_key=>Sequel.subscript(Sequel[:attributes_nodes][:node_id], 0)
-    @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id[0] = 1234)'
-  end
-  
   it "should respect :predicate_key when lazily loading" do
     @c2.many_to_many :attributes, :class => @c1, :predicate_key=>Sequel.subscript(Sequel[:attributes_nodes][:node_id], 0)
     @c2.new(:id => 1234).attributes_dataset.sql.must_equal 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id[0] = 1234)'
@@ -2206,12 +2099,9 @@ describe Sequel::Model, "many_to_many" do
     a.must_equal n.add_attribute(a)
     a.must_equal n.remove_attribute(a)
     n.remove_all_attributes
-    sqls = DB.sqls
-    ['INSERT INTO attribute2node (node_id, attribute_id) VALUES (1234, 2345)',
-     'INSERT INTO attribute2node (attribute_id, node_id) VALUES (2345, 1234)'].must_include(sqls.shift)
-    ["DELETE FROM attribute2node WHERE ((node_id = 1234) AND (attribute_id = 2345))", 
-     "DELETE FROM attribute2node WHERE ((attribute_id = 2345) AND (node_id = 1234))"].must_include(sqls.shift)
-    sqls.must_equal ["DELETE FROM attribute2node WHERE (node_id = 1234)"]
+    DB.sqls.must_equal ["INSERT INTO attribute2node (node_id, attribute_id) VALUES (1234, 2345)",
+      "DELETE FROM attribute2node WHERE ((node_id = 1234) AND (attribute_id = 2345))",
+      "DELETE FROM attribute2node WHERE (node_id = 1234)"]
   end
   
   with_symbol_splitting "should handle an aliased symbol join table" do
@@ -2222,12 +2112,9 @@ describe Sequel::Model, "many_to_many" do
     a.must_equal n.add_attribute(a)
     a.must_equal n.remove_attribute(a)
     n.remove_all_attributes
-    sqls = DB.sqls
-    ['INSERT INTO attribute2node (node_id, attribute_id) VALUES (1234, 2345)',
-     'INSERT INTO attribute2node (attribute_id, node_id) VALUES (2345, 1234)'].must_include(sqls.shift)
-    ["DELETE FROM attribute2node WHERE ((node_id = 1234) AND (attribute_id = 2345))", 
-     "DELETE FROM attribute2node WHERE ((attribute_id = 2345) AND (node_id = 1234))"].must_include(sqls.shift)
-    sqls.must_equal ["DELETE FROM attribute2node WHERE (node_id = 1234)"]
+    DB.sqls.must_equal ["INSERT INTO attribute2node (node_id, attribute_id) VALUES (1234, 2345)",
+      "DELETE FROM attribute2node WHERE ((node_id = 1234) AND (attribute_id = 2345))",
+      "DELETE FROM attribute2node WHERE (node_id = 1234)"]
   end
   
   it "should define an add_ method that works on existing records" do
@@ -2236,10 +2123,7 @@ describe Sequel::Model, "many_to_many" do
     n = @c2.load(:id => 1234)
     a = @c1.load(:id => 2345)
     n.add_attribute(a).must_equal a
-    sqls = DB.sqls
-    ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 2345)',
-     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (2345, 1234)'].must_include(sqls.shift)
-    sqls.must_equal []
+    DB.sqls.must_equal ["INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 2345)"]
   end
 
   it "should define an add_ method that works with a primary key" do
@@ -2249,10 +2133,8 @@ describe Sequel::Model, "many_to_many" do
     a = @c1.load(:id => 2345)
     @c1.dataset = @c1.dataset.with_fetch(:id=>2345)
     n.add_attribute(2345).must_equal a
-    sqls = DB.sqls
-    ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 2345)',
-     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (2345, 1234)'].must_include(sqls.pop)
-    sqls.must_equal ["SELECT * FROM attributes WHERE id = 2345"]
+    DB.sqls.must_equal ["SELECT * FROM attributes WHERE id = 2345",
+      "INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 2345)"]
   end
 
   it "should raise an error if the primary key passed to the add_ method does not match an existing record" do
@@ -2270,11 +2152,9 @@ describe Sequel::Model, "many_to_many" do
     n = @c2.load(:id => 1234)
     @c1.dataset = @c1.dataset.with_fetch(:id=>1)
     n.add_attribute(:id => 1).must_equal @c1.load(:id => 1)
-    sqls = DB.sqls
-    ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 1)',
-     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (1, 1234)'
-    ].must_include(sqls.pop)
-    sqls.must_equal ['INSERT INTO attributes (id) VALUES (1)', "SELECT * FROM attributes WHERE id = 1"]
+    DB.sqls.must_equal ['INSERT INTO attributes (id) VALUES (1)',
+      "SELECT * FROM attributes WHERE id = 1",
+      "INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 1)"]
   end
 
   it "should define a remove_ method that works on existing records" do
@@ -2311,11 +2191,7 @@ describe Sequel::Model, "many_to_many" do
     n = @c2.load(:id => 1234).set(:xxx=>5)
     a = @c1.load(:id => 2345).set(:yyy=>8)
     n.add_attribute(a).must_equal a
-    sqls = DB.sqls
-    ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (5, 8)',
-     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (8, 5)'
-    ].must_include(sqls.pop)
-    sqls.must_equal []
+    DB.sqls.must_equal ["INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (5, 8)"]
   end
   
   it "should have add_ method not add the same object to the cached association array if the object is already in the array" do
@@ -2358,10 +2234,8 @@ describe Sequel::Model, "many_to_many" do
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345, :z=>8)
     n.add_attribute([2345, 8]).must_equal a
-    sqls = DB.sqls
-    sqls.shift.must_match(/SELECT \* FROM attributes WHERE \(\((id|z) = (8|2345)\) AND \((id|z) = (8|2345)\)\) LIMIT 1/)
-    sqls.pop.must_match(/INSERT INTO attributes_nodes \([lr][12], [lr][12], [lr][12], [lr][12]\) VALUES \((1234|5|2345|8), (1234|5|2345|8), (1234|5|2345|8), (1234|5|2345|8)\)/)
-    sqls.must_equal []
+    DB.sqls.must_equal ["SELECT * FROM attributes WHERE ((id = 2345) AND (z = 8)) LIMIT 1",
+      "INSERT INTO attributes_nodes (l1, l2, r1, r2) VALUES (1234, 5, 2345, 8)"]
   end
 
   it "should have the remove_ method respect the :left_primary_key and :right_primary_key options" do
@@ -2387,10 +2261,8 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
     @c1.load(:id => 234, :y=>8).must_equal n.remove_attribute([234, 8])
-    sqls = DB.sqls
-    ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (attributes.id = 234) AND (attributes.y = 8)) LIMIT 1",
-      "SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (attributes.y = 8) AND (attributes.id = 234)) LIMIT 1"].must_include(sqls.shift)
-    sqls.must_equal ["DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 234))"]
+    DB.sqls.must_equal ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (attributes.id = 234) AND (attributes.y = 8)) LIMIT 1",
+      "DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 234))"]
   end
     
   it "should raise an error if the model object doesn't have a valid primary key" do
@@ -2479,10 +2351,6 @@ describe Sequel::Model, "many_to_many" do
     n.associations[:attributes] = 42
     n.attributes(:reload=>true).wont_equal 42
     DB.sqls.must_equal ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)"]
-    deprecated do
-      n.attributes(true).wont_equal 42
-      DB.sqls.must_equal ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234)"]
-    end
   end
 
   it "should add item to cache if it exists when calling add_" do
@@ -2531,28 +2399,28 @@ describe Sequel::Model, "many_to_many" do
 
   it "should not create the add_, remove_, or remove_all_ methods if :read_only option is used" do
     @c2.many_to_many :attributes, :class => @c1, :read_only=>true
-    im = @c2.instance_methods.collect{|x| x.to_s}
-    im.must_include('attributes')
-    im.must_include('attributes_dataset')
-    im.wont_include('add_attribute')
-    im.wont_include('remove_attribute')
-    im.wont_include('remove_all_attributes')
+    im = @c2.instance_methods
+    im.must_include(:attributes)
+    im.must_include(:attributes_dataset)
+    im.wont_include(:add_attribute)
+    im.wont_include(:remove_attribute)
+    im.wont_include(:remove_all_attributes)
   end
 
   it "should not add associations methods directly to class" do
     @c2.many_to_many :attributes, :class => @c1
-    im = @c2.instance_methods.collect{|x| x.to_s}
-    im.must_include('attributes')
-    im.must_include('attributes_dataset')
-    im.must_include('add_attribute')
-    im.must_include('remove_attribute')
-    im.must_include('remove_all_attributes')
-    im2 = @c2.instance_methods(false).collect{|x| x.to_s}
-    im2.wont_include('attributes')
-    im2.wont_include('attributes_dataset')
-    im2.wont_include('add_attribute')
-    im2.wont_include('remove_attribute')
-    im2.wont_include('remove_all_attributes')
+    im = @c2.instance_methods
+    im.must_include(:attributes)
+    im.must_include(:attributes_dataset)
+    im.must_include(:add_attribute)
+    im.must_include(:remove_attribute)
+    im.must_include(:remove_all_attributes)
+    im2 = @c2.instance_methods(false)
+    im2.wont_include(:attributes)
+    im2.wont_include(:attributes_dataset)
+    im2.wont_include(:add_attribute)
+    im2.wont_include(:remove_attribute)
+    im2.wont_include(:remove_all_attributes)
   end
 
   it "should have an remove_all_ method that removes all associations" do
@@ -2625,7 +2493,7 @@ describe Sequel::Model, "many_to_many" do
 
   it "should call an _add_ method internally to add attributes" do
     @c2.many_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_add_attribute")
+    @c2.private_instance_methods.must_include(:_add_attribute)
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
     def p._add_attribute(x)
@@ -2660,7 +2528,7 @@ describe Sequel::Model, "many_to_many" do
 
   it "should call a _remove_ method internally to remove attributes" do
     @c2.many_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_remove_attribute")
+    @c2.private_instance_methods.must_include(:_remove_attribute)
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
     def p._remove_attribute(x)
@@ -2705,7 +2573,7 @@ describe Sequel::Model, "many_to_many" do
 
   it "should call a _remove_all_ method internally to remove attributes" do
     @c2.many_to_many :attributes, :class => @c1
-    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_remove_all_attributes")
+    @c2.private_instance_methods.must_include(:_remove_all_attributes)
     p = @c2.load(:id=>10)
     def p._remove_all_attributes
       @x = :foo
@@ -2766,40 +2634,6 @@ describe Sequel::Model, "many_to_many" do
     attributes.collect{|a| a.pk}.must_equal [20, 30]
   end
 
-  deprecated "should raise error and not call internal add or remove method if before callback returns false if raise_on_save_failure is true" do
-    p = @c2.load(:id=>10)
-    c = @c1.load(:id=>123)
-    @c2.many_to_many :attributes, :class => @c1, :before_add=>:ba, :before_remove=>:br
-    def p.ba(c) false end
-    def p._add_attribute; raise; end
-    def p._remove_attribute; raise; end
-    p.associations[:attributes] = []
-    p.raise_on_save_failure = true
-    proc{p.add_attribute(c)}.must_raise(Sequel::HookFailed)
-    p.attributes.must_equal []
-    p.associations[:attributes] = [c]
-    def p.br(c) false end
-    proc{p.remove_attribute(c)}.must_raise(Sequel::HookFailed)
-    p.attributes.must_equal [c]
-  end
-
-  deprecated "should return nil and not call internal add or remove method if before callback returns false if raise_on_save_failure is false" do
-    p = @c2.load(:id=>10)
-    c = @c1.load(:id=>123)
-    p.raise_on_save_failure = false
-    @c2.many_to_many :attributes, :class => @c1, :before_add=>:ba, :before_remove=>:br
-    def p.ba(c) false end
-    def p._add_attribute; raise; end
-    def p._remove_attribute; raise; end
-    p.associations[:attributes] = []
-    p.add_attribute(c).must_be_nil
-    p.attributes.must_equal []
-    p.associations[:attributes] = [c]
-    def p.br(c) false end
-    p.remove_attribute(c).must_be_nil
-    p.attributes.must_equal [c]
-  end
-
   it "should raise error and not call internal add or remove method if before callback calls cancel_action if raise_on_save_failure is true" do
     p = @c2.load(:id=>10)
     c = @c1.load(:id=>123)
@@ -3077,20 +2911,16 @@ describe Sequel::Model, "one_through_one" do
     n.associations[:attribute] = 42
     n.attribute(:reload=>true).wont_equal 42
     DB.sqls.must_equal ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1"]
-    deprecated do
-      n.attribute(true).wont_equal 42
-      DB.sqls.must_equal ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE (attributes_nodes.node_id = 1234) LIMIT 1"]
-    end
   end
 
   it "should not add associations methods directly to class" do
     @c2.one_through_one :attribute, :class => @c1
-    im = @c2.instance_methods.collect{|x| x.to_s}
-    im.must_include('attribute')
-    im.must_include('attribute_dataset')
-    im2 = @c2.instance_methods(false).collect{|x| x.to_s}
-    im2.wont_include('attribute')
-    im2.wont_include('attribute_dataset')
+    im = @c2.instance_methods
+    im.must_include(:attribute)
+    im.must_include(:attribute_dataset)
+    im2 = @c2.instance_methods(false)
+    im2.wont_include(:attribute)
+    im2.wont_include(:attribute_dataset)
   end
 
   it "should support after_load association callback" do
@@ -3116,9 +2946,9 @@ describe Sequel::Model, "one_through_one" do
 
   it "should not add a setter method if the :read_only option is true" do
     @c2.one_through_one :attribute, :class => @c1, :read_only=>true
-    im = @c2.instance_methods.collect{|x| x.to_s}
-    im.must_include('attribute')
-    im.wont_include('attribute=')
+    im = @c2.instance_methods
+    im.must_include(:attribute)
+    im.wont_include(:attribute=)
   end
 
   it "should add a setter method" do
@@ -3130,10 +2960,8 @@ describe Sequel::Model, "one_through_one" do
     DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 1234) LIMIT 1"]
 
     o.attribute = attrib
-    sqls = DB.sqls
-    ["INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (3, 1234)",
-      "INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 3)"].must_include(sqls.slice! 1)
-    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 1234) LIMIT 1"]
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 1234) LIMIT 1",
+      "INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (3, 1234)"]
 
     DB.fetch = {:node_id=>1234, :attribute_id=>5}
     o.attribute = nil
@@ -3168,10 +2996,8 @@ describe Sequel::Model, "one_through_one" do
     DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (a AND (node_id = 1234)) LIMIT 1"]
 
     o.attribute = attrib
-    sqls = DB.sqls
-    ["INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (3, 1234)",
-      "INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 3)"].must_include(sqls.slice! 1)
-    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (a AND (node_id = 1234)) LIMIT 1"]
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (a AND (node_id = 1234)) LIMIT 1",
+      "INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (3, 1234)"]
 
     DB.fetch = {:node_id=>1234, :attribute_id=>5}
     o.attribute = nil
@@ -3192,10 +3018,8 @@ describe Sequel::Model, "one_through_one" do
     DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 5) LIMIT 1"]
 
     o.attribute = attrib
-    sqls = DB.sqls
-    ["INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (7, 5)",
-      "INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (5, 7)"].must_include(sqls.slice! 1)
-    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 5) LIMIT 1"]
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE (node_id = 5) LIMIT 1",
+      "INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (7, 5)"]
 
     DB.fetch = {:node_id=>1234, :attribute_id=>9}
     o.attribute = nil
@@ -3217,9 +3041,8 @@ describe Sequel::Model, "one_through_one" do
     DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5)) LIMIT 1"]
 
     o.attribute = attrib
-    sqls = DB.sqls
-    sqls.slice!(1).must_match(/\AINSERT INTO attributes_nodes \((attribute_id|z|node_id|y), (attribute_id|z|node_id|y), (attribute_id|z|node_id|y), (attribute_id|z|node_id|y)\) VALUES \((3|7|1234|5), (3|7|1234|5), (3|7|1234|5), (3|7|1234|5)\)\z/)
-    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5)) LIMIT 1"]
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5)) LIMIT 1",
+      "INSERT INTO attributes_nodes (attribute_id, z, node_id, y) VALUES (3, 7, 1234, 5)"]
 
     DB.fetch = {:node_id=>1234, :attribute_id=>10, :y=>6, :z=>8}
     o.attribute = nil
@@ -3227,10 +3050,8 @@ describe Sequel::Model, "one_through_one" do
       "DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5) AND (attribute_id = 10) AND (z = 8))"]
 
     o.attribute = attrib
-    sqls = DB.sqls
-    ["UPDATE attributes_nodes SET attribute_id = 3, z = 7 WHERE ((node_id = 1234) AND (y = 5) AND (attribute_id = 10) AND (z = 8))",
-     "UPDATE attributes_nodes SET z = 7, attribute_id = 3 WHERE ((node_id = 1234) AND (y = 5) AND (attribute_id = 10) AND (z = 8))"].must_include(sqls.slice!(1))
-    sqls.must_equal ["SELECT * FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5)) LIMIT 1"]
+    DB.sqls.must_equal ["SELECT * FROM attributes_nodes WHERE ((node_id = 1234) AND (y = 5)) LIMIT 1",
+      "UPDATE attributes_nodes SET attribute_id = 3, z = 7 WHERE ((node_id = 1234) AND (y = 5) AND (attribute_id = 10) AND (z = 8))"]
   end
 
   it "should raise an error if the current model object that doesn't have a valid primary key" do
@@ -3249,7 +3070,7 @@ describe Sequel::Model, "one_through_one" do
 
   it "should make the change to the foreign_key value inside a _association= method" do
     @c2.one_through_one :attribute, :class => @c1
-    @c2.private_instance_methods.collect{|x| x.to_s}.sort.must_include("_attribute=")
+    @c2.private_instance_methods.must_include(:_attribute=)
     attrib = @c1.new(:id=>3)
     o = @c2.new(:id => 1234)
     def o._attribute=(x)