sequel 3.21.0 → 3.29.0

data/spec/model/associations_spec.rb

@@ -2,42 +2,47 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "associate" do
   it "should use explicit class if given a class, symbol, or string" do
-    MODEL_DB.reset
-    klass = Class.new(Sequel::Model(:nodes))
-    class ::ParParent < Sequel::Model
+    begin
+      klass = Class.new(Sequel::Model(:nodes))
+      class ::ParParent < Sequel::Model; end
+      
+      klass.associate :many_to_one, :par_parent0, :class=>ParParent
+      klass.associate :one_to_many, :par_parent1s, :class=>'ParParent'
+      klass.associate :many_to_many, :par_parent2s, :class=>:ParParent
+      
+      klass.association_reflection(:"par_parent0").associated_class.should == ParParent
+      klass.association_reflection(:"par_parent1s").associated_class.should == ParParent
+      klass.association_reflection(:"par_parent2s").associated_class.should == ParParent
+    ensure
+      Object.send(:remove_const, :ParParent)
     end
-    
-    klass.associate :many_to_one, :par_parent0, :class=>ParParent
-    klass.associate :one_to_many, :par_parent1s, :class=>'ParParent'
-    klass.associate :many_to_many, :par_parent2s, :class=>:ParParent
-    
-    klass.association_reflection(:"par_parent0").associated_class.should == ParParent
-    klass.association_reflection(:"par_parent1s").associated_class.should == ParParent
-    klass.association_reflection(:"par_parent2s").associated_class.should == ParParent
   end
 
   it "should default to associating to other models in the same scope" do
-    class ::AssociationModuleTest
-      class Album < Sequel::Model
-        many_to_one :artist
-        many_to_many :tags
-      end
-      class Artist< Sequel::Model
-        one_to_many :albums
-      end
-      class Tag < Sequel::Model
-        many_to_many :albums
+    begin
+      class ::AssociationModuleTest
+        class Album < Sequel::Model
+          many_to_one :artist
+          many_to_many :tags
+        end
+        class Artist< Sequel::Model
+          one_to_many :albums
+        end
+        class Tag < Sequel::Model
+          many_to_many :albums
+        end
       end
+      
+      ::AssociationModuleTest::Album.association_reflection(:artist).associated_class.should == ::AssociationModuleTest::Artist
+      ::AssociationModuleTest::Album.association_reflection(:tags).associated_class.should == ::AssociationModuleTest::Tag
+      ::AssociationModuleTest::Artist.association_reflection(:albums).associated_class.should == ::AssociationModuleTest::Album
+      ::AssociationModuleTest::Tag.association_reflection(:albums).associated_class.should == ::AssociationModuleTest::Album
+    ensure
+      Object.send(:remove_const, :AssociationModuleTest)
     end
-    
-    ::AssociationModuleTest::Album.association_reflection(:artist).associated_class.should == ::AssociationModuleTest::Artist
-    ::AssociationModuleTest::Album.association_reflection(:tags).associated_class.should == ::AssociationModuleTest::Tag
-    ::AssociationModuleTest::Artist.association_reflection(:albums).associated_class.should == ::AssociationModuleTest::Album
-    ::AssociationModuleTest::Tag.association_reflection(:albums).associated_class.should == ::AssociationModuleTest::Album
   end
 
   it "should add a model_object and association_reflection accessors to the dataset, and return it with the current model object" do
-    MODEL_DB.reset
     klass = Class.new(Sequel::Model(:nodes)) do
       columns :id, :a_id
     end
@@ -64,7 +69,6 @@ describe Sequel::Model, "associate" do
   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
@@ -91,44 +95,46 @@ describe Sequel::Model, "associate" do
   end
 
   it "should clone an existing association with the :clone option" do
-    MODEL_DB.reset
-    klass = Class.new(Sequel::Model(:nodes))
-    
-    klass.many_to_one(:par_parent, :order=>:a){1}
-    klass.one_to_many(:par_parent1s, :class=>'ParParent', :limit=>12){4}
-    klass.many_to_many(:par_parent2s, :class=>:ParParent, :uniq=>true){2}
+    begin
+      class ::ParParent < Sequel::Model; end
+      klass = Class.new(Sequel::Model(:nodes))
+      
+      klass.many_to_one(:par_parent, :order=>:a){1}
+      klass.one_to_many(:par_parent1s, :class=>'ParParent', :limit=>12){4}
+      klass.many_to_many(:par_parent2s, :class=>:ParParent, :uniq=>true){2}
 
-    klass.many_to_one :par, :clone=>:par_parent, :select=>:b
-    klass.one_to_many :par1s, :clone=>:par_parent1s, :order=>:b, :limit=>10, :block=>nil
-    klass.many_to_many(:par2s, :clone=>:par_parent2s, :order=>:c){3}
-    
-    klass.association_reflection(:par).associated_class.should == ParParent
-    klass.association_reflection(:par1s).associated_class.should == ParParent
-    klass.association_reflection(:par2s).associated_class.should == ParParent
-    
-    klass.association_reflection(:par)[:order].should == :a
-    klass.association_reflection(:par).select.should == :b
-    klass.association_reflection(:par)[:block].call.should == 1
-    klass.association_reflection(:par1s)[:limit].should == 10
-    klass.association_reflection(:par1s)[:order].should == :b
-    klass.association_reflection(:par1s)[:block].should == nil
-    klass.association_reflection(:par2s)[:after_load].length.should == 1
-    klass.association_reflection(:par2s)[:order].should == :c
-    klass.association_reflection(:par2s)[:block].call.should == 3
+      klass.many_to_one :par, :clone=>:par_parent, :select=>:b
+      klass.one_to_many :par1s, :clone=>:par_parent1s, :order=>:b, :limit=>10, :block=>nil
+      klass.many_to_many(:par2s, :clone=>:par_parent2s, :order=>:c){3}
+      
+      klass.association_reflection(:par).associated_class.should == ParParent
+      klass.association_reflection(:par1s).associated_class.should == ParParent
+      klass.association_reflection(:par2s).associated_class.should == ParParent
+      
+      klass.association_reflection(:par)[:order].should == :a
+      klass.association_reflection(:par).select.should == :b
+      klass.association_reflection(:par)[:block].call.should == 1
+      klass.association_reflection(:par1s)[:limit].should == 10
+      klass.association_reflection(:par1s)[:order].should == :b
+      klass.association_reflection(:par1s)[:block].should == nil
+      klass.association_reflection(:par2s)[:after_load].length.should == 1
+      klass.association_reflection(:par2s)[:order].should == :c
+      klass.association_reflection(:par2s)[:block].call.should == 3
+    ensure
+      Object.send(:remove_const, :ParParent)
+    end
   end
 
 end
 
 describe Sequel::Model, "many_to_one" do
   before do
-    MODEL_DB.reset
-    
     @c2 = Class.new(Sequel::Model(:nodes)) do
       unrestrict_primary_key
       columns :id, :parent_id, :par_parent_id, :blah
     end
-
     @dataset = @c2.dataset
+    MODEL_DB.reset
   end
 
   it "should use implicit key if omitted" do
@@ -143,31 +149,27 @@ describe Sequel::Model, "many_to_one" do
   end
   
   it "should use implicit class if omitted" do
-    class ::ParParent < Sequel::Model
+    begin
+      class ::ParParent < Sequel::Model; end
+      @c2.many_to_one :par_parent
+      @c2.new(:id => 1, :par_parent_id => 234).par_parent.class.should == ParParent
+      MODEL_DB.sqls.should == ["SELECT * FROM par_parents WHERE (par_parents.id = 234) LIMIT 1"]
+    ensure
+      Object.send(:remove_const, :ParParent)
     end
-    
-    @c2.many_to_one :par_parent
-    
-    d = @c2.new(:id => 1, :par_parent_id => 234)
-    p = d.par_parent
-    p.class.should == ParParent
-    
-    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
-    module ::Par 
-      class Parent < Sequel::Model
+    begin
+      module ::Par 
+        class Parent < Sequel::Model; end
       end
+      @c2.many_to_one :par_parent, :class=>"Par::Parent"
+      @c2.new(:id => 1, :par_parent_id => 234).par_parent.class.should == Par::Parent
+      MODEL_DB.sqls.should == ["SELECT * FROM parents WHERE (parents.id = 234) LIMIT 1"]
+    ensure
+      Object.send(:remove_const, :Par)
     end
-    
-    @c2.many_to_one :par_parent, :class=>"Par::Parent"
-    
-    d = @c2.new(:id => 1, :par_parent_id => 234)
-    p = d.par_parent
-    p.class.should == Par::Parent
-    
-    MODEL_DB.sqls.should == ["SELECT * FROM parents WHERE (parents.id = 234) LIMIT 1"]
   end
 
   it "should use explicit key if given" do
@@ -181,6 +183,12 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 567) LIMIT 1"]
   end
 
+  it "should respect :qualify => false option" do
+    @c2.many_to_one :parent, :class => @c2, :key => :blah, :qualify=>false
+    @c2.new(:id => 1, :blah => 567).parent
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (id = 567) LIMIT 1"]
+  end
+  
   it "should use :primary_key option if given" do
     @c2.many_to_one :parent, :class => @c2, :key => :blah, :primary_key => :pk
     @c2.new(:id => 1, :blah => 567).parent
@@ -218,14 +226,12 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 567) AND (a = 32)) LIMIT 1"]
 
     @c2.many_to_one :parent, :class => @c2, :key => :blah, :conditions=>:a
-    MODEL_DB.sqls.clear
     @c2.new(:id => 1, :blah => 567).parent
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 567) AND a) 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|
+    @c2.many_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{model.filter(:parent_id=>pk)}, :limit=>[10,20], :order=>:name do |ds|
       ds.filter(:x.sql_number > 1)
     end
     @c2.load(:id => 100).child_20
@@ -234,24 +240,19 @@ describe Sequel::Model, "many_to_one" do
 
   it "should return nil if key value is nil" do
     @c2.many_to_one :parent, :class => @c2
-
-    d = @c2.new(:id => 1)
-    d.parent.should == nil
+    @c2.new(:id => 1).parent.should == nil
+    MODEL_DB.sqls.should == []
   end
 
   it "should cache negative lookup" do
     @c2.many_to_one :parent, :class => @c2
-    ds = @c2.dataset
-    def ds.fetch_rows(sql, &block)
-      MODEL_DB.sqls << sql
-    end
-
+    @c2.dataset._fetch = []
     d = @c2.new(:id => 1, :parent_id=>555)
     MODEL_DB.sqls.should == []
     d.parent.should == nil
     MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.id = 555) LIMIT 1']
     d.parent.should == nil
-    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.id = 555) LIMIT 1']
+    MODEL_DB.sqls.should == []
   end
 
   it "should define a setter method" do
@@ -314,11 +315,9 @@ describe Sequel::Model, "many_to_one" do
     @c2.many_to_one :parent, :class => @c2
 
     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
+    @c2.dataset._fetch = {:id=>234}
     e = d.parent 
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"]
     d.associations[:parent].should == e
@@ -357,13 +356,32 @@ describe Sequel::Model, "many_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.id = 234) LIMIT 1"]
   end
   
+  it "should use a callback if given one as the argument" do
+    @c2.many_to_one :parent, :class => @c2
+
+    d = @c2.create(:id => 1)
+    MODEL_DB.reset
+    d.parent_id = 234
+    d.associations[:parent] = 42
+    d.parent(proc{|ds| ds.filter{name > 'M'}}).should_not == 42 
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 234) AND (name > 'M')) LIMIT 1"]
+  end
+  
+  it "should use a block given to the association method as a callback on ruby 1.8.7+" do
+    @c2.many_to_one :parent, :class => @c2
+
+    d = @c2.create(:id => 1)
+    MODEL_DB.reset
+    d.parent_id = 234
+    d.associations[:parent] = 42
+    d.parent{|ds| ds.filter{name > 'M'}}.should_not == 42 
+    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.id = 234) AND (name > 'M')) LIMIT 1"]
+  end if RUBY_VERSION >= '1.8.7'
+  
   it "should have the setter add to the reciprocal one_to_many cached association list if it exists" do
     @c2.many_to_one :parent, :class => @c2
     @c2.one_to_many :children, :class => @c2, :key=>:parent_id
-    ds = @c2.dataset
-    def ds.fetch_rows(sql, &block)
-      MODEL_DB.sqls << sql
-    end
+    @c2.dataset._fetch = []
 
     d = @c2.new(:id => 1)
     e = @c2.new(:id => 2)
@@ -372,14 +390,13 @@ describe Sequel::Model, "many_to_one" do
     e.children.should_not(include(d))
     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 * FROM nodes WHERE (nodes.parent_id = 2)']
     d.parent = e
     e.children.should(include(d))
-    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.parent_id = 2)']
+    MODEL_DB.sqls.should == []
   end
 
   it "should have many_to_one setter deal with a one_to_one reciprocal" do
@@ -407,10 +424,7 @@ describe Sequel::Model, "many_to_one" do
   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
     @c2.many_to_one :parent, :class => @c2
     @c2.one_to_many :children, :class => @c2, :key=>:parent_id
-    ds = @c2.dataset
-    def ds.fetch_rows(sql, &block)
-      MODEL_DB.sqls << sql
-    end
+    @c2.dataset._fetch = []
 
     d = @c2.new(:id => 1)
     e = @c2.new(:id => 2)
