sequel 4.41.0 → 4.42.0

data/spec/extensions/instance_filters_spec.rb

@@ -3,7 +3,6 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "instance_filters plugin" do
   before do
     @c = Class.new(Sequel::Model(:people))
-    @c.dataset.quote_identifiers = false
     @c.columns :id, :name, :num
     @c.plugin :instance_filters
     @p = @c.load(:id=>1, :name=>'John', :num=>1)
@@ -14,7 +13,7 @@ describe "instance_filters plugin" do
     @p.update(:name=>'Bob')
     DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
     @p.instance_filter(:name=>'Jim')
-    @p.this.numrows = 0
+    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
     proc{@p.update(:name=>'Joe')}.must_raise(Sequel::Plugins::InstanceFilters::Error)
     DB.sqls.must_equal ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"]
   end 
@@ -23,7 +22,7 @@ describe "instance_filters plugin" do
     @p.destroy
     DB.sqls.must_equal ["DELETE FROM people WHERE id = 1"]
     @p.instance_filter(:name=>'Jim')
-    @p.this.numrows = 0
+    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
     proc{@p.destroy}.must_raise(Sequel::Plugins::InstanceFilters::Error)
     DB.sqls.must_equal ["DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"]
   end 
@@ -34,16 +33,16 @@ describe "instance_filters plugin" do
     @p.update(:name=>'Bob')
     DB.sqls.must_equal ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
     @p.instance_filter(:name=>'Jim')
-    @p.this.numrows = 0
+    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
     proc{@p.update(:name=>'Joe')}.must_raise(Sequel::Plugins::InstanceFilters::Error)
     DB.sqls.must_equal ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"]
 
     @p = @c.load(:id=>1, :name=>'John', :num=>1)
-    @p.this.numrows = 1
+    @p.instance_variable_set(:@this, @p.this.with_numrows(1))
     @p.destroy
     DB.sqls.must_equal ["DELETE FROM people WHERE (id = 1)"]
     @p.instance_filter(:name=>'Jim')
-    @p.this.numrows = 0
+    @p.instance_variable_set(:@this, @p.this.with_numrows(0))
     proc{@p.destroy}.must_raise(Sequel::Plugins::InstanceFilters::Error)
     DB.sqls.must_equal ["DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"]
     

data/spec/extensions/instance_hooks_spec.rb

@@ -28,10 +28,10 @@ describe "InstanceHooks plugin" do
     @o.after_create_hook{r 1}
     @o.before_create_hook{r false}
     @o.before_create_hook{r 4}
-    @o.save.must_equal nil
+    @o.save.must_be_nil
     @r.must_equal [4, false]
     @r.clear
-    @o.save.must_equal nil
+    @o.save.must_be_nil
     @r.must_equal [4, false]
   end
 
@@ -50,10 +50,10 @@ describe "InstanceHooks plugin" do
     @x.after_update_hook{r 1}
     @x.before_update_hook{r false}
     @x.before_update_hook{r 4}
-    @x.save.must_equal nil
+    @x.save.must_be_nil
     @r.must_equal [4, false]
     @r.clear
-    @x.save.must_equal nil
+    @x.save.must_be_nil
     @r.must_equal [4, false]
   end
 
@@ -80,17 +80,17 @@ describe "InstanceHooks plugin" do
     @x.after_save_hook{r 1}
     @x.before_save_hook{r false}
     @x.before_save_hook{r 4}
-    @x.save.must_equal nil
+    @x.save.must_be_nil
     @r.must_equal [4, false]
     @r.clear
     
     @x.after_save_hook{r 1}
     @x.before_save_hook{r false}
     @x.before_save_hook{r 4}
-    @x.save.must_equal nil
+    @x.save.must_be_nil
     @r.must_equal [4, false]
     @r.clear
-    @x.save.must_equal nil
+    @x.save.must_be_nil
     @r.must_equal [4, false]
   end
 
@@ -107,7 +107,7 @@ describe "InstanceHooks plugin" do
     @x.after_destroy_hook{r 1}
     @x.before_destroy_hook{r false}
     @x.before_destroy_hook{r 4}
-    @x.destroy.must_equal nil
+    @x.destroy.must_be_nil
     @r.must_equal [4, false]
   end
 
@@ -180,9 +180,9 @@ describe "InstanceHooks plugin" do
   it "should not clear validations hooks on successful save" do
     @x.after_validation_hook{@x.errors.add(:id, 'a') if @x.id == 1; r 1}
     @x.before_validation_hook{r 2}
-    @x.save.must_equal nil
+    @x.save.must_be_nil
     @r.must_equal [2, 1]
-    @x.save.must_equal nil
+    @x.save.must_be_nil
     @r.must_equal [2, 1, 2, 1]
     @x.id = 2
     @x.save.must_equal @x
@@ -237,7 +237,7 @@ describe "InstanceHooks plugin with transactions" do
   it "should support after_rollback_hook" do
     @or.after_rollback_hook{@db.execute('ar1')}
     @or.after_rollback_hook{@db.execute('ar2')}
-    @or.save.must_equal nil
+    @or.save.must_be_nil
     @db.sqls.must_equal ['BEGIN', 'as', 'ROLLBACK', 'ar1', 'ar2']
   end
   
@@ -251,7 +251,7 @@ describe "InstanceHooks plugin with transactions" do
   it "should support after_rollback_hook" do
     @or.after_destroy_rollback_hook{@db.execute('adr1')}
     @or.after_destroy_rollback_hook{@db.execute('adr2')}
-    @or.destroy.must_equal nil
+    @or.destroy.must_be_nil
     @db.sqls.must_equal ['BEGIN', "DELETE FROM items WHERE (id = 1)", 'ad', 'ROLLBACK', 'adr1', 'adr2']
   end
 

data/spec/extensions/json_serializer_spec.rb

@@ -174,16 +174,15 @@ describe "Sequel::Plugins::JsonSerializer" do
   end
 
   it "should support a to_json class and dataset method" do
-    Album.dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
-    Artist.dataset._fetch = {:id=>2, :name=>'YJM'}
+    Album.dataset = Album.dataset.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
+    Artist.dataset = Artist.dataset.with_fetch(:id=>2, :name=>'YJM')
     Album.array_from_json(Album.to_json).must_equal [@album]
     Album.array_from_json(Album.to_json(:include=>:artist), :associations=>:artist).map{|x| x.artist}.must_equal [@artist]
     Album.array_from_json(Album.dataset.to_json(:only=>:name)).must_equal [Album.load(:name=>@album.name)]
   end
 
   it "should have dataset to_json method work with naked datasets" do
-    ds = Album.dataset.naked
-    ds._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
+    ds = Album.dataset.naked.with_fetch(:id=>1, :name=>'RF', :artist_id=>2)
     Sequel.parse_json(ds.to_json).must_equal [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]
   end
 
@@ -227,7 +226,7 @@ describe "Sequel::Plugins::JsonSerializer" do
       end
     end
     Namespace::Album.new({}).to_json(:root=>true).to_s.must_equal '{"album":{}}'
-    Namespace::Album.dataset._fetch = [{}]
+    Namespace::Album.dataset = Namespace::Album.dataset.with_fetch([{}])
     Namespace::Album.dataset.to_json(:root=>:collection).to_s.must_equal '{"albums":[{}]}'
     Namespace::Album.dataset.to_json(:root=>:both).to_s.must_equal '{"albums":[{"album":{}}]}'
     Object.send(:remove_const, :Namespace)
@@ -239,25 +238,23 @@ describe "Sequel::Plugins::JsonSerializer" do
   end
   
   it "should handle the :root=>:both option to qualify a dataset of records" do
