sequel 2.1.0 → 2.2.0

data/spec/association_reflection_spec.rb

@@ -76,10 +76,18 @@ describe Sequel::Model::Associations::AssociationReflection, "#select" do
     @c.association_reflection(:c).should include(:select)
     @c.association_reflection(:c).select.should == [:par_parents__id]
   end
-  it "should use the associated_table.* if :select is not present" do
+  it "should be the associated_table.* if :select is not present for a many_to_many associaiton" do
+    @c.many_to_many :cs, :class=>'ParParent'
+    @c.association_reflection(:cs).should_not include(:select)
+    @c.association_reflection(:cs).select.should == :par_parents.*
+  end
+  it "should be if :select is not present for a many_to_one and one_to_many associaiton" do
+    @c.one_to_many :cs, :class=>'ParParent'
+    @c.association_reflection(:cs).should_not include(:select)
+    @c.association_reflection(:cs).select.should == nil
     @c.many_to_one :c, :class=>'ParParent'
     @c.association_reflection(:c).should_not include(:select)
-    @c.association_reflection(:c).select.should == :par_parents.*
+    @c.association_reflection(:c).select.should == nil
   end
 end
 

data/spec/associations_spec.rb

@@ -15,20 +15,40 @@ describe Sequel::Model, "associate" do
     klass.association_reflection(:"par_parent1s").associated_class.should == ParParent
     klass.association_reflection(:"par_parent2s").associated_class.should == ParParent
   end
+  it "should allow extending the dataset with :extend option" do
+    MODEL_DB.reset
+    klass = Class.new(Sequel::Model(:nodes)) do
+      columns :id, :a_id
+    end
+    mod = Module.new do
+      def blah
+       1
+      end
+    end
+    mod2 = Module.new do
+      def blar
+       2
+      end
+    end
+    
+    klass.associate :many_to_one, :a, :class=>klass, :extend=>mod
+    klass.associate :one_to_many, :bs, :class=>klass, :extend=>[mod]
+    klass.associate :many_to_many, :cs, :class=>klass, :extend=>[mod, mod2]
+    
+    node = klass.load(:id=>1)
+    node.a_dataset.blah.should == 1
+    node.bs_dataset.blah.should == 1
+    node.cs_dataset.blah.should == 1
+    node.cs_dataset.blar.should == 2
+  end
 end
 
 describe Sequel::Model, "many_to_one" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
       columns :id, :parent_id, :par_parent_id, :blah
-      def self.create_new(values)
-        obj = self.new(values)
-        obj.instance_variable_set(:@new, false)
-        obj
-      end
     end
 
     @dataset = @c2.dataset
@@ -42,7 +62,7 @@ describe Sequel::Model, "many_to_one" do
     p.class.should == @c2
     p.values.should == {:x => 1, :id => 1}
 
-    MODEL_DB.sqls.should == ["SELECT nodes.* FROM nodes WHERE (id = 234) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"]
   end
   
   it "should use implicit class if omitted" do
@@ -55,7 +75,7 @@ describe Sequel::Model, "many_to_one" do
     p = d.par_parent
     p.class.should == ParParent
     
-    MODEL_DB.sqls.should == ["SELECT par_parents.* FROM par_parents WHERE (id = 234) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT * FROM par_parents WHERE (par_parents.id = 234) LIMIT 1"]
   end
 
   it "should use class inside module if given as a string" do
@@ -70,7 +90,7 @@ describe Sequel::Model, "many_to_one" do
     p = d.par_parent
     p.class.should == Par::Parent
     
-    MODEL_DB.sqls.should == ["SELECT parents.* FROM parents WHERE (id = 234) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT * FROM parents WHERE (parents.id = 234) LIMIT 1"]
   end
 
   it "should use explicit key if given" do
@@ -81,13 +101,22 @@ describe Sequel::Model, "many_to_one" do
     p.class.should == @c2
     p.values.should == {:x => 1, :id => 1}
 
-    MODEL_DB.sqls.should == ["SELECT nodes.* FROM nodes WHERE (id = 567) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 567) LIMIT 1"]
   end
 
   it "should use :select option if given" do
     @c2.many_to_one :parent, :class => @c2, :key => :blah, :select=>[:id, :name]
     @c2.new(:id => 1, :blah => 567).parent