@@ -429,17 +443,9 @@ describe Sequel::Model, "many_to_one" do
   end
 
   it "should get all matching records and only return the first if :key option is set to nil" do
-    c2 = @c2
     @c2.one_to_many :children, :class => @c2, :key=>:parent_id
-    @c2.many_to_one :first_grand_parent, :class => @c2, :key=>nil, :eager_graph=>:children, :dataset=>proc{c2.filter(:children_id=>parent_id)}
-    ds = @c2.dataset
-    def ds.columns
-      [:id, :parent_id, :par_parent_id, :blah]
-    end
-    def ds.fetch_rows(sql, &block)
-      MODEL_DB.sqls << sql
-      yield({:id=>1, :parent_id=>0, :par_parent_id=>3, :blah=>4, :children_id=>2, :children_parent_id=>1, :children_par_parent_id=>5, :children_blah=>6})
-    end
+    @c2.many_to_one :first_grand_parent, :class => @c2, :key=>nil, :eager_graph=>:children, :dataset=>proc{model.filter(:children_id=>parent_id)}
+    @c2.dataset.columns(:id, :parent_id, :par_parent_id, :blah)._fetch = [{:id=>1, :parent_id=>0, :par_parent_id=>3, :blah=>4, :children_id=>2, :children_parent_id=>1, :children_par_parent_id=>5, :children_blah=>6}, {}]
     p = @c2.new(:parent_id=>2)
     fgp = p.first_grand_parent
     MODEL_DB.sqls.should == ["SELECT nodes.id, nodes.parent_id, nodes.par_parent_id, nodes.blah, children.id AS children_id, children.parent_id AS children_parent_id, children.par_parent_id AS children_par_parent_id, children.blah AS children_blah FROM nodes LEFT OUTER JOIN nodes AS children ON (children.parent_id = nodes.id) WHERE (children_id = 2)"]
@@ -500,15 +506,15 @@ describe Sequel::Model, "many_to_one" do
     h = []
     @c2.many_to_one :parent, :class => @c2, :before_set=>[proc{|x,y| h << x.pk; h << (y ? -y.pk : :y)}, :blah], :after_set=>proc{h << 3}
     @c2.class_eval do
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def []=(a, v)
-        a == :parent_id ? (self.class.send(:class_variable_get, :@@blah) << (v ? 4 : 5)) : super
+        a == :parent_id ? (model::Foo << (v ? 4 : 5)) : super
       end
       def blah(x)
-        self.class.send(:class_variable_get, :@@blah) << (x ? x.pk : :x)
+        model::Foo << (x ? x.pk : :x)
       end
       def blahr(x)
-        self.class.send(:class_variable_get, :@@blah) << 6
+        model::Foo << 6
       end
     end
     p = @c2.load(:id=>10)
@@ -524,13 +530,11 @@ describe Sequel::Model, "many_to_one" do
     h = []
     @c2.many_to_one :parent, :class => @c2, :after_load=>[proc{|x,y| h << [x.pk, y.pk]}, :al]
     @c2.class_eval do
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def al(v)
-        self.class.send(:class_variable_get, :@@blah) << v.pk
-      end
-      def @dataset.fetch_rows(sql)
-        yield({:id=>20})
+        model::Foo << v.pk
       end
+      dataset._fetch = {:id=>20}
     end
     p = @c2.load(:id=>10, :parent_id=>20)
     parent = p.parent
@@ -538,6 +542,18 @@ describe Sequel::Model, "many_to_one" do
     parent.pk.should == 20
   end
 
+  it "should support after_load association callback that changes the cached object" do
+    @c2.many_to_one :parent, :class => @c2, :after_load=>:al
+    @c2.class_eval do
+      def al(v)
+        associations[:parent] = :foo
+      end
+    end
+    p = @c2.load(:id=>10, :parent_id=>20)
+    p.parent.should == :foo
+    p.associations[:parent].should == :foo
+  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
@@ -565,35 +581,32 @@ describe Sequel::Model, "many_to_one" do
     d = @c2.load(:id=>321)
     p = @c2.new
     p.associations[:parent] = d
-    h = []
     @c2.many_to_one :parent, :class => @c2, :before_set=>:bs, :after_set=>:as
     @c2.class_eval do
-      class_variable_set(:@@blah, h)
+      self::Foo = []
       def []=(a, v)
-        a == :parent_id ? (self.class.send(:class_variable_get, :@@blah) << 5) : super
+        a == :parent_id ? (model::Foo << 5) : super
       end
       def bs(x)
-        self.class.send(:class_variable_get, :@@blah) << x.pk
+        model::Foo << x.pk
       end
       def as(x)
-        self.class.send(:class_variable_get, :@@blah) << x.pk * 2
+        model::Foo << x.pk * 2
       end
     end
     p.parent = c
-    h.should == [123, 5, 246]
+    @c2::Foo.should == [123, 5, 246]
   end
 end
 
 describe Sequel::Model, "one_to_one" do
   before do
     @c1 = Class.new(Sequel::Model(:attributes)) do
-      def _refresh(ds); end
       unrestrict_primary_key
       columns :id, :node_id, :y
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
-      def _refresh(ds); end
       unrestrict_primary_key
       attr_accessor :xxx
       
@@ -602,24 +615,8 @@ describe Sequel::Model, "one_to_one" do
       columns :id, :x, :parent_id, :par_parent_id, :blah, :node_id
     end
     @dataset = @c2.dataset
-    
-    @c2.dataset.extend(Module.new {
-      def empty?; false; end
-      def fetch_rows(sql)
-        @db << sql
-        yield Hash.new
-      end
-    })
-
-    @c1.dataset.extend(Module.new {
-      def empty?; opts.has_key?(:empty) ? (super; true) : false; end
-      def fetch_rows(sql)
-        @db << sql
-        yield Hash.new
-      end
-    })
-
-    @dataset = @c2.dataset
+    @dataset._fetch = {}
+    @c1.dataset._fetch = {}
     MODEL_DB.reset
   end
   
@@ -641,26 +638,24 @@ describe Sequel::Model, "one_to_one" do
   it "should add a setter method" do
     @c2.one_to_one :attribute, :class => @c1
     attrib = @c1.new(:id=>3)
-    d = @c1.dataset
-    @c1.class_eval{remove_method :_refresh}
-    def d.fetch_rows(s); yield({:id=>3}) end
+    @c1.dataset._fetch = {:id=>3}
     @c2.new(:id => 1234).attribute = attrib
+    sqls = MODEL_DB.sqls
     ['INSERT INTO attributes (node_id, id) VALUES (1234, 3)',
-      'INSERT INTO attributes (id, node_id) VALUES (3, 1234)'].should(include(MODEL_DB.sqls.last))
-    MODEL_DB.sqls.first.should == 'UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))'
-    MODEL_DB.sqls.length.should == 2
+      'INSERT INTO attributes (id, node_id) VALUES (3, 1234)'].should(include(sqls.slice! 1))
+    sqls.should == ['UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))', "SELECT * FROM attributes WHERE (id = 3) LIMIT 1"]
+
     @c2.new(:id => 1234).attribute.should == attrib
-    MODEL_DB.sqls.clear
     attrib = @c1.load(:id=>3)
     @c2.new(:id => 1234).attribute = attrib
-    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))',
+    MODEL_DB.sqls.should == ["SELECT * FROM attributes WHERE (attributes.node_id = 1234) LIMIT 1",
+      'UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (id != 3))',
       "UPDATE attributes SET node_id = 1234 WHERE (id = 3)"]
   end
 
   it "should use a transaction in the setter method" do
     @c2.one_to_one :attribute, :class => @c1
     @c2.use_transactions = true
-    MODEL_DB.sqls.clear
     attrib = @c1.load(:id=>3)
     @c2.new(:id => 1234).attribute = attrib
     MODEL_DB.sqls.should == ['BEGIN',
@@ -673,7 +668,6 @@ describe Sequel::Model, "one_to_one" do
     @c2.one_to_one :attribute, :class => @c1, :conditions=>{:a=>1} do |ds|
       ds.filter(:b=>2)
     end
-    MODEL_DB.sqls.clear
     attrib = @c1.load(:id=>3)
     @c2.new(:id => 1234).attribute = attrib
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE ((node_id = 1234) AND (a = 1) AND (b = 2) AND (id != 3))',
@@ -683,30 +677,30 @@ describe Sequel::Model, "one_to_one" do
   it "should have the setter method respect the :primary_key option" do
     @c2.one_to_one :attribute, :class => @c1, :primary_key=>:xxx
     attrib = @c1.new(:id=>3)
-    d = @c1.dataset
-    @c1.class_eval{remove_method :_refresh}
-    def d.fetch_rows(s); yield({:id=>3}) end
+    @c1.dataset._fetch = {:id=>3}
     @c2.new(:id => 1234, :xxx=>5).attribute = attrib
+    sqls = MODEL_DB.sqls
     ['INSERT INTO attributes (node_id, id) VALUES (5, 3)',
-      'INSERT INTO attributes (id, node_id) VALUES (3, 5)'].should(include(MODEL_DB.sqls.last))
-    MODEL_DB.sqls.first.should == 'UPDATE attributes SET node_id = NULL WHERE ((node_id = 5) AND (id != 3))'
-    MODEL_DB.sqls.length.should == 2
+      'INSERT INTO attributes (id, node_id) VALUES (3, 5)'].should(include(sqls.slice! 1))
+    sqls.should == ['UPDATE attributes SET node_id = NULL WHERE ((node_id = 5) AND (id != 3))', "SELECT * FROM attributes WHERE (id = 3) LIMIT 1"]
+
     @c2.new(:id => 321, :xxx=>5).attribute.should == attrib
-    MODEL_DB.sqls.clear
     attrib = @c1.load(:id=>3)
     @c2.new(:id => 621, :xxx=>5).attribute = attrib
-    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE ((node_id = 5) AND (id != 3))',
+    MODEL_DB.sqls.should == ["SELECT * FROM attributes WHERE (attributes.node_id = 5) LIMIT 1",
+      'UPDATE attributes SET node_id = NULL WHERE ((node_id = 5) AND (id != 3))',
       'UPDATE attributes SET node_id = 5 WHERE (id = 3)']
     end
     
   it "should have the setter method respect composite keys" do
     @c2.one_to_one :attribute, :class => @c1, :key=>[:node_id, :y], :primary_key=>[:id, :x]
     attrib = @c1.load(:id=>3, :y=>6)
-    d = @c1.dataset
-    def d.fetch_rows(s); yield({:id=>3, :y=>6}) end
+    @c1.dataset._fetch = {:id=>3, :y=>6}
     @c2.load(:id => 1234, :x=>5).attribute = attrib
-    MODEL_DB.sqls.last.should =~ /UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 3\)/
-    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(\(node_id = 1234\) AND \(y = 5\) AND \(id != 3\)\)/
+    sqls = MODEL_DB.sqls
+    sqls.last.should =~ /UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 3\)/
+    sqls.first.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(\(node_id = 1234\) AND \(y = 5\) AND \(id != 3\)\)/
+    sqls.length.should == 2
   end
 
   it "should use implicit key if omitted" do
@@ -721,31 +715,27 @@ describe Sequel::Model, "one_to_one" do
   end
   
   it "should use implicit class if omitted" do
-    class ::ParParent < Sequel::Model
+    begin
+      class ::ParParent < Sequel::Model; end
+      @c2.one_to_one :par_parent
+      @c2.new(:id => 234).par_parent.class.should == ParParent
+      MODEL_DB.sqls.should == ["SELECT * FROM par_parents WHERE (par_parents.node_id = 234) LIMIT 1"]
+    ensure
+      Object.send(:remove_const, :ParParent)
     end
-    
-    @c2.one_to_one :par_parent
-    
-    d = @c2.new(:id => 234)
-    p = d.par_parent
-    p.class.should == ParParent
-    
-    MODEL_DB.sqls.should == ["SELECT * FROM par_parents WHERE (par_parents.node_id = 234) LIMIT 1"]
   end
 
   it "should use class inside module if given as a string" do
-    module ::Par 
-      class Parent < Sequel::Model
+    begin
+      module ::Par 
+        class Parent < Sequel::Model; end
       end
+      @c2.one_to_one :par_parent, :class=>"Par::Parent"
+      @c2.new(:id => 234).par_parent.class.should == Par::Parent
+      MODEL_DB.sqls.should == ["SELECT * FROM parents WHERE (parents.node_id = 234) LIMIT 1"]
+    ensure
+      Object.send(:remove_const, :Par)
     end
-    
-    @c2.one_to_one :par_parent, :class=>"Par::Parent"
-    
-    d = @c2.new(:id => 234)
-    p = d.par_parent
-    p.class.should == Par::Parent
-    
-    MODEL_DB.sqls.should == ["SELECT * FROM parents WHERE (parents.node_id = 234) LIMIT 1"]
   end
 
   it "should use explicit key if given" do
@@ -796,14 +786,12 @@ describe Sequel::Model, "one_to_one" do
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.node_id = 567) AND (a = 32)) LIMIT 1"]
 
     @c2.one_to_one :parent, :class => @c2, :conditions=>:a
-    MODEL_DB.sqls.clear
     @c2.new(:id => 567).parent
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE ((nodes.node_id = 567) AND a) LIMIT 1"]
   end
 
   it "should support :order, :limit (only for offset), and :dataset options, as well as a block" do