-    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
-    Album.dataset.to_json(:root=>:both, :only => :id).to_s.must_equal '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
+    Album.dataset.with_fetch([{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]).to_json(:root=>:both, :only => :id).to_s.must_equal '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
   end
 
   it "should handle the :root=>:collection option to qualify just the collection" do
-    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
-    Album.dataset.to_json(:root=>:collection, :only => :id).to_s.must_equal '{"albums":[{"id":1},{"id":1}]}'
-    Album.dataset.to_json(:root=>true, :only => :id).to_s.must_equal '{"albums":[{"id":1},{"id":1}]}'
+    ds = Album.dataset.with_fetch([{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}])
+    ds.to_json(:root=>:collection, :only => :id).to_s.must_equal '{"albums":[{"id":1},{"id":1}]}'
+    ds.to_json(:root=>true, :only => :id).to_s.must_equal '{"albums":[{"id":1},{"id":1}]}'
   end
 
   it "should handle the :root=>:instance option to qualify just the instances" do
-    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
-    Album.dataset.to_json(:root=>:instance, :only => :id).to_s.must_equal '[{"album":{"id":1}},{"album":{"id":1}}]'
+    Album.dataset.with_fetch([{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]).to_json(:root=>:instance, :only => :id).to_s.must_equal '[{"album":{"id":1}},{"album":{"id":1}}]'
   end
 
   it "should handle the :root=>string option to qualify just the collection using the string as the key" do
-    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
-    Album.dataset.to_json(:root=>"foos", :only => :id).to_s.must_equal '{"foos":[{"id":1},{"id":1}]}'
-    Album.dataset.to_json(:root=>"bars", :only => :id).to_s.must_equal '{"bars":[{"id":1},{"id":1}]}'
+    ds = Album.dataset.with_fetch([{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}])
+    ds.to_json(:root=>"foos", :only => :id).to_s.must_equal '{"foos":[{"id":1},{"id":1}]}'
+    ds.to_json(:root=>"bars", :only => :id).to_s.must_equal '{"bars":[{"id":1},{"id":1}]}'
   end
 
   it "should use an alias for an included asscociation to qualify an association" do

data/spec/extensions/lazy_attributes_spec.rb

@@ -12,7 +12,7 @@ describe "Sequel::Plugins::LazyAttributes" do
       meta_def(:columns){[:id, :name]}
       lazy_attributes :name
       meta_def(:columns){[:id]}
-      instance_dataset._fetch = dataset._fetch = proc do |sql|
+      set_dataset dataset.with_fetch(proc do |sql|
         if sql !~ /WHERE/
           if sql =~ /name/
             [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
@@ -32,7 +32,7 @@ describe "Sequel::Plugins::LazyAttributes" do
             end
           end
         end
-      end
+      end)
     end
     @c = ::LazyAttributesModel
     @ds = LazyAttributesModel.dataset
@@ -108,7 +108,7 @@ describe "Sequel::Plugins::LazyAttributes" do
   it "should not lazily load the attribute for a single model object if it is a new record" do
     m = @c.new
     m.values.must_equal({})
-    m.name.must_equal nil
+    m.name.must_be_nil
     @db.sqls.must_equal []
   end
 
@@ -148,7 +148,7 @@ describe "Sequel::Plugins::LazyAttributes" do
 
   it "should work with the serialization plugin" do
     @c.plugin :serialization, :yaml, :name
-    @c.instance_dataset._fetch = @ds._fetch = [[{:id=>1}, {:id=>2}], [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}], [{:id=>1}], [{:name=>"--- 3\n"}]]
+    @ds = @c.dataset = @ds.with_fetch([[{:id=>1}, {:id=>2}], [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}], [{:id=>1}], [{:name=>"--- 3\n"}]])
     ms = @ds.all
     ms.map{|m| m.values}.must_equal [{:id=>1}, {:id=>2}]
     ms.map{|m| m.name}.must_equal [3,6]

data/spec/extensions/list_spec.rb

@@ -56,7 +56,7 @@ describe "List plugin" do
   end
 
   it "should be able to access the scope proc as a class attribute" do
-    @c.scope_proc.must_equal nil
+    @c.scope_proc.must_be_nil
     @sc.scope_proc[@sc.new(:scope_id=>4)].sql.must_equal 'SELECT * FROM items WHERE (scope_id = 4) ORDER BY scope_id, position'
   end
 
@@ -67,17 +67,16 @@ describe "List plugin" do
   end
 
   it "should have at_position return the model object at the given position" do
-    @c.dataset._fetch = {:id=>1, :position=>1}
+    @c.dataset = @c.dataset.with_fetch(:id=>1, :position=>1)
     @o.at_position(10).must_equal @c.load(:id=>1, :position=>1)
-    @sc.dataset._fetch = {:id=>2, :position=>2, :scope_id=>5}
+    @sc.dataset = @sc.dataset.with_fetch(:id=>2, :position=>2, :scope_id=>5)
     @so.at_position(20).must_equal @sc.load(:id=>2, :position=>2, :scope_id=>5)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (position = 10) ORDER BY position LIMIT 1",
       "SELECT * FROM items WHERE ((scope_id = 5) AND (position = 20)) ORDER BY scope_id, position LIMIT 1"]
   end
 
   it "should have position field set to max+1 when creating if not already set" do