-    MODEL_DB.sqls.should == ["SELECT id, name FROM nodes WHERE (id = 567) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT id, name FROM nodes WHERE (nodes.id = 567) LIMIT 1"]
+  end
+
+  it "should support :order, :limit (only for offset), and :dataset options, as well as a block" do
+    c2 = @c2
+    @c2.many_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{c2.filter(:parent_id=>pk)}, :limit=>[10,20], :order=>:name do |ds|
+      ds.filter(:x > 1)
+    end
+    @c2.load(:id => 100).child_20
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((parent_id = 100) AND (x > 1)) ORDER BY name LIMIT 1 OFFSET 20"]
   end
 
   it "should return nil if key value is nil" do
@@ -107,9 +136,9 @@ describe Sequel::Model, "many_to_one" do
     d = @c2.new(:id => 1, :parent_id=>555)
     MODEL_DB.sqls.should == []
     d.parent.should == nil
-    MODEL_DB.sqls.should == ['SELECT nodes.* FROM nodes WHERE (id = 555) LIMIT 1']
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.id = 555) LIMIT 1']
     d.parent.should == nil
-    MODEL_DB.sqls.should == ['SELECT nodes.* FROM nodes WHERE (id = 555) LIMIT 1']
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.id = 555) LIMIT 1']
   end
 
   it "should define a setter method" do
@@ -130,7 +159,7 @@ describe Sequel::Model, "many_to_one" do
   it "should not persist changes until saved" do
     @c2.many_to_one :parent, :class => @c2
 
-    d = @c2.create_new(:id => 1)
+    d = @c2.load(:id => 1)
     MODEL_DB.reset
     d.parent = @c2.new(:id => 345)
     MODEL_DB.sqls.should == []
@@ -141,14 +170,14 @@ describe Sequel::Model, "many_to_one" do
   it "should set cached instance variable when accessed" do
     @c2.many_to_one :parent, :class => @c2
 
-    d = @c2.create_new(:id => 1)
+    d = @c2.load(:id => 1)
     MODEL_DB.reset
     d.parent_id = 234
     d.associations[:parent].should == nil
     ds = @c2.dataset
     def ds.fetch_rows(sql, &block); MODEL_DB.sqls << sql; yield({:id=>234}) end
     e = d.parent 
-    MODEL_DB.sqls.should == ["SELECT nodes.* FROM nodes WHERE (id = 234) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"]
     d.associations[:parent].should == e
   end
 
@@ -182,7 +211,7 @@ describe Sequel::Model, "many_to_one" do
     d.parent_id = 234
     d.associations[:parent] = 42
     d.parent(true).should_not == 42 
-    MODEL_DB.sqls.should == ["SELECT nodes.* FROM nodes WHERE (id = 234) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"]
   end
   
   it "should have the setter add to the reciprocal one_to_many cached association list if it exists" do
@@ -198,16 +227,16 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == []
     d.parent = e
     e.children.should_not(include(d))
-    MODEL_DB.sqls.should == ['SELECT nodes.* FROM nodes WHERE (parent_id = 2)']
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.parent_id = 2)']
 
     MODEL_DB.reset
     d = @c2.new(:id => 1)
     e = @c2.new(:id => 2)
     e.children.should_not(include(d))
-    MODEL_DB.sqls.should == ['SELECT nodes.* FROM nodes WHERE (parent_id = 2)']
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.parent_id = 2)']
     d.parent = e
     e.children.should(include(d))
-    MODEL_DB.sqls.should == ['SELECT nodes.* FROM nodes WHERE (parent_id = 2)']
+    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.parent_id = 2)']
   end
 
   it "should have the setter remove the object from the previous associated object's reciprocal one_to_many cached association list if it exists" do
@@ -250,16 +279,117 @@ describe Sequel::Model, "many_to_one" do
   it "should have belongs_to alias" do
     @c2.belongs_to :parent, :class => @c2
 
-    d = @c2.create_new(:id => 1)
+    d = @c2.load(:id => 1)
     MODEL_DB.reset
     d.parent_id = 234
     d.associations[:parent].should == nil
     ds = @c2.dataset
     def ds.fetch_rows(sql, &block); MODEL_DB.sqls << sql; yield({:id=>234}) end
     e = d.parent 
-    MODEL_DB.sqls.should == ["SELECT nodes.* FROM nodes WHERE (id = 234) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"]
     d.associations[:parent].should == e
   end