-    c2 = @c2
-    @c2.one_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{c2.filter(:parent_id=>pk)}, :limit=>[10,20], :order=>:name do |ds|
+    @c2.one_to_one :child_20, :class => @c2, :key=>:id, :dataset=>proc{model.filter(:parent_id=>pk)}, :limit=>[10,20], :order=>:name do |ds|
       ds.filter(:x.sql_number > 1)
     end
     @c2.load(:id => 100).child_20
@@ -813,24 +801,19 @@ describe Sequel::Model, "one_to_one" do
   it "should return nil if primary_key value is nil" do
     @c2.one_to_one :parent, :class => @c2, :primary_key=>:node_id
 
-    d = @c2.new(:id => 1)
-    d.parent.should == nil
+    @c2.new(:id => 1).parent.should be_nil
     MODEL_DB.sqls.should == []
   end
 
   it "should cache negative lookup" do
     @c2.one_to_one :parent, :class => @c2
-    ds = @c2.dataset
-    def ds.fetch_rows(sql, &block)
-      MODEL_DB.sqls << sql
-    end
-
+    @c2.dataset._fetch = []
     d = @c2.new(:id => 555)
     MODEL_DB.sqls.should == []
     d.parent.should == nil
     MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.node_id = 555) LIMIT 1']
     d.parent.should == nil
-    MODEL_DB.sqls.should == ['SELECT * FROM nodes WHERE (nodes.node_id = 555) LIMIT 1']
+    MODEL_DB.sqls.should == []
   end
 
   it "should define a setter method" do
@@ -838,28 +821,44 @@ describe Sequel::Model, "one_to_one" do
 
     d = @c2.new(:id => 1)
     f = @c2.new(:id => 3, :node_id=> 4321)
+    @c2.dataset._fetch = {:id => 3, :node_id=>1}
     d.parent = f
     f.values.should == {:id => 3, :node_id=>1}
     d.parent.should == f
+    sqls = MODEL_DB.sqls
+    ["INSERT INTO nodes (node_id, id) VALUES (1, 3)",
+     "INSERT INTO nodes (id, node_id) VALUES (3, 1)"].should include(sqls.slice! 1)
+    sqls.should == ["UPDATE nodes SET node_id = NULL WHERE ((node_id = 1) AND (id != 3))", "SELECT * FROM nodes WHERE (id = 3) LIMIT 1"]
     
     d.parent = nil
     d.parent.should == nil
+    MODEL_DB.sqls.should == ["UPDATE nodes SET node_id = NULL WHERE (node_id = 1)"]
   end
   
   it "should have the setter method respect the :primary_key option" do
     @c2.one_to_one :parent, :class => @c2, :primary_key=>:blah
     d = @c2.new(:id => 1, :blah => 3)
     e = @c2.new(:id => 4321, :node_id=>444)
+    @c2.dataset._fetch = {:id => 4321, :node_id => 3}
     d.parent = e
     e.values.should == {:id => 4321, :node_id => 3}
+    sqls = MODEL_DB.sqls
+    ["INSERT INTO nodes (node_id, id) VALUES (3, 4321)",
+     "INSERT INTO nodes (id, node_id) VALUES (4321, 3)"].should include(sqls.slice! 1)
+    sqls.should == ["UPDATE nodes SET node_id = NULL WHERE ((node_id = 3) AND (id != 4321))", "SELECT * FROM nodes WHERE (id = 4321) LIMIT 1"]
   end
   
   it "should have the setter method respect the :key option" do
     @c2.one_to_one :parent, :class => @c2, :key=>:blah
     d = @c2.new(:id => 3)
     e = @c2.new(:id => 4321, :blah=>444)
+    @c2.dataset._fetch = {:id => 4321, :blah => 3}
     d.parent = e
     e.values.should == {:id => 4321, :blah => 3}
+    sqls = MODEL_DB.sqls
+    ["INSERT INTO nodes (blah, id) VALUES (3, 4321)",
+     "INSERT INTO nodes (id, blah) VALUES (4321, 3)"].should include(sqls.slice! 1)
+    sqls.should == ["UPDATE nodes SET blah = NULL WHERE ((blah = 3) AND (id != 4321))", "SELECT * FROM nodes WHERE (id = 4321) LIMIT 1"]
   end
   
   it "should persist changes to associated object when the setter is called" do
@@ -875,12 +874,11 @@ describe Sequel::Model, "one_to_one" do
 
     d = @c2.load(:id => 1)
     d.associations[:parent].should == nil
-    ds = @c2.dataset
-    def ds.fetch_rows(sql, &block); MODEL_DB.sqls << sql; yield({:id=>234}) end
+    @c2.dataset._fetch = {:id=>234}
     e = d.parent 
     MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.node_id = 1) LIMIT 1"]
     d.parent
-    MODEL_DB.sqls.should == ["SELECT * FROM nodes WHERE (nodes.node_id = 1) LIMIT 1"]
+    MODEL_DB.sqls.should == []
     d.associations[:parent].should == e
   end
 
@@ -922,7 +920,6 @@ describe Sequel::Model, "one_to_one" do
     e.child.should == d
     MODEL_DB.sqls.should == ["UPDATE nodes SET parent_id = NULL WHERE ((parent_id = 1) AND (id != 2))",
       "UPDATE nodes SET parent_id = 1 WHERE (id = 2)"]
-    MODEL_DB.reset
     d.parent = nil
     e.child.should == nil
     MODEL_DB.sqls.should == ["UPDATE nodes SET parent_id = NULL WHERE (parent_id = 1)"]
@@ -931,17 +928,13 @@ describe Sequel::Model, "one_to_one" do
   it "should have the setter remove the object from the previous associated object's reciprocal many_to_one cached association list if it exists" do
     @c2.one_to_one :parent, :class => @c2, :key=>:parent_id
     @c2.many_to_one :child, :class => @c2, :key=>:parent_id
-    ds = @c2.dataset
-    def ds.fetch_rows(sql, &block)
-      MODEL_DB.sqls << sql
-    end
+    @c2.dataset._fetch = []
 
     d = @c2.load(:id => 1)
     e = @c2.load(:id => 2)
     f = @c2.load(:id => 3)
     e.child.should == nil
     f.child.should == nil
-    MODEL_DB.reset
     d.parent = e
     e.child.should == d
     d.parent = f
@@ -983,12 +976,12 @@ describe Sequel::Model, "one_to_one" do
     h = []
     @c2.one_to_one :parent, :class => @c2, :before_set=>[proc{|x,y| h << x.pk; h << (y ? -y.pk : :y)}, :blah], :after_set=>proc{h << 3}
     @c2.class_eval do
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def blah(x)
-        self.class.send(:class_variable_get, :@@blah) << (x ? x.pk : :x)
+        model::Foo << (x ? x.pk : :x)
       end
       def blahr(x)
-        self.class.send(:class_variable_get, :@@blah) << 6
+        model::Foo << 6
       end
     end
     p = @c2.load(:id=>10)
@@ -1004,13 +997,11 @@ describe Sequel::Model, "one_to_one" do
     h = []
     @c2.one_to_one :parent, :class => @c2, :after_load=>[proc{|x,y| h << [x.pk, y.pk]}, :al]
     @c2.class_eval do
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def al(v)
-        self.class.send(:class_variable_get, :@@blah) << v.pk
-      end
-      def @dataset.fetch_rows(sql)
-        yield({:id=>20})
+        model::Foo << v.pk
       end
+      @dataset._fetch = {:id=>20}
     end
     p = @c2.load(:id=>10)
     parent = p.parent
@@ -1048,15 +1039,15 @@ describe Sequel::Model, "one_to_one" do
     h = []
     @c2.one_to_one :parent, :class => @c2, :before_set=>:bs, :after_set=>:as
     @c2.class_eval do
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def []=(a, v)
-        a == :node_id ? (self.class.send(:class_variable_get, :@@blah) << 5) : super
+        a == :node_id ? (model::Foo << 5) : super
       end
       def bs(x)
-        self.class.send(:class_variable_get, :@@blah) << x.pk
+        model::Foo << x.pk
       end
       def as(x)
-        self.class.send(:class_variable_get, :@@blah) << x.pk * 2
+        model::Foo << x.pk * 2
       end
     end
     p.parent = c
@@ -1072,16 +1063,9 @@ end
 
 describe Sequel::Model, "one_to_many" do
   before do
-    MODEL_DB.reset
-
     @c1 = Class.new(Sequel::Model(:attributes)) do
-      def _refresh(ds); end
       unrestrict_primary_key
       columns :id, :node_id, :y, :z
-
-      def self.[](id)
-        load(id.is_a?(Array) ? {:id => id[0], :z => id[1]} : {:id => id})
-      end
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
@@ -1094,68 +1078,58 @@ describe Sequel::Model, "one_to_many" do
       columns :id, :x
     end
     @dataset = @c2.dataset
-    
-    @c2.dataset.extend(Module.new {
-      def empty?; false; end
-      def fetch_rows(sql)
-        @db << sql
-        yield Hash.new
-      end
-    })
-
-    @c1.dataset.extend(Module.new {
-      def empty?; opts.has_key?(:empty) ? (super; true) : false; end
-      def fetch_rows(sql)
-        @db << sql
-        yield Hash.new
-      end
-    })
+    @dataset._fetch = {}
+    @c1.dataset._fetch = proc{|sql| sql =~ /SELECT 1/ ? {:a=>1} : {}}
+    MODEL_DB.reset
   end
 
   it "should use implicit key if omitted" do
     @c2.one_to_many :attributes, :class => @c1 
-
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT * FROM attributes WHERE (attributes.node_id = 1234)'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT * FROM attributes WHERE (attributes.node_id = 1234)'
   end
   
   it "should use implicit class if omitted" do
-    class ::HistoricalValue < Sequel::Model
+    begin
+      class ::HistoricalValue < Sequel::Model; end
+      @c2.one_to_many :historical_values
+      
+      v = @c2.new(:id => 1234).historical_values_dataset
+      v.should be_a_kind_of(Sequel::Dataset)
+      v.sql.should == 'SELECT * FROM historical_values WHERE (historical_values.node_id = 1234)'
+      v.model.should == HistoricalValue
+    ensure
+      Object.send(:remove_const, :HistoricalValue)
     end
-    
-    @c2.one_to_many :historical_values
-    
-    n = @c2.new(:id => 1234)
-    v = n.historical_values_dataset
-    v.should be_a_kind_of(Sequel::Dataset)
-    v.sql.should == 'SELECT * FROM historical_values WHERE (historical_values.node_id = 1234)'
-    v.model.should == HistoricalValue
   end
   
   it "should use class inside a module if given as a string" do
-    module ::Historical
-      class Value < Sequel::Model
+    begin
+      module ::Historical
+        class Value < Sequel::Model; end
       end
+      @c2.one_to_many :historical_values, :class=>'Historical::Value'
+      
+      v = @c2.new(:id => 1234).historical_values_dataset
+      v.should be_a_kind_of(Sequel::Dataset)
+      v.sql.should == 'SELECT * FROM values WHERE (values.node_id = 1234)'
+      v.model.should == Historical::Value
+    ensure
+      Object.send(:remove_const, :Historical)
     end
-    
-    @c2.one_to_many :historical_values, :class=>'Historical::Value'
-    
-    n = @c2.new(:id => 1234)
-    v = n.historical_values_dataset
-    v.should be_a_kind_of(Sequel::Dataset)
-    v.sql.should == 'SELECT * FROM values WHERE (values.node_id = 1234)'
-    v.model.should == Historical::Value
   end
 