-    @c.instance_dataset._fetch = @c.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :position=>2}]]
-    @c.instance_dataset.autoid = @c.dataset.autoid = 1
+    @c.dataset = @c.dataset.with_autoid(1).with_fetch([[{:pos=>nil}], [{:id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :position=>2}]])
     @c.create.values.must_equal(:id=>1, :position=>1)
     @c.create.values.must_equal(:id=>2, :position=>2)
     @db.sqls.must_equal ["SELECT max(position) AS max FROM items LIMIT 1",
@@ -89,8 +88,7 @@ describe "List plugin" do
   end
 
   it "should have position field set to max+1 in scope when creating if not already set" do
-    @sc.instance_dataset._fetch = @sc.dataset._fetch = [[{:pos=>nil}], [{:id=>1, :scope_id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :scope_id=>1, :position=>2}], [{:pos=>nil}], [{:id=>3, :scope_id=>2, :position=>1}]]
-    @sc.instance_dataset.autoid = @sc.dataset.autoid = 1
+    @sc.dataset = @sc.dataset.with_autoid(1).with_fetch([[{:pos=>nil}], [{:id=>1, :scope_id=>1, :position=>1}], [{:pos=>1}], [{:id=>2, :scope_id=>1, :position=>2}], [{:pos=>nil}], [{:id=>3, :scope_id=>2, :position=>1}]])
     @sc.create(:scope_id=>1).values.must_equal(:id=>1, :scope_id=>1, :position=>1)
     @sc.create(:scope_id=>1).values.must_equal(:id=>2, :scope_id=>1, :position=>2)
     @sc.create(:scope_id=>2).values.must_equal(:id=>3, :scope_id=>2, :position=>1)
@@ -112,9 +110,9 @@ describe "List plugin" do
   end
 
   it "should have last_position return the last position in the list" do
-    @c.dataset._fetch  = {:max=>10}
+    @c.dataset = @c.dataset.with_fetch(:max=>10)
     @o.last_position.must_equal 10
-    @sc.dataset._fetch = {:max=>20}
+    @sc.dataset = @sc.dataset.with_fetch(:max=>20)
     @so.last_position.must_equal 20
     @db.sqls.must_equal ["SELECT max(position) AS max FROM items LIMIT 1",
       "SELECT max(position) AS max FROM items WHERE (scope_id = 5) LIMIT 1"]
@@ -129,7 +127,7 @@ describe "List plugin" do
   end
 
   it "should have move_down without an argument move down a single position" do
-    @c.dataset._fetch = {:max=>10}
+    @c.dataset = @c.dataset.with_fetch(:max=>10)
     @o.move_down.must_equal @o
     @o.position.must_equal 4
     @db.sqls.must_equal ["SELECT max(position) AS max FROM items LIMIT 1",
@@ -138,7 +136,7 @@ describe "List plugin" do
   end
 
   it "should have move_down with an argument move down the given number of positions" do
-    @c.dataset._fetch = {:max=>10}
+    @c.dataset = @c.dataset.with_fetch(:max=>10)
     @o.move_down(3).must_equal @o
     @o.position.must_equal 6
     @db.sqls.must_equal ["SELECT max(position) AS max FROM items LIMIT 1",
@@ -156,7 +154,7 @@ describe "List plugin" do
   it "should have move_to handle out of range targets" do
     @o.move_to(0)
     @o.position.must_equal 1
-    @c.dataset._fetch = {:max=>10}
+    @c.dataset = @c.dataset.with_fetch(:max=>10)
     @o.move_to(11)
     @o.position.must_equal 10
   end
@@ -183,13 +181,13 @@ describe "List plugin" do
   end
 
   it "should have move to shift entries correctly between current and target if moving down" do
-    @c.dataset._fetch = {:max=>10}
+    @c.dataset = @c.dataset.with_fetch(:max=>10)
     @o.move_to(4)
     @db.sqls[1].must_equal "UPDATE items SET position = (position - 1) WHERE ((position >= 4) AND (position <= 4))"
   end
 
   it "should have move_to_bottom move the item to the last position" do
-    @c.dataset._fetch = {:max=>10}
+    @c.dataset = @c.dataset.with_fetch(:max=>10)
     @o.move_to_bottom
     @db.sqls.must_equal ["SELECT max(position) AS max FROM items LIMIT 1",
       "UPDATE items SET position = (position - 1) WHERE ((position >= 4) AND (position <= 10))",
@@ -217,7 +215,7 @@ describe "List plugin" do
   end
 
   it "should have move_up with a negative argument move down the given number of positions" do
-    @c.dataset._fetch = {:max=>10}
+    @c.dataset = @c.dataset.with_fetch(:max=>10)
     @o.move_up(-1).must_equal @o
     @o.position.must_equal 4
     @db.sqls.must_equal ["SELECT max(position) AS max FROM items LIMIT 1",
@@ -226,19 +224,19 @@ describe "List plugin" do
   end
 
   it "should have next return the next entry in the list if not given an argument" do
-    @c.dataset._fetch = {:id=>9, :position=>4}
+    @c.dataset = @c.dataset.with_fetch(:id=>9, :position=>4)
     @o.next.must_equal @c.load(:id=>9, :position=>4)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (position = 4) ORDER BY position LIMIT 1"]
   end
 
   it "should have next return the entry the given number of positions below the instance if given an argument" do
-    @c.dataset._fetch = {:id=>9, :position=>5}
+    @c.dataset = @c.dataset.with_fetch(:id=>9, :position=>5)
     @o.next(2).must_equal @c.load(:id=>9, :position=>5)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (position = 5) ORDER BY position LIMIT 1"]
   end
 
   it "should have next return a previous entry if given a negative argument" do
-    @c.dataset._fetch = {:id=>9, :position=>2}
+    @c.dataset = @c.dataset.with_fetch(:id=>9, :position=>2)
     @o.next(-1).must_equal @c.load(:id=>9, :position=>2)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (position = 2) ORDER BY position LIMIT 1"]
   end
@@ -248,19 +246,19 @@ describe "List plugin" do
   end
 
   it "should have prev return the previous entry in the list if not given an argument" do
-    @c.dataset._fetch = {:id=>9, :position=>2}
+    @c.dataset = @c.dataset.with_fetch(:id=>9, :position=>2)
     @o.prev.must_equal @c.load(:id=>9, :position=>2)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (position = 2) ORDER BY position LIMIT 1"]
   end
 
   it "should have prev return the entry the given number of positions above the instance if given an argument" do
-    @c.dataset._fetch = {:id=>9, :position=>1}
+    @c.dataset = @c.dataset.with_fetch(:id=>9, :position=>1)
     @o.prev(2).must_equal @c.load(:id=>9, :position=>1)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (position = 1) ORDER BY position LIMIT 1"]
   end
 
   it "should have prev return a following entry if given a negative argument" do
-    @c.dataset._fetch = {:id=>9, :position=>4}
+    @c.dataset = @c.dataset.with_fetch(:id=>9, :position=>4)
     @o.prev(-1).must_equal @c.load(:id=>9, :position=>4)
     @db.sqls.must_equal ["SELECT * FROM items WHERE (position = 4) ORDER BY position LIMIT 1"]
   end

data/spec/extensions/many_through_many_spec.rb

@@ -12,8 +12,7 @@ describe Sequel::Model, "many_through_many" do
     end
     @c1 = Artist
     @c2 = Tag
-    @dataset = @c2.dataset
-    @dataset._fetch = {:id=>1}
+    @dataset = @c2.dataset = @c2.dataset.with_fetch(:id=>1)
     DB.reset
   end
   after do
@@ -50,8 +49,8 @@ describe Sequel::Model, "many_through_many" do
 
   it "should support using a custom :left_primary_key option when eager loading many_to_many associations" do
     @c1.send(:define_method, :id3){id*3}
-    @c1.dataset._fetch = {:id=>1}
-    @c2.dataset._fetch = {:id=>4, :x_foreign_key_x=>3}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1)
+    @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>3)
     @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:id3
     a = @c1.eager(:tags).all
     a.must_equal [@c1.load(:id => 1)]
@@ -61,8 +60,8 @@ describe Sequel::Model, "many_through_many" do
   end
 
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do
-    @c1.dataset._fetch = {:id=>1}
-    @c2.dataset._fetch = {:id=>4, :x_foreign_key_x=>1}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1)
+    @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>1)
     @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>Sequel./(:albums_artists__artist_id, 3)
     a = @c1.eager(:tags).all
     a.must_equal [@c1.load(:id => 1)]
@@ -74,12 +73,13 @@ describe Sequel::Model, "many_through_many" do
     @c1.many_through_many :tags, :through=>[[:myschema__albums_artists, :artist_id, :album_id], [:myschema__albums, :id, :id], [:myschema__albums_tags, :album_id, :tag_id]]
     @c1.load(:id=>1).tags_dataset.sql.must_equal "SELECT tags.* FROM tags INNER JOIN myschema.albums_tags ON (myschema.albums_tags.tag_id = tags.id) INNER JOIN myschema.albums ON (myschema.albums.id = myschema.albums_tags.album_id) INNER JOIN myschema.albums_artists ON (myschema.albums_artists.album_id = myschema.albums.id) WHERE (myschema.albums_artists.artist_id = 1)"
 
-    @c1.dataset._fetch = {:id=>1}
-    @c2.dataset._fetch = {:id=>4, :x_foreign_key_x=>1}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1)
+    @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>1)
     a = @c1.eager(:tags).all
     a.must_equal [@c1.load(:id => 1)]
     DB.sqls.must_equal ['SELECT * FROM artists', "SELECT tags.*, myschema.albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN myschema.albums_tags ON (myschema.albums_tags.tag_id = tags.id) INNER JOIN myschema.albums ON (myschema.albums.id = myschema.albums_tags.album_id) INNER JOIN myschema.albums_artists ON (myschema.albums_artists.album_id = myschema.albums.id) WHERE (myschema.albums_artists.artist_id IN (1))"]
 
+    Tag.dataset.columns(:id, :h1, :h2)
     @c1.eager_graph(:tags).sql.must_equal 'SELECT artists.id, tags.id AS tags_id, tags.h1, tags.h2 FROM artists LEFT OUTER JOIN myschema.albums_artists AS albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN myschema.albums AS albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN myschema.albums_tags AS albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)'
   end
   
@@ -200,25 +200,25 @@ describe Sequel::Model, "many_through_many" do
   end
 
   it "should allowing filtering by many_through_many associations with :limit" do
-    def (@c2.dataset).supports_window_functions?; true end
+    @c2.dataset = @c2.dataset.with_extend{def supports_window_functions?; true end}
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :limit=>10
     @c1.filter(:tags=>@c2.load(:id=>1234)).sql.must_equal 'SELECT * FROM artists WHERE (artists.id IN (SELECT albums_artists.artist_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((albums_artists.artist_id IS NOT NULL) AND ((albums_artists.artist_id, tags.id) IN (SELECT b, c FROM (SELECT albums_artists.artist_id AS b, tags.id AS c, row_number() OVER (PARTITION BY albums_artists.artist_id) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id)) AS t1 WHERE (x_sequel_row_number_x <= 10))) AND (tags.id = 1234))))'
   end
 
   it "should allowing filtering by many_through_many associations with :limit and composite keys" do
-    def (@c2.dataset).supports_window_functions?; true end
+    @c2.dataset = @c2.dataset.with_extend{def supports_window_functions?; true end}
     @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy], :limit=>10
     @c1.filter(:tags=>@c2.load(:id=>1, :h1=>1234, :h2=>85)).sql.must_equal 'SELECT * FROM artists WHERE ((artists.id, artists.yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2)) WHERE ((albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL) AND ((albums_artists.b1, albums_artists.b2, tags.id) IN (SELECT b, c, d FROM (SELECT albums_artists.b1 AS b, albums_artists.b2 AS c, tags.id AS d, row_number() OVER (PARTITION BY albums_artists.b1, albums_artists.b2) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2))) AS t1 WHERE (x_sequel_row_number_x <= 10))) AND (tags.id = 1))))'
   end
 
   it "should allowing filtering by many_through_many associations with :limit and :conditions" do