+
+  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.sort.should(include("_parent="))
+    p = @c2.new
+    c = @c2.load(:id=>123)
+    def p._parent=(x)
+      @x = x
+    end
+    p.should_not_receive(:parent_id=)
+    p.parent = c
+    p.instance_variable_get(:@x).should == c
+  end
+
+  it "should support (before|after)_(add|remove) callbacks" do
+    h = []
+    @c2.many_to_one :parent, :class => @c2, :before_add=>[proc{|x,y| h << x.pk; h << -y.pk}, :blah], :after_add=>proc{h << 3}, :before_remove=>:blah, :after_remove=>[:blahr]
+    @c2.class_eval do
+      @@blah = h
+      def []=(a, v)
+        a == :parent_id ? (@@blah << (v ? 4 : 5)) : super
+      end
+      def blah(x)
+        @@blah << x.pk
+      end
+      def blahr(x)
+        @@blah << 6
+      end
+    end
+    p = @c2.load(:id=>10)
+    c = @c2.load(:id=>123)
+    h.should == []
+    p.parent = c
+    h.should == [10, -123, 123, 4, 3]
+    p.parent = nil
+    h.should == [10, -123, 123, 4, 3, 123, 5, 6]
+  end
+
+  it "should support after_load association callback" do
+    h = []
+    @c2.many_to_one :parent, :class => @c2, :after_load=>[proc{|x,y| h << [x.pk, y.pk]}, :al]
+    @c2.class_eval do
+      @@blah = h
+      def al(v)
+        @@blah << v.pk
+      end
+      def @dataset.fetch_rows(sql)
+        yield({:id=>20})
+      end
+    end
+    p = @c2.load(:id=>10, :parent_id=>20)
+    parent = p.parent
+    h.should == [[10, 20], 20]
+    parent.pk.should == 20
+  end
+
+  it "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
+    # The reason for this is that assignment in ruby always returns the argument instead of the result
+    # of the method, so we can't return nil to signal that the association callback prevented the modification
+    p = @c2.new
+    c = @c2.load(:id=>123)
+    p.raise_on_save_failure = false
+    @c2.many_to_one :parent, :class => @c2, :before_add=>:ba, :before_remove=>:br
+    p.should_receive(:ba).once.with(c).and_return(false)
+    p.should_not_receive(:_parent=)
+    proc{p.parent = c}.should raise_error(Sequel::Error)
+    p.parent.should == nil
+    p.associations[:parent] = c
+    p.parent.should == c
+    p.should_receive(:br).once.with(c).and_return(false)
+    proc{p.parent = nil}.should raise_error(Sequel::Error)
+  end
+
+  it "should call the remove callbacks for the previous object and the add callbacks for the new object" do
+    c = @c2.load(:id=>123)
+    d = @c2.load(:id=>321)
+    p = @c2.new
+    p.associations[:parent] = d
+    h = []
+    @c2.many_to_one :parent, :class => @c2, :before_add=>:ba, :before_remove=>:br, :after_add=>:aa, :after_remove=>:ar
+    @c2.class_eval do
+      @@blah = h
+      def []=(a, v)
+        a == :parent_id ? (@@blah << 5) : super
+      end
+      def ba(x)
+        @@blah << x.pk
+      end
+      def br(x)
+        @@blah << x.pk * -1
+      end
+      def aa(x)
+        @@blah << x.pk * 2
+      end
+      def ar(x)
+        @@blah << x.pk * -2
+      end
+    end
+    p.parent = c
+    h.should == [-321, 123, 5, 246, -642]
+  end
 end
 
 describe Sequel::Model, "one_to_many" do
@@ -301,7 +431,7 @@ describe Sequel::Model, "one_to_many" do
     n = @c2.new(:id => 1234)
     a = n.attributes_dataset
     a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.* FROM attributes WHERE (node_id = 1234)'
+    a.sql.should == 'SELECT * FROM attributes WHERE (attributes.node_id = 1234)'
   end
   
   it "should use implicit class if omitted" do
@@ -313,7 +443,7 @@ describe Sequel::Model, "one_to_many" do
     n = @c2.new(:id => 1234)
     v = n.historical_values_dataset
     v.should be_a_kind_of(Sequel::Dataset)