-  it "should use explicit key if given" do
+  it "should use a callback if given one as the argument" do
     @c2.one_to_many :attributes, :class => @c1, :key => :nodeid
     
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT * FROM attributes WHERE (attributes.nodeid = 1234)'
+    d = @c2.load(:id => 1234)
+    d.associations[:attributes] = []
+    d.attributes(proc{|ds| ds.filter{name > 'M'}}).should_not == []
+    MODEL_DB.sqls.should == ["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.should == 'SELECT * FROM attributes WHERE (attributes.nodeid = 1234)'
   end
   
   it "should support_composite keys" do
@@ -1180,10 +1154,8 @@ describe Sequel::Model, "one_to_many" do
   it "should define an add_ method that works on existing records" do
     @c2.one_to_many :attributes, :class => @c1
     
-    n = @c2.new(:id => 1234)
-    a = @c1.new(:id => 2345)
-    a.save
-    MODEL_DB.reset
+    n = @c2.load(:id => 1234)
+    a = @c1.load(:id => 2345)
     a.should == n.add_attribute(a)
     a.values.should == {:node_id => 1234, :id => 2345}
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 1234 WHERE (id = 2345)']
@@ -1192,34 +1164,32 @@ describe Sequel::Model, "one_to_many" do
   it "should define an add_ method that works on new records" do
     @c2.one_to_many :attributes, :class => @c1
     
-    n = @c2.new(:id => 1234)
+    n = @c2.load(:id => 1234)
     a = @c1.new(:id => 234)
-    # do not save
-    MODEL_DB.reset
+    @c1.dataset._fetch = {:node_id => 1234, :id => 234}
     a.should == n.add_attribute(a)
-    MODEL_DB.sqls.first.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/
+    sqls = MODEL_DB.sqls
+    sqls.shift.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/
+    sqls.should == ["SELECT * FROM attributes WHERE (id = 234) LIMIT 1"]
     a.values.should == {:node_id => 1234, :id => 234}
   end
 
   it "should define a remove_ method that works on existing records" do
     @c2.one_to_many :attributes, :class => @c1
     
-    n = @c2.new(:id => 1234)
-    a = @c1.new(:id => 2345, :node_id => 1234)
-    a.save
-    MODEL_DB.reset
+    n = @c2.load(:id => 1234)
+    a = @c1.load(:id => 2345, :node_id => 1234)
     a.should == n.remove_attribute(a)
     a.values.should == {:node_id => nil, :id => 2345}
-    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE (id = 2345)']
+    MODEL_DB.sqls.should == ["SELECT 1 FROM attributes WHERE ((attributes.node_id = 1234) AND (id = 2345)) LIMIT 1", 'UPDATE attributes SET node_id = NULL WHERE (id = 2345)']
   end
 
   it "should have the remove_ method raise an error if the passed object is not already associated" do
     @c2.one_to_many :attributes, :class => @c1
-    @c1.dataset.opts[:empty] = true
     
     n = @c2.new(:id => 1234)
     a = @c1.load(:id => 2345, :node_id => 1234)
-    MODEL_DB.reset
+    @c1.dataset._fetch = []
     proc{n.remove_attribute(a)}.should raise_error(Sequel::Error)
     MODEL_DB.sqls.should == ["SELECT 1 FROM attributes WHERE ((attributes.node_id = 1234) AND (id = 2345)) LIMIT 1"]
   end
@@ -1228,16 +1198,19 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
     MODEL_DB.reset
-    @c1.load(:node_id => 1234, :id => 234).should == n.add_attribute(:id => 234)
-    MODEL_DB.sqls.first.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/
+    @c1.dataset._fetch = {:node_id => 1234, :id => 234}
+    n.add_attribute(:id => 234).should == @c1.load(:node_id => 1234, :id => 234)
+    sqls = MODEL_DB.sqls
+    sqls.shift.should =~ /INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/
+    sqls.should == ["SELECT * FROM attributes WHERE (id = 234) LIMIT 1"]
   end
 
   it "should accept a primary key for the add_ method" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
-    MODEL_DB.reset
-    @c1.load(:node_id => 1234, :id => 234).should == n.add_attribute(234)
-    MODEL_DB.sqls.first.should == "UPDATE attributes SET node_id = 1234 WHERE (id = 234)"
+    @c1.dataset._fetch = {:id=>234, :node_id=>nil}
+    n.add_attribute(234).should == @c1.load(:node_id => 1234, :id => 234)
+    MODEL_DB.sqls.should == ["SELECT * FROM attributes WHERE id = 234", "UPDATE attributes SET node_id = 1234 WHERE (id = 234)"]
   end
 
   it "should raise an error in the add_ method if the passed associated object is not of the correct type" do
@@ -1248,13 +1221,8 @@ describe Sequel::Model, "one_to_many" do
   it "should accept a primary key for the remove_ method and remove an existing record" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
-    ds = @c1.dataset
-    def ds.fetch_rows(sql)
-      db << sql
-      yield({:id=>234, :node_id=>1234})
-    end
-    MODEL_DB.reset
-    @c1.load(:node_id => nil, :id => 234).should == n.remove_attribute(234)
+    @c1.dataset._fetch = {:id=>234, :node_id=>1234}
+    n.remove_attribute(234).should == @c1.load(:node_id => nil, :id => 234)
     MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (attributes.id = 234)) LIMIT 1',
       'UPDATE attributes SET node_id = NULL WHERE (id = 234)']
   end
@@ -1268,10 +1236,8 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1, :primary_key=>:xxx
     
     n = @c2.new(:id => 1234, :xxx=>5)
-    a = @c1.new(:id => 2345)
-    a.save
-    MODEL_DB.reset
-    a.should == n.add_attribute(a)
+    a = @c1.load(:id => 2345)
+    n.add_attribute(a).should == a
     MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 5 WHERE (id = 2345)']
   end
   
@@ -1279,15 +1245,13 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1
     
     n = @c2.new(:id => 1234)
-    a = @c1.new(:id => 2345)
-    a.save
-    MODEL_DB.reset
+    a = @c1.load(:id => 2345)
     n.associations[:attributes] = []
     a.should == n.add_attribute(a)
     a.should == n.add_attribute(a)
     a.values.should == {:node_id => 1234, :id => 2345}
-    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 1234 WHERE (id = 2345)'] * 2
     n.attributes.should == [a]
+    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = 1234 WHERE (id = 2345)'] * 2
   end
 
   it "should have add_ method respect composite keys" do
@@ -1295,18 +1259,24 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345)
-    a.should == n.add_attribute(a)
-    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 2345\)/
+    n.add_attribute(a).should == a
+    sqls = MODEL_DB.sqls
+    sqls.shift.should =~ /UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 2345\)/
+    sqls.should == []
   end
 
   it "should have add_ method accept a composite key" do
     @c1.set_primary_key :id, :z
     @c2.one_to_many :attributes, :class => @c1, :key =>[:node_id, :y], :primary_key=>[:id, :x]
+    @c1.dataset._fetch = {:id => 2345, :z => 8, :node_id => 1234, :y=>5}
     
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345, :z => 8, :node_id => 1234, :y=>5)
-    a.should == n.add_attribute([2345, 8])
-    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id|y) = (1234|5), (node_id|y) = (1234|5) WHERE \(\((id|z) = (2345|8)\) AND \((id|z) = (2345|8)\)\)/
+    n.add_attribute([2345, 8]).should == a
+    sqls = MODEL_DB.sqls
+    sqls.shift.should =~ /SELECT \* FROM attributes WHERE \(\((id|z) = (2345|8)\) AND \((id|z) = (2345|8)\)\) LIMIT 1/
+    sqls.shift.should =~ /UPDATE attributes SET (node_id|y) = (1234|5), (node_id|y) = (1234|5) WHERE \(\((id|z) = (2345|8)\) AND \((id|z) = (2345|8)\)\)/
+    sqls.should == []
   end
   
   it "should have remove_ method respect composite keys" do
@@ -1314,31 +1284,29 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345, :node_id=>1234, :y=>5)
-    a.should == n.remove_attribute(a)
-    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(id = 2345\)/
+    n.remove_attribute(a).should == a
+    sqls = MODEL_DB.sqls
+    sqls.pop.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(id = 2345\)/
+    sqls.should == ["SELECT 1 FROM attributes WHERE ((attributes.node_id = 1234) AND (attributes.y = 5) AND (id = 2345)) LIMIT 1"]
   end
   
   it "should accept a array of composite primary key values for the remove_ method and remove an existing record" do
     @c1.set_primary_key :id, :y
     @c2.one_to_many :attributes, :class => @c1, :key=>:node_id, :primary_key=>:id
     n = @c2.new(:id => 123)
-    ds = @c1.dataset
-    def ds.fetch_rows(sql)
-      db << sql
-      yield({:id=>234, :node_id=>123, :y=>5})
-    end
-    MODEL_DB.reset
-    @c1.load(:node_id => nil, :y => 5, :id => 234).should == n.remove_attribute([234, 5])
-    MODEL_DB.sqls.length.should == 2
-    MODEL_DB.sqls.first.should =~ /SELECT \* FROM attributes WHERE \(\(attributes.node_id = 123\) AND \(attributes\.(id|y) = (234|5)\) AND \(attributes\.(id|y) = (234|5)\)\) LIMIT 1/
-    MODEL_DB.sqls.last.should =~ /UPDATE attributes SET node_id = NULL WHERE \(\((id|y) = (234|5)\) AND \((id|y) = (234|5)\)\)/
+    @c1.dataset._fetch = {:id=>234, :node_id=>123, :y=>5}
+    n.remove_attribute([234, 5]).should == @c1.load(:node_id => nil, :y => 5, :id => 234)
+    sqls = MODEL_DB.sqls
+    sqls.length.should == 2
+    sqls.first.should =~ /SELECT \* FROM attributes WHERE \(\(attributes.node_id = 123\) AND \(attributes\.(id|y) = (234|5)\) AND \(attributes\.(id|y) = (234|5)\)\) LIMIT 1/
+    sqls.last.should =~ /UPDATE attributes SET node_id = NULL WHERE \(\((id|y) = (234|5)\) AND \((id|y) = (234|5)\)\)/
   end
   
   it "should raise an error in add_ and remove_ if the passed object returns false to save (is not valid)" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
     a = @c1.new(:id => 2345)
-    def a.valid?(opts); false; end
+    def a.validate() errors.add(:id, 'foo') end
     proc{n.add_attribute(a)}.should raise_error(Sequel::Error)
     proc{n.remove_attribute(a)}.should raise_error(Sequel::Error)
   end
@@ -1347,7 +1315,7 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1, :validate=>false
     n = @c2.new(:id => 1234)
     a = @c1.new(:id => 2345)
-    def a.valid?(opts); false; end
+    def a.validate() errors.add(:id, 'foo') end
     n.add_attribute(a).should == a
     n.remove_attribute(a).should == a
   end
@@ -1364,81 +1332,48 @@ describe Sequel::Model, "one_to_many" do
   
   it "should use :primary_key option if given" do
     @c1.one_to_many :nodes, :class => @c2, :primary_key => :node_id, :key=>:id
-    n = @c1.load(:id => 1234, :node_id=>4321)
-    n.nodes_dataset.sql.should == "SELECT * FROM nodes WHERE (nodes.id = 4321)"
+    @c1.load(:id => 1234, :node_id=>4321).nodes_dataset.sql.should == "SELECT * FROM nodes WHERE (nodes.id = 4321)"
   end
 
   it "should support a select option" 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 (attributes.node_id = 1234)"
+    @c2.new(:id => 1234).attributes_dataset.sql.should == "SELECT id, name FROM attributes WHERE (attributes.node_id = 1234)"
   end
   
   it "should support a conditions option" do
     @c2.one_to_many :attributes, :class => @c1, :conditions => {:a=>32}
-    n = @c2.new(:id => 1234)
-    n.attributes_dataset.sql.should == "SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (a = 32))"
+    @c2.new(:id => 1234).attributes_dataset.sql.should == "SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (a = 32))"
     @c2.one_to_many :attributes, :class => @c1, :conditions => ~:a
-    n = @c2.new(:id => 1234)
-    n.attributes_dataset.sql.should == "SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND NOT a)"
+    @c2.new(:id => 1234).attributes_dataset.sql.should == "SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND NOT a)"
   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 * FROM attributes WHERE (attributes.node_id = 1234) ORDER BY kind"
+    @c2.new(:id => 1234).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 * FROM attributes WHERE (attributes.node_id = 1234) ORDER BY kind1, kind2"
+    @c2.new(:id => 1234).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
     @c2.one_to_many :attributes, :class => @c1
-    
-    n = @c2.new(:id => 1234)
-    atts = n.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 (attributes.node_id = 1234)']
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT * FROM attributes WHERE (attributes.node_id = 1234)'
   end
   
   it "should accept a block" do
     @c2.one_to_many :attributes, :class => @c1 do |ds|
       ds.filter(:xxx => @xxx)
     end
-    
-    n = @c2.new(:id => 1234)
-    atts = n.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 ((attributes.node_id = 1234) AND (xxx IS NULL))']
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (xxx IS NULL))'
   end
   
   it "should support :order option with block" do
     @c2.one_to_many :attributes, :class => @c1, :order => :kind do |ds|
       ds.filter(:xxx => @xxx)
     end
-    
-    n = @c2.new(:id => 1234)
-    atts = n.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 ((attributes.node_id = 1234) AND (xxx IS NULL)) ORDER BY kind']
+    @c2.new(:id => 1234).attributes_dataset.sql.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
@@ -1450,18 +1385,11 @@ describe Sequel::Model, "one_to_many" do
   
   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|
+    @c2.one_to_many :all_other_attributes, :class => @c1, :dataset=>proc{c1.exclude(:nodeid=>pk)}, :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 == {}
-    
+    @c2.new(:id => 1234).all_other_attributes.should == [@c1.load({})]
     MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE ((nodeid != 1234) AND (xxx = 5)) ORDER BY a LIMIT 10']
   end
   
@@ -1479,9 +1407,7 @@ describe Sequel::Model, "one_to_many" do
   
   it "should set cached instance variable when accessed" do
     @c2.one_to_many :attributes, :class => @c1
-
     n = @c2.new(:id => 1234)
-    MODEL_DB.reset
     n.associations.include?(:attributes).should == false
     atts = n.attributes
     atts.should == n.associations[:attributes]
@@ -1490,9 +1416,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should use cached instance variable if available" do
     @c2.one_to_many :attributes, :class => @c1
-
     n = @c2.new(:id => 1234)
-    MODEL_DB.reset
     n.associations[:attributes] = 42
     n.attributes.should == 42
     MODEL_DB.sqls.should == []
@@ -1500,9 +1424,7 @@ describe Sequel::Model, "one_to_many" do
 
   it "should not use cached instance variable if asked to reload" do
     @c2.one_to_many :attributes, :class => @c1
-
     n = @c2.new(:id => 1234)
-    MODEL_DB.reset
     n.associations[:attributes] = 42
     n.attributes(true).should_not == 42
     MODEL_DB.sqls.should == ['SELECT * FROM attributes WHERE (attributes.node_id = 1234)']