-    def (@c2.dataset).supports_window_functions?; true end
+    @c2.dataset = @c2.dataset.with_extend{def supports_window_functions?; true end}
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>{:name=>'A'}, :limit=>10
     @c1.filter(:tags=>@c2.load(:id=>1234)).sql.must_equal "SELECT * FROM artists WHERE (artists.id IN (SELECT albums_artists.artist_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((name = 'A') AND (albums_artists.artist_id IS NOT NULL) AND ((albums_artists.artist_id, tags.id) IN (SELECT b, c FROM (SELECT albums_artists.artist_id AS b, tags.id AS c, row_number() OVER (PARTITION BY albums_artists.artist_id) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (name = 'A')) AS t1 WHERE (x_sequel_row_number_x <= 10))) AND (tags.id = 1234))))"
   end
 
   it "should allowing filtering by many_through_many associations with :limit and :conditions and composite keys" do
-    def (@c2.dataset).supports_window_functions?; true end
+    @c2.dataset = @c2.dataset.with_extend{def supports_window_functions?; true end}
     @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy], :conditions=>{:name=>'A'}, :limit=>10
     @c1.filter(:tags=>@c2.load(:id=>1, :h1=>1234, :h2=>85)).sql.must_equal "SELECT * FROM artists WHERE ((artists.id, artists.yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2)) WHERE ((name = 'A') AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL) AND ((albums_artists.b1, albums_artists.b2, tags.id) IN (SELECT b, c, d FROM (SELECT albums_artists.b1 AS b, albums_artists.b2 AS c, tags.id AS d, row_number() OVER (PARTITION BY albums_artists.b1, albums_artists.b2) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2)) WHERE (name = 'A')) AS t1 WHERE (x_sequel_row_number_x <= 10))) AND (tags.id = 1))))"
   end
@@ -419,7 +419,7 @@ describe Sequel::Model, "many_through_many" do
   it "should populate cache when accessed" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     n = @c1.load(:id => 1234)
-    n.associations[:tags].must_equal nil
+    n.associations[:tags].must_be_nil
     DB.sqls.must_equal []
     n.tags.must_equal [@c2.load(:id=>1)]
     DB.sqls.must_equal ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id = 1234)']
@@ -465,7 +465,7 @@ describe Sequel::Model, "many_through_many" do
         v.each{|x| model::Foo << x.pk * 20}
       end
     end
-    @c2.dataset._fetch = [{:id=>20}, {:id=>30}]
+    @c2.dataset = @c2.dataset.with_fetch([{:id=>20}, {:id=>30}])
     p = @c1.load(:id=>10, :parent_id=>20)
     p.tags
     h.must_equal [400, 600]
@@ -474,7 +474,7 @@ describe Sequel::Model, "many_through_many" do
 
   it "should support a :uniq option that removes duplicates from the association" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :uniq=>true
-    @c2.dataset._fetch = [{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}]
+    @c2.dataset = @c2.dataset.with_fetch([{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}])
     @c1.load(:id=>10).tags.must_equal [@c2.load(:id=>20), @c2.load(:id=>30)]
   end
 end
@@ -514,7 +514,7 @@ describe 'Sequel::Plugins::ManyThroughMany::ManyThroughManyAssociationReflection
   end
   
   it "#reciprocal should be nil" do
-    @ar.reciprocal.must_equal nil
+    @ar.reciprocal.must_be_nil
   end
 end
 
@@ -535,7 +535,7 @@ describe "many_through_many eager loading methods" do
     end
     class ::Track < Sequel::Model
     end
-    Artist.dataset.columns(:id)._fetch = proc do |sql|
+    Artist.dataset = Artist.dataset.with_fetch(proc do |sql|
       h = {:id => 1}
       if sql =~ /FROM artists LEFT OUTER JOIN albums_artists/
         h[:tags_id] = 2
@@ -545,9 +545,10 @@ describe "many_through_many eager loading methods" do
         h[:artists_0_id] = 10 if sql =~ /artists_0\.id AS artists_0_id/
       end
       h
-    end
+    end)
+    Artist.dataset.columns(:id)
     
-    Tag.dataset._fetch = proc do |sql|
+    Tag.dataset = Tag.dataset.with_fetch(proc do |sql|
       h = {:id => 2}
       if sql =~ /albums_artists.artist_id IN \(([18])\)/
         h[:x_foreign_key_x] = $1.to_i 
@@ -556,19 +557,19 @@ describe "many_through_many eager loading methods" do
       end
       h[:tag_id] = h.delete(:id) if sql =~ /albums_artists.artist_id IN \(8\)/
       h
-    end
+    end)
     
-    Album.dataset._fetch = proc do |sql|
+    Album.dataset = Album.dataset.with_fetch(proc do |sql|
       h = {:id => 3}
       h[:x_foreign_key_x] = 1 if sql =~ /albums_artists.artist_id IN \(1\)/
       h
-    end
+    end)
     
-    Track.dataset._fetch = proc do |sql|
+    Track.dataset = Track.dataset.with_fetch(proc do |sql|
       h = {:id => 4}
       h[:x_foreign_key_x] = 2 if sql =~ /albums_tags.tag_id IN \(2\)/
       h
-    end
+    end)
 
     @c1 = Artist
     DB.reset
@@ -654,12 +655,7 @@ describe "many_through_many eager loading methods" do
   end
   
   it "should respect :eager_graph when lazily loading an association" do
-    Tag.dataset._fetch = {:id=>2, :tracks_id=>4}
-    Tag.dataset.extend(Module.new {
-      def columns
-        [:id]
-      end
-    })
+    Tag.dataset = Tag.dataset.with_fetch(:id=>2, :tracks_id=>4).with_extend{def columns; [:id] end}
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_graph=>:tracks
     a = @c1.load(:id=>1)
     a.tags
@@ -711,7 +707,7 @@ describe "many_through_many eager loading methods" do
 
   it "should respect the :limit option on a many_through_many association" do
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2
-    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}]
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}])
     a = @c1.eager(:first_two_tags).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -720,7 +716,7 @@ describe "many_through_many eager loading methods" do
     DB.sqls.length.must_equal 0
 
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[1,1]
-    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>6}]
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>6}])
     a = @c1.eager(:first_two_tags).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -729,7 +725,7 @@ describe "many_through_many eager loading methods" do
     DB.sqls.length.must_equal 0
 
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[nil,1]
-    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>6}, {:x_foreign_key_x=>1, :id=>7}]
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>6}, {:x_foreign_key_x=>1, :id=>7}])
     a = @c1.eager(:first_two_tags).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -740,7 +736,7 @@ describe "many_through_many eager loading methods" do
 
   it "should respect the :limit option on a many_through_many association using a :ruby strategy" do
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>:ruby
-    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}, {:x_foreign_key_x=>1, :id=>7}]
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}, {:x_foreign_key_x=>1, :id=>7}])
     a = @c1.eager(:first_two_tags).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -766,9 +762,8 @@ describe "many_through_many eager loading methods" do
   end
 
   it "should respect the :limit option on a many_through_many association using a :window_function strategy" do
-    Tag.dataset.meta_def(:supports_window_functions?){true}
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :order=>:name, :eager_limit_strategy=>:window_function
-    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}]
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}]).with_extend{def supports_window_functions?; true end}
     a = @c1.eager(:first_two_tags).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -794,12 +789,11 @@ describe "many_through_many eager loading methods" do
   end
 
   it "should respect the :limit option on a many_through_many association with composite primary keys on the main table" do
-    Tag.dataset.meta_def(:supports_window_functions?){true}
+    @c1.dataset = @c1.dataset.with_fetch([{:id1=>1, :id2=>2}])
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}, {:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>6}]).with_extend{def supports_window_functions?; true end}
     @c1.set_primary_key([:id1, :id2])
     @c1.columns :id1, :id2
     @c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :order=>:name