-    v.sql.should == 'SELECT historical_values.* FROM historical_values WHERE (node_id = 1234)'
+    v.sql.should == 'SELECT * FROM historical_values WHERE (historical_values.node_id = 1234)'
     v.model_classes.should == {nil => HistoricalValue}
   end
   
@@ -328,7 +458,7 @@ describe Sequel::Model, "one_to_many" do
     n = @c2.new(:id => 1234)
     v = n.historical_values_dataset
     v.should be_a_kind_of(Sequel::Dataset)
-    v.sql.should == 'SELECT values.* FROM values WHERE (node_id = 1234)'
+    v.sql.should == 'SELECT * FROM values WHERE (values.node_id = 1234)'
     v.model_classes.should == {nil => Historical::Value}
   end
 
@@ -338,7 +468,7 @@ describe Sequel::Model, "one_to_many" do
     n = @c2.new(:id => 1234)
     a = n.attributes_dataset
     a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.* FROM attributes WHERE (nodeid = 1234)'
+    a.sql.should == 'SELECT * FROM attributes WHERE (attributes.nodeid = 1234)'
   end
 
   it "should define an add_ method" do
@@ -387,21 +517,21 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1, :select => [:id, :name]
 
     n = @c2.new(:id => 1234)
-    n.attributes_dataset.sql.should == "SELECT id, name FROM attributes WHERE (node_id = 1234)"
+    n.attributes_dataset.sql.should == "SELECT id, name FROM attributes WHERE (attributes.node_id = 1234)"
   end
   
   it "should support an order option" do
     @c2.one_to_many :attributes, :class => @c1, :order => :kind
 
     n = @c2.new(:id => 1234)
-    n.attributes_dataset.sql.should == "SELECT attributes.* FROM attributes WHERE (node_id = 1234) ORDER BY kind"
+    n.attributes_dataset.sql.should == "SELECT * FROM attributes WHERE (attributes.node_id = 1234) ORDER BY kind"
   end
   
   it "should support an array for the order option" do
     @c2.one_to_many :attributes, :class => @c1, :order => [:kind1, :kind2]
 
     n = @c2.new(:id => 1234)
-    n.attributes_dataset.sql.should == "SELECT attributes.* FROM attributes WHERE (node_id = 1234) ORDER BY kind1, kind2"
+    n.attributes_dataset.sql.should == "SELECT * FROM attributes WHERE (attributes.node_id = 1234) ORDER BY kind1, kind2"
   end
   
   it "should return array with all members of the association" do
@@ -414,7 +544,7 @@ describe Sequel::Model, "one_to_many" do
     atts.first.should be_a_kind_of(@c1)
     atts.first.values.should == {}
     
-    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
   end
   
   it "should accept a block" do
@@ -429,10 +559,10 @@ describe Sequel::Model, "one_to_many" do
     atts.first.should be_a_kind_of(@c1)
     atts.first.values.should == {}
     
-    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE ((node_id = 1234) AND (xxx IS NULL))']
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (xxx IS NULL))']
   end
   
-  it "should support order option with block" do
+  it "should support :order option with block" do
     @c2.one_to_many :attributes, :class => @c1, :order => :kind do |ds|
       ds.filter(:xxx => @xxx)
     end
@@ -444,21 +574,38 @@ describe Sequel::Model, "one_to_many" do
     atts.first.should be_a_kind_of(@c1)
     atts.first.values.should == {}
     
-    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE ((node_id = 1234) AND (xxx IS NULL)) ORDER BY kind']
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (xxx IS NULL)) ORDER BY kind']
   end
   
   it "should have the block argument affect the _dataset method" do
     @c2.one_to_many :attributes, :class => @c1 do |ds|
       ds.filter(:xxx => 456)
     end
-    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes WHERE ((node_id = 1234) AND (xxx = 456))'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (xxx = 456))'
+  end
+  
+  it "should support a :dataset option that is used instead of the default" do
+    c1 = @c1
+    @c2.one_to_many :all_other_attributes, :class => @c1, :dataset=>proc{c1.filter(:nodeid=>pk).invert}, :order=>:a, :limit=>10 do |ds|
+      ds.filter(:xxx => 5)
+    end
+    
+    @c2.new(:id => 1234).all_other_attributes_dataset.sql.should == 'SELECT * FROM attributes WHERE ((nodeid != 1234) AND (xxx = 5)) ORDER BY a LIMIT 10'
+    n = @c2.new(:id => 1234)
+    atts = n.all_other_attributes
+    atts.should be_a_kind_of(Array)
+    atts.size.should == 1
+    atts.first.should be_a_kind_of(@c1)
+    atts.first.values.should == {}
+    
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE ((nodeid != 1234) AND (xxx = 5)) ORDER BY a LIMIT 10']
   end
   
   it "should support a :limit option" do
     @c2.one_to_many :attributes, :class => @c1 , :limit=>10