@@ -1510,10 +1432,8 @@ describe Sequel::Model, "one_to_many" do
 
   it "should add item to cached instance variable if it exists when calling add_" do
     @c2.one_to_many :attributes, :class => @c1
-
     n = @c2.new(:id => 1234)
-    att = @c1.new(:id => 345)
-    MODEL_DB.reset
+    att = @c1.load(:id => 345)
     a = []
     n.associations[:attributes] = a
     n.add_attribute(att)
@@ -1535,7 +1455,6 @@ describe Sequel::Model, "one_to_many" do
 
     n = @c2.load(:id => 1234)
     att = @c1.load(:id => 345)
-    MODEL_DB.reset
     a = [att]
     n.associations[:attributes] = a
     n.remove_attribute(att)
@@ -1587,13 +1506,9 @@ describe Sequel::Model, "one_to_many" do
     n = @c2.new(:id => 1234)
     atts = n.attributes
     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)
-    atts.first.values.should == {}
-    atts.first.node.should == n
-    
-    MODEL_DB.sqls.length.should == 1
+    atts.should == [@c1.load({})]
+    atts.map{|a| a.node}.should == [n]
+    MODEL_DB.sqls.should == []
   end
   
   it "should use an explicit reciprocal instance variable if given" do
@@ -1602,19 +1517,15 @@ describe Sequel::Model, "one_to_many" do
     n = @c2.new(:id => 1234)
     atts = n.attributes
     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)
-    atts.first.values.should == {}
-    atts.first.associations[:wxyz].should == n
-    
-    MODEL_DB.sqls.length.should == 1
+    atts.should == [@c1.load({})]
+    atts.map{|a| a.associations[:wxyz]}.should == [n]
+    MODEL_DB.sqls.should == []
   end
   
   it "should have an remove_all_ method that removes all associations" do
     @c2.one_to_many :attributes, :class => @c1
     @c2.new(:id => 1234).remove_all_attributes
-    MODEL_DB.sqls.first.should == 'UPDATE attributes SET node_id = NULL WHERE (node_id = 1234)'
+    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE (node_id = 1234)']
   end
 
   it "should have remove_all method respect association filters" do
@@ -1628,13 +1539,15 @@ describe Sequel::Model, "one_to_many" do
   it "should have the remove_all_ method respect the :primary_key option" do
     @c2.one_to_many :attributes, :class => @c1, :primary_key=>:xxx
     @c2.new(:id => 1234, :xxx=>5).remove_all_attributes
-    MODEL_DB.sqls.first.should == 'UPDATE attributes SET node_id = NULL WHERE (node_id = 5)'
+    MODEL_DB.sqls.should == ['UPDATE attributes SET node_id = NULL WHERE (node_id = 5)']
   end
   
   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
-    MODEL_DB.sqls.first.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(\(node_id = 1234\) AND \(y = 5\)\)/
+    sqls = MODEL_DB.sqls
+    sqls.pop.should =~ /UPDATE attributes SET (node_id|y) = NULL, (node_id|y) = NULL WHERE \(\(node_id = 1234\) AND \(y = 5\)\)/
+    sqls.should == []
   end
 
   it "remove_all should set the cached instance variable to []" do
@@ -1648,10 +1561,8 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1
     attrib = @c1.new(:id=>3)
     node = @c2.new(:id => 1234)
-    d = @c1.dataset
-    def d.fetch_rows(s); end
+    @c1.dataset._fetch = [[], [{:id=>3, :node_id=>1234}]]
     node.attributes.should == []
-    def attrib.save(*); self end
     node.add_attribute(attrib)
     node.associations[:attributes].should == [attrib]
     node.remove_all_attributes.should == [attrib]
@@ -1665,15 +1576,12 @@ describe Sequel::Model, "one_to_many" do
   it "remove_all should remove the current item from all reciprocal instance varaibles if it cached instance variable exists" do
     @c2.one_to_many :attributes, :class => @c1
     @c1.many_to_one :node, :class => @c2
-    d = @c1.dataset
-    def d.fetch_rows(s); end
-    d = @c2.dataset
-    def d.fetch_rows(s); end
+    @c2.dataset._fetch = []
+    @c1.dataset._fetch = [[], [{:id=>3, :node_id=>1234}]]
     attrib = @c1.new(:id=>3)
-    node = @c2.new(:id => 1234)
+    node = @c2.load(:id => 1234)
     node.attributes.should == []
     attrib.node.should == nil
-    def attrib.save(*); self end
     node.add_attribute(attrib)
     attrib.associations[:node].should == node 
     node.remove_all_attributes
@@ -1761,18 +1669,18 @@ describe Sequel::Model, "one_to_many" 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
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def _add_attribute(v)
-        self.class.send(:class_variable_get, :@@blah) << 4
+        model::Foo << 4
       end
       def _remove_attribute(v)
-        self.class.send(:class_variable_get, :@@blah) << 5
+        model::Foo << 5
       end
       def blah(x)
-        self.class.send(:class_variable_get, :@@blah) << x.pk
+        model::Foo << x.pk
       end
       def blahr(x)
-        self.class.send(:class_variable_get, :@@blah) << 6
+        model::Foo << 6
       end
     end
     p = @c2.load(:id=>10)
@@ -1788,17 +1696,12 @@ describe Sequel::Model, "one_to_many" 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
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def al(v)
-        v.each{|x| self.class.send(:class_variable_get, :@@blah) << x.pk}
-      end
-    end
-    @c1.class_eval do
-      def @dataset.fetch_rows(sql)
-        yield({:id=>20})
-        yield({:id=>30})
+        v.each{|x| model::Foo << x.pk}
       end
     end
+    @c1.dataset._fetch = [{:id=>20}, {:id=>30}]
     p = @c2.load(:id=>10, :parent_id=>20)
     attributes = p.attributes
     h.should == [[10, [20, 30]], 20, 30]
@@ -1845,23 +1748,13 @@ describe Sequel::Model, "one_to_many" do
 end
 
 describe Sequel::Model, "many_to_many" do
-
   before do
-    MODEL_DB.reset
-
     @c1 = Class.new(Sequel::Model(:attributes)) do
       unrestrict_primary_key
       attr_accessor :yyy
       def self.name; 'Attribute'; end
       def self.to_s; 'Attribute'; end
       columns :id, :y
-      def _refresh(ds)
-        self
-      end
-      
-      def self.[](id)
-        load(id.is_a?(Array) ? {:id => id[0], :y => id[1]} : {:id => id})
-      end
     end
 
     @c2 = Class.new(Sequel::Model(:nodes)) do
@@ -1873,98 +1766,61 @@ describe Sequel::Model, "many_to_many" do
       columns :id, :x
     end
     @dataset = @c2.dataset
+    @c1.dataset.autoid = 1
 
-    [@c1, @c2].each do |c|
-      c.dataset.extend(Module.new {
-        def fetch_rows(sql)
-          @db << sql
-          yield Hash.new
-        end
-      })
-    end
+    [@c1, @c2].each{|c| c.dataset._fetch = {}}
+    MODEL_DB.reset
   end
 
   it "should use implicit key values and join table if omitted" do
     @c2.many_to_many :attributes, :class => @c1 
-
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))'
+    @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))'
   end
   
   it "should use implicit class if omitted" do
-    class ::Tag < Sequel::Model
+    begin
+      class ::Tag < Sequel::Model; end
+      @c2.many_to_many :tags
+      @c2.new(:id => 1234).tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN nodes_tags ON ((nodes_tags.tag_id = tags.id) AND (nodes_tags.node_id = 1234))'
+    ensure
+      Object.send(:remove_const, :Tag)
     end
-    
-    @c2.many_to_many :tags
-
-    n = @c2.new(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN nodes_tags ON ((nodes_tags.tag_id = tags.id) AND (nodes_tags.node_id = 1234))'
   end
   
   it "should use class inside module if given as a string" do
-    module ::Historical
-      class Tag < Sequel::Model
+    begin
+      module ::Historical
+        class Tag < Sequel::Model; end
       end
+      @c2.many_to_many :tags, :class=>'::Historical::Tag'
+      @c2.new(:id => 1234).tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN nodes_tags ON ((nodes_tags.tag_id = tags.id) AND (nodes_tags.node_id = 1234))'
+    ensure
+      Object.send(:remove_const, :Historical)
     end
-    
-    @c2.many_to_many :tags, :class=>'::Historical::Tag'
-
-    n = @c2.new(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN nodes_tags ON ((nodes_tags.tag_id = tags.id) AND (nodes_tags.node_id = 1234))'
   end
   
   it "should use explicit key values and join table if given" do
     @c2.many_to_many :attributes, :class => @c1, :left_key => :nodeid, :right_key => :attributeid, :join_table => :attribute2node
-    
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attribute2node ON ((attribute2node.attributeid = attributes.id) AND (attribute2node.nodeid = 1234))'
-  end
-  
-  it "should handle an aliased join table when eager loading" do
-    r = @c2.many_to_many(:attributes, :class => @c1, :join_table => :attribute2node___attributes_nodes)
-    
-    a = @c2.eager_loading_dataset(r, @c2.dataset, [:id], nil)
-    a.sql.should == 'SELECT id, attributes_nodes.node_id AS x_foreign_key_x FROM nodes'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attribute2node ON ((attribute2node.attributeid = attributes.id) AND (attribute2node.nodeid = 1234))'
   end
   
   it "should support a conditions option" do
     @c2.many_to_many :attributes, :class => @c1, :conditions => {:a=>32}
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (a = 32)'
+    @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 (a = 32)'
+
     @c2.many_to_many :attributes, :class => @c1, :conditions => ['a = ?', 32]
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (a = 32)'
-    n.attributes.should == [@c1.load({})]
+    @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 (a = 32)'
+    @c2.new(:id => 1234).attributes.should == [@c1.load({})]
   end
   
   it "should support an order option" do
     @c2.many_to_many :attributes, :class => @c1, :order => :blah
-
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) ORDER BY blah'
+    @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)) ORDER BY blah'
   end
   
   it "should support an array for the order option" do
     @c2.many_to_many :attributes, :class => @c1, :order => [:blah1, :blah2]
-
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) ORDER BY blah1, blah2'
+    @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)) ORDER BY blah1, blah2'
   end
   
   it "should support :left_primary_key and :right_primary_key options" do
@@ -1999,19 +1855,13 @@ describe Sequel::Model, "many_to_many" do
   it "should support a select option" do
     @c2.many_to_many :attributes, :class => @c1, :select => :blah
 
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT blah FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT blah FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))'
   end
   
   it "should support an array for the select option" do
     @c2.many_to_many :attributes, :class => @c1, :select => [:attributes.*, :attribute_nodes__blah2]
 
-    n = @c2.new(:id => 1234)
-    a = n.attributes_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT attributes.*, attribute_nodes.blah2 FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))'
+    @c2.new(:id => 1234).attributes_dataset.sql.should == 'SELECT attributes.*, attribute_nodes.blah2 FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))'
   end
   
   it "should accept a block" do
@@ -2021,11 +1871,7 @@ describe Sequel::Model, "many_to_many" do
 
     n = @c2.new(:id => 1234)
     n.xxx = 555
-    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 attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 555)'
+    n.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 = 555)'
   end
 
   it "should allow the :order option while accepting a block" do
@@ -2035,20 +1881,9 @@ describe Sequel::Model, "many_to_many" do
 
     n = @c2.new(:id => 1234)
     n.xxx = 555
-    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 attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (xxx = 555) ORDER BY blah1, blah2'
+    n.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 = 555) ORDER BY blah1, blah2'
   end
 
-  it "should have the block argument affect the _dataset method" do
-    @c2.many_to_many :attributes, :class => @c1 do |ds|
-      ds.filter(:xxx => 456)
-    end
-    @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|
@@ -2058,11 +1893,8 @@ describe Sequel::Model, "many_to_many" do
     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'
+    n.attributes.should == [@c1.load({})]
+    MODEL_DB.sqls.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
@@ -2077,15 +1909,32 @@ describe Sequel::Model, "many_to_many" do
     @c2.new(:id => 1234).attributes_dataset.opts[:eager].should == {:attributes=>nil}
   end
   
+  it "should handle an aliased join table" do
+    @c2.many_to_many :attributes, :class => @c1, :join_table => :attribute2node___attributes_nodes
+    n = @c2.load(:id => 1234)
+    a = @c1.load(:id => 2345)
+    n.attributes_dataset.sql.should == "SELECT attributes.* FROM attributes INNER JOIN attribute2node AS attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))"
+    a.should == n.add_attribute(a)
+    a.should == n.remove_attribute(a)
+    n.remove_all_attributes
+    sqls = MODEL_DB.sqls
+    ['INSERT INTO attribute2node (node_id, attribute_id) VALUES (1234, 2345)',
+     'INSERT INTO attribute2node (attribute_id, node_id) VALUES (2345, 1234)'].should(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))"].should(include(sqls.shift))
+    sqls.should == ["DELETE FROM attribute2node WHERE (node_id = 1234)"]
+  end
+  
   it "should define an add_ method that works on existing records" do
     @c2.many_to_many :attributes, :class => @c1
     
     n = @c2.load(:id => 1234)
     a = @c1.load(:id => 2345)
-    a.should == n.add_attribute(a)
+    n.add_attribute(a).should == a
+    sqls = MODEL_DB.sqls
     ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 2345)',