-    @c1.dataset._fetch = [{:id1=>1, :id2=>2}]
-    Tag.dataset._fetch = [{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}, {:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>6}]
     a = @c1.eager(:first_two_tags).all
     a.must_equal [@c1.load(:id1=>1, :id2=>2)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -817,12 +811,11 @@ describe "many_through_many eager loading methods" do
   end
 
   it "should respect the :limit option on a many_through_many association with composite primary keys on the main table using a :window_function strategy" do
-    Tag.dataset.meta_def(:supports_window_functions?){true}
+    @c1.dataset = @c1.dataset.with_fetch([{:id1=>1, :id2=>2}])
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}, {:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>6}]).with_extend{def supports_window_functions?; true end}
     @c1.set_primary_key([:id1, :id2])
     @c1.columns :id1, :id2
     @c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :order=>:name, :eager_limit_strategy=>:window_function
-    @c1.dataset._fetch = [{:id1=>1, :id2=>2}]
-    Tag.dataset._fetch = [{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}, {:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>6}]
     a = @c1.eager(:first_two_tags).all
     a.must_equal [@c1.load(:id1=>1, :id2=>2)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -857,8 +850,7 @@ describe "many_through_many eager loading methods" do
 
   it "should respect many_through_many association's :left_primary_key and :right_primary_key options" do
     @c1.send(:define_method, :yyy){values[:yyy]}
-    @c1.dataset._fetch = {:id=>1, :yyy=>8}
-    @c1.dataset.meta_def(:columns){[:id, :yyy]}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1, :yyy=>8).with_extend{def columns; [:id, :yyy] end}
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:yyy, :right_primary_key=>:tag_id
     a = @c1.eager(:tags).all
     a.must_equal [@c1.load(:id=>1, :yyy=>8)]
@@ -870,8 +862,7 @@ describe "many_through_many eager loading methods" do
   
   it "should handle composite keys" do
     @c1.send(:define_method, :yyy){values[:yyy]}
-    @c1.dataset._fetch = {:id=>1, :yyy=>8}
-    @c1.dataset.meta_def(:columns){[:id, :yyy]}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1, :yyy=>8).with_extend{def columns; [:id, :yyy] end}
     @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
     a = @c1.eager(:tags).all
     a.must_equal [@c1.load(:id=>1, :yyy=>8)]
@@ -912,12 +903,12 @@ describe "many_through_many eager loading methods" do
   end
 
   it "should eagerly graph a single many_through_many association using the :window_function strategy" do
-    def (Tag.dataset).supports_window_functions?() true end
-    def (Tag.dataset).columns() literal(opts[:select]) =~ /x_foreign_key_x/ ? [:id, :x_foreign_key_x] : [:id] end
+    Tag.dataset = Tag.dataset.with_extend do
+      def supports_window_functions?; true end
+      def columns; literal(opts[:select]) =~ /x_foreign_key_x/ ? [:id, :x_foreign_key_x] : [:id] end
+    end
     @c1.many_through_many :tags, :clone=>:tags, :limit=>2
-    ds = @c1.eager_graph_with_options(:tags, :limit_strategy=>true)
-    ds._fetch = {:id=>1, :tags_id=>2}
-    a = ds.all
+    a = @c1.eager_graph_with_options(:tags, :limit_strategy=>true).with_fetch(:id=>1, :tags_id=>2).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN (SELECT id, x_foreign_key_x FROM (SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x, row_number() OVER (PARTITION BY albums_artists.artist_id) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id)) AS t1 WHERE (x_sequel_row_number_x <= 2)) AS tags ON (tags.x_foreign_key_x = artists.id)']
     a.first.tags.must_equal [Tag.load(:id=>2)]
@@ -955,10 +946,7 @@ describe "many_through_many eager loading methods" do
   end
   
   it "eager graphing should eliminate duplicates caused by cartesian products" do
-    ds = @c1.eager_graph(:tags)
-    # Assume artist has 2 albums each with 2 tags
-    ds._fetch = [{:id=>1, :tags_id=>2}, {:id=>1, :tags_id=>3}, {:id=>1, :tags_id=>2}, {:id=>1, :tags_id=>3}]
-    a = ds.all
+    a = @c1.eager_graph(:tags).with_fetch([{:id=>1, :tags_id=>2}, {:id=>1, :tags_id=>3}, {:id=>1, :tags_id=>2}, {:id=>1, :tags_id=>3}]).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']
     a.first.tags.must_equal [Tag.load(:id=>2), Tag.load(:id=>3)]
@@ -1001,9 +989,7 @@ describe "many_through_many eager loading methods" do
   end
 
   it "should handle no associated records when eagerly graphing a single many_through_many association" do
-    ds = @c1.eager_graph(:tags)
-    ds._fetch = {:id=>1, :tags_id=>nil}
-    a = ds.all
+    a = @c1.eager_graph(:tags).with_fetch(:id=>1, :tags_id=>nil).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']
     a.first.tags.must_equal []
@@ -1011,9 +997,7 @@ describe "many_through_many eager loading methods" do
   end
 
   it "should handle no associated records when eagerly graphing multiple many_through_many associations" do
-    ds = @c1.eager_graph(:tags, :albums)
-    ds._fetch = [{:id=>1, :tags_id=>nil, :albums_0_id=>3}, {:id=>1, :tags_id=>2, :albums_0_id=>nil}, {:id=>1, :tags_id=>5, :albums_0_id=>6}, {:id=>7, :tags_id=>nil, :albums_0_id=>nil}]
-    a = ds.all
+    a = @c1.eager_graph(:tags, :albums).with_fetch([{:id=>1, :tags_id=>nil, :albums_0_id=>3}, {:id=>1, :tags_id=>2, :albums_0_id=>nil}, {:id=>1, :tags_id=>5, :albums_0_id=>6}, {:id=>7, :tags_id=>nil, :albums_0_id=>nil}]).all
     a.must_equal [@c1.load(:id=>1), @c1.load(:id=>7)]
     DB.sqls.must_equal ['SELECT artists.id, tags.id AS tags_id, albums_0.id AS albums_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id)']
     a.first.tags.must_equal [Tag.load(:id=>2), Tag.load(:id=>5)]
@@ -1024,9 +1008,7 @@ describe "many_through_many eager loading methods" do
   end
 
   it "should handle missing associated records when cascading eager graphing for associations of associated models" do
-    ds = @c1.eager_graph(:tags=>:tracks)
-    ds._fetch = [{:id=>1, :tags_id=>2, :tracks_id=>4}, {:id=>1, :tags_id=>3, :tracks_id=>nil}, {:id=>2, :tags_id=>nil, :tracks_id=>nil}]
-    a = ds.all
+    a = @c1.eager_graph(:tags=>:tracks).with_fetch([{:id=>1, :tags_id=>2, :tracks_id=>4}, {:id=>1, :tags_id=>3, :tracks_id=>nil}, {:id=>2, :tags_id=>nil, :tracks_id=>nil}]).all
     a.must_equal [@c1.load(:id=>1), @c1.load(:id=>2)]
     DB.sqls.must_equal ['SELECT artists.id, tags.id AS tags_id, tracks.id AS tracks_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums_0.id)']
     a.last.tags.must_equal []
@@ -1039,11 +1021,9 @@ describe "many_through_many eager loading methods" do
 
   it "eager graphing should respect :left_primary_key and :right_primary_key options" do 
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:yyy, :right_primary_key=>:tag_id
-    @c1.dataset.meta_def(:columns){[:id, :yyy]}
-    Tag.dataset.meta_def(:columns){[:id, :tag_id]}
-    ds = @c1.eager_graph(:tags)
-    ds._fetch = {:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4}
-    a = ds.all
+    @c1.dataset = @c1.dataset.with_extend{def columns; [:id, :yyy] end}
+    Tag.dataset = Tag.dataset.with_extend{def columns; [:id, :tag_id] end}
+    a = @c1.eager_graph(:tags).with_fetch(:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4).all
     a.must_equal [@c1.load(:id=>1, :yyy=>8)]
     DB.sqls.must_equal ['SELECT artists.id, artists.yyy, tags.id AS tags_id, tags.tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.yyy) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.tag_id = albums_tags.tag_id)']
     a.first.tags.must_equal [Tag.load(:id=>2, :tag_id=>4)]
@@ -1052,11 +1032,9 @@ describe "many_through_many eager loading methods" do
   
   it "eager graphing should respect composite keys" do 
     @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:id, :tag_id], :left_primary_key=>[:id, :yyy]