-    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes WHERE (node_id = 1234) LIMIT 10'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT * FROM attributes WHERE (attributes.node_id = 1234) LIMIT 10'
     @c2.one_to_many :attributes, :class => @c1 , :limit=>[10,10]
-    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes WHERE (node_id = 1234) LIMIT 10 OFFSET 10'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT * FROM attributes WHERE (attributes.node_id = 1234) LIMIT 10 OFFSET 10'
   end
 
   it "should have the :eager option affect the _dataset method" do
@@ -474,7 +621,7 @@ describe Sequel::Model, "one_to_many" do
     n.associations.include?(:attributes).should == false
     atts = n.attributes
     atts.should == n.associations[:attributes]
-    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
   end
 
   it "should use cached instance variable if available" do
@@ -494,7 +641,7 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.reset
     n.associations[:attributes] = 42
     n.attributes(true).should_not == 42
-    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
   end
 
   it "should add item to cached instance variable if it exists when calling add_" do
@@ -563,7 +710,7 @@ describe Sequel::Model, "one_to_many" do
     atts.first.should be_a_kind_of(@c1)
     atts.first.values.should == {}
     
-    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
   end
   
   it "should populate the reciprocal many_to_one instance variable when loading the one_to_many association" do
@@ -572,7 +719,7 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.new(:id => 1234)
     atts = n.attributes
-    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
     atts.should be_a_kind_of(Array)
     atts.size.should == 1
     atts.first.should be_a_kind_of(@c1)
@@ -587,7 +734,7 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.new(:id => 1234)
     atts = n.attributes
-    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
     atts.should be_a_kind_of(Array)
     atts.size.should == 1
     atts.first.should be_a_kind_of(@c1)
@@ -649,7 +796,7 @@ describe Sequel::Model, "one_to_many" do
   it "should add a getter method if the :one_to_one option is true" do
     @c2.one_to_many :attributes, :class => @c1, :one_to_one=>true
     att = @c2.new(:id => 1234).attribute
-    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes WHERE (node_id = 1234)']
+    MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
     att.should be_a_kind_of(@c1)
     att.values.should == {}
   end
@@ -682,8 +829,9 @@ describe Sequel::Model, "one_to_many" do
     MODEL_DB.sqls.clear
     attrib = @c1.load(:id=>3)
     @c2.new(:id => 1234).attribute = attrib
-    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 1234, id = 3 WHERE (id = 3)',
-      'UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))']
+    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id = 1234, id = 3|id = 3, node_id = 1234) WHERE \(id = 3\)/
+    MODEL_DB.sqls.last.should == 'UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))'
   end
 
   it "should raise an error if the one_to_one getter would be the same as the association name" do
@@ -703,6 +851,113 @@ describe Sequel::Model, "one_to_many" do
     meths.should(include("add_attribute"))
     meths.should(include("attributes_dataset"))
   end