-     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (2345, 1234)'
-    ].should(include(MODEL_DB.sqls.first))
+     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (2345, 1234)'].should(include(sqls.shift))
+    sqls.should == []
   end
 
   it "should define an add_ method that works with a primary key" do
@@ -2093,21 +1942,25 @@ describe Sequel::Model, "many_to_many" do
     
     n = @c2.load(:id => 1234)
     a = @c1.load(:id => 2345)
-    a.should == n.add_attribute(2345)
+    @c1.dataset._fetch = {:id=>2345}
+    n.add_attribute(2345).should == a
+    sqls = MODEL_DB.sqls
     ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 2345)',
-     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (2345, 1234)'
-    ].should(include(MODEL_DB.sqls.first))
+     'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (2345, 1234)'].should(include(sqls.pop))
+    sqls.should == ["SELECT * FROM attributes WHERE id = 2345"]
   end
 
   it "should allow passing a hash to the add_ method which creates a new record" do
     @c2.many_to_many :attributes, :class => @c1
     
     n = @c2.load(:id => 1234)
-    @c1.load(:id => 1).should == n.add_attribute(:id => 1)
-    MODEL_DB.sqls.first.should == 'INSERT INTO attributes (id) VALUES (1)'
+    @c1.dataset._fetch = {:id=>1}
+    n.add_attribute(:id => 1).should == @c1.load(:id => 1)
+    sqls = MODEL_DB.sqls
     ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 1)',
      'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (1, 1234)'
-    ].should(include(MODEL_DB.sqls.last))
+    ].should(include(sqls.pop))
+    sqls.should == ['INSERT INTO attributes (id) VALUES (1)', "SELECT * FROM attributes WHERE (id = 1) LIMIT 1"]
   end
 
   it "should define a remove_ method that works on existing records" do
@@ -2115,8 +1968,8 @@ describe Sequel::Model, "many_to_many" do
     
     n = @c2.new(:id => 1234)
     a = @c1.new(:id => 2345)
-    a.should == n.remove_attribute(a)
-    MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 2345))'
+    n.remove_attribute(a).should == a
+    MODEL_DB.sqls.should == ['DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 2345))']
   end
 
   it "should raise an error in the add_ method if the passed associated object is not of the correct type" do
@@ -2127,13 +1980,8 @@ describe Sequel::Model, "many_to_many" do
   it "should accept a primary key for the remove_ method and remove an existing record" do
     @c2.many_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
-    ds = @c1.dataset
-    def ds.fetch_rows(sql)
-      db << sql
-      yield({:id=>234})
-    end
-    MODEL_DB.reset
-    @c1.load(:id => 234).should == n.remove_attribute(234)
+    @c1.dataset._fetch = {:id=>234}
+    n.remove_attribute(234).should == @c1.load(:id => 234)
     MODEL_DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE (attributes.id = 234) LIMIT 1",
       "DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 234))"]
   end
@@ -2148,10 +1996,12 @@ describe Sequel::Model, "many_to_many" do
     
     n = @c2.load(:id => 1234).set(:xxx=>5)
     a = @c1.load(:id => 2345).set(:yyy=>8)
-    a.should == n.add_attribute(a)
+    n.add_attribute(a).should == a
+    sqls = MODEL_DB.sqls
     ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (5, 8)',
      'INSERT INTO attributes_nodes (attribute_id, node_id) VALUES (8, 5)'
-    ].should(include(MODEL_DB.sqls.first))
+    ].should(include(sqls.pop))
+    sqls.should == []
   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
@@ -2170,7 +2020,9 @@ describe Sequel::Model, "many_to_many" do
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345, :y=>8)
     a.should == n.add_attribute(a)
-    m = /INSERT INTO attributes_nodes \((\w+), (\w+), (\w+), (\w+)\) VALUES \((\d+), (\d+), (\d+), (\d+)\)/.match(MODEL_DB.sqls.first)
+    sqls = MODEL_DB.sqls
+    m = /INSERT INTO attributes_nodes \((\w+), (\w+), (\w+), (\w+)\) VALUES \((\d+), (\d+), (\d+), (\d+)\)/.match(sqls.pop)
+    sqls.should == []
     m.should_not == nil
     map = {'l1'=>1234, 'l2'=>5, 'r1'=>2345, 'r2'=>8}
     %w[l1 l2 r1 r2].each do |x|
@@ -2187,10 +2039,15 @@ describe Sequel::Model, "many_to_many" do
   
   it "should have the add_ method respect composite keys" do
     @c2.many_to_many :attributes, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :y]
+    @c1.set_primary_key [:id, :y]
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345, :y=>8)
-    a.should == n.add_attribute([2345, 8])
-    MODEL_DB.sqls.first.should =~ /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)\)/
+    @c1.dataset._fetch = {:id => 2345, :y=>8}
+    n.add_attribute([2345, 8]).should == a
+    sqls = MODEL_DB.sqls
+    sqls.shift.should =~ /SELECT \* FROM attributes WHERE \(\((id|y) = (8|2345)\) AND \((id|y) = (8|2345)\)\) LIMIT 1/
+    sqls.pop.should =~ /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.should == []
   end
 
   it "should have the remove_ method respect the :left_primary_key and :right_primary_key options" do
@@ -2198,8 +2055,8 @@ describe Sequel::Model, "many_to_many" do
     
     n = @c2.new(:id => 1234, :xxx=>5)
     a = @c1.new(:id => 2345, :yyy=>8)
-    a.should == n.remove_attribute(a)
-    MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE ((node_id = 5) AND (attribute_id = 8))'
+    n.remove_attribute(a).should == a
+    MODEL_DB.sqls.should == ['DELETE FROM attributes_nodes WHERE ((node_id = 5) AND (attribute_id = 8))']
   end
   
   it "should have the remove_ method respect composite keys" do
@@ -2214,17 +2071,12 @@ describe Sequel::Model, "many_to_many" do
     @c1.set_primary_key [:id, :y]
     @c2.many_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
-    ds = @c1.dataset
-    def ds.fetch_rows(sql)
-      db << sql
-      yield({:id=>234, :y=>8})
-    end
-    MODEL_DB.reset
+    @c1.dataset._fetch = {:id=>234, :y=>8}
     @c1.load(:id => 234, :y=>8).should == n.remove_attribute([234, 8])
+    sqls = MODEL_DB.sqls
     ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE ((attributes.id = 234) AND (attributes.y = 8)) LIMIT 1",
-      "SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE ((attributes.y = 8) AND (attributes.id = 234)) LIMIT 1"].should include(MODEL_DB.sqls.first)
-    MODEL_DB.sqls.last.should == "DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 234))"
-    MODEL_DB.sqls.length.should == 2
+      "SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234)) WHERE ((attributes.y = 8) AND (attributes.id = 234)) LIMIT 1"].should include(sqls.shift)
+    sqls.should == ["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
@@ -2242,6 +2094,7 @@ describe Sequel::Model, "many_to_many" do
     n = @c1.new
     a = @c2.load(:id=>123)
     n.new?.should == true
+    @c1.dataset._fetch = {:id=>1}
     a.add_attribute(n)
     n.new?.should == false
   end
@@ -2250,7 +2103,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1 
     n = @c1.new
     a = @c2.load(:id=>123)
-    def n.valid?(opts); false; end
+    def n.validate() errors.add(:id, 'foo') end
     proc{a.add_attribute(n)}.should raise_error(Sequel::ValidationFailed)
   end
 
@@ -2259,7 +2112,7 @@ describe Sequel::Model, "many_to_many" do
     n = @c1.new
     n.raise_on_save_failure = false
     a = @c2.load(:id=>123)
-    def n.valid?(opts); false; end
+    def n.validate() errors.add(:id, 'foo') end
     proc{a.add_attribute(n)}.should raise_error(Sequel::Error)
   end
 
@@ -2267,7 +2120,8 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1, :validate=>false
     n = @c1.new
     a = @c2.load(:id=>123)
-    def n.valid?(opts); false; end
+    def n.validate() errors.add(:id, 'foo') end
+    @c1.dataset._fetch = {:id=>1}
     a.add_attribute(n)
     n.new?.should == false
   end
@@ -2282,31 +2136,23 @@ describe Sequel::Model, "many_to_many" do
   it "should provide an array with all members of the association" do
     @c2.many_to_many :attributes, :class => @c1
     
-    n = @c2.new(:id => 1234)
-    atts = n.attributes
-    atts.should be_a_kind_of(Array)
-    atts.size.should == 1
-    atts.first.should be_a_kind_of(@c1)
-
-    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))'
+    @c2.new(:id => 1234).attributes.should == [@c1.load({})]
+    MODEL_DB.sqls.should == ['SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))']
   end
 
   it "should set cached instance variable when accessed" do
     @c2.many_to_many :attributes, :class => @c1
 
     n = @c2.new(:id => 1234)
-    MODEL_DB.reset
     n.associations.include?(:attributes).should == false
     atts = n.attributes
     atts.should == n.associations[:attributes]
-    MODEL_DB.sqls.length.should == 1
   end
 
   it "should use cached instance variable if available" do
     @c2.many_to_many :attributes, :class => @c1
 
     n = @c2.new(:id => 1234)
-    MODEL_DB.reset
     n.associations[:attributes] = 42
     n.attributes.should == 42
     MODEL_DB.sqls.should == []
@@ -2316,18 +2162,16 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
 
     n = @c2.new(:id => 1234)
-    MODEL_DB.reset
     n.associations[:attributes] = 42
     n.attributes(true).should_not == 42
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1234))"]
   end
 
   it "should add item to cached instance variable if it exists when calling add_" do
     @c2.many_to_many :attributes, :class => @c1
 
     n = @c2.new(:id => 1234)
-    att = @c1.new(:id => 345)
-    MODEL_DB.reset
+    att = @c1.load(:id => 345)
     a = []
     n.associations[:attributes] = a
     n.add_attribute(att)
@@ -2339,7 +2183,7 @@ describe Sequel::Model, "many_to_many" do
     @c1.many_to_many :nodes, :class => @c2
 
     n = @c2.new(:id => 1234)
-    att = @c1.new(:id => 345)
+    att = @c1.load(:id => 345)
     att.associations[:nodes] = []
     n.add_attribute(att)
     att.nodes.should == [n]
@@ -2349,8 +2193,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
 
     n = @c2.new(:id => 1234)
-    att = @c1.new(:id => 345)
-    MODEL_DB.reset
+    att = @c1.load(:id => 345)
     a = [att]
     n.associations[:attributes] = a
     n.remove_attribute(att)
@@ -2397,13 +2240,13 @@ describe Sequel::Model, "many_to_many" do
   it "should have an remove_all_ method that removes all associations" do
     @c2.many_to_many :attributes, :class => @c1
     @c2.new(:id => 1234).remove_all_attributes
-    MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE (node_id = 1234)'
+    MODEL_DB.sqls.should == ['DELETE FROM attributes_nodes WHERE (node_id = 1234)']
   end
 
   it "should have the remove_all_ method respect the :left_primary_key option" do
     @c2.many_to_many :attributes, :class => @c1, :left_primary_key=>:xxx
     @c2.new(:id => 1234, :xxx=>5).remove_all_attributes
-    MODEL_DB.sqls.first.should == 'DELETE FROM attributes_nodes WHERE (node_id = 5)'
+    MODEL_DB.sqls.should == ['DELETE FROM attributes_nodes WHERE (node_id = 5)']
   end
   
   it "should have the remove_all_ method respect composite keys" do
@@ -2421,10 +2264,9 @@ describe Sequel::Model, "many_to_many" do
 
   it "remove_all should return the array of previously associated items if the cached instance variable exists" do
     @c2.many_to_many :attributes, :class => @c1
-    attrib = @c1.new(:id=>3)
-    node = @c2.new(:id => 1234)
-    d = @c1.dataset
-    def d.fetch_rows(s); end
+    attrib = @c1.load(:id=>3)
+    node = @c2.load(:id => 1234)
+    @c1.dataset._fetch = []
     node.attributes.should == []
     node.add_attribute(attrib)
     node.associations[:attributes].should == [attrib]
@@ -2439,11 +2281,9 @@ describe Sequel::Model, "many_to_many" do
   it "remove_all should remove the current item from all reciprocal instance varaibles if it cached instance variable exists" do
     @c2.many_to_many :attributes, :class => @c1
     @c1.many_to_many :nodes, :class => @c2
-    d = @c1.dataset
-    def d.fetch_rows(s); end
-    d = @c2.dataset
-    def d.fetch_rows(s); end
-    attrib = @c1.new(:id=>3)
+    @c1.dataset._fetch = []
+    @c2.dataset._fetch = []
+    attrib = @c1.load(:id=>3)
     node = @c2.new(:id => 1234)
     node.attributes.should == []
     attrib.nodes.should == []
@@ -2459,8 +2299,9 @@ describe Sequel::Model, "many_to_many" do
     o.add_attribute(@c1.load(:id=>44))
     o.remove_attribute(@c1.load(:id=>45))
     o.remove_all_attributes