-    @c1.dataset.meta_def(:columns){[:id, :yyy]}
-    Tag.dataset.meta_def(:columns){[:id, :tag_id]}
-    ds = @c1.eager_graph(:tags)
-    ds._fetch = {:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4}
-    a = ds.all
+    @c1.dataset = @c1.dataset.with_extend{def columns; [:id, :yyy] end}
+    Tag.dataset = Tag.dataset.with_extend{def columns; [:id, :tag_id] end}
+    a = @c1.eager_graph(:tags).with_fetch(:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4).all
     a.must_equal [@c1.load(:id=>1, :yyy=>8)]
     DB.sqls.must_equal ['SELECT artists.id, artists.yyy, tags.id AS tags_id, tags.tag_id FROM artists LEFT OUTER JOIN albums_artists ON ((albums_artists.b1 = artists.id) AND (albums_artists.b2 = artists.yyy)) LEFT OUTER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) LEFT OUTER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) LEFT OUTER JOIN tags ON ((tags.id = albums_tags.g1) AND (tags.tag_id = albums_tags.g2))']
     a.first.tags.must_equal [Tag.load(:id=>2, :tag_id=>4)]
@@ -1065,9 +1043,7 @@ describe "many_through_many eager loading methods" do
 
   it "should respect the association's :graph_select option" do 
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :graph_select=>:b
-    ds = @c1.eager_graph(:tags)
-    ds._fetch = {:id=>1, :b=>2}
-    a = ds.all
+    a = @c1.eager_graph(:tags).with_fetch(:id=>1, :b=>2).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT artists.id, tags.b FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']
     a.first.tags.must_equal [Tag.load(:b=>2)]
@@ -1216,8 +1192,7 @@ describe Sequel::Model, "one_through_many" do
     end
     @c1 = Artist
     @c2 = Tag
-    @dataset = @c2.dataset
-    @dataset._fetch = {:id=>1}
+    @dataset = @c2.dataset = @c2.dataset.with_fetch(:id=>1)
     DB.reset
   end
   after do
@@ -1227,8 +1202,8 @@ describe Sequel::Model, "one_through_many" do
 
   it "should support using a custom :left_primary_key option when eager loading many_to_many associations" do
     @c1.send(:define_method, :id3){id*3}
-    @c1.dataset._fetch = {:id=>1}
-    @c2.dataset._fetch = {:id=>4, :x_foreign_key_x=>3}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1)
+    @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>3)
     @c1.one_through_many :tag, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:id3
     a = @c1.eager(:tag).all
     a.must_equal [@c1.load(:id => 1)]
@@ -1238,8 +1213,8 @@ describe Sequel::Model, "one_through_many" do
   end
 
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup" do
-    @c1.dataset._fetch = {:id=>1}
-    @c2.dataset._fetch = {:id=>4, :x_foreign_key_x=>1}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1)
+    @c2.dataset = @c2.dataset.with_fetch(:id=>4, :x_foreign_key_x=>1)
     @c1.one_through_many :tag, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_loading_predicate_key=>Sequel./(:albums_artists__artist_id, 3)
     a = @c1.eager(:tag).all
     a.must_equal [@c1.load(:id => 1)]
@@ -1348,25 +1323,25 @@ describe Sequel::Model, "one_through_many" do
   end
 
   it "should allowing filtering by one_through_many associations with :order" do
-    def (@c2.dataset).supports_distinct_on?; true end
+    @c2.dataset = @c2.dataset.with_extend{def supports_distinct_on?; true end}
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :order=>:name
     @c1.filter(:tag=>@c2.load(:id=>1234)).sql.must_equal 'SELECT * FROM artists WHERE (artists.id IN (SELECT albums_artists.artist_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((albums_artists.artist_id IS NOT NULL) AND ((albums_artists.artist_id, tags.id) IN (SELECT DISTINCT ON (albums_artists.artist_id) albums_artists.artist_id, tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) ORDER BY albums_artists.artist_id, name)) AND (tags.id = 1234))))'
   end
 
   it "should allowing filtering by one_through_many associations with :order and composite keys" do
-    def (@c2.dataset).supports_distinct_on?; true end
+    @c2.dataset = @c2.dataset.with_extend{def supports_distinct_on?; true end}
     @c1.one_through_many :tag, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy], :order=>:name
     @c1.filter(:tag=>@c2.load(:id=>1, :h1=>1234, :h2=>85)).sql.must_equal 'SELECT * FROM artists WHERE ((artists.id, artists.yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2)) WHERE ((albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL) AND ((albums_artists.b1, albums_artists.b2, tags.id) IN (SELECT DISTINCT ON (albums_artists.b1, albums_artists.b2) albums_artists.b1, albums_artists.b2, tags.id FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2)) ORDER BY albums_artists.b1, albums_artists.b2, name)) AND (tags.id = 1))))'
   end
 
   it "should allowing filtering by one_through_many associations with :order and :conditions" do
-    def (@c2.dataset).supports_distinct_on?; true end
+    @c2.dataset = @c2.dataset.with_extend{def supports_distinct_on?; true end}
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>{:name=>'A'}, :order=>:name
     @c1.filter(:tag=>@c2.load(:id=>1234)).sql.must_equal "SELECT * FROM artists WHERE (artists.id IN (SELECT albums_artists.artist_id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((name = 'A') AND (albums_artists.artist_id IS NOT NULL) AND ((albums_artists.artist_id, tags.id) IN (SELECT DISTINCT ON (albums_artists.artist_id) albums_artists.artist_id, tags.id FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (name = 'A') ORDER BY albums_artists.artist_id, name)) AND (tags.id = 1234))))"
   end
 
   it "should allowing filtering by one_through_many associations with :order and :conditions and composite keys" do
-    def (@c2.dataset).supports_distinct_on?; true end
+    @c2.dataset = @c2.dataset.with_extend{def supports_distinct_on?; true end}
     @c1.one_through_many :tag, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy], :conditions=>{:name=>'A'}, :order=>:name
     @c1.filter(:tag=>@c2.load(:id=>1, :h1=>1234, :h2=>85)).sql.must_equal "SELECT * FROM artists WHERE ((artists.id, artists.yyy) IN (SELECT albums_artists.b1, albums_artists.b2 FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2)) WHERE ((name = 'A') AND (albums_artists.b1 IS NOT NULL) AND (albums_artists.b2 IS NOT NULL) AND ((albums_artists.b1, albums_artists.b2, tags.id) IN (SELECT DISTINCT ON (albums_artists.b1, albums_artists.b2) albums_artists.b1, albums_artists.b2, tags.id FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2)) WHERE (name = 'A') ORDER BY albums_artists.b1, albums_artists.b2, name)) AND (tags.id = 1))))"
   end
@@ -1562,7 +1537,7 @@ describe Sequel::Model, "one_through_many" do
   it "should populate cache when accessed" do
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     n = @c1.load(:id => 1234)
-    n.associations[:tag].must_equal nil
+    n.associations[:tag].must_be_nil
     DB.sqls.must_equal []
     n.tag.must_equal @c2.load(:id=>1)
     DB.sqls.must_equal ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id = 1234) LIMIT 1']
@@ -1574,7 +1549,7 @@ describe Sequel::Model, "one_through_many" do
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     n = @c1.load(:id => 1234)
     n.associations[:tag] = nil
-    n.tag.must_equal nil
+    n.tag.must_be_nil
     DB.sqls.must_equal []
   end
 
@@ -1608,7 +1583,7 @@ describe Sequel::Model, "one_through_many" do
         model::Foo << v.pk * 20
       end
     end
-    @c2.dataset._fetch = [{:id=>20}]
+    @c2.dataset = @c2.dataset.with_fetch(:id=>20)
     p = @c1.load(:id=>10, :parent_id=>20)
     p.tag
     h.must_equal [400]
@@ -1633,7 +1608,7 @@ describe "one_through_many eager loading methods" do
     end
     class ::Track < Sequel::Model
     end
-    Artist.dataset.columns(:id)._fetch = proc do |sql|
+    Artist.dataset = Artist.dataset.with_fetch(proc do |sql|
       h = {:id => 1}
       if sql =~ /FROM artists LEFT OUTER JOIN albums_artists/
         h[:tag_id] = 2
@@ -1643,9 +1618,10 @@ describe "one_through_many eager loading methods" do
         h[:artist_id] = 10 if sql =~ /artists_0\.id AS artist_id/
       end
       h
-    end
+    end)
+    Artist.dataset.columns(:id)
     