+
+  it "should call an _add_ method internally to add attributes" do
+    @c2.one_to_many :attributes, :class => @c1
+    @c2.private_instance_methods.sort.should(include("_add_attribute"))
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    def p._add_attribute(x)
+      @x = x
+    end
+    c.should_not_receive(:node_id=)
+    p.add_attribute(c)
+    p.instance_variable_get(:@x).should == c
+  end
+
+  it "should call a _remove_ method internally to remove attributes" do
+    @c2.one_to_many :attributes, :class => @c1
+    @c2.private_instance_methods.sort.should(include("_remove_attribute"))
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    def p._remove_attribute(x)
+      @x = x
+    end
+    c.should_not_receive(:node_id=)
+    p.remove_attribute(c)
+    p.instance_variable_get(:@x).should == c
+  end
+
+  it "should support (before|after)_(add|remove) callbacks" do
+    h = []
+    @c2.one_to_many :attributes, :class => @c1, :before_add=>[proc{|x,y| h << x.pk; h << -y.pk}, :blah], :after_add=>proc{h << 3}, :before_remove=>:blah, :after_remove=>[:blahr]
+    @c2.class_eval do
+      @@blah = h
+      def _add_attribute(v)
+        @@blah << 4
+      end
+      def _remove_attribute(v)
+        @@blah << 5
+      end
+      def blah(x)
+        @@blah << x.pk
+      end
+      def blahr(x)
+        @@blah << 6
+      end
+    end
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    h.should == []
+    p.add_attribute(c)
+    h.should == [10, -123, 123, 4, 3]
+    p.remove_attribute(c)
+    h.should == [10, -123, 123, 4, 3, 123, 5, 6]
+  end
+
+  it "should support after_load association callback" do
+    h = []
+    @c2.one_to_many :attributes, :class => @c1, :after_load=>[proc{|x,y| h << [x.pk, y.collect{|z|z.pk}]}, :al]
+    @c2.class_eval do
+      @@blah = h
+      def al(v)
+        v.each{|x| @@blah << x.pk}
+      end
+    end
+    @c1.class_eval do
+      def @dataset.fetch_rows(sql)
+        yield({:id=>20})
+        yield({:id=>30})
+      end
+    end
+    p = @c2.load(:id=>10, :parent_id=>20)
+    attributes = p.attributes
+    h.should == [[10, [20, 30]], 20, 30]
+    attributes.collect{|a| a.pk}.should == [20, 30]
+  end
+
+  it "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
+    p.should_receive(:ba).once.with(c).and_return(false)
+    p.should_not_receive(:_add_attribute)
+    p.should_not_receive(:_remove_attribute)
+    p.associations[:attributes] = []
+    proc{p.add_attribute(c)}.should raise_error(Sequel::Error)
+    p.attributes.should == []
+    p.associations[:attributes] = [c]
+    p.should_receive(:br).once.with(c).and_return(false)
+    proc{p.remove_attribute(c)}.should raise_error(Sequel::Error)
+    p.attributes.should == [c]
+  end
+
+  it "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
+    p.should_receive(:ba).once.with(c).and_return(false)
+    p.should_not_receive(:_add_attribute)
+    p.should_not_receive(:_remove_attribute)
+    p.associations[:attributes] = []
+    p.add_attribute(c).should == nil
+    p.attributes.should == []
+    p.associations[:attributes] = [c]
+    p.should_receive(:br).once.with(c).and_return(false)
+    p.remove_attribute(c).should == nil
+    p.attributes.should == [c]
+  end
 end
 
 describe Sequel::Model, "many_to_many" do
@@ -829,7 +1084,7 @@ describe Sequel::Model, "many_to_many" do
     MODEL_DB.sqls.first.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 555)'
   end
 
-  it "should allow the order option while accepting a block" do
+  it "should allow the :order option while accepting a block" do
     @c2.many_to_many :attributes, :class => @c1, :order=>[:blah1, :blah2] do |ds|
       ds.filter(:xxx => @xxx)
     end
@@ -850,6 +1105,22 @@ describe Sequel::Model, "many_to_many" do
     @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 456)'
   end
   
+  it "should support a :dataset option that is used instead of the default" do
+    c1 = @c1
+    @c2.many_to_many :attributes, :class => @c1, :dataset=>proc{c1.join_table(:natural, :an).filter(:an__nodeid=>pk)}, :order=> :a, :limit=>10, :select=>nil do |ds|
+      ds.filter(:xxx => @xxx)
+    end
+
+    n = @c2.new(:id => 1234)
+    n.xxx = 555
+    n.attributes_dataset.sql.should == 'SELECT * FROM attributes NATURAL JOIN an WHERE ((an.nodeid = 1234) AND (xxx = 555)) ORDER BY a LIMIT 10'
+    a = n.attributes
+    a.should be_a_kind_of(Array)
+    a.size.should == 1
+    a.first.should be_a_kind_of(@c1)
+    MODEL_DB.sqls.first.should == 'SELECT * FROM attributes NATURAL JOIN an WHERE ((an.nodeid = 1234) AND (xxx = 555)) ORDER BY a LIMIT 10'
+  end
+
   it "should support a :limit option" do
     @c2.many_to_many :attributes, :class => @c1 , :limit=>10
     @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) LIMIT 10'