-    MODEL_DB.sqls.first =~ /INSERT INTO attributes_nodes \((node_id|attribute_id|x), (node_id|attribute_id|x), (node_id|attribute_id|x)\) VALUES \((1234|123|44), (1234|123|44), (1234|123|44)\)/
-    MODEL_DB.sqls[1..-1].should == ["DELETE FROM attributes_nodes WHERE ((x = 123) AND (node_id = 1234) AND (attribute_id = 45))",
+    sqls = MODEL_DB.sqls
+    sqls.shift =~ /INSERT INTO attributes_nodes \((node_id|attribute_id|x), (node_id|attribute_id|x), (node_id|attribute_id|x)\) VALUES \((1234|123|44), (1234|123|44), (1234|123|44)\)/
+    sqls.should == ["DELETE FROM attributes_nodes WHERE ((x = 123) AND (node_id = 1234) AND (attribute_id = 45))",
       "DELETE FROM attributes_nodes WHERE ((x = 123) AND (node_id = 1234))"]
   end
 
@@ -2543,18 +2384,18 @@ describe Sequel::Model, "many_to_many" 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
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def _add_attribute(v)
-        self.class.send(:class_variable_get, :@@blah) << 4
+        model::Foo << 4
       end
       def _remove_attribute(v)
-        self.class.send(:class_variable_get, :@@blah) << 5
+        model::Foo << 5
       end
       def blah(x)
-        self.class.send(:class_variable_get, :@@blah) << x.pk
+        model::Foo << x.pk
       end
       def blahr(x)
-        self.class.send(:class_variable_get, :@@blah) << 6
+        model::Foo << 6
       end
     end
     p = @c2.load(:id=>10)
@@ -2570,17 +2411,12 @@ describe Sequel::Model, "many_to_many" 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
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def al(v)
-        v.each{|x| self.class.send(:class_variable_get, :@@blah) << x.pk}
-      end
-    end
-    @c1.class_eval do
-      def @dataset.fetch_rows(sql)
-        yield({:id=>20})
-        yield({:id=>30})
+        v.each{|x| model::Foo << x.pk}
       end
     end
+    @c1.dataset._fetch = [{:id=>20}, {:id=>30}]
     p = @c2.load(:id=>10, :parent_id=>20)
     attributes = p.attributes
     h.should == [[10, [20, 30]], 20, 30]
@@ -2623,14 +2459,7 @@ describe Sequel::Model, "many_to_many" do
 
   it "should support a :uniq option that removes duplicates from the association" do
     @c2.many_to_many :attributes, :class => @c1, :uniq=>true
-    @c1.class_eval do
-      def @dataset.fetch_rows(sql)
-        yield({:id=>20})
-        yield({:id=>30})
-        yield({:id=>20})
-        yield({:id=>30})
-      end
-    end
+    @c1.dataset._fetch = [{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}]
     @c2.load(:id=>10, :parent_id=>20).attributes.should == [@c1.load(:id=>20), @c1.load(:id=>30)]
   end
   
@@ -2651,76 +2480,435 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1 do |ds|
       ds.filter(:join_table_att=>3)
     end
-    @c1.dataset.instance_eval do
-      def fetch_rows(sql, &block)
-        db.sqls << sql
-        yield(:id=>2)
-      end
-    end
+    @c1.dataset._fetch = {:id=>2}
     @c2.load(:id=>1).remove_attribute(2)
     MODEL_DB.sqls.should == ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON ((attributes_nodes.attribute_id = attributes.id) AND (attributes_nodes.node_id = 1)) WHERE ((join_table_att = 3) AND (attributes.id = 2)) LIMIT 1",
       "DELETE FROM attributes_nodes WHERE ((node_id = 1) AND (attribute_id = 2))"] 
   end
 end
 
-describe Sequel::Model, " association reflection methods" do
+describe "Filtering by associations" do
   before do
-    MODEL_DB.reset
-    @c1 = Class.new(Sequel::Model(:nodes)) do
-      def self.name; 'Node'; end
-      def self.to_s; 'Node'; end
+    @Album = Class.new(Sequel::Model(:albums))
+    artist = @Artist = Class.new(Sequel::Model(:artists))
+    tag = @Tag = Class.new(Sequel::Model(:tags))
+    track = @Track = Class.new(Sequel::Model(:tracks))
+    album_info = @AlbumInfo = Class.new(Sequel::Model(:album_infos))
+    @Artist.columns :id, :id1, :id2
+    @Tag.columns :id, :tid1, :tid2
+    @Track.columns :id, :album_id, :album_id1, :album_id2
+    @AlbumInfo.columns :id, :album_id, :album_id1, :album_id2
+    @Album.class_eval do
+      columns :id, :id1, :id2, :artist_id, :artist_id1, :artist_id2
+      many_to_one :artist, :class=>artist
+      one_to_many :tracks, :class=>track, :key=>:album_id
+      one_to_one :album_info, :class=>album_info, :key=>:album_id
+      many_to_many :tags, :class=>tag, :left_key=>:album_id, :join_table=>:albums_tags
+
+      many_to_one :cartist, :class=>artist, :key=>[:artist_id1, :artist_id2], :primary_key=>[:id1, :id2]
+      one_to_many :ctracks, :class=>track, :key=>[:album_id1, :album_id2], :primary_key=>[:id1, :id2]
+      one_to_one :calbum_info, :class=>album_info, :key=>[:album_id1, :album_id2], :primary_key=>[:id1, :id2]
+      many_to_many :ctags, :class=>tag, :left_key=>[:album_id1, :album_id2], :left_primary_key=>[:id1, :id2], :right_key=>[:tag_id1, :tag_id2], :right_primary_key=>[:tid1, :tid2], :join_table=>:albums_tags
     end
   end