-    Tag.dataset._fetch = proc do |sql|
+    Tag.dataset = Tag.dataset.with_fetch(proc do |sql|
       h = {:id => 2}
       if sql =~ /albums_artists.artist_id IN \(([18])\)/
         h[:x_foreign_key_x] = $1.to_i 
@@ -1654,19 +1630,19 @@ describe "one_through_many eager loading methods" do
       end
       h[:tag_id] = h.delete(:id) if sql =~ /albums_artists.artist_id IN \(8\)/
       h
-    end
+    end)
     
-    Album.dataset._fetch = proc do |sql|
+    Album.dataset = Album.dataset.with_fetch(proc do |sql|
       h = {:id => 3}
       h[:x_foreign_key_x] = 1 if sql =~ /albums_artists.artist_id IN \(1\)/
       h
-    end
+    end)
     
-    Track.dataset._fetch = proc do |sql|
+    Track.dataset = Track.dataset.with_fetch(proc do |sql|
       h = {:id => 4}
       h[:x_foreign_key_x] = 2 if sql =~ /albums_tags.tag_id IN \(2\)/
       h
-    end
+    end)
 
     @c1 = Artist
     DB.reset
@@ -1752,12 +1728,7 @@ describe "one_through_many eager loading methods" do
   end
   
   it "should respect :eager_graph when lazily loading an association" do
-    Tag.dataset._fetch = {:id=>2, :track_id=>4}
-    Tag.dataset.extend(Module.new {
-      def columns
-        [:id]
-      end
-    })
+    Tag.dataset = Tag.dataset.with_fetch(:id=>2, :track_id=>4).with_extend{def columns; [:id] end}
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_graph=>:track
     a = @c1.load(:id=>1)
     a.tag
@@ -1809,7 +1780,7 @@ describe "one_through_many eager loading methods" do
 
   it "should respect the :limit option on a one_through_many association" do
     @c1.one_through_many :second_tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[nil,1]
-    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>6}]
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>6}])
     a = @c1.eager(:second_tag).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -1820,7 +1791,7 @@ describe "one_through_many eager loading methods" do
 
   it "should respect the :limit option on a one_through_many association using the :ruby strategy" do
     @c1.one_through_many :second_tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[nil,1], :eager_limit_strategy=>:ruby
-    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5}, {:x_foreign_key_x=>1, :id=>6}]
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>5}, {:x_foreign_key_x=>1, :id=>6}])
     a = @c1.eager(:second_tag).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -1830,9 +1801,8 @@ describe "one_through_many eager loading methods" do
   end
 
   it "should eagerly load a single one_through_many association using the :distinct_on strategy" do
-    Tag.dataset.meta_def(:supports_distinct_on?){true}
     @c1.one_through_many :second_tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :order=>:name, :eager_limit_strategy=>:distinct_on
-    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5}]
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>5}]).with_extend{def supports_distinct_on?; true end}
     a = @c1.eager(:second_tag).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists', "SELECT DISTINCT ON (albums_artists.artist_id) tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE (albums_artists.artist_id IN (1)) ORDER BY albums_artists.artist_id, name"]
@@ -1841,9 +1811,8 @@ describe "one_through_many eager loading methods" do
   end
   
   it "should eagerly load a single one_through_many association using the :window_function strategy" do
-    Tag.dataset.meta_def(:supports_window_functions?){true}
     @c1.one_through_many :second_tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[nil,1], :order=>:name, :eager_limit_strategy=>:window_function
-    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5}]
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>5}]).with_extend{def supports_window_functions?; true end}
     a = @c1.eager(:second_tag).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT * FROM artists',
@@ -1853,15 +1822,12 @@ describe "one_through_many eager loading methods" do
   end
 
   it "should respect the :limit option on a one_through_many association with composite primary keys on the main table" do
-    Tag.dataset.meta_def(:supports_window_functions?){true}
     @c1.set_primary_key([:id1, :id2])
     @c1.columns :id1, :id2
 
     @c1.one_through_many :second_tag, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[nil,1], :order=>:name
-    ds = @c1.eager(:second_tag)
-    ds._fetch = {:id1=>1, :id2=>2}
-    Tag.dataset._fetch = [{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}]
-    a = ds.all
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}]).with_extend{def supports_window_functions?; true end}
+    a = @c1.eager(:second_tag).with_fetch(:id1=>1, :id2=>2).all
     a.must_equal [@c1.load(:id1=>1, :id2=>2)]
     DB.sqls.must_equal ['SELECT * FROM artists',
       'SELECT * FROM (SELECT tags.*, albums_artists.artist_id1 AS x_foreign_key_0_x, albums_artists.artist_id2 AS x_foreign_key_1_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((1 = albums_artists.artist_id1) AND (2 = albums_artists.artist_id2)) ORDER BY name LIMIT 1 OFFSET 1) AS t1']
@@ -1870,15 +1836,12 @@ describe "one_through_many eager loading methods" do
   end
 
   it "should respect the :limit option on a one_through_many association with composite primary keys on the main table using a :window_function strategy" do
-    Tag.dataset.meta_def(:supports_window_functions?){true}
     @c1.set_primary_key([:id1, :id2])
     @c1.columns :id1, :id2
 
     @c1.one_through_many :second_tag, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[nil,1], :order=>:name, :eager_limit_strategy=>:window_function
-    ds = @c1.eager(:second_tag)
-    ds._fetch = {:id1=>1, :id2=>2}
-    Tag.dataset._fetch = [{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}]
-    a = ds.all
+    Tag.dataset = Tag.dataset.with_fetch([{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}]).with_extend{def supports_window_functions?; true end}
+    a = @c1.eager(:second_tag).with_fetch(:id1=>1, :id2=>2).all
     a.must_equal [@c1.load(:id1=>1, :id2=>2)]
     DB.sqls.must_equal ['SELECT * FROM artists',
       'SELECT * FROM (SELECT tags.*, albums_artists.artist_id1 AS x_foreign_key_0_x, albums_artists.artist_id2 AS x_foreign_key_1_x, row_number() OVER (PARTITION BY albums_artists.artist_id1, albums_artists.artist_id2 ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) WHERE ((albums_artists.artist_id1, albums_artists.artist_id2) IN ((1, 2)))) AS t1 WHERE (x_sequel_row_number_x = 2)']
@@ -1904,8 +1867,7 @@ describe "one_through_many eager loading methods" do
 
   it "should respect one_through_many association's :left_primary_key and :right_primary_key options" do
     @c1.send(:define_method, :yyy){values[:yyy]}
-    @c1.dataset._fetch = {:id=>1, :yyy=>8}
-    @c1.dataset.meta_def(:columns){[:id, :yyy]}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1, :yyy=>8).with_extend{def columns; [:id, :yyy] end}
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:yyy, :right_primary_key=>:tag_id
     a = @c1.eager(:tag).all
     a.must_equal [@c1.load(:id=>1, :yyy=>8)]
@@ -1917,8 +1879,7 @@ describe "one_through_many eager loading methods" do
   
   it "should handle composite keys" do
     @c1.send(:define_method, :yyy){values[:yyy]}
-    @c1.dataset._fetch = {:id=>1, :yyy=>8}
-    @c1.dataset.meta_def(:columns){[:id, :yyy]}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1, :yyy=>8).with_extend{def columns; [:id, :yyy] end}
     @c1.one_through_many :tag, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
     a = @c1.eager(:tag).all
     a.must_equal [@c1.load(:id=>1, :yyy=>8)]
@@ -1951,10 +1912,8 @@ describe "one_through_many eager loading methods" do
   end
 
   it "should eagerly graph a single one_through_many association using the :distinct_on strategy" do
-    def (Tag.dataset).supports_distinct_on?() true end
-    ds = @c1.eager_graph_with_options(:tag, :limit_strategy=>true)
-    ds._fetch = {:id=>1, :tag_id=>2}
-    a = ds.all
+    Tag.dataset = Tag.dataset.with_extend{def supports_distinct_on?; true end}
+    a = @c1.eager_graph_with_options(:tag, :limit_strategy=>true).with_fetch(:id=>1, :tag_id=>2).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT artists.id, tag.id AS tag_id FROM artists LEFT OUTER JOIN (SELECT DISTINCT ON (albums_artists.artist_id) tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) ORDER BY albums_artists.artist_id) AS tag ON (tag.x_foreign_key_x = artists.id)']
     a.first.tag.must_equal Tag.load(:id=>2)