@@ -1055,10 +1326,118 @@ describe Sequel::Model, "many_to_many" do
     node.remove_all_attributes
     attrib.associations[:nodes].should == []
   end
+
+  it "should call an _add_ method internally to add attributes" do
+    @c2.many_to_many :attributes, :class => @c1
+    @c2.private_instance_methods.sort.should(include("_add_attribute"))
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    def p._add_attribute(x)
+      @x = x
+    end
+    p.add_attribute(c)
+    p.instance_variable_get(:@x).should == c
+    MODEL_DB.sqls.should == []
+  end
+
+  it "should call a _remove_ method internally to remove attributes" do
+    @c2.many_to_many :attributes, :class => @c1
+    @c2.private_instance_methods.sort.should(include("_remove_attribute"))
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    def p._remove_attribute(x)
+      @x = x
+    end
+    p.remove_attribute(c)
+    p.instance_variable_get(:@x).should == c
+    MODEL_DB.sqls.should == []
+  end
+
+  it "should support (before|after)_(add|remove) callbacks" do
+    h = []
+    @c2.many_to_many :attributes, :class => @c1, :before_add=>[proc{|x,y| h << x.pk; h << -y.pk}, :blah], :after_add=>proc{h << 3}, :before_remove=>:blah, :after_remove=>[:blahr]
+    @c2.class_eval do
+      @@blah = h
+      def _add_attribute(v)
+        @@blah << 4
+      end
+      def _remove_attribute(v)
+        @@blah << 5
+      end
+      def blah(x)
+        @@blah << x.pk
+      end
+      def blahr(x)
+        @@blah << 6
+      end
+    end
+    p = @c2.load(:id=>10)
+    c = @c1.load(:id=>123)
+    h.should == []
+    p.add_attribute(c)
+    h.should == [10, -123, 123, 4, 3]
+    p.remove_attribute(c)
+    h.should == [10, -123, 123, 4, 3, 123, 5, 6]
+  end
+
+  it "should support after_load association callback" do
+    h = []
+    @c2.many_to_many :attributes, :class => @c1, :after_load=>[proc{|x,y| h << [x.pk, y.collect{|z|z.pk}]}, :al]
+    @c2.class_eval do
+      @@blah = h
+      def al(v)
+        v.each{|x| @@blah << x.pk}
+      end
+    end
+    @c1.class_eval do
+      def @dataset.fetch_rows(sql)
+        yield({:id=>20})
+        yield({:id=>30})
+      end
+    end
+    p = @c2.load(:id=>10, :parent_id=>20)
+    attributes = p.attributes
+    h.should == [[10, [20, 30]], 20, 30]
+    attributes.collect{|a| a.pk}.should == [20, 30]
+  end
+
+  it "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
+    p.should_receive(:ba).once.with(c).and_return(false)
+    p.should_not_receive(:_add_attribute)
+    p.should_not_receive(:_remove_attribute)
+    p.associations[:attributes] = []
+    p.raise_on_save_failure = true
+    proc{p.add_attribute(c)}.should raise_error(Sequel::Error)
+    p.attributes.should == []
+    p.associations[:attributes] = [c]
+    p.should_receive(:br).once.with(c).and_return(false)
+    proc{p.remove_attribute(c)}.should raise_error(Sequel::Error)
+    p.attributes.should == [c]
+  end
+
+  it "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
+    p.should_receive(:ba).once.with(c).and_return(false)
+    p.should_not_receive(:_add_attribute)
+    p.should_not_receive(:_remove_attribute)
+    p.associations[:attributes] = []
+    p.add_attribute(c).should == nil
+    p.attributes.should == []
+    p.associations[:attributes] = [c]
+    p.should_receive(:br).once.with(c).and_return(false)
+    p.remove_attribute(c).should == nil
+    p.attributes.should == [c]
+  end
 end
 
-describe Sequel::Model, "all_association_reflections" do
-  before(:each) do
+describe Sequel::Model, " association reflection methods" do
+  before do
     MODEL_DB.reset
     @c1 = Class.new(Sequel::Model(:nodes)) do
       def self.name; 'Node'; end
@@ -1066,64 +1445,40 @@ describe Sequel::Model, "all_association_reflections" do
     end
   end
   