-  
-  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.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]
+  it "should be able to filter on many_to_one associations" do
+    @Album.filter(:artist=>@Artist.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (artist_id = 3)'
+  end
+
+  it "should be able to filter on one_to_many associations" do
+    @Album.filter(:tracks=>@Track.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE (id = 3)'
+  end
+
+  it "should be able to filter on one_to_one associations" do
+    @Album.filter(:album_info=>@AlbumInfo.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE (id = 3)'
+  end
+
+  it "should be able to filter on many_to_many associations" do
+    @Album.filter(:tags=>@Tag.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM albums_tags WHERE ((tag_id = 3) AND (album_id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on many_to_one associations with composite keys" do
+    @Album.filter(:cartist=>@Artist.load(:id1=>3, :id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((artist_id1 = 3) AND (artist_id2 = 4))'
+  end
+
+  it "should be able to filter on one_to_many associations with composite keys" do
+    @Album.filter(:ctracks=>@Track.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 = 3) AND (id2 = 4))'
+  end
+
+  it "should be able to filter on one_to_one associations with composite keys" do
+    @Album.filter(:calbum_info=>@AlbumInfo.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 = 3) AND (id2 = 4))' 
+  end
+
+  it "should be able to filter on many_to_many associations with composite keys" do
+    @Album.filter(:ctags=>@Tag.load(:tid1=>3, :tid2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE ((tag_id1 = 3) AND (tag_id2 = 4) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should work inside a complex filter" do
+    artist = @Artist.load(:id=>3)
+    @Album.filter{foo & {:artist=>artist}}.sql.should == 'SELECT * FROM albums WHERE (foo AND (artist_id = 3))'
+    track = @Track.load(:album_id=>4)
+    @Album.filter{foo & [[:artist, artist], [:tracks, track]]}.sql.should == 'SELECT * FROM albums WHERE (foo AND (artist_id = 3) AND (id = 4))'
+  end
+
+  it "should raise for an invalid association name" do
+    proc{@Album.filter(:foo=>@Artist.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise for an invalid association type" do
+    @Album.many_to_many :iatags, :clone=>:tags
+    @Album.association_reflection(:iatags)[:type] = :foo
+    proc{@Album.filter(:iatags=>@Tag.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise for an invalid associated object class " do
+    proc{@Album.filter(:tags=>@Artist.load(:id=>3)).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise for an invalid associated object class when multiple objects are used" do
+    proc{@Album.filter(:tags=>[@Tag.load(:id=>3), @Artist.load(:id=>3)]).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should correctly handle case when a multiple value association is used" do
+    proc{@Album.filter(:tags=>[@Tag.load(:id=>3), @Artist.load(:id=>3)]).sql}.should raise_error(Sequel::Error)
+  end
+
+  it "should not affect non-association IN/NOT IN filtering with an empty array" do
+    @Album.filter(:tag_id=>[]).sql.should == 'SELECT * FROM albums WHERE (tag_id != tag_id)'
+    @Album.exclude(:tag_id=>[]).sql.should == 'SELECT * FROM albums WHERE (1 = 1)'
+  end
+
+  it "should work correctly in subclasses" do
+    c = Class.new(@Album)
+    c.many_to_one :sartist, :class=>@Artist
+    c.filter(:sartist=>@Artist.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE (sartist_id = 3)'
+  end
+
+  it "should be able to exclude on many_to_one associations" do
+    @Album.exclude(:artist=>@Artist.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE ((artist_id != 3) OR (artist_id IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_many associations" do
+    @Album.exclude(:tracks=>@Track.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE ((id != 3) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_one associations" do
+    @Album.exclude(:album_info=>@AlbumInfo.load(:album_id=>3)).sql.should == 'SELECT * FROM albums WHERE ((id != 3) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on many_to_many associations" do
+    @Album.exclude(:tags=>@Tag.load(:id=>3)).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM albums_tags WHERE ((tag_id = 3) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on many_to_one associations with composite keys" do
+    @Album.exclude(:cartist=>@Artist.load(:id1=>3, :id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((artist_id1 != 3) OR (artist_id2 != 4) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_many associations with composite keys" do
+    @Album.exclude(:ctracks=>@Track.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 != 3) OR (id2 != 4) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_one associations with composite keys" do
+    @Album.exclude(:calbum_info=>@AlbumInfo.load(:album_id1=>3, :album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE ((id1 != 3) OR (id2 != 4) OR (id1 IS NULL) OR (id2 IS NULL))' 
+  end
+
+  it "should be able to exclude on many_to_many associations with composite keys" do
+    @Album.exclude(:ctags=>@Tag.load(:tid1=>3, :tid2=>4)).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE ((tag_id1 = 3) AND (tag_id2 = 4) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to filter on multiple many_to_one associations" do
+    @Album.filter(:artist=>[@Artist.load(:id=>3), @Artist.load(:id=>4)]).sql.should == 'SELECT * FROM albums WHERE (artist_id IN (3, 4))'
+  end
+
+  it "should be able to filter on multiple one_to_many associations" do
+    @Album.filter(:tracks=>[@Track.load(:album_id=>3), @Track.load(:album_id=>4)]).sql.should == 'SELECT * FROM albums WHERE (id IN (3, 4))'
+  end
+
+  it "should be able to filter on multiple one_to_one associations" do
+    @Album.filter(:album_info=>[@AlbumInfo.load(:album_id=>3), @AlbumInfo.load(:album_id=>4)]).sql.should == 'SELECT * FROM albums WHERE (id IN (3, 4))'
+  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]
+  it "should be able to filter on multiple many_to_many associations" do
+    @Album.filter(:tags=>[@Tag.load(:id=>3), @Tag.load(:id=>4)]).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (3, 4)) AND (album_id IS NOT NULL))))'
   end
 
-  it "#association_reflection should return nil for nonexistent association" do
-    @c1.association_reflection(:blah).should == nil
+  it "should be able to filter on multiple many_to_one associations with composite keys" do
+    @Album.filter(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.load(:id1=>5, :id2=>6)]).sql.should == 'SELECT * FROM albums WHERE ((artist_id1, artist_id2) IN ((3, 4), (5, 6)))'
   end
 
-  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 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
+  it "should be able to filter on multiple one_to_many associations with composite keys" do
+    @Album.filter(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.load(:album_id1=>5, :album_id2=>6)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4), (5, 6)))'
+  end
+
+  it "should be able to filter on multiple one_to_one associations with composite keys" do
+    @Album.filter(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.load(:album_id1=>5, :album_id2=>6)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4), (5, 6)))' 
+  end
+
+  it "should be able to filter on multiple many_to_many associations with composite keys" do
+    @Album.filter(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.load(:tid1=>5, :tid2=>6)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4), (5, 6))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to exclude on multiple many_to_one associations" do
+    @Album.exclude(:artist=>[@Artist.load(:id=>3), @Artist.load(:id=>4)]).sql.should == 'SELECT * FROM albums WHERE ((artist_id NOT IN (3, 4)) OR (artist_id IS NULL))'
+  end
+
+  it "should be able to exclude on multiple one_to_many associations" do
+    @Album.exclude(:tracks=>[@Track.load(:album_id=>3), @Track.load(:album_id=>4)]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (3, 4)) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on multiple one_to_one associations" do
+    @Album.exclude(:album_info=>[@AlbumInfo.load(:album_id=>3), @AlbumInfo.load(:album_id=>4)]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (3, 4)) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on multiple many_to_many associations" do
+    @Album.exclude(:tags=>[@Tag.load(:id=>3), @Tag.load(:id=>4)]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (3, 4)) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on multiple many_to_one associations with composite keys" do
+    @Album.exclude(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.load(:id1=>5, :id2=>6)]).sql.should == 'SELECT * FROM albums WHERE (((artist_id1, artist_id2) NOT IN ((3, 4), (5, 6))) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+  end
+
+  it "should be able to exclude on multiple one_to_many associations with composite keys" do
+    @Album.exclude(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.load(:album_id1=>5, :album_id2=>6)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4), (5, 6))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to exclude on multiple one_to_one associations with composite keys" do
+    @Album.exclude(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.load(:album_id1=>5, :album_id2=>6)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4), (5, 6))) OR (id1 IS NULL) OR (id2 IS NULL))' 
+  end
+
+  it "should be able to exclude on multiple many_to_many associations with composite keys" do
+    @Album.exclude(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.load(:tid1=>5, :tid2=>6)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4), (5, 6))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to handle NULL values when filtering many_to_one associations" do
+    @Album.filter(:artist=>@Artist.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering one_to_many associations" do
+    @Album.filter(:tracks=>@Track.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering one_to_one associations" do
+    @Album.filter(:album_info=>@AlbumInfo.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering many_to_many associations" do
+    @Album.filter(:tags=>@Tag.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle filteringing with NULL values for many_to_one associations with composite keys" do
+    @Album.filter(:cartist=>@Artist.load(:id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:cartist=>@Artist.load(:id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:cartist=>@Artist.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to filtering with NULL values for one_to_many associations with composite keys" do
+    @Album.filter(:ctracks=>@Track.load(:album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:ctracks=>@Track.load(:album_id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:ctracks=>@Track.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to filtering with NULL values for one_to_one associations with composite keys" do
+    @Album.filter(:calbum_info=>@AlbumInfo.load(:album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'f\'' 
+    @Album.filter(:calbum_info=>@AlbumInfo.load(:album_id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'f\'' 
+    @Album.filter(:calbum_info=>@AlbumInfo.new).sql.should == 'SELECT * FROM albums WHERE \'f\'' 
+  end
+
+  it "should be able to filtering with NULL values for many_to_many associations with composite keys" do
+    @Album.filter(:ctags=>@Tag.load(:tid1=>3)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:ctags=>@Tag.load(:tid2=>4)).sql.should == 'SELECT * FROM albums WHERE \'f\''
+    @Album.filter(:ctags=>@Tag.new).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when excluding many_to_one associations" do
+    @Album.exclude(:artist=>@Artist.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding one_to_many associations" do
+    @Album.exclude(:tracks=>@Track.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding one_to_one associations" do
+    @Album.exclude(:album_info=>@AlbumInfo.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding many_to_many associations" do
+    @Album.exclude(:tags=>@Tag.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle excluding with NULL values for many_to_one associations with composite keys" do
+    @Album.exclude(:cartist=>@Artist.load(:id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:cartist=>@Artist.load(:id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:cartist=>@Artist.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to excluding with NULL values for one_to_many associations with composite keys" do
+    @Album.exclude(:ctracks=>@Track.load(:album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:ctracks=>@Track.load(:album_id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:ctracks=>@Track.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to excluding with NULL values for one_to_one associations with composite keys" do
+    @Album.exclude(:calbum_info=>@AlbumInfo.load(:album_id2=>4)).sql.should == 'SELECT * FROM albums WHERE \'t\'' 
+    @Album.exclude(:calbum_info=>@AlbumInfo.load(:album_id1=>3)).sql.should == 'SELECT * FROM albums WHERE \'t\'' 
+    @Album.exclude(:calbum_info=>@AlbumInfo.new).sql.should == 'SELECT * FROM albums WHERE \'t\'' 
+  end
+
+  it "should be able to excluding with NULL values for many_to_many associations with composite keys" do
+    @Album.exclude(:ctags=>@Tag.load(:tid1=>3)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:ctags=>@Tag.load(:tid2=>4)).sql.should == 'SELECT * FROM albums WHERE \'t\''
+    @Album.exclude(:ctags=>@Tag.new).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple many_to_one associations" do
+    @Album.filter(:artist=>[@Artist.load(:id=>3), @Artist.new]).sql.should == 'SELECT * FROM albums WHERE (artist_id IN (3))'
+    @Album.filter(:artist=>[@Artist.new, @Artist.new]).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple one_to_many associations" do
+    @Album.filter(:tracks=>[@Track.load(:album_id=>3), @Track.new]).sql.should == 'SELECT * FROM albums WHERE (id IN (3))'
+    @Album.filter(:tracks=>[@Track.new, @Track.new]).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple one_to_one associations" do
+    @Album.filter(:album_info=>[@AlbumInfo.load(:album_id=>3), @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE (id IN (3))'
+    @Album.filter(:album_info=>[@AlbumInfo.new, @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple many_to_many associations" do
+    @Album.filter(:tags=>[@Tag.load(:id=>3), @Tag.new]).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (3)) AND (album_id IS NOT NULL))))'
+    @Album.filter(:tags=>[@Tag.new, @Tag.new]).sql.should == 'SELECT * FROM albums WHERE \'f\''
+  end
+
+  it "should be able to handle NULL values when filtering multiple many_to_one associations with composite keys" do
+    @Album.filter(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.load(:id1=>3)]).sql.should == 'SELECT * FROM albums WHERE ((artist_id1, artist_id2) IN ((3, 4)))'
+    @Album.filter(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.new]).sql.should == 'SELECT * FROM albums WHERE ((artist_id1, artist_id2) IN ((3, 4)))'
+  end
+
+  it "should be able handle NULL values when filtering multiple one_to_many associations with composite keys" do
+    @Album.filter(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.load(:album_id1=>3)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4)))'
+    @Album.filter(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.new]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4)))'
+  end
+
+  it "should be able to handle NULL values when filtering multiple one_to_one associations with composite keys" do
+    @Album.filter(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.load(:album_id1=>5)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4)))' 
+    @Album.filter(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN ((3, 4)))' 
+  end
+
+  it "should be able to handle NULL values when filtering multiple many_to_many associations with composite keys" do
+    @Album.filter(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.load(:tid1=>5)]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+    @Album.filter(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.new]).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to handle NULL values when excluding multiple many_to_one associations" do
+    @Album.exclude(:artist=>[@Artist.load(:id=>3), @Artist.new]).sql.should == 'SELECT * FROM albums WHERE ((artist_id NOT IN (3)) OR (artist_id IS NULL))'
+    @Album.exclude(:artist=>[@Artist.new, @Artist.new]).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding multiple one_to_many associations" do
+    @Album.exclude(:tracks=>[@Track.load(:album_id=>3), @Track.new]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (3)) OR (id IS NULL))'
+    @Album.exclude(:tracks=>[@Track.new, @Track.new]).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding multiple one_to_one associations" do
+    @Album.exclude(:album_info=>[@AlbumInfo.load(:album_id=>3), @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (3)) OR (id IS NULL))'
+    @Album.exclude(:album_info=>[@AlbumInfo.new, @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding multiple many_to_many associations" do
+    @Album.exclude(:tags=>[@Tag.load(:id=>3), @Tag.new]).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (3)) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+    @Album.exclude(:tags=>[@Tag.new, @Tag.new]).sql.should == 'SELECT * FROM albums WHERE \'t\''
+  end
+
+  it "should be able to handle NULL values when excluding multiple many_to_one associations with composite keys" do
+    @Album.exclude(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.load(:id1=>3)]).sql.should == 'SELECT * FROM albums WHERE (((artist_id1, artist_id2) NOT IN ((3, 4))) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+    @Album.exclude(:cartist=>[@Artist.load(:id1=>3, :id2=>4), @Artist.new]).sql.should == 'SELECT * FROM albums WHERE (((artist_id1, artist_id2) NOT IN ((3, 4))) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+  end
+
+  it "should be able handle NULL values when excluding multiple one_to_many associations with composite keys" do
+    @Album.exclude(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.load(:album_id1=>3)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4))) OR (id1 IS NULL) OR (id2 IS NULL))'
+    @Album.exclude(:ctracks=>[@Track.load(:album_id1=>3, :album_id2=>4), @Track.new]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to handle NULL values when excluding multiple one_to_one associations with composite keys" do
+    @Album.exclude(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.load(:album_id1=>5)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4))) OR (id1 IS NULL) OR (id2 IS NULL))' 
+    @Album.exclude(:calbum_info=>[@AlbumInfo.load(:album_id1=>3, :album_id2=>4), @AlbumInfo.new]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN ((3, 4))) OR (id1 IS NULL) OR (id2 IS NULL))' 
+  end
+
+  it "should be able to handle NULL values when excluding multiple many_to_many associations with composite keys" do
+    @Album.exclude(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.load(:tid1=>5)]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+    @Album.exclude(:ctags=>[@Tag.load(:tid1=>3, :tid2=>4), @Tag.new]).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN ((3, 4))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to filter on many_to_one association datasets" do
+    @Album.filter(:artist=>@Artist.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (artist_id IN (SELECT id FROM artists WHERE ((x = 1) AND (id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on one_to_many association datasets" do
+    @Album.filter(:tracks=>@Track.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM tracks WHERE ((x = 1) AND (album_id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on one_to_one association datasets" do
+    @Album.filter(:album_info=>@AlbumInfo.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM album_infos WHERE ((x = 1) AND (album_id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on many_to_many association datasets" do
+    @Album.filter(:tags=>@Tag.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (id IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (SELECT id FROM tags WHERE ((x = 1) AND (id IS NOT NULL)))) AND (album_id IS NOT NULL))))'
+  end
+
+  it "should be able to filter on many_to_one association datasets with composite keys" do
+    @Album.filter(:cartist=>@Artist.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((artist_id1, artist_id2) IN (SELECT id1, id2 FROM artists WHERE ((x = 1) AND (id1 IS NOT NULL) AND (id2 IS NOT NULL))))'
+  end
+
+  it "should be able to filter on one_to_many association datasets with composite keys" do
+    @Album.filter(:ctracks=>@Track.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM tracks WHERE ((x = 1) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to filter on one_to_one association datasets with composite keys" do
+    @Album.filter(:calbum_info=>@AlbumInfo.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM album_infos WHERE ((x = 1) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to filter on many_to_many association datasets with composite keys" do
+    @Album.filter(:ctags=>@Tag.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id1, id2) IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN (SELECT tid1, tid2 FROM tags WHERE ((x = 1) AND (tid1 IS NOT NULL) AND (tid2 IS NOT NULL)))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL))))'
+  end
+
+  it "should be able to exclude on many_to_one association datasets" do
+    @Album.exclude(:artist=>@Artist.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((artist_id NOT IN (SELECT id FROM artists WHERE ((x = 1) AND (id IS NOT NULL)))) OR (artist_id IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_many association datasets" do
+    @Album.exclude(:tracks=>@Track.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM tracks WHERE ((x = 1) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_one association datasets" do
+    @Album.exclude(:album_info=>@AlbumInfo.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM album_infos WHERE ((x = 1) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on many_to_many association datasets" do
+    @Album.exclude(:tags=>@Tag.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE ((id NOT IN (SELECT album_id FROM albums_tags WHERE ((tag_id IN (SELECT id FROM tags WHERE ((x = 1) AND (id IS NOT NULL)))) AND (album_id IS NOT NULL)))) OR (id IS NULL))'
+  end
+
+  it "should be able to exclude on many_to_one association datasets with composite keys" do
+    @Album.exclude(:cartist=>@Artist.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (((artist_id1, artist_id2) NOT IN (SELECT id1, id2 FROM artists WHERE ((x = 1) AND (id1 IS NOT NULL) AND (id2 IS NOT NULL)))) OR (artist_id1 IS NULL) OR (artist_id2 IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_many association datasets with composite keys" do
+    @Album.exclude(:ctracks=>@Track.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM tracks WHERE ((x = 1) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  end
+
+  it "should be able to exclude on one_to_one association datasets with composite keys" do
+    @Album.exclude(:calbum_info=>@AlbumInfo.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM album_infos WHERE ((x = 1) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
+  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
+  it "should be able to exclude on many_to_many association datasets with composite keys" do
+    @Album.exclude(:ctags=>@Tag.filter(:x=>1)).sql.should == 'SELECT * FROM albums WHERE (((id1, id2) NOT IN (SELECT album_id1, album_id2 FROM albums_tags WHERE (((tag_id1, tag_id2) IN (SELECT tid1, tid2 FROM tags WHERE ((x = 1) AND (tid1 IS NOT NULL) AND (tid2 IS NOT NULL)))) AND (album_id1 IS NOT NULL) AND (album_id2 IS NOT NULL)))) OR (id1 IS NULL) OR (id2 IS NULL))'
   end
 
-  it "#associations should include all association names" do
-    @c1.associations.should == []
-    @c1.associate :many_to_one, :parent, :class => @c1
-    @c1.associations.should == [:parent]
-    @c1.associate :one_to_many, :children, :class => @c1
-    @c1.associations.sort_by{|x|x.to_s}.should == [:children, :parent]
+  it "should do a regular IN query if the dataset for a different model is used" do
+    @Album.filter(:artist=>@Album.select(:x)).sql.should == 'SELECT * FROM albums WHERE (artist IN (SELECT x FROM albums))'
   end
 
-  it "association reflections should be copied upon subclasing" do
-    @c1.associate :many_to_one, :parent, :class => @c1
-    c = Class.new(@c1)
-    @c1.associations.should == [:parent]
-    c.associations.should == [:parent]
-    c.associate :many_to_one, :parent2, :class => @c1
-    @c1.associations.should == [:parent]
-    c.associations.sort_by{|x| x.to_s}.should == [:parent, :parent2]
-    c.instance_methods.map{|x| x.to_s}.should include('parent')
+  it "should do a regular IN query if a non-model dataset is used" do
+    @Album.filter(:artist=>@Album.db.from(:albums).select(:x)).sql.should == 'SELECT * FROM albums WHERE (artist IN (SELECT x FROM albums))'
   end
 end