@@ -1962,11 +1921,11 @@ describe "one_through_many eager loading methods" do
   end
   
   it "should eagerly graph a single one_through_many association using the :window_function strategy" do
-    def (Tag.dataset).supports_window_functions?() true end
-    def (Tag.dataset).columns() literal(opts[:select]) =~ /x_foreign_key_x/ ? [:id, :x_foreign_key_x] : [:id] end
-    ds = @c1.eager_graph_with_options(:tag, :limit_strategy=>true)
-    ds._fetch = {:id=>1, :tag_id=>2}
-    a = ds.all
+    Tag.dataset = Tag.dataset.with_extend do
+      def supports_window_functions?; true end
+      def columns; literal(opts[:select]) =~ /x_foreign_key_x/ ? [:id, :x_foreign_key_x] : [:id] end
+    end
+    a = @c1.eager_graph_with_options(:tag, :limit_strategy=>true).with_fetch(:id=>1, :tag_id=>2).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT artists.id, tag.id AS tag_id FROM artists LEFT OUTER JOIN (SELECT id, x_foreign_key_x FROM (SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x, row_number() OVER (PARTITION BY albums_artists.artist_id) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON (albums_artists.album_id = albums.id)) AS t1 WHERE (x_sequel_row_number_x = 1)) AS tag ON (tag.x_foreign_key_x = artists.id)']
     a.first.tag.must_equal Tag.load(:id=>2)
@@ -2014,9 +1973,7 @@ describe "one_through_many eager loading methods" do
   end
 
   it "should eager graph a self_referential association" do
-    ds = @c1.eager_graph(:tag, :artist)
-    ds._fetch = {:id=>1, :tag_id=>2, :artist_id=>10}
-    a = ds.all
+    a = @c1.eager_graph(:tag, :artist).with_fetch(:id=>1, :tag_id=>2, :artist_id=>10).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT artists.id, tag.id AS tag_id, artist.id AS artist_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id) LEFT OUTER JOIN albums_artists AS albums_artists_1 ON (albums_artists_1.album_id = albums_0.id) LEFT OUTER JOIN artists AS artist ON (artist.id = albums_artists_1.artist_id)']
     a = a.first
@@ -2037,48 +1994,40 @@ describe "one_through_many eager loading methods" do
   end
 
   it "should handle no associated records when eagerly graphing a single one_through_many association" do
-    ds = @c1.eager_graph(:tag)
-    ds._fetch = {:id=>1, :tag_id=>nil}
-    a = ds.all
+    a = @c1.eager_graph(:tag).with_fetch(:id=>1, :tag_id=>nil).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT artists.id, tag.id AS tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id)']
-    a.first.tag.must_equal nil
+    a.first.tag.must_be_nil
     DB.sqls.length.must_equal 0
   end
 
   it "should handle no associated records when eagerly graphing multiple one_through_many associations" do
-    ds = @c1.eager_graph(:tag, :album)
-    ds._fetch = [{:id=>1, :tag_id=>5, :album_id=>6}, {:id=>7, :tag_id=>nil, :albums_0_id=>nil}]
-    a = ds.all
+    a = @c1.eager_graph(:tag, :album).with_fetch([{:id=>1, :tag_id=>5, :album_id=>6}, {:id=>7, :tag_id=>nil, :albums_0_id=>nil}]).all
     a.must_equal [@c1.load(:id=>1), @c1.load(:id=>7)]
     DB.sqls.must_equal ['SELECT artists.id, tag.id AS tag_id, album.id AS album_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS album ON (album.id = albums_artists_0.album_id)']
     a.first.tag.must_equal Tag.load(:id=>5)
     a.first.album.must_equal Album.load(:id=>6)
-    a.last.tag.must_equal nil
-    a.last.album.must_equal nil
+    a.last.tag.must_be_nil
+    a.last.album.must_be_nil
     DB.sqls.length.must_equal 0
   end
 
   it "should handle missing associated records when cascading eager graphing for associations of associated models" do
-    ds = @c1.eager_graph(:tag=>:track)
-    ds._fetch = [{:id=>1, :tag_id=>2, :track_id=>nil}, {:id=>2, :tag_id=>nil, :tracks_id=>nil}]
-    a = ds.all
+    a = @c1.eager_graph(:tag=>:track).with_fetch([{:id=>1, :tag_id=>2, :track_id=>nil}, {:id=>2, :tag_id=>nil, :tracks_id=>nil}]).all
     a.must_equal [@c1.load(:id=>1), @c1.load(:id=>2)]
     DB.sqls.must_equal ['SELECT artists.id, tag.id AS tag_id, track.id AS track_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tag.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks AS track ON (track.album_id = albums_0.id)']
-    a.last.tag.must_equal nil
+    a.last.tag.must_be_nil
     a = a.first
     a.tag.must_equal Tag.load(:id=>2)
-    a.tag.track.must_equal nil
+    a.tag.track.must_be_nil
     DB.sqls.length.must_equal 0
   end
 
   it "eager graphing should respect :left_primary_key and :right_primary_key options" do 
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:yyy, :right_primary_key=>:tag_id
-    @c1.dataset.meta_def(:columns){[:id, :yyy]}
-    Tag.dataset.meta_def(:columns){[:id, :tag_id]}
-    ds = @c1.eager_graph(:tag)
-    ds._fetch = {:id=>1, :yyy=>8, :tag_id=>2, :tag_tag_id=>4}
-    a = ds.all
+    @c1.dataset = @c1.dataset.with_extend{def columns; [:id, :yyy] end}
+    Tag.dataset = Tag.dataset.with_extend{def columns; [:id, :tag_id] end}
+    a = @c1.eager_graph(:tag).with_fetch(:id=>1, :yyy=>8, :tag_id=>2, :tag_tag_id=>4).all
     a.must_equal [@c1.load(:id=>1, :yyy=>8)]
     DB.sqls.must_equal ['SELECT artists.id, artists.yyy, tag.id AS tag_id, tag.tag_id AS tag_tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.yyy) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.tag_id = albums_tags.tag_id)']
     a.first.tag.must_equal Tag.load(:id=>2, :tag_id=>4)
@@ -2087,11 +2036,9 @@ describe "one_through_many eager loading methods" do
   
   it "eager graphing should respect composite keys" do 
     @c1.one_through_many :tag, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:id, :tag_id], :left_primary_key=>[:id, :yyy]
-    @c1.dataset.meta_def(:columns){[:id, :yyy]}
-    Tag.dataset.meta_def(:columns){[:id, :tag_id]}
-    ds = @c1.eager_graph(:tag)
-    ds._fetch = {:id=>1, :yyy=>8, :tag_id=>2, :tag_tag_id=>4}
-    a = ds.all
+    @c1.dataset = @c1.dataset.with_extend{def columns; [:id, :yyy] end}
+    Tag.dataset = Tag.dataset.with_extend{def columns; [:id, :tag_id] end}
+    a = @c1.eager_graph(:tag).with_fetch(:id=>1, :yyy=>8, :tag_id=>2, :tag_tag_id=>4).all
     a.must_equal [@c1.load(:id=>1, :yyy=>8)]
     DB.sqls.must_equal ['SELECT artists.id, artists.yyy, tag.id AS tag_id, tag.tag_id AS tag_tag_id FROM artists LEFT OUTER JOIN albums_artists ON ((albums_artists.b1 = artists.id) AND (albums_artists.b2 = artists.yyy)) LEFT OUTER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) LEFT OUTER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) LEFT OUTER JOIN tags AS tag ON ((tag.id = albums_tags.g1) AND (tag.tag_id = albums_tags.g2))']
     a.first.tag.must_equal Tag.load(:id=>2, :tag_id=>4)
@@ -2100,9 +2047,7 @@ describe "one_through_many eager loading methods" do
 
   it "should respect the association's :graph_select option" do 
     @c1.one_through_many :tag, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :graph_select=>:b
-    ds = @c1.eager_graph(:tag)
-    ds._fetch = {:id=>1, :b=>2}
-    a = ds.all
+    a = @c1.eager_graph(:tag).with_fetch(:id=>1, :b=>2).all
     a.must_equal [@c1.load(:id=>1)]
     DB.sqls.must_equal ['SELECT artists.id, tag.b FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags AS tag ON (tag.id = albums_tags.tag_id)']
     a.first.tag.must_equal Tag.load(:b=>2)