-  it "should include all association reflection hashes" do
+  it "#all_association_reflections should include all association reflection hashes" do
     @c1.all_association_reflections.should == []
+
     @c1.associate :many_to_one, :parent, :class => @c1
-    @c1.all_association_reflections.should == [{
-      :type => :many_to_one, :name => :parent, :class_name => 'Node', 
-      :class => @c1, :key => :parent_id, :block => nil, :cache => true,
-      :graph_join_type=>:left_outer, :graph_conditions=>[], :eager_block => nil, :model => @c1
-    }]
-    @c1.associate :one_to_many, :children, :class => @c1
-    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.should == [{
-      :type => :one_to_many, :name => :children, :class_name => 'Node', 
-      :class => @c1, :key => :node_id, :block => nil, :cache => true,
-      :graph_join_type=>:left_outer, :graph_conditions=>[], :eager_block => nil, :model => @c1}, {
-      :type => :many_to_one, :name => :parent, :class_name => 'Node',
-      :class => @c1, :key => :parent_id, :block => nil, :cache => true,
-      :graph_join_type=>:left_outer, :graph_conditions=>[], :eager_block => nil, :model => @c1}]
-  end
-end
+    @c1.all_association_reflections.collect{|v| v[:name]}.should == [:parent]
+    @c1.all_association_reflections.collect{|v| v[:type]}.should == [:many_to_one]
+    @c1.all_association_reflections.collect{|v| v[:class]}.should == [@c1]
 
-describe Sequel::Model, "association_reflection" do
-  before(:each) do
-    MODEL_DB.reset
-    @c1 = Class.new(Sequel::Model(:nodes)) do
-      def self.name; 'Node'; end
-      def self.to_s; 'Node'; end
-    end
+    @c1.associate :one_to_many, :children, :class => @c1
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:name]}.should == [:children, :parent]
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:type]}.should == [:one_to_many, :many_to_one]
+    @c1.all_association_reflections.sort_by{|x|x[:name].to_s}.collect{|v| v[:class]}.should == [@c1, @c1]
   end
 
-  it "should return nil for nonexistent association" do
+  it "#association_reflection should return nil for nonexistent association" do
     @c1.association_reflection(:blah).should == nil
   end
 
-  it "should return association reflection hash if association exists" do
+  it "#association_reflection should return association reflection hash if association exists" do
     @c1.associate :many_to_one, :parent, :class => @c1
-    @c1.association_reflection(:parent).should == {
-      :type => :many_to_one, :name => :parent, :class_name => 'Node', 
-      :class => @c1, :key => :parent_id, :block => nil, :cache => true,
-      :graph_join_type=>:left_outer, :graph_conditions=>[], :eager_block => nil, :model => @c1
-    }
-    @c1.associate :one_to_many, :children, :class => @c1
-    @c1.association_reflection(:children).should == {
-      :type => :one_to_many, :name => :children, :class_name => 'Node', 
-      :class => @c1, :key => :node_id, :block => nil, :cache => true,
-      :graph_join_type=>:left_outer, :graph_conditions=>[], :eager_block => nil, :model => @c1
-    }
-  end
-end
+    @c1.association_reflection(:parent).should be_a_kind_of(Sequel::Model::Associations::AssociationReflection)
+    @c1.association_reflection(:parent)[:name].should == :parent
+    @c1.association_reflection(:parent)[:type].should == :many_to_one
+    @c1.association_reflection(:parent)[:class].should == @c1
 
-describe Sequel::Model, "associations" do
-  before(:each) do
-    MODEL_DB.reset
-    @c1 = Class.new(Sequel::Model(:nodes)) do
-      def self.name; 'Node'; end
-      def self.to_s; 'Node'; end
-    end
+    @c1.associate :one_to_many, :children, :class => @c1
+    @c1.association_reflection(:children).should be_a_kind_of(Sequel::Model::Associations::AssociationReflection)
+    @c1.association_reflection(:children)[:name].should == :children
+    @c1.association_reflection(:children)[:type].should == :one_to_many
+    @c1.association_reflection(:children)[:class].should == @c1
   end
 
-  it "should include all association names" do
+  it "#associations should include all association names" do
     @c1.associations.should == []
     @c1.associate :many_to_one, :parent, :class => @c1
     @c1.associations.should == [:parent]