sequel 4.41.0 → 4.42.0

data/spec/model/base_spec.rb

@@ -160,7 +160,7 @@ describe Sequel::Model, ".def_dataset_method" do
     @c.def_dataset_method(:return_3, :return_4)
     proc{@c.return_3}.must_raise(NoMethodError)
     proc{@c.return_4}.must_raise(NoMethodError)
-    @c.dataset.instance_eval do
+    @c.dataset = @c.dataset.with_extend do
       def return_3; 3; end
       def return_4; 4; end
     end
@@ -279,7 +279,122 @@ describe Sequel::Model, ".dataset_module" do
     @c.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND released)'
   end
 
-  it "should raise error if called with both an argument and ablock" do
+  it "should have dataset_module support a where method" do
+    @c.dataset_module{where :released, :released}
+    @c.released.sql.must_equal 'SELECT * FROM items WHERE released'
+    @c.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND released)'
+  end
+
+  it "should have dataset_module support a having method" do
+    @c.dataset_module{having(:released){released}}
+    @c.released.sql.must_equal 'SELECT * FROM items HAVING released'
+    @c.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING released'
+  end
+
+  it "should have dataset_module support an exclude method" do
+    @c.dataset_module{exclude :released, :released}
+    @c.released.sql.must_equal 'SELECT * FROM items WHERE NOT released'
+    @c.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE (foo AND NOT released)'
+  end
+
+  it "should have dataset_module support an exclude_having method" do
+    @c.dataset_module{exclude_having :released, :released}
+    @c.released.sql.must_equal 'SELECT * FROM items HAVING NOT released'
+    @c.where(:foo).released.sql.must_equal 'SELECT * FROM items WHERE foo HAVING NOT released'
+  end
+
+  it "should have dataset_module support a distinct method" do
+    @c.dataset = @c.dataset.with_extend{def supports_distinct_on?; true end}
+    @c.dataset_module{distinct :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items'
+    @c.where(:bar).foo.sql.must_equal 'SELECT DISTINCT ON (baz) * FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a grep method" do
+    @c.dataset_module{grep :foo, :baz, 'quux%'}
+    @c.foo.sql.must_equal 'SELECT * FROM items WHERE ((baz LIKE \'quux%\' ESCAPE \'\\\'))'
+    @c.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE (bar AND ((baz LIKE \'quux%\' ESCAPE \'\\\')))'
+  end
+
+  it "should have dataset_module support a group method" do
+    @c.dataset_module{group :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
+    @c.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a group_and_count method" do
+    @c.dataset_module{group_and_count :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items GROUP BY baz'
+    @c.where(:bar).foo.sql.must_equal 'SELECT baz, count(*) AS count FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a group_append method" do
+    @c.dataset_module{group_append :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT * FROM items GROUP BY baz'
+    @c.group(:bar).foo.sql.must_equal 'SELECT * FROM items GROUP BY bar, baz'
+  end
+
+  it "should have dataset_module support a limit method" do
+    @c.dataset_module{limit :foo, 1}
+    @c.foo.sql.must_equal 'SELECT * FROM items LIMIT 1'
+    @c.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar LIMIT 1'
+  end
+
+  it "should have dataset_module support a offset method" do
+    @c.dataset_module{offset :foo, 1}
+    @c.foo.sql.must_equal 'SELECT * FROM items OFFSET 1'
+    @c.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar OFFSET 1'
+  end
+
+  it "should have dataset_module support a order method" do
+    @c.dataset_module{order(:foo){:baz}}
+    @c.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    @c.where(:bar).foo.sql.must_equal 'SELECT * FROM items WHERE bar ORDER BY baz'
+  end
+
+  it "should have dataset_module support a order_append method" do
+    @c.dataset_module{order_append :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    @c.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY bar, baz'
+  end
+
+  it "should have dataset_module support a order_prepend method" do
+    @c.dataset_module{order_prepend :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT * FROM items ORDER BY baz'
+    @c.order(:bar).foo.sql.must_equal 'SELECT * FROM items ORDER BY baz, bar'
+  end
+
+  it "should have dataset_module support a select method" do
+    @c.dataset_module{select :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT baz FROM items'
+    @c.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_all method" do
+    @c.dataset_module{select_all :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT baz.* FROM items'
+    @c.where(:bar).foo.sql.must_equal 'SELECT baz.* FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_append method" do
+    @c.dataset_module{select_append :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT *, baz FROM items'
+    @c.where(:bar).foo.sql.must_equal 'SELECT *, baz FROM items WHERE bar'
+  end
+
+  it "should have dataset_module support a select_group method" do
+    @c.dataset_module{select_group :foo, :baz}
+    @c.foo.sql.must_equal 'SELECT baz FROM items GROUP BY baz'
+    @c.where(:bar).foo.sql.must_equal 'SELECT baz FROM items WHERE bar GROUP BY baz'
+  end
+
+  it "should have dataset_module support a server method" do
+    @c.dataset_module{server :foo, :baz}
+    @c.foo.opts[:server].must_equal :baz
+    @c.where(:bar).foo.opts[:server].must_equal :baz
+  end
+
+  it "should raise error if called with both an argument and a block" do
     proc{@c.dataset_module(Module.new{def return_3() 3 end}){}}.must_raise(Sequel::Error)
   end
 end
@@ -333,7 +448,7 @@ describe "Model.primary_key" do
   
   it "should use nil for no primary key" do
     @c.no_primary_key
-    @c.primary_key.must_equal nil
+    @c.primary_key.must_be_nil
   end
 end
 
@@ -392,7 +507,7 @@ describe "Model.db" do
     Sequel::DATABASES.clear
   end
   after do
-    Sequel::Model.instance_variable_get(:@db).must_equal nil
+    Sequel::Model.instance_variable_get(:@db).must_be_nil
     Sequel::DATABASES.replace(@databases)
     Sequel::Model.db = @model_db
   end
@@ -470,7 +585,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
   end
   
   it "should set the allowed columns correctly" do
-    @c.allowed_columns.must_equal nil
+    @c.allowed_columns.must_be_nil
     @c.set_allowed_columns :x
     @c.allowed_columns.must_equal [:x]
     @c.set_allowed_columns :x, :y
@@ -484,7 +599,7 @@ describe Sequel::Model, ".(allowed|restricted)_columns " do
     i.set(:x => 4, :y => 5, :z => 6)
     i.values.must_equal(:x => 4, :y => 5)
 
-    @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 7}
+    @c.dataset = @c.dataset.with_fetch(:x => 7)
     i = @c.new
     i.update(:x => 7, :z => 9)
     i.values.must_equal(:x => 7)
@@ -563,10 +678,8 @@ end
 
 describe Sequel::Model, ".require_modification" do
   before do
-    @ds1 = DB[:items]
-    def @ds1.provides_accurate_rows_matched?() false end
-    @ds2 = DB[:items]
-    def @ds2.provides_accurate_rows_matched?() true end
+    @ds1 = DB[:items].with_extend{def provides_accurate_rows_matched?; false end}
+    @ds2 = DB[:items].with_extend{def provides_accurate_rows_matched?; true end}
   end
   after do
     Sequel::Model.require_modification = nil
@@ -591,89 +704,74 @@ end
 describe Sequel::Model, ".[] optimization" do
   before do
     @db = Sequel.mock
-    @db.quote_identifiers = true
     def @db.schema(*) [[:id, {:primary_key=>true}]] end
     def @db.supports_schema_parsing?() true end
     @c = Class.new(Sequel::Model(@db))
+    @ds = @db.dataset.with_quote_identifiers(true)
   end
 
   it "should set simple_pk to the literalized primary key column name if a single primary key" do
     @c.set_primary_key :id
-    @c.simple_pk.must_equal '"id"'
+    @c.simple_pk.must_equal 'id'
     @c.set_primary_key :b
-    @c.simple_pk.must_equal '"b"'
+    @c.simple_pk.must_equal 'b'
     @c.set_primary_key Sequel.identifier(:b__a)
-    @c.simple_pk.must_equal '"b__a"'
+    @c.simple_pk.must_equal 'b__a'
   end
 
   it "should have simple_pk be blank if compound or no primary key" do
     @c.no_primary_key
-    @c.simple_pk.must_equal nil
+    @c.simple_pk.must_be_nil
     @c.set_primary_key [:b, :a]
-    @c.simple_pk.must_equal nil
+    @c.simple_pk.must_be_nil
   end
 
   it "should have simple table set if passed a Symbol to set_dataset" do
     @c.set_dataset :a
-    @c.simple_table.must_equal '"a"'
+    @c.simple_table.must_equal 'a'
     @c.set_dataset :b
-    @c.simple_table.must_equal '"b"'
+    @c.simple_table.must_equal 'b'
     @c.set_dataset :b__a
-    @c.simple_table.must_equal '"b"."a"'
+    @c.simple_table.must_equal 'b.a'
   end
 
   it "should have simple_table set if passed a simple select all dataset to set_dataset" do
-    @c.set_dataset @db[:a]
+    @c.set_dataset @ds.from(:a)
     @c.simple_table.must_equal '"a"'
-    @c.set_dataset @db[:b]
+    @c.set_dataset @ds.from(:b)
     @c.simple_table.must_equal '"b"'
-    @c.set_dataset @db[:b__a]
+    @c.set_dataset @ds.from(:b__a)
     @c.simple_table.must_equal '"b"."a"'
   end
 
-  it "should have simple_pk and simple_table respect dataset's identifier input methods" do
-    ds = @db[:ab]
-    ds.identifier_input_method = :reverse
-    @c.set_dataset ds
-    @c.simple_table.must_equal '"ba"'
-    @c.set_primary_key :cd
-    @c.simple_pk.must_equal '"dc"'
-
-    @c.set_dataset ds.from(:ef__gh)
-    @c.simple_table.must_equal '"fe"."hg"'
-  end
-
   it "should have simple_table = nil if passed a non-simple select all dataset to set_dataset" do
     @c.set_dataset @c.db[:a].filter(:active)
-    @c.simple_table.must_equal nil
+    @c.simple_table.must_be_nil
   end
 
   it "should have simple_table inherit superclass's setting" do
-    Class.new(@c).simple_table.must_equal nil
+    Class.new(@c).simple_table.must_be_nil
     @c.set_dataset :a
-    Class.new(@c).simple_table.must_equal '"a"'
+    Class.new(@c).simple_table.must_equal 'a'
   end
 
   it "should use Dataset#with_sql if simple_table and simple_pk are true" do
-    @c.set_dataset :a
-    @c.instance_dataset._fetch = @c.dataset._fetch = {:id => 1}
+    @c.set_dataset @db[:a].with_fetch(:id=>1)
     @c[1].must_equal @c.load(:id=>1)
-    @db.sqls.must_equal ['SELECT * FROM "a" WHERE "id" = 1']
+    @db.sqls.must_equal ['SELECT * FROM a WHERE id = 1']
   end
 
   it "should not use Dataset#with_sql if either simple_table or simple_pk is nil" do
-    @c.set_dataset @db[:a].filter(:active)
-    @c.dataset._fetch = {:id => 1}
+    @c.set_dataset @db[:a].where(:active).with_fetch(:id=>1)
     @c[1].must_equal @c.load(:id=>1)
-    @db.sqls.must_equal ['SELECT * FROM "a" WHERE ("active" AND ("id" = 1)) LIMIT 1']
+    @db.sqls.must_equal ['SELECT * FROM a WHERE (active AND (id = 1)) LIMIT 1']
   end
 end
 
 describe "Model datasets #with_pk with #with_pk!" do
   before do
     @c = Class.new(Sequel::Model(:a))
-    @ds = @c.dataset
-    @ds._fetch = {:id=>1}
+    @ds = @c.dataset = @c.dataset.with_fetch(:id=>1)
     DB.reset
   end
 
@@ -691,6 +789,14 @@ describe "Model datasets #with_pk with #with_pk!" do
     DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
+  it "should work when called repeatedly on a frozen dataset" do
+    @ds.freeze
+    5.times do
+      @ds.with_pk(1).must_equal @c.load(:id=>1)
+      DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
+    end
+  end
+
   it "should handle existing filters" do
     @ds.filter(:a=>2).with_pk(1)
     DB.sqls.must_equal ["SELECT * FROM a WHERE ((a = 2) AND (a.id = 1)) LIMIT 1"]
@@ -720,17 +826,29 @@ describe "Model datasets #with_pk with #with_pk!" do
     sqls.must_equal []
   end
 
+  it "should work with composite primary keys when called repeatedly on a frozen dataset with" do
+    @c.set_primary_key [:id1, :id2]
+    @ds.freeze
+    5.times do
+      @ds.with_pk([1,2])
+      sqls = DB.sqls
+      ["SELECT * FROM a WHERE ((a.id1 = 1) AND (a.id2 = 2)) LIMIT 1",
+      "SELECT * FROM a WHERE ((a.id2 = 2) AND (a.id1 = 1)) LIMIT 1"].must_include(sqls.pop)
+      sqls.must_equal []
+    end
+  end
+
   it "should have with_pk return nil and with_pk! raise if no rows match" do
-    @ds._fetch = []
-    @ds.with_pk(1).must_equal nil
+    @ds = @ds.with_fetch([])
+    @ds.with_pk(1).must_be_nil
     DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
     proc{@ds.with_pk!(1)}.must_raise(Sequel::NoMatchingRow)
     DB.sqls.must_equal ["SELECT * FROM a WHERE (a.id = 1) LIMIT 1"]
   end
 
   it "should have with_pk return nil and with_pk! raise if no rows match when calling the class method" do
-    @ds._fetch = []
-    @c.with_pk(1).must_equal nil
+    @c.dataset = @c.dataset.with_fetch([])
+    @c.with_pk(1).must_be_nil
     DB.sqls.must_equal ["SELECT * FROM a WHERE id = 1"]
     proc{@c.with_pk!(1)}.must_raise(Sequel::NoMatchingRow)
     DB.sqls.must_equal ["SELECT * FROM a WHERE id = 1"]
@@ -745,6 +863,14 @@ describe "Model datasets #with_pk with #with_pk!" do
     @ds['foo'].must_equal @c.load(:id=>1)
     DB.sqls.must_equal ["SELECT * FROM a WHERE (foo) LIMIT 1"]
   end
+
+  it "should raise Error if called on a dataset with no primary key" do
+    @c.no_primary_key
+    @ds.freeze
+    5.times do
+      proc{@ds.with_pk(1)}.must_raise Sequel::Error
+    end
+  end
 end
 
 describe "Model::include" do

data/spec/model/class_dataset_methods_spec.rb

@@ -3,12 +3,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe Sequel::Model, "class dataset methods"  do
   before do
     @db = Sequel.mock
-    @c = Class.new(Sequel::Model(@db[:items]))
+    @c = Class.new(Sequel::Model(@db[:items].with_extend{def supports_cte?(*) true end}.with_fetch(:id=>1).with_autoid(1).with_numrows(0)))
     @d = @c.dataset
-    def @d.supports_cte?(*) true end
-    @d._fetch = {:id=>1}
-    @d.autoid = 1
-    @d.numrows = 0
     @db.sqls
   end
 
@@ -78,7 +74,7 @@ describe Sequel::Model, "class dataset methods"  do
     @db.sqls.must_equal ["SELECT min(id) AS min FROM items LIMIT 1"]
     @c.multi_insert([{:id=>1}])
     @db.sqls.must_equal ["BEGIN", "INSERT INTO items (id) VALUES (1)", "COMMIT"]
-    @c.naked.row_proc.must_equal nil
+    @c.naked.row_proc.must_be_nil
     @c.natural_full_join(@c).sql.must_equal "SELECT * FROM items NATURAL FULL JOIN items"
     @c.natural_join(@c).sql.must_equal "SELECT * FROM items NATURAL JOIN items"
     @c.natural_left_join(@c).sql.must_equal "SELECT * FROM items NATURAL LEFT JOIN items"
@@ -134,7 +130,8 @@ describe Sequel::Model, "class dataset methods"  do
     sc.set_dataset(@d.where(:a).order(:a).select(:a).group(:a).limit(2))
     @db.sqls
     sc.invert.sql.must_equal 'SELECT a FROM items WHERE NOT a GROUP BY a ORDER BY a LIMIT 2'
-    sc.dataset._fetch = {:v1=>1, :v2=>2}
+    sc.dataset = sc.dataset.with_fetch(:v1=>1, :v2=>2)
+    @db.sqls
     sc.range(:a).must_equal(1..2)
     @db.sqls.must_equal ["SELECT min(a) AS v1, max(a) AS v2 FROM (SELECT a FROM items WHERE a GROUP BY a ORDER BY a LIMIT 2) AS t1 LIMIT 1"]
     sc.reverse.sql.must_equal 'SELECT a FROM items WHERE a GROUP BY a ORDER BY a DESC LIMIT 2'
@@ -144,7 +141,6 @@ describe Sequel::Model, "class dataset methods"  do
     sc.ungrouped.sql.must_equal 'SELECT a FROM items WHERE a ORDER BY a LIMIT 2'
     sc.unordered.sql.must_equal 'SELECT a FROM items WHERE a GROUP BY a LIMIT 2'
     sc.unlimited.sql.must_equal 'SELECT a FROM items WHERE a GROUP BY a ORDER BY a'
-    sc.dataset.graph!(:a)
-    sc.dataset.ungraphed.opts[:graph].must_equal nil
+    sc.dataset.graph(:a).ungraphed.opts[:graph].must_be_nil
   end
 end

data/spec/model/dataset_methods_spec.rb

@@ -9,7 +9,7 @@ describe Sequel::Model::DatasetMethods, "#destroy"  do
       end
     end
     @d = @c.dataset
-    @d._fetch = [{:id=>1}, {:id=>2}]
+    @d = @d.with_fetch([{:id=>1}, {:id=>2}])
     DB.reset
   end
 
@@ -20,7 +20,7 @@ describe Sequel::Model::DatasetMethods, "#destroy"  do
 
   it "should return the number of records destroyed" do
     @d.destroy.must_equal 2
-    @d._fetch = [[{:i=>1}], []]
+    @d = @d.with_fetch([[{:id=>1}], []])
     @d.destroy.must_equal 1
     @d.destroy.must_equal 0
   end
@@ -47,7 +47,7 @@ describe Sequel::Model::DatasetMethods, "#to_hash"  do
   end
 
   it "should result in a hash with primary key value keys and model object values" do
-    @d._fetch = [{:name=>1}, {:name=>2}]
+    @d = @d.with_fetch([{:name=>1}, {:name=>2}])
     h = @d.to_hash
     h.must_be_kind_of(Hash)
     a = h.to_a
@@ -56,7 +56,7 @@ describe Sequel::Model::DatasetMethods, "#to_hash"  do
   end
 
   it "should result in a hash with given value keys and model object values" do
-    @d._fetch = [{:name=>1, :number=>3}, {:name=>2, :number=>4}]
+    @d = @d.with_fetch([{:name=>1, :number=>3}, {:name=>2, :number=>4}])
     h = @d.to_hash(:number)
     h.must_be_kind_of(Hash)
     a = h.to_a
@@ -105,7 +105,7 @@ describe Sequel::Model::DatasetMethods  do
     @c.last.must_be_kind_of(@c)
     @c.db.sqls.must_equal ['SELECT * FROM items ORDER BY id DESC LIMIT 1']
     @c.where(:id=>2).last(:foo=>2){{bar=>3}}.must_be_kind_of(@c)
-    @c.db.sqls.must_equal ['SELECT * FROM items WHERE ((id = 2) AND (bar = 3) AND (foo = 2)) ORDER BY id DESC LIMIT 1']
+    @c.db.sqls.must_equal ['SELECT * FROM items WHERE ((id = 2) AND (foo = 2) AND (bar = 3)) ORDER BY id DESC LIMIT 1']
   end
 
   it "#last should use existing order if there is one" do

data/spec/model/eager_loading_spec.rb

@@ -55,8 +55,7 @@ describe Sequel::Model, "#eager" do
       many_to_many :bands, :class=>'EagerBand', :left_key=>:member_id, :right_key=>:band_id, :join_table=>:bm, :order =>:id
     end
     
-    EagerAlbum.dataset.columns(:id, :band_id)
-    EagerAlbum.dataset._fetch = proc do |sql|
+    EagerAlbum.dataset = EagerAlbum.dataset.with_fetch(proc do |sql|
       h = if sql =~ /101/
         {:id => 101, :band_id=> 101}
       else
@@ -64,9 +63,10 @@ describe Sequel::Model, "#eager" do
       end
       h[:x_foreign_key_x] = 4 if sql =~ /ag\.genre_id/
       h
-    end
+    end)
+    EagerAlbum.dataset.columns(:id, :band_id)
 
-    EagerBand.dataset._fetch = proc do |sql|
+    EagerBand.dataset = EagerBand.dataset.with_fetch(proc do |sql|
       case sql
       when /id IN (101)/
         # nothing
@@ -77,21 +77,21 @@ describe Sequel::Model, "#eager" do
         h[:x_foreign_key_x] = 5 if sql =~ /bm\.member_id/
         h
       end
-    end
+    end)
     
-    EagerTrack.dataset._fetch = {:id => 3, :album_id => 1}
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch(:id => 3, :album_id => 1)
     
-    EagerGenre.dataset._fetch = proc do |sql|
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch(proc do |sql|
       h = {:id => 4}
       h[:x_foreign_key_x] = 1 if sql =~ /ag\.album_id/
       h
-    end
+    end)
     
-    EagerBandMember.dataset._fetch = proc do |sql|
+    EagerBandMember.dataset = EagerBandMember.dataset.with_fetch(proc do |sql|
       h = {:id => 5}
       h[:x_foreign_key_x] = 2 if sql =~ /bm\.band_id/
       h
-    end
+    end)
 
     DB.reset
   end
@@ -148,12 +148,12 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should skip eager loading for a many_to_one association with no matching keys" do
-    EagerAlbum.dataset._fetch = [{:id=>1, :band_id=>nil}]
+    EagerAlbum.dataset = EagerAlbum.dataset.with_fetch([{:id=>1, :band_id=>nil}])
     a = EagerAlbum.eager(:band).all
     DB.sqls.must_equal ['SELECT * FROM albums']
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => nil)]
-    a.first.associations.fetch(:band).must_equal nil
-    a.first.band.must_equal nil
+    a.first.associations.fetch(:band).must_be_nil
+    a.first.band.must_be_nil
     DB.sqls.must_equal []
   end
   
@@ -185,7 +185,7 @@ describe Sequel::Model, "#eager" do
   
   it "should eagerly load a single one_to_one association without an order" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id
-    EagerTrack.dataset._fetch = [{:id => 3, :album_id=>1}, {:id => 4, :album_id=>1}]
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([{:id => 3, :album_id=>1}, {:id => 4, :album_id=>1}])
     a = EagerAlbum.eager(:track).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
@@ -203,7 +203,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should eagerly load a single one_to_one association using the :distinct_on strategy" do
-    def (EagerTrack.dataset).supports_distinct_on?() true end
+    EagerTrack.dataset = EagerTrack.dataset.with_extend{def supports_distinct_on?; true end}
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :order=>:a, :eager_limit_strategy=>:distinct_on
     a = EagerAlbum.eager(:track).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -213,7 +213,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should eagerly load a single one_to_one association using the :window_function strategy" do
-    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerTrack.dataset = EagerTrack.dataset.with_extend{def supports_window_functions?; true end}
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :order=>:name, :eager_limit_strategy=>:window_function
     a = EagerAlbum.eager(:track).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -224,7 +224,7 @@ describe Sequel::Model, "#eager" do
   
   it "should automatically use an eager limit stategy if the association has an offset" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :limit=>[1,1]
-    EagerTrack.dataset._fetch = [{:id => 4, :album_id=>1}]
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([{:id => 4, :album_id=>1}])
     a = EagerAlbum.eager(:track).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT * FROM tracks WHERE (1 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1']
@@ -234,7 +234,7 @@ describe Sequel::Model, "#eager" do
   
   it "should handle offsets when using the :ruby eager limit stategy" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :limit=>[1,1], :eager_limit_strategy=>:ruby
-    EagerTrack.dataset._fetch = [{:id => 3, :album_id=>1}, {:id => 4, :album_id=>1}]
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([{:id => 3, :album_id=>1}, {:id => 4, :album_id=>1}])
     a = EagerAlbum.eager(:track).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1))']
@@ -244,8 +244,8 @@ describe Sequel::Model, "#eager" do
   
   it "should support a :subqueries_per_union option for the number of subqueries in a union" do
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :limit=>[1,1], :subqueries_per_union=>1
-    EagerAlbum.dataset._fetch = [{:id => 1, :band_id => 2}, {:id => 2, :band_id => 3}, {:id => 3, :band_id => 4}]
-    EagerTrack.dataset._fetch = [[{:id => 4, :album_id=>1}], [{:id=>5, :album_id=>2}], [{:id=>6, :album_id=>3}]]
+    EagerAlbum.dataset = EagerAlbum.dataset.with_fetch([{:id => 1, :band_id => 2}, {:id => 2, :band_id => 3}, {:id => 3, :band_id => 4}])
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([[{:id => 4, :album_id=>1}], [{:id=>5, :album_id=>2}], [{:id=>6, :album_id=>3}]])
     a = EagerAlbum.eager(:track).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2), EagerAlbum.load(:id => 2, :band_id => 3), EagerAlbum.load(:id => 3, :band_id => 4)]
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT * FROM tracks WHERE (1 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1', 'SELECT * FROM (SELECT * FROM tracks WHERE (2 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1', 'SELECT * FROM (SELECT * FROM tracks WHERE (3 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1']
@@ -253,7 +253,7 @@ describe Sequel::Model, "#eager" do
     DB.sqls.must_equal []
 
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :limit=>[1,1], :subqueries_per_union=>2
-    EagerTrack.dataset._fetch = [[{:id => 4, :album_id=>1}, {:id=>5, :album_id=>2}], [{:id=>6, :album_id=>3}]]
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([[{:id => 4, :album_id=>1}, {:id=>5, :album_id=>2}], [{:id=>6, :album_id=>3}]])
     a = EagerAlbum.eager(:track).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2), EagerAlbum.load(:id => 2, :band_id => 3), EagerAlbum.load(:id => 3, :band_id => 4)]
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT * FROM tracks WHERE (1 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1 UNION ALL SELECT * FROM (SELECT * FROM tracks WHERE (2 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1', 'SELECT * FROM (SELECT * FROM tracks WHERE (3 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1']
@@ -261,7 +261,7 @@ describe Sequel::Model, "#eager" do
     DB.sqls.must_equal []
 
     EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :limit=>[1,1], :subqueries_per_union=>3
-    EagerTrack.dataset._fetch = [[{:id => 4, :album_id=>1}, {:id=>5, :album_id=>2}, {:id=>6, :album_id=>3}]]
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([[{:id => 4, :album_id=>1}, {:id=>5, :album_id=>2}, {:id=>6, :album_id=>3}]])
     a = EagerAlbum.eager(:track).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2), EagerAlbum.load(:id => 2, :band_id => 3), EagerAlbum.load(:id => 3, :band_id => 4)]
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT * FROM tracks WHERE (1 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1 UNION ALL SELECT * FROM (SELECT * FROM tracks WHERE (2 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1 UNION ALL SELECT * FROM (SELECT * FROM tracks WHERE (3 = tracks.album_id) LIMIT 1 OFFSET 1) AS t1']
@@ -286,7 +286,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should use first matching entry when eager loading one_through_one association" do
-    EagerGenre.dataset._fetch = [{:id => 3, :x_foreign_key_x=>1}, {:id => 4, :x_foreign_key_x=>1}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:id => 3, :x_foreign_key_x=>1}, {:id => 4, :x_foreign_key_x=>1}])
     a = EagerAlbum.eager(:genre).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (1))"]
@@ -304,7 +304,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should eagerly load a single one_through_one association using the :distinct_on strategy" do
-    def (EagerGenre.dataset).supports_distinct_on?() true end
+    EagerGenre.dataset = EagerGenre.dataset.with_extend{def supports_distinct_on?; true end}
     EagerAlbum.one_through_one :genre, :clone=>:genre, :order=>:a, :eager_limit_strategy=>:distinct_on
     a = EagerAlbum.eager(:genre).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -314,7 +314,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should eagerly load a single one_through_one association using the :window_function strategy" do
-    def (EagerGenre.dataset).supports_window_functions?() true end
+    EagerGenre.dataset = EagerGenre.dataset.with_extend{def supports_window_functions?; true end}
     EagerAlbum.one_through_one :genre, :clone=>:genre, :eager_limit_strategy=>:window_function
     a = EagerAlbum.eager(:genre).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -324,7 +324,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should automatically use an eager limit stategy if the association has an offset" do
-    EagerGenre.dataset._fetch = [{:id => 3, :x_foreign_key_x=>1}, {:id => 4, :x_foreign_key_x=>1}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:id => 3, :x_foreign_key_x=>1}, {:id => 4, :x_foreign_key_x=>1}])
     a = EagerAlbum.eager(:genre).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (1))"]
@@ -342,7 +342,7 @@ describe Sequel::Model, "#eager" do
   
   it "should support using a custom :key option when eager loading many_to_one associations" do
     EagerAlbum.many_to_one :sband, :clone=>:band, :key=>:band_id3
-    EagerBand.dataset._fetch = {:id=>6}
+    EagerBand.dataset = EagerBand.dataset.with_fetch(:id=>6)
     a = EagerAlbum.eager(:sband).all
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM bands WHERE (bands.id IN (6))']
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -352,7 +352,7 @@ describe Sequel::Model, "#eager" do
   
   it "should support using a custom :primary_key option when eager loading one_to_many associations" do
     EagerBand.one_to_many :salbums, :clone=>:albums, :primary_key=>:id3, :eager=>nil, :reciprocal=>nil
-    EagerBand.dataset._fetch = {:id=>6}
+    EagerBand.dataset = EagerBand.dataset.with_fetch(:id=>6)
     a = EagerBand.eager(:salbums).all
     DB.sqls.must_equal ['SELECT * FROM bands', 'SELECT * FROM albums WHERE (albums.band_id IN (2))']
     a.must_equal [EagerBand.load(:id => 6)]
@@ -362,7 +362,7 @@ describe Sequel::Model, "#eager" do
 
   it "should support using a custom :left_primary_key option when eager loading many_to_many associations" do
     EagerAlbum.many_to_many :sgenres, :clone=>:genres, :left_primary_key=>:band_id3
-    EagerGenre.dataset._fetch = {:id=>4, :x_foreign_key_x=>6}
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch(:id=>4, :x_foreign_key_x=>6)
     a = EagerAlbum.eager(:sgenres).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (6))"]
@@ -372,7 +372,7 @@ describe Sequel::Model, "#eager" do
 
   it "should support using a custom :left_primary_key option when eager loading one_through_one associations" do
     EagerAlbum.one_through_one :sgenre, :clone=>:genre, :left_primary_key=>:band_id3
-    EagerGenre.dataset._fetch = {:id=>4, :x_foreign_key_x=>6}
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch(:id=>4, :x_foreign_key_x=>6)
     a = EagerAlbum.eager(:sgenre).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (6))"]
@@ -382,7 +382,7 @@ describe Sequel::Model, "#eager" do
 
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for many_to_one associations" do
     EagerAlbum.many_to_one :sband, :clone=>:band, :eager_loading_predicate_key=>Sequel./(:bands__id, 3), :primary_key_method=>:id3
-    EagerBand.dataset._fetch = {:id=>6}
+    EagerBand.dataset = EagerBand.dataset.with_fetch(:id=>6)
     a = EagerAlbum.eager(:sband).all
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM bands WHERE ((bands.id / 3) IN (2))']
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -392,7 +392,7 @@ describe Sequel::Model, "#eager" do
   
   it "should handle a :eager_loading_predicate_key option to change the SQL used in the lookup, for one_to_many associations" do
     EagerBand.one_to_many :salbums, :clone=>:albums, :eager_loading_predicate_key=>Sequel.*(:albums__band_id, 3), :key_method=>:band_id3, :eager=>nil, :reciprocal=>nil
-    EagerBand.dataset._fetch = {:id=>6}
+    EagerBand.dataset = EagerBand.dataset.with_fetch(:id=>6)
     a = EagerBand.eager(:salbums).all
     DB.sqls.must_equal ['SELECT * FROM bands', 'SELECT * FROM albums WHERE ((albums.band_id * 3) IN (6))']
     a.must_equal [EagerBand.load(:id => 6)]
@@ -430,7 +430,7 @@ describe Sequel::Model, "#eager" do
     ds = EagerAlbum.eager(:sgenres)
     ds.all
     eo[:key_hash].must_equal({})
-    eo[:id_map].must_equal nil
+    eo[:id_map].must_be_nil
   end
   
   it "should correctly handle a :select=>[] option to many_to_many" do
@@ -580,7 +580,9 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should cascade eagerly loading when the :eager_graph association option is used" do
-    EagerAlbum.dataset._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
+    EagerAlbum.dataset = EagerAlbum.dataset.with_fetch(:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1)
+    EagerAlbum.dataset.columns(:id, :band_id)
+    EagerTrack.dataset.columns(:id, :album_id)
     a = EagerBand.eager(:graph_albums).all
     a.must_equal [EagerBand.load(:id=>2)]
     DB.sqls.must_equal ['SELECT * FROM bands', 
@@ -599,7 +601,9 @@ describe Sequel::Model, "#eager" do
     a.must_equal [EagerBand.load(:id=>2)]
     DB.sqls.must_equal ['SELECT * FROM bands']
     a = a.first
-    EagerAlbum.dataset._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
+    EagerAlbum.dataset = EagerAlbum.dataset.with_fetch(:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1)
+    EagerAlbum.dataset.columns(:id, :band_id)
+    EagerTrack.dataset.columns(:id, :album_id)
     a.graph_albums
     DB.sqls.must_equal ['SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) WHERE (albums.band_id = 2)']
     a.graph_albums.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -608,10 +612,9 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should respect :eager_graph when lazily loading a many_to_many association" do
-    ds = EagerBandMember.dataset
-    def ds.columns() [:id] end
-    ds._fetch = [{:id=>5, :bands_id=>2, :p_k=>6}, {:id=>5, :bands_id=>3, :p_k=>6}]
+    EagerBandMember.dataset = EagerBandMember.dataset.with_fetch([{:id=>5, :bands_id=>2, :p_k=>6}, {:id=>5, :bands_id=>3, :p_k=>6}]).with_extend{def columns; [:id] end}
     a = EagerBand.load(:id=>2)
+    EagerBand.dataset.columns(:id, :p_k)
     a.graph_members.must_equal [EagerBandMember.load(:id=>5)]
     DB.sqls.must_equal ['SELECT members.id, bands.id AS bands_id, bands.p_k FROM (SELECT members.* FROM members INNER JOIN bm ON (bm.member_id = members.id) WHERE (bm.band_id = 2)) AS members LEFT OUTER JOIN bm AS bm_0 ON (bm_0.member_id = members.id) LEFT OUTER JOIN bands ON (bands.id = bm_0.band_id) ORDER BY bands.id']
     a.graph_members.first.bands.must_equal [EagerBand.load(:id=>2, :p_k=>6), EagerBand.load(:id=>3, :p_k=>6)]
@@ -652,8 +655,8 @@ describe Sequel::Model, "#eager" do
     a = EagerAlbum.eager(:band).filter(:id=>101).all
     a.must_equal [EagerAlbum.load(:id => 101, :band_id => 101)]
     DB.sqls.must_equal ['SELECT * FROM albums WHERE (id = 101)', 'SELECT * FROM bands WHERE (bands.id IN (101))']
-    a.first.associations.fetch(:band, 2).must_equal nil
-    a.first.band.must_equal nil
+    a.first.associations.fetch(:band, 2).must_be_nil
+    a.first.band.must_be_nil
     DB.sqls.must_equal []
   end
   
@@ -695,7 +698,7 @@ describe Sequel::Model, "#eager" do
 
   it "should respect many_to_one association's :qualify option" do
     EagerAlbum.many_to_one :special_band, :class=>:EagerBand, :qualify=>false, :key=>:band_id
-    EagerBand.dataset._fetch = {:id=>2}
+    EagerBand.dataset = EagerBand.dataset.with_fetch(:id=>2)
     as = EagerAlbum.eager(:special_band).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM bands WHERE (id IN (2))"]
     as.map{|a| a.special_band}.must_equal [EagerBand.load(:id=>2)]
@@ -704,14 +707,14 @@ describe Sequel::Model, "#eager" do
 
   it "should respect the association's :primary_key option" do
     EagerAlbum.many_to_one :special_band, :class=>:EagerBand, :primary_key=>:p_k, :key=>:band_id
-    EagerBand.dataset._fetch = {:p_k=>2, :id=>1}
+    EagerBand.dataset = EagerBand.dataset.with_fetch(:p_k=>2, :id=>1)
     as = EagerAlbum.eager(:special_band).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM bands WHERE (bands.p_k IN (2))"]
     as.length.must_equal 1
     as.first.special_band.must_equal EagerBand.load(:p_k=>2, :id=>1)
 
     EagerAlbum.one_to_many :special_tracks, :class=>:EagerTrack, :primary_key=>:band_id, :key=>:album_id, :reciprocal=>nil
-    EagerTrack.dataset._fetch = {:album_id=>2, :id=>1}
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch(:album_id=>2, :id=>1)
     as = EagerAlbum.eager(:special_tracks).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (2))"]
     as.length.must_equal 1
@@ -720,7 +723,7 @@ describe Sequel::Model, "#eager" do
   
   it "should respect the many_to_one association's composite keys" do
     EagerAlbum.many_to_one :special_band, :class=>:EagerBand, :primary_key=>[:id, :p_k], :key=>[:band_id, :id]
-    EagerBand.dataset._fetch = {:p_k=>1, :id=>2}
+    EagerBand.dataset = EagerBand.dataset.with_fetch(:p_k=>1, :id=>2)
     as = EagerAlbum.eager(:special_band).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM bands WHERE ((bands.id, bands.p_k) IN ((2, 1)))"]
     as.length.must_equal 1
@@ -729,7 +732,7 @@ describe Sequel::Model, "#eager" do
   
   it "should respect the one_to_many association's composite keys" do
     EagerAlbum.one_to_many :special_tracks, :class=>:EagerTrack, :primary_key=>[:band_id, :id], :key=>[:id, :album_id]
-    EagerTrack.dataset._fetch = {:album_id=>1, :id=>2}
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch(:album_id=>1, :id=>2)
     as = EagerAlbum.eager(:special_tracks).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM tracks WHERE ((tracks.id, tracks.album_id) IN ((2, 1)))"]
     as.length.must_equal 1
@@ -738,7 +741,7 @@ describe Sequel::Model, "#eager" do
 
   it "should respect many_to_many association's composite keys" do
     EagerAlbum.many_to_many :special_genres, :class=>:EagerGenre, :left_primary_key=>[:band_id, :id], :left_key=>[:l1, :l2], :right_primary_key=>[:xxx, :id], :right_key=>[:r1, :r2], :join_table=>:ag
-    EagerGenre.dataset._fetch = [{:x_foreign_key_0_x=>2, :x_foreign_key_1_x=>1, :id=>5}, {:x_foreign_key_0_x=>2, :x_foreign_key_1_x=>1, :id=>6}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_0_x=>2, :x_foreign_key_1_x=>1, :id=>5}, {:x_foreign_key_0_x=>2, :x_foreign_key_1_x=>1, :id=>6}])
     as = EagerAlbum.eager(:special_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.l1 AS x_foreign_key_0_x, ag.l2 AS x_foreign_key_1_x FROM genres INNER JOIN ag ON ((ag.r1 = genres.xxx) AND (ag.r2 = genres.id)) WHERE ((ag.l1, ag.l2) IN ((2, 1)))"]
     as.length.must_equal 1
@@ -747,7 +750,7 @@ describe Sequel::Model, "#eager" do
   
   it "should respect one_through_one association's composite keys" do
     EagerAlbum.one_through_one :special_genre, :class=>:EagerGenre, :left_primary_key=>[:band_id, :id], :left_key=>[:l1, :l2], :right_primary_key=>[:xxx, :id], :right_key=>[:r1, :r2], :join_table=>:ag
-    EagerGenre.dataset._fetch = [{:x_foreign_key_0_x=>2, :x_foreign_key_1_x=>1, :id=>5}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_0_x=>2, :x_foreign_key_1_x=>1, :id=>5}])
     as = EagerAlbum.eager(:special_genre).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.l1 AS x_foreign_key_0_x, ag.l2 AS x_foreign_key_1_x FROM genres INNER JOIN ag ON ((ag.r1 = genres.xxx) AND (ag.r2 = genres.id)) WHERE ((ag.l1, ag.l2) IN ((2, 1)))"]
     as.length.must_equal 1
@@ -756,7 +759,7 @@ describe Sequel::Model, "#eager" do
   
   it "should respect many_to_many association's :left_primary_key and :right_primary_key options" do
     EagerAlbum.many_to_many :special_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_primary_key=>:xxx, :right_key=>:genre_id, :join_table=>:ag
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}])
     as = EagerAlbum.eager(:special_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.xxx) WHERE (ag.album_id IN (2))"]
     as.length.must_equal 1
@@ -765,7 +768,7 @@ describe Sequel::Model, "#eager" do
 
   it "should respect one_through_one association's :left_primary_key and :right_primary_key options" do
     EagerAlbum.one_through_one :special_genre, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_primary_key=>:xxx, :right_key=>:genre_id, :join_table=>:ag
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}])
     as = EagerAlbum.eager(:special_genre).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.xxx) WHERE (ag.album_id IN (2))"]
     as.length.must_equal 1
@@ -774,7 +777,7 @@ describe Sequel::Model, "#eager" do
 
   it "should respect the :limit option on a one_to_many association using the :ruby strategy" do
     EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>2, :eager_limit_strategy=>:ruby
-    EagerTrack.dataset._fetch = [{:album_id=>1, :id=>2}, {:album_id=>1, :id=>3}, {:album_id=>1, :id=>4}]
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([{:album_id=>1, :id=>2}, {:album_id=>1, :id=>3}, {:album_id=>1, :id=>4}])
     as = EagerAlbum.eager(:first_two_tracks).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM tracks WHERE (tracks.album_id IN (1))"]
     as.length.must_equal 1
@@ -828,7 +831,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should respect the :limit option on a one_to_many association using the :window_function strategy" do
-    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerTrack.dataset = EagerTrack.dataset.with_extend{def supports_window_functions?; true end}
     EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :order=>:name, :limit=>2, :eager_limit_strategy=>:window_function
     a = EagerAlbum.eager(:tracks).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -854,7 +857,8 @@ describe Sequel::Model, "#eager" do
   it "should use a ruby strategy for limit if :eager_graph option is used" do
     EagerTrack.many_to_one :album2, :clone=>:album
     EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>2, :eager_graph=>:album2
-    EagerTrack.dataset._fetch = [{:album_id=>1, :id=>2, :album2_id=>1, :band_id=>5}, {:album_id=>1, :id=>3, :album2_id=>1, :band_id=>5}, {:album_id=>1, :id=>4, :album2_id=>1, :band_id=>5}]
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([{:album_id=>1, :id=>2, :album2_id=>1, :band_id=>5}, {:album_id=>1, :id=>3, :album2_id=>1, :band_id=>5}, {:album_id=>1, :id=>4, :album2_id=>1, :band_id=>5}])
+    EagerTrack.dataset.columns(:id, :album_id)
     as = EagerAlbum.eager(:first_two_tracks).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT tracks.id, tracks.album_id, album2.id AS album2_id, album2.band_id FROM tracks LEFT OUTER JOIN albums AS album2 ON (album2.id = tracks.album_id) WHERE (tracks.album_id IN (1))"]
     as.length.must_equal 1
@@ -865,7 +869,7 @@ describe Sequel::Model, "#eager" do
   end
   
   it "should not use a union strategy for limit by default if providing a per-eager load callback" do
-    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerTrack.dataset = EagerTrack.dataset.with_extend{def supports_window_functions?; true end}
     EagerAlbum.one_to_many :tracks, :class=>'EagerTrack', :key=>:album_id, :order=>:name, :limit=>2
     a = EagerAlbum.eager(:tracks=>proc{|ds| ds.where(:id=>3)}).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id => 2)]
@@ -876,20 +880,20 @@ describe Sequel::Model, "#eager" do
 
   it "should respect the limit option on a many_to_many association using the :ruby strategy" do
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>2, :eager_limit_strategy=>:ruby
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}, {:x_foreign_key_x=>2, :id=>7}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}, {:x_foreign_key_x=>2, :id=>7}])
     as = EagerAlbum.eager(:first_two_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (2))"]
     as.length.must_equal 1
     as.first.first_two_genres.must_equal [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
     
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}, {:x_foreign_key_x=>2, :id=>7}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}, {:x_foreign_key_x=>2, :id=>7}])
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>[1, 1], :eager_limit_strategy=>:ruby
     as = EagerAlbum.eager(:first_two_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (2))"]
     as.length.must_equal 1
     as.first.first_two_genres.must_equal [EagerGenre.load(:id=>6)]
     
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}, {:x_foreign_key_x=>2, :id=>7}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}, {:x_foreign_key_x=>2, :id=>7}])
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>[nil, 1], :eager_limit_strategy=>:ruby
     as = EagerAlbum.eager(:first_two_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (2))"]
@@ -898,22 +902,21 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should respect the limit option on a many_to_many association" do
-    def (EagerGenre.dataset).supports_window_functions?() true end
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]).with_extend{def supports_window_functions?; true end}
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>2, :order=>:name
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
     as = EagerAlbum.eager(:first_two_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (2 = ag.album_id) ORDER BY name LIMIT 2) AS t1"]
     as.length.must_equal 1
     as.first.first_two_genres.must_equal [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
 
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}])
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>[1, 1], :order=>:name
     as = EagerAlbum.eager(:first_two_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (2 = ag.album_id) ORDER BY name LIMIT 1 OFFSET 1) AS t1"]
     as.length.must_equal 1
     as.first.first_two_genres.must_equal [EagerGenre.load(:id=>5)]
 
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}])
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>[nil, 1], :order=>:name
     as = EagerAlbum.eager(:first_two_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (2 = ag.album_id) ORDER BY name OFFSET 1) AS t1"]
@@ -922,22 +925,21 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should respect the limit option on a many_to_many association using the :window_function strategy" do
-    def (EagerGenre.dataset).supports_window_functions?() true end
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]).with_extend{def supports_window_functions?; true end}
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>2, :order=>:name, :eager_limit_strategy=>:window_function
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
     as = EagerAlbum.eager(:first_two_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (2))) AS t1 WHERE (x_sequel_row_number_x <= 2)"]
     as.length.must_equal 1
     as.first.first_two_genres.must_equal [EagerGenre.load(:id=>5), EagerGenre.load(:id=>6)]
 
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}])
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>[1, 1], :order=>:name, :eager_limit_strategy=>:window_function
     as = EagerAlbum.eager(:first_two_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (2))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 3))"]
     as.length.must_equal 1
     as.first.first_two_genres.must_equal [EagerGenre.load(:id=>5)]
 
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>2, :id=>5}, {:x_foreign_key_x=>2, :id=>6}])
     EagerAlbum.many_to_many :first_two_genres, :class=>:EagerGenre, :left_primary_key=>:band_id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>[nil, 1], :order=>:name, :eager_limit_strategy=>:window_function
     as = EagerAlbum.eager(:first_two_genres).all
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT * FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id ORDER BY name) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (2))) AS t1 WHERE (x_sequel_row_number_x >= 2)"]
@@ -985,7 +987,7 @@ describe Sequel::Model, "#eager" do
   
   it "should respect :uniq option when eagerly loading many_to_many associations" do
     EagerAlbum.many_to_many :al_genres, :class=>'EagerGenre', :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :uniq=>true
-    EagerGenre.dataset._fetch = [{:x_foreign_key_x=>1, :id=>8}, {:x_foreign_key_x=>1, :id=>8}]
+    EagerGenre.dataset = EagerGenre.dataset.with_fetch([{:x_foreign_key_x=>1, :id=>8}, {:x_foreign_key_x=>1, :id=>8}])
     a = EagerAlbum.eager(:al_genres).all.first
     DB.sqls.must_equal ['SELECT * FROM albums', "SELECT genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) WHERE (ag.album_id IN (1))"]
     a.must_equal EagerAlbum.load(:id => 1, :band_id => 2)
@@ -1082,8 +1084,8 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should allow cascading of eager loading with custom callback with symbol value when association has a limit" do
-    EagerAlbum.dataset._fetch = (1..11).map{|i| {:band_id=>2, :id=>i}}
-    EagerTrack.dataset._fetch = [{:id=>3, :album_id=>1}]
+    EagerAlbum.dataset = EagerAlbum.dataset.with_fetch((1..11).map{|i| {:band_id=>2, :id=>i}})
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([{:id=>3, :album_id=>1}])
     a = EagerBand.eager(:top_10_albums=>{proc{|ds| ds.select(:id, :name)}=>:tracks}).all
     a.must_equal [EagerBand.load(:id => 2)]
     sqls = DB.sqls
@@ -1096,9 +1098,8 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should allow cascading of eager loading with custom callback with symbol value when association has a limit when using window function eager limit strategy" do
-    def (EagerAlbum.dataset).supports_window_functions?() true end
-    EagerAlbum.dataset._fetch = {:band_id=>2, :id=>1}
-    EagerTrack.dataset._fetch = [{:id=>3, :album_id=>1}]
+    EagerAlbum.dataset = EagerAlbum.dataset.with_fetch(:band_id=>2, :id=>1).with_extend{def supports_window_functions?; true end}
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch([{:id=>3, :album_id=>1}])
     a = EagerBand.eager(:top_10_albums=>{proc{|ds| ds.select(:id, :name)}=>:tracks}).all
     a.must_equal [EagerBand.load(:id => 2)]
     DB.sqls.must_equal ['SELECT * FROM bands',
@@ -1131,8 +1132,7 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should respect an :eager_limit option passed in a custom callback" do
-    # Should default to a window function on its own.
-    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerTrack.dataset = EagerTrack.dataset.with_extend{def supports_window_functions?; true end}
     a = EagerAlbum.eager(:tracks=> proc{|ds| ds.clone(:eager_limit=>5)}).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id=> 2)]
     sqls = DB.sqls
@@ -1143,21 +1143,20 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should respect an :eager_limit option that includes an offset" do
-    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerTrack.dataset = EagerTrack.dataset.with_extend{def supports_window_functions?; true end}
     EagerAlbum.eager(:tracks=> proc{|ds| ds.clone(:eager_limit=>[5, 5])}).all
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE ((x_sequel_row_number_x >= 6) AND (x_sequel_row_number_x < 11))']
   end
 
   it "should have an :eager_limit option passed in a custom callback override a :limit defined in the association" do
-    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerTrack.dataset = EagerTrack.dataset.with_extend{def supports_window_functions?; true end}
     EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>2
     EagerAlbum.eager(:first_two_tracks=> proc{|ds| ds.clone(:eager_limit=>5)}).all
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x <= 5)']
   end
 
   it "should respect an :eager_limit_strategy option passed in a custom callback" do
-    def (EagerTrack.dataset).supports_window_functions?() true end
-    EagerTrack.dataset._fetch = (1..4).map{|i| {:album_id=>1, :id=>i}}
+    EagerTrack.dataset = EagerTrack.dataset.with_fetch((1..4).map{|i| {:album_id=>1, :id=>i}}).with_extend{def supports_window_functions?; true end}
     a = EagerAlbum.eager(:tracks=> proc{|ds| ds.clone(:eager_limit=>2, :eager_limit_strategy=>:ruby)}).all
     a.must_equal [EagerAlbum.load(:id => 1, :band_id=> 2)]
     sqls = DB.sqls
@@ -1168,17 +1167,32 @@ describe Sequel::Model, "#eager" do
   end
 
   it "should have an :eager_limit_strategy option passed in a custom callback override a :eager_limit_strategy defined in the association" do
-    def (EagerTrack.dataset).supports_window_functions?() true end
+    EagerTrack.dataset = EagerTrack.dataset.with_extend{def supports_window_functions?; true end}
     EagerAlbum.one_to_many :first_two_tracks, :class=>:EagerTrack, :key=>:album_id, :limit=>2, :eager_limit_strategy=>:ruby
     EagerAlbum.eager(:first_two_tracks=> proc{|ds| ds.clone(:eager_limit_strategy=>:window_function)}).all
     DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks WHERE (tracks.album_id IN (1))) AS t1 WHERE (x_sequel_row_number_x <= 2)']
   end
+
+  it "should raise error if using :eager_limit for a singular association" do
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id
+    proc{EagerAlbum.eager(:track=> proc{|ds| ds.clone(:eager_limit=>1)}).all}.must_raise Sequel::Error
+    DB.sqls.must_equal ['SELECT * FROM albums']
+  end
+
+  it "should raise error if using :eager_limit for a singular association" do
+    EagerAlbum.one_to_one :track, :class=>'EagerTrack', :key=>:album_id, :order=>:name
+    a = EagerAlbum.eager(:track=> proc{|ds| ds.order(:foo)}).all
+    DB.sqls.must_equal ['SELECT * FROM albums', 'SELECT * FROM tracks WHERE (tracks.album_id IN (1)) ORDER BY foo']
+    a = a.first
+    a.track.must_equal EagerTrack.load(:id => 3, :album_id => 1)
+    DB.sqls.must_equal []
+  end
+
 end
 
 describe Sequel::Model, "#eager_graph" do
   before(:all) do
     class ::GraphAlbum < Sequel::Model(:albums)
-      dataset.opts[:from] = [:albums]
       columns :id, :band_id
       many_to_one :band, :class=>'GraphBand', :key=>:band_id
       one_to_many :tracks, :class=>'GraphTrack', :key=>:album_id
@@ -1189,7 +1203,6 @@ describe Sequel::Model, "#eager_graph" do
     end
 
     class ::GraphBand < Sequel::Model(:bands)
-      dataset.opts[:from] = [:bands]
       columns :id, :vocalist_id
       many_to_one :vocalist, :class=>'GraphBandMember', :key=>:vocalist_id
       one_to_many :albums, :class=>'GraphAlbum', :key=>:band_id
@@ -1198,19 +1211,16 @@ describe Sequel::Model, "#eager_graph" do
     end
     
     class ::GraphTrack < Sequel::Model(:tracks)
-      dataset.opts[:from] = [:tracks]
       columns :id, :album_id
       many_to_one :album, :class=>'GraphAlbum', :key=>:album_id
     end
     
     class ::GraphGenre < Sequel::Model(:genres)
-      dataset.opts[:from] = [:genres]
       columns :id
       many_to_many :albums, :class=>'GraphAlbum', :left_key=>:genre_id, :right_key=>:album_id, :join_table=>:ag
     end
     
     class ::GraphBandMember < Sequel::Model(:members)
-      dataset.opts[:from] = [:members]
       columns :id
       many_to_many :bands, :class=>'GraphBand', :left_key=>:member_id, :right_key=>:band_id, :join_table=>:bm
     end
@@ -1228,26 +1238,22 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should work correctly with select_map" do
     ds = GraphAlbum.eager_graph(:band)
-    ds._fetch = [{:id=>1}, {:id=>2}]
-    ds.select_map(:albums__id).must_equal [1, 2]
+    ds.with_fetch([{:id=>1}, {:id=>2}]).select_map(:albums__id).must_equal [1, 2]
     DB.sqls.must_equal ['SELECT albums.id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)']
-    ds._fetch = [{:id=>1}, {:id=>2}]
-    ds.select_map([:albums__id, :albums__id]).must_equal [[1, 1], [2, 2]]
+    ds.with_fetch([{:id=>1}, {:id=>2}]).select_map([:albums__id, :albums__id]).must_equal [[1, 1], [2, 2]]
     DB.sqls.must_equal ['SELECT albums.id, albums.id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)']
   end
 
   it "should work correctly with single_value" do
     ds = GraphAlbum.eager_graph(:band).select(:albums__id)
-    ds._fetch = [{:id=>1}]
-    ds.single_value.must_equal 1
+    ds.with_fetch([{:id=>1}]).single_value.must_equal 1
     DB.sqls.must_equal ['SELECT albums.id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id) LIMIT 1']
   end
 
   it "should not split results and assign associations if ungraphed is called" do
     ds = GraphAlbum.eager_graph(:band).ungraphed
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3}
-    ds.all.must_equal [GraphAlbum.load(:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3)]
+    ds.with_fetch(:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3).all.must_equal [GraphAlbum.load(:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3)]
   end
 
   it "should not modify existing dataset" do
@@ -1261,8 +1267,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should allow manually selecting the alias base per call via an AliasedExpression" do
     ds = GraphAlbum.eager_graph(Sequel.as(:band, :b))
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, b.id AS b_id, b.vocalist_id FROM albums LEFT OUTER JOIN bands AS b ON (b.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :b_id=>2, :vocalist_id=>3}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :b_id=>2, :vocalist_id=>3).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.band.must_equal GraphBand.load(:id => 2, :vocalist_id=>3)
   end
@@ -1270,8 +1275,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should handle multiple associations using the same alias base" do
     ds = GraphAlbum.eager_graph(Sequel.as(:genres, :b), Sequel.as(:tracks, :b), Sequel.as(:band, :b))
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, b.id AS b_id, b_0.id AS b_0_id, b_0.album_id, b_1.id AS b_1_id, b_1.vocalist_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS b ON (b.id = ag.genre_id) LEFT OUTER JOIN tracks AS b_0 ON (b_0.album_id = albums.id) LEFT OUTER JOIN bands AS b_1 ON (b_1.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :b_id=>4, :b_0_id=>3, :album_id=>1, :b_1_id=>2, :vocalist_id=>6}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :b_id=>4, :b_0_id=>3, :album_id=>1, :b_1_id=>2, :vocalist_id=>6).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a = a.first
     a.band.must_equal GraphBand.load(:id => 2, :vocalist_id=>6)
@@ -1280,8 +1284,7 @@ describe Sequel::Model, "#eager_graph" do
 
     ds = GraphTrack.eager_graph(Sequel.as(:album, :b)=>{Sequel.as(:band, :b)=>Sequel.as(:members, :b)})
     ds.sql.must_equal 'SELECT tracks.id, tracks.album_id, b.id AS b_id, b.band_id, b_0.id AS b_0_id, b_0.vocalist_id, b_1.id AS b_1_id FROM tracks LEFT OUTER JOIN albums AS b ON (b.id = tracks.album_id) LEFT OUTER JOIN bands AS b_0 ON (b_0.id = b.band_id) LEFT OUTER JOIN bm ON (bm.band_id = b_0.id) LEFT OUTER JOIN members AS b_1 ON (b_1.id = bm.member_id)'
-    ds._fetch = {:id=>3, :album_id=>1, :b_id=>1, :band_id=>2, :b_1_id=>5, :b_0_id=>2, :vocalist_id=>6}
-    a = ds.all
+    a = ds.with_fetch(:id=>3, :album_id=>1, :b_id=>1, :band_id=>2, :b_1_id=>5, :b_0_id=>2, :vocalist_id=>6).all
     a.must_equal [GraphTrack.load(:id => 3, :album_id => 1)]
     a = a.first
     a.album.must_equal GraphAlbum.load(:id => 1, :band_id => 2)
@@ -1315,8 +1318,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a single many_to_one association" do
     ds = GraphAlbum.eager_graph(:band)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.band.must_equal GraphBand.load(:id => 2, :vocalist_id=>3)
   end
@@ -1326,8 +1328,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_one :band_id, :key_column=>:band_id, :class=>GraphBand
     ds = GraphAlbum.eager_graph(:band_id)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, band_id.id AS band_id_id, band_id.vocalist_id FROM albums LEFT OUTER JOIN bands AS band_id ON (band_id.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :band_id_id=>2, :vocalist_id=>3}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :band_id_id=>2, :vocalist_id=>3).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.band_id.must_equal GraphBand.load(:id => 2, :vocalist_id=>3)
   end
@@ -1335,8 +1336,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should support :join_type eager_graph option one_to_one association" do
     ds = GraphAlbum.eager_graph_with_options(:track, :join_type=>:inner)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, track.id AS track_id, track.album_id FROM albums INNER JOIN tracks AS track ON (track.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :track_id=>3, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :track_id=>3, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.track.must_equal GraphTrack.load(:id => 3, :album_id=>1)
   end
@@ -1344,47 +1344,49 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a single one_to_one association" do
     ds = GraphAlbum.eager_graph(:track)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, track.id AS track_id, track.album_id FROM albums LEFT OUTER JOIN tracks AS track ON (track.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :track_id=>3, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :track_id=>3, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.track.must_equal GraphTrack.load(:id => 3, :album_id=>1)
   end
 
   it "should eagerly graph a single one_to_one association using the :distinct_on strategy" do
     sub = Class.new(GraphTrack)
-    def (sub.dataset).supports_distinct_on?() true end
-    def (sub.dataset).columns() [:id, :album_id] end
+    sub.dataset = sub.dataset.with_extend do
+      def supports_distinct_on?; true end
+      def columns; [:id, :album_id] end
+    end
     GraphAlbum.one_to_one :ltrack, :clone=>:track, :class=>sub
     ds = GraphAlbum.eager_graph_with_options(:ltrack, :limit_strategy=>true)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, ltrack.id AS ltrack_id, ltrack.album_id FROM albums LEFT OUTER JOIN (SELECT DISTINCT ON (tracks.album_id) * FROM tracks ORDER BY tracks.album_id) AS ltrack ON (ltrack.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :ltrack_id=>3, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :ltrack_id=>3, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.ltrack.must_equal sub.load(:id => 3, :album_id=>1)
   end
   
   it "should eagerly graph a single one_to_one association using the :window_function strategy" do
     sub = Class.new(GraphTrack)
-    def (sub.dataset).supports_window_functions?() true end
-    def (sub.dataset).columns() [:id, :album_id] end
+    sub.dataset = sub.dataset.with_extend do
+      def supports_window_functions?; true end
+      def columns; [:id, :album_id] end
+    end
     GraphAlbum.one_to_one :ltrack, :clone=>:track, :class=>sub
     ds = GraphAlbum.eager_graph_with_options(:ltrack, :limit_strategy=>true)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, ltrack.id AS ltrack_id, ltrack.album_id FROM albums LEFT OUTER JOIN (SELECT id, album_id FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks) AS t1 WHERE (x_sequel_row_number_x = 1)) AS ltrack ON (ltrack.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :ltrack_id=>3, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :ltrack_id=>3, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.ltrack.must_equal sub.load(:id => 3, :album_id=>1)
   end
   
   it "should eagerly graph a single one_to_one association using the :correlated_subquery strategy" do
     sub = Class.new(GraphTrack)
-    def (sub.dataset).supports_window_functions?() true end
-    def (sub.dataset).columns() [:id, :album_id] end
+    sub.dataset = sub.dataset.with_extend do
+      def supports_window_functions?; true end
+      def columns; [:id, :album_id] end
+    end
     GraphAlbum.one_to_one :ltrack, :clone=>:track, :class=>sub
     ds = GraphAlbum.eager_graph_with_options(:ltrack, :limit_strategy=>:correlated_subquery)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, ltrack.id AS ltrack_id, ltrack.album_id FROM albums LEFT OUTER JOIN (SELECT * FROM tracks WHERE (tracks.id IN (SELECT t1.id FROM tracks AS t1 WHERE (t1.album_id = tracks.album_id) LIMIT 1))) AS ltrack ON (ltrack.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :ltrack_id=>3, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :ltrack_id=>3, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.ltrack.must_equal sub.load(:id => 3, :album_id=>1)
   end
@@ -1392,21 +1394,21 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a single one_to_many association" do
     ds = GraphAlbum.eager_graph(:tracks)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.tracks.must_equal [GraphTrack.load(:id => 3, :album_id=>1)]
   end
 
   it "should eagerly graph a single one_to_many association using the :window_function strategy" do
     sub = Class.new(GraphTrack)
-    def (sub.dataset).supports_window_functions?() true end
-    def (sub.dataset).columns() [:id, :album_id] end
+    sub.dataset = sub.dataset.with_extend do
+      def supports_window_functions?; true end
+      def columns; [:id, :album_id] end
+    end
     GraphAlbum.one_to_many :ltracks, :clone=>:tracks, :limit=>2, :class=>sub
     ds = GraphAlbum.eager_graph_with_options(:ltracks, :limit_strategy=>true)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, ltracks.id AS ltracks_id, ltracks.album_id FROM albums LEFT OUTER JOIN (SELECT id, album_id FROM (SELECT *, row_number() OVER (PARTITION BY tracks.album_id) AS x_sequel_row_number_x FROM tracks) AS t1 WHERE (x_sequel_row_number_x <= 2)) AS ltracks ON (ltracks.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :ltracks_id=>3, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :ltracks_id=>3, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.ltracks.must_equal [sub.load(:id => 3, :album_id=>1)]
   end
@@ -1414,21 +1416,21 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a single many_to_many association" do
     ds = GraphAlbum.eager_graph(:genres)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ag.genre_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :genres_id=>4}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :genres_id=>4).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.genres.must_equal [GraphGenre.load(:id => 4)]
   end
 
   it "should eagerly graph a single many_to_many association using the :window_function strategy" do
     sub = Class.new(GraphGenre)
-    def (sub.dataset).supports_window_functions?() true end
-    def (sub.dataset).columns() literal(opts[:select]) =~ /x_foreign_key_x/ ? [:id, :x_foreign_key_x] : [:id] end
+    sub.dataset = sub.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
     GraphAlbum.many_to_many :lgenres, :clone=>:genres, :class=>sub, :limit=>2
     ds = GraphAlbum.eager_graph_with_options(:lgenres, :limit_strategy=>true)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, lgenres.id AS lgenres_id FROM albums LEFT OUTER JOIN (SELECT id, x_foreign_key_x FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id)) AS t1 WHERE (x_sequel_row_number_x <= 2)) AS lgenres ON (lgenres.x_foreign_key_x = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :lgenres_id=>4}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :lgenres_id=>4).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.lgenres.must_equal [sub.load(:id => 4)]
   end
@@ -1436,38 +1438,47 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a single one_through_one association" do
     ds = GraphAlbum.eager_graph(:genre)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, genre.id AS genre_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genre ON (genre.id = ag.genre_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :genre_id=>4}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :genre_id=>4).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.genre.must_equal GraphGenre.load(:id => 4)
   end
 
   it "should eagerly graph a single one_through_one association using the :distinct_on strategy" do
     sub = Class.new(GraphGenre)
-    def (sub.dataset).supports_distinct_on?() true end
-    def (sub.dataset).columns() [:id] end
+    sub.dataset = sub.dataset.with_extend do
+      def supports_distinct_on?; true end
+      def columns; [:id] end
+    end
     GraphAlbum.one_through_one :lgenre, :clone=>:genre, :class=>sub
     ds = GraphAlbum.eager_graph_with_options(:lgenre, :limit_strategy=>true)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, lgenre.id AS lgenre_id FROM albums LEFT OUTER JOIN (SELECT DISTINCT ON (ag.album_id) genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) ORDER BY ag.album_id) AS lgenre ON (lgenre.x_foreign_key_x = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :lgenre_id=>4}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :lgenre_id=>4).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.lgenre.must_equal sub.load(:id => 4)
   end
   
   it "should eagerly graph a single one_through_one association using the :window_function strategy" do
     sub = Class.new(GraphGenre)
-    def (sub.dataset).supports_window_functions?() true end
-    def (sub.dataset).columns() literal(opts[:select]) =~ /x_foreign_key_x/ ? [:id, :x_foreign_key_x] : [:id] end
+    sub.dataset = sub.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
     GraphAlbum.one_through_one :lgenre, :clone=>:genre, :class=>sub
     ds = GraphAlbum.eager_graph_with_options(:lgenre, :limit_strategy=>true)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, lgenre.id AS lgenre_id FROM albums LEFT OUTER JOIN (SELECT id, x_foreign_key_x FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id)) AS t1 WHERE (x_sequel_row_number_x = 1)) AS lgenre ON (lgenre.x_foreign_key_x = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :lgenre_id=>4}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :lgenre_id=>4).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.lgenre.must_equal sub.load(:id => 4)
   end
   
+  it "should correctly handle an aliased join table in many_to_many and one_through_one" do
+    c = Class.new(GraphAlbum)
+    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :conditions=>'true', :ignore_conditions_warning=> true
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ga.genre_id)'
+    c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga, :conditions=>'true', :graph_block => proc{true}
+    c.eager_graph(:genres).sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag AS ga ON (ga.album_id = albums.id) LEFT OUTER JOIN genres ON ((genres.id = ga.genre_id) AND \'t\')'
+  end
+
   it "should correctly handle an aliased join table in many_to_many and one_through_one" do
     c = Class.new(GraphAlbum)
     c.many_to_many :genres, :clone=>:genres, :join_table=>:ag___ga
@@ -1490,8 +1501,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load multiple associations in a single call" do 
     ds = GraphAlbum.eager_graph(:genres, :tracks, :band)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id, tracks.id AS tracks_id, tracks.album_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ag.genre_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :genres_id=>4, :tracks_id=>3, :album_id=>1, :band_id_0=>2, :vocalist_id=>6}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :genres_id=>4, :tracks_id=>3, :album_id=>1, :band_id_0=>2, :vocalist_id=>6).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a = a.first
     a.band.must_equal GraphBand.load(:id => 2, :vocalist_id=>6)
@@ -1501,16 +1511,17 @@ describe Sequel::Model, "#eager_graph" do
 
   it "should eagerly load multiple associations with different limit strategies in a single call" do 
     subg = Class.new(GraphGenre)
-    def (subg.dataset).supports_distinct_on?() true end
-    def (subg.dataset).supports_window_functions?() true end
-    def (subg.dataset).columns() literal(opts[:select]) =~ /x_foreign_key_x/ ? [:id, :x_foreign_key_x] : [:id] end
+    subg.dataset = subg.dataset.with_extend do
+      def supports_distinct_on?; true end
+      def supports_window_functions?; true end
+      def columns; literal(opts[:select]) =~ /x_foreign_key_x/ ? [:id, :x_foreign_key_x] : [:id] end
+    end
     GraphAlbum.one_through_one :lgenre, :clone=>:genre, :class=>subg
     GraphAlbum.many_to_many :lgenres, :clone=>:genres, :class=>subg, :limit=>2
 
     ds = GraphAlbum.eager_graph_with_options([:lgenre, :lgenres], :limit_strategy=>{:lgenre=>:distinct_on, :lgenres=>:window_function})
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, lgenre.id AS lgenre_id, lgenres.id AS lgenres_id FROM albums LEFT OUTER JOIN (SELECT DISTINCT ON (ag.album_id) genres.*, ag.album_id AS x_foreign_key_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id) ORDER BY ag.album_id) AS lgenre ON (lgenre.x_foreign_key_x = albums.id) LEFT OUTER JOIN (SELECT id, x_foreign_key_x FROM (SELECT genres.*, ag.album_id AS x_foreign_key_x, row_number() OVER (PARTITION BY ag.album_id) AS x_sequel_row_number_x FROM genres INNER JOIN ag ON (ag.genre_id = genres.id)) AS t1 WHERE (x_sequel_row_number_x <= 2)) AS lgenres ON (lgenres.x_foreign_key_x = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :lgenres_id=>4, :lgenre_id=>3}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :lgenres_id=>4, :lgenre_id=>3).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a = a.first
     a.lgenre.must_equal subg.load(:id => 3)
@@ -1524,8 +1535,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load multiple associations in separate calls" do 
     ds = GraphAlbum.eager_graph(:genres).eager_graph(:tracks).eager_graph(:band)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id, tracks.id AS tracks_id, tracks.album_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ag.genre_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :genres_id=>4, :tracks_id=>3, :album_id=>1, :band_id_0=>2, :vocalist_id=>6}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :genres_id=>4, :tracks_id=>3, :album_id=>1, :band_id_0=>2, :vocalist_id=>6).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a = a.first
     a.band.must_equal GraphBand.load(:id => 2, :vocalist_id=>6)
@@ -1545,8 +1555,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should allow cascading of eager loading for associations of associated models" do
     ds = GraphTrack.eager_graph(:album=>{:band=>:members})
     ds.sql.must_equal 'SELECT tracks.id, tracks.album_id, album.id AS album_id_0, album.band_id, band.id AS band_id_0, band.vocalist_id, members.id AS members_id FROM tracks LEFT OUTER JOIN albums AS album ON (album.id = tracks.album_id) LEFT OUTER JOIN bands AS band ON (band.id = album.band_id) LEFT OUTER JOIN bm ON (bm.band_id = band.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
-    ds._fetch = {:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :members_id=>5, :band_id_0=>2, :vocalist_id=>6}
-    a = ds.all
+    a = ds.with_fetch(:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :members_id=>5, :band_id_0=>2, :vocalist_id=>6).all
     a.must_equal [GraphTrack.load(:id => 3, :album_id => 1)]
     a = a.first
     a.album.must_equal GraphAlbum.load(:id => 1, :band_id => 2)
@@ -1557,7 +1566,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should allow cascading of eager loading for multiple *_to_many associations, eliminating duplicates caused by cartesian products" do
     ds = GraphBand.eager_graph({:albums=>:tracks}, :members)
     ds.sql.must_equal 'SELECT bands.id, bands.vocalist_id, albums.id AS albums_id, albums.band_id, tracks.id AS tracks_id, tracks.album_id, members.id AS members_id FROM bands LEFT OUTER JOIN albums ON (albums.band_id = bands.id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
-    ds._fetch = [{:id=>1, :vocalist_id=>2, :albums_id=>3, :band_id=>1, :tracks_id=>4, :album_id=>3, :members_id=>5},
+    a = ds.with_fetch([{:id=>1, :vocalist_id=>2, :albums_id=>3, :band_id=>1, :tracks_id=>4, :album_id=>3, :members_id=>5},
       {:id=>1, :vocalist_id=>2, :albums_id=>3, :band_id=>1, :tracks_id=>4, :album_id=>3, :members_id=>6},
       {:id=>1, :vocalist_id=>2, :albums_id=>3, :band_id=>1, :tracks_id=>5, :album_id=>3, :members_id=>5},
       {:id=>1, :vocalist_id=>2, :albums_id=>3, :band_id=>1, :tracks_id=>5, :album_id=>3, :members_id=>6},
@@ -1572,8 +1581,7 @@ describe Sequel::Model, "#eager_graph" do
       {:id=>2, :vocalist_id=>2, :albums_id=>6, :band_id=>2, :tracks_id=>1, :album_id=>6, :members_id=>5},
       {:id=>2, :vocalist_id=>2, :albums_id=>6, :band_id=>2, :tracks_id=>1, :album_id=>6, :members_id=>6},
       {:id=>2, :vocalist_id=>2, :albums_id=>6, :band_id=>2, :tracks_id=>2, :album_id=>6, :members_id=>5},
-      {:id=>2, :vocalist_id=>2, :albums_id=>6, :band_id=>2, :tracks_id=>2, :album_id=>6, :members_id=>6}]
-    a = ds.all
+      {:id=>2, :vocalist_id=>2, :albums_id=>6, :band_id=>2, :tracks_id=>2, :album_id=>6, :members_id=>6}]).all
     a.must_equal [GraphBand.load(:id=>1, :vocalist_id=>2), GraphBand.load(:id=>2, :vocalist_id=>2)]
     members = a.map{|x| x.members}
     members.must_equal [[GraphBandMember.load(:id=>5), GraphBandMember.load(:id=>6)], [GraphBandMember.load(:id=>5), GraphBandMember.load(:id=>6)]]
@@ -1587,8 +1595,7 @@ describe Sequel::Model, "#eager_graph" do
     DB.reset
     ds = GraphAlbum.eager_graph(:tracks)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a = a.first
     a.tracks.must_equal [GraphTrack.load(:id => 3, :album_id=>1)]
@@ -1599,8 +1606,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should eager load multiple associations from the same table" do
     ds = GraphBand.eager_graph(:vocalist, :members)
     ds.sql.must_equal 'SELECT bands.id, bands.vocalist_id, vocalist.id AS vocalist_id_0, members.id AS members_id FROM bands LEFT OUTER JOIN members AS vocalist ON (vocalist.id = bands.vocalist_id) LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
-    ds._fetch = {:id=>2, :vocalist_id=>6, :vocalist_id_0=>6, :members_id=>5}
-    a = ds.all
+    a = ds.with_fetch(:id=>2, :vocalist_id=>6, :vocalist_id_0=>6, :members_id=>5).all
     a.must_equal [GraphBand.load(:id => 2, :vocalist_id => 6)]
     a = a.first
     a.vocalist.must_equal GraphBandMember.load(:id => 6)
@@ -1610,15 +1616,13 @@ describe Sequel::Model, "#eager_graph" do
   it "should give you a plain hash when called without .all" do 
     ds = GraphAlbum.eager_graph(:band)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3}
-    ds.first.must_equal(:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3)
+    ds.with_fetch(:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3).first.must_equal(:id=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>3)
   end
 
   it "should not drop any associated objects if the graph could not be a cartesian product" do
     ds = GraphBand.eager_graph(:members, :vocalist)
     ds.sql.must_equal 'SELECT bands.id, bands.vocalist_id, members.id AS members_id, vocalist.id AS vocalist_id_0 FROM bands LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id) LEFT OUTER JOIN members AS vocalist ON (vocalist.id = bands.vocalist_id)'
-    ds._fetch = [{:id=>2, :vocalist_id=>6, :members_id=>5, :vocalist_id_0=>6}, {:id=>2, :vocalist_id=>6, :members_id=>5, :vocalist_id_0=>6}]
-    a = ds.all
+    a = ds.with_fetch([{:id=>2, :vocalist_id=>6, :members_id=>5, :vocalist_id_0=>6}, {:id=>2, :vocalist_id=>6, :members_id=>5, :vocalist_id_0=>6}]).all
     a.must_equal [GraphBand.load(:id => 2, :vocalist_id => 6)]
     a = a.first
     a.vocalist.must_equal GraphBandMember.load(:id => 6)
@@ -1629,8 +1633,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphBand.many_to_one :other_vocalist, :class=>'GraphBandMember', :key=>:vocalist_id, :cartesian_product_number=>1
     ds = GraphBand.eager_graph(:members, :other_vocalist)
     ds.sql.must_equal 'SELECT bands.id, bands.vocalist_id, members.id AS members_id, other_vocalist.id AS other_vocalist_id FROM bands LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id) LEFT OUTER JOIN members AS other_vocalist ON (other_vocalist.id = bands.vocalist_id)'
-    ds._fetch = [{:id=>2, :vocalist_id=>6, :members_id=>5, :other_vocalist_id=>6}, {:id=>2, :vocalist_id=>6, :members_id=>5, :other_vocalist_id=>6}]
-    a = ds.all
+    a = ds.with_fetch([{:id=>2, :vocalist_id=>6, :members_id=>5, :other_vocalist_id=>6}, {:id=>2, :vocalist_id=>6, :members_id=>5, :other_vocalist_id=>6}]).all
     a.must_equal [GraphBand.load(:id=>2, :vocalist_id => 6)]
     a.first.other_vocalist.must_equal GraphBandMember.load(:id=>6)
     a.first.members.must_equal [GraphBandMember.load(:id=>5)]
@@ -1639,11 +1642,10 @@ describe Sequel::Model, "#eager_graph" do
   it "should drop duplicate items that occur in sequence if the graph could be a cartesian product" do
     ds = GraphBand.eager_graph(:members, :genres)
     ds.sql.must_equal 'SELECT bands.id, bands.vocalist_id, members.id AS members_id, genres.id AS genres_id FROM bands LEFT OUTER JOIN bm ON (bm.band_id = bands.id) LEFT OUTER JOIN members ON (members.id = bm.member_id) LEFT OUTER JOIN bg ON (bg.band_id = bands.id) LEFT OUTER JOIN genres ON (genres.id = bg.genre_id)'
-    ds._fetch = [{:id=>2, :vocalist_id=>6, :members_id=>5, :genres_id=>7},
+    a = ds.with_fetch([{:id=>2, :vocalist_id=>6, :members_id=>5, :genres_id=>7},
       {:id=>2, :vocalist_id=>6, :members_id=>5, :genres_id=>8},
       {:id=>2, :vocalist_id=>6, :members_id=>6, :genres_id=>7},
-      {:id=>2, :vocalist_id=>6, :members_id=>6, :genres_id=>8}]
-    a = ds.all
+      {:id=>2, :vocalist_id=>6, :members_id=>6, :genres_id=>8}]).all
     a.must_equal [GraphBand.load(:id => 2, :vocalist_id => 6)]
     a = a.first
     a.members.must_equal [GraphBandMember.load(:id => 5), GraphBandMember.load(:id => 6)]
@@ -1653,10 +1655,8 @@ describe Sequel::Model, "#eager_graph" do
   it "should be able to be used in combination with #eager" do
     DB.reset
     ds = GraphAlbum.eager_graph(:tracks).eager(:genres)
-    ds._fetch = {:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1}
-    ds2 = GraphGenre.dataset
-    ds2._fetch = {:id=>6, :x_foreign_key_x=>1}
-    a = ds.all
+    GraphGenre.dataset = GraphGenre.dataset.with_fetch(:id=>6, :x_foreign_key_x=>1)
+    a = ds.with_fetch(:id=>1, :band_id=>2, :tracks_id=>3, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a = a.first
     a.tracks.must_equal [GraphTrack.load(:id=>3, :album_id=>1)]
@@ -1668,26 +1668,23 @@ describe Sequel::Model, "#eager_graph" do
   it "should handle no associated records for a single many_to_one association" do
     ds = GraphAlbum.eager_graph(:band)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :band_id_0=>nil, :vocalist_id=>nil}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :band_id_0=>nil, :vocalist_id=>nil).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
-    a.first.band.must_equal nil
+    a.first.band.must_be_nil
   end
 
   it "should handle no associated records for a single one_to_one association" do
     ds = GraphAlbum.eager_graph(:track)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, track.id AS track_id, track.album_id FROM albums LEFT OUTER JOIN tracks AS track ON (track.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :track_id=>nil, :album_id=>nil}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :track_id=>nil, :album_id=>nil).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
-    a.first.track.must_equal nil
+    a.first.track.must_be_nil
   end
 
   it "should handle no associated records for a single one_to_many association" do
     ds = GraphAlbum.eager_graph(:tracks)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, tracks.id AS tracks_id, tracks.album_id FROM albums LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :tracks_id=>nil, :album_id=>nil}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :tracks_id=>nil, :album_id=>nil).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.tracks.must_equal []
   end
@@ -1695,17 +1692,15 @@ describe Sequel::Model, "#eager_graph" do
   it "should handle no associated records for a single one_through_one association" do
     ds = GraphAlbum.eager_graph(:genre)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, genre.id AS genre_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS genre ON (genre.id = ag.genre_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :genres_id=>nil}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :genres_id=>nil).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
-    a.first.genre.must_equal nil
+    a.first.genre.must_be_nil
   end
 
   it "should handle no associated records for a single many_to_many association" do
     ds = GraphAlbum.eager_graph(:genres)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ag.genre_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :genres_id=>nil}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :genres_id=>nil).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.genres.must_equal []
   end
@@ -1713,27 +1708,25 @@ describe Sequel::Model, "#eager_graph" do
   it "should handle missing associated records when loading multiple associations" do 
     ds = GraphAlbum.eager_graph(:genres, :tracks, :band)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id, tracks.id AS tracks_id, tracks.album_id, band.id AS band_id_0, band.vocalist_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres ON (genres.id = ag.genre_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id) LEFT OUTER JOIN bands AS band ON (band.id = albums.band_id)'
-    ds._fetch = [{:id=>1, :band_id=>2, :genres_id=>nil, :tracks_id=>3, :album_id=>1, :band_id_0=>nil, :vocalist_id=>nil},
+    a = ds.with_fetch([{:id=>1, :band_id=>2, :genres_id=>nil, :tracks_id=>3, :album_id=>1, :band_id_0=>nil, :vocalist_id=>nil},
       {:id=>1, :band_id=>2, :genres_id=>nil, :tracks_id=>4, :album_id=>1, :band_id_0=>nil, :vocalist_id=>nil},
       {:id=>1, :band_id=>2, :genres_id=>nil, :tracks_id=>5, :album_id=>1, :band_id_0=>nil, :vocalist_id=>nil},
-      {:id=>1, :band_id=>2, :genres_id=>nil, :tracks_id=>6, :album_id=>1, :band_id_0=>nil, :vocalist_id=>nil}]
-    a = ds.all
+      {:id=>1, :band_id=>2, :genres_id=>nil, :tracks_id=>6, :album_id=>1, :band_id_0=>nil, :vocalist_id=>nil}]).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a = a.first
     a.tracks.must_equal [GraphTrack.load(:id => 3, :album_id => 1), GraphTrack.load(:id => 4, :album_id => 1), GraphTrack.load(:id => 5, :album_id => 1), GraphTrack.load(:id => 6, :album_id => 1)]
-    a.band.must_equal nil
+    a.band.must_be_nil
     a.genres.must_equal []
   end
 
   it "should handle missing associated records when cascading eager loading for associations of associated models" do
     ds = GraphTrack.eager_graph(:album=>{:band=>:members})
     ds.sql.must_equal 'SELECT tracks.id, tracks.album_id, album.id AS album_id_0, album.band_id, band.id AS band_id_0, band.vocalist_id, members.id AS members_id FROM tracks LEFT OUTER JOIN albums AS album ON (album.id = tracks.album_id) LEFT OUTER JOIN bands AS band ON (band.id = album.band_id) LEFT OUTER JOIN bm ON (bm.band_id = band.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
-    ds._fetch = [{:id=>2, :album_id=>2, :album_id_0=>nil, :band_id=>nil, :members_id=>nil, :band_id_0=>nil, :vocalist_id=>nil},
+    a = ds.with_fetch([{:id=>2, :album_id=>2, :album_id_0=>nil, :band_id=>nil, :members_id=>nil, :band_id_0=>nil, :vocalist_id=>nil},
       {:id=>3, :album_id=>3, :album_id_0=>3, :band_id=>3, :members_id=>nil, :band_id_0=>nil, :vocalist_id=>nil},
       {:id=>4, :album_id=>4, :album_id_0=>4, :band_id=>2, :members_id=>nil, :band_id_0=>2, :vocalist_id=>6},
       {:id=>5, :album_id=>1, :album_id_0=>1, :band_id=>4, :members_id=>5, :band_id_0=>4, :vocalist_id=>8},
-      {:id=>5, :album_id=>1, :album_id_0=>1, :band_id=>4, :members_id=>6, :band_id_0=>4, :vocalist_id=>8}]
-    a = ds.all
+      {:id=>5, :album_id=>1, :album_id_0=>1, :band_id=>4, :members_id=>6, :band_id_0=>4, :vocalist_id=>8}]).all
     a.must_equal [GraphTrack.load(:id => 2, :album_id => 2), GraphTrack.load(:id => 3, :album_id => 3), GraphTrack.load(:id => 4, :album_id => 4), GraphTrack.load(:id => 5, :album_id => 1)]
     a.map{|x| x.album}.must_equal [nil, GraphAlbum.load(:id => 3, :band_id => 3), GraphAlbum.load(:id => 4, :band_id => 2), GraphAlbum.load(:id => 1, :band_id => 4)]
     a.map{|x| x.album.band if x.album}.must_equal [nil, nil, GraphBand.load(:id => 2, :vocalist_id=>6), GraphBand.load(:id => 4, :vocalist_id=>8)]
@@ -1744,16 +1737,14 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_one :inner_band, :class=>'GraphBand', :key=>:band_id, :primary_key=>:vocalist_id
     ds = GraphAlbum.eager_graph(:inner_band)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, inner_band.id AS inner_band_id, inner_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS inner_band ON (inner_band.vocalist_id = albums.band_id)'
-    ds._fetch = {:id=>3, :band_id=>2, :inner_band_id=>5, :vocalist_id=>2}
-    as = ds.all
+    as = ds.with_fetch(:id=>3, :band_id=>2, :inner_band_id=>5, :vocalist_id=>2).all
     as.must_equal [GraphAlbum.load(:id=>3, :band_id=>2)]
     as.first.inner_band.must_equal GraphBand.load(:id=>5, :vocalist_id=>2)
 
     GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>:album_id, :primary_key=>:band_id, :reciprocal=>nil
     ds = GraphAlbum.eager_graph(:right_tracks)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON (right_tracks.album_id = albums.band_id)'
-    ds._fetch = [{:id=>3, :band_id=>2, :right_tracks_id=>5, :album_id=>2}, {:id=>3, :band_id=>2, :right_tracks_id=>6, :album_id=>2}]
-    as = ds.all
+    as = ds.with_fetch([{:id=>3, :band_id=>2, :right_tracks_id=>5, :album_id=>2}, {:id=>3, :band_id=>2, :right_tracks_id=>6, :album_id=>2}]).all
     as.must_equal [GraphAlbum.load(:id=>3, :band_id=>2)]
     as.first.right_tracks.must_equal [GraphTrack.load(:id=>5, :album_id=>2), GraphTrack.load(:id=>6, :album_id=>2)]
   end
@@ -1762,8 +1753,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_one :inner_band, :class=>'GraphBand', :key=>[:band_id, :id], :primary_key=>[:vocalist_id, :id]
     ds = GraphAlbum.eager_graph(:inner_band)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, inner_band.id AS inner_band_id, inner_band.vocalist_id FROM albums LEFT OUTER JOIN bands AS inner_band ON ((inner_band.vocalist_id = albums.band_id) AND (inner_band.id = albums.id))'
-    ds._fetch = {:id=>3, :band_id=>2, :inner_band_id=>3, :vocalist_id=>2}
-    as = ds.all
+    as = ds.with_fetch(:id=>3, :band_id=>2, :inner_band_id=>3, :vocalist_id=>2).all
     as.must_equal [GraphAlbum.load(:id=>3, :band_id=>2)]
     as.first.inner_band.must_equal GraphBand.load(:id=>3, :vocalist_id=>2)
   end
@@ -1772,8 +1762,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.one_to_many :right_tracks, :class=>'GraphTrack', :key=>[:album_id, :id], :primary_key=>[:band_id, :id]
     ds = GraphAlbum.eager_graph(:right_tracks)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, right_tracks.id AS right_tracks_id, right_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS right_tracks ON ((right_tracks.album_id = albums.band_id) AND (right_tracks.id = albums.id))'
-    ds._fetch = {:id=>3, :band_id=>2, :right_tracks_id=>3, :album_id=>2}
-    as = ds.all
+    as = ds.with_fetch(:id=>3, :band_id=>2, :right_tracks_id=>3, :album_id=>2).all
     as.must_equal [GraphAlbum.load(:id=>3, :band_id=>2)]
     as.first.right_tracks.must_equal [GraphTrack.load(:id=>3, :album_id=>2)]
   end
@@ -1782,8 +1771,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_many :sbands, :class=>'GraphBand', :left_key=>[:l1, :l2], :left_primary_key=>[:band_id, :id], :right_key=>[:r1, :r2], :right_primary_key=>[:vocalist_id, :id], :join_table=>:b
     ds = GraphAlbum.eager_graph(:sbands)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, sbands.id AS sbands_id, sbands.vocalist_id FROM albums LEFT OUTER JOIN b ON ((b.l1 = albums.band_id) AND (b.l2 = albums.id)) LEFT OUTER JOIN bands AS sbands ON ((sbands.vocalist_id = b.r1) AND (sbands.id = b.r2))'
-    ds._fetch = [{:id=>3, :band_id=>2, :sbands_id=>5, :vocalist_id=>6}, {:id=>3, :band_id=>2, :sbands_id=>6, :vocalist_id=>22}]
-    as = ds.all
+    as = ds.with_fetch([{:id=>3, :band_id=>2, :sbands_id=>5, :vocalist_id=>6}, {:id=>3, :band_id=>2, :sbands_id=>6, :vocalist_id=>22}]).all
     as.must_equal [GraphAlbum.load(:id=>3, :band_id=>2)]
     as.first.sbands.must_equal [GraphBand.load(:id=>5, :vocalist_id=>6), GraphBand.load(:id=>6, :vocalist_id=>22)]
   end
@@ -1792,8 +1780,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :left_primary_key=>:band_id, :right_key=>:genre_id, :right_primary_key=>:xxx, :join_table=>:ag
     ds = GraphAlbum.eager_graph(:inner_genres)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.band_id) LEFT OUTER JOIN genres AS inner_genres ON (inner_genres.xxx = ag.genre_id)'
-    ds._fetch = [{:id=>3, :band_id=>2, :inner_genres_id=>5, :xxx=>12}, {:id=>3, :band_id=>2, :inner_genres_id=>6, :xxx=>22}]
-    as = ds.all
+    as = ds.with_fetch([{:id=>3, :band_id=>2, :inner_genres_id=>5, :xxx=>12}, {:id=>3, :band_id=>2, :inner_genres_id=>6, :xxx=>22}]).all
     as.must_equal [GraphAlbum.load(:id=>3, :band_id=>2)]
     as.first.inner_genres.must_equal [GraphGenre.load(:id=>5), GraphGenre.load(:id=>6)]
   end
@@ -1807,11 +1794,10 @@ describe Sequel::Model, "#eager_graph" do
     c2.one_to_many :salbums, :class=>c1, :key=>[:band_id, :id]
     ds = c1.eager_graph(:sbands=>:salbums)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, sbands.id AS sbands_id, sbands.vocalist_id, salbums.id AS salbums_id, salbums.band_id AS salbums_band_id FROM albums LEFT OUTER JOIN b ON ((b.l1 = albums.band_id) AND (b.l2 = albums.id)) LEFT OUTER JOIN bands AS sbands ON ((sbands.vocalist_id = b.r1) AND (sbands.id = b.r2)) LEFT OUTER JOIN albums AS salbums ON ((salbums.band_id = sbands.vocalist_id) AND (salbums.id = sbands.id))'
-    ds._fetch = [{:id=>3, :band_id=>2, :sbands_id=>5, :vocalist_id=>6, :salbums_id=>7, :salbums_band_id=>8},
+    as = ds.with_fetch([{:id=>3, :band_id=>2, :sbands_id=>5, :vocalist_id=>6, :salbums_id=>7, :salbums_band_id=>8},
       {:id=>3, :band_id=>2, :sbands_id=>5, :vocalist_id=>6, :salbums_id=>9, :salbums_band_id=>10},
       {:id=>3, :band_id=>2, :sbands_id=>6, :vocalist_id=>22, :salbums_id=>nil, :salbums_band_id=>nil},
-      {:id=>7, :band_id=>8, :sbands_id=>nil, :vocalist_id=>nil, :salbums_id=>nil, :salbums_band_id=>nil}]
-    as = ds.all
+      {:id=>7, :band_id=>8, :sbands_id=>nil, :vocalist_id=>nil, :salbums_id=>nil, :salbums_band_id=>nil}]).all
     as.must_equal [c1.load(:id=>3, :band_id=>2), c1.load(:id=>7, :band_id=>8)]
     as.map{|x| x.sbands}.must_equal [[c2.load(:id=>5, :vocalist_id=>6), c2.load(:id=>6, :vocalist_id=>22)], []]
     as.map{|x| x.sbands.map{|y| y.salbums}}.must_equal [[[c1.load(:id=>7, :band_id=>8), c1.load(:id=>9, :band_id=>10)], []], []]
@@ -1989,8 +1975,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_many :inner_genres, :class=>'GraphGenre', :left_key=>:album_id, :left_primary_key=>:band_id, :right_key=>:genre_id, :right_primary_key=>:xxx, :join_table=>:ag
     ds = GraphAlbum.eager_graph(:inner_genres)
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, inner_genres.id AS inner_genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.band_id) LEFT OUTER JOIN genres AS inner_genres ON (inner_genres.xxx = ag.genre_id)'
-    ds._fetch = [{:id=>3, :band_id=>2, :inner_genres_id=>5, :xxx=>12}, {:id=>3, :band_id=>2, :inner_genres_id=>6, :xxx=>22}]
-    as = ds.all
+    as = ds.with_fetch([{:id=>3, :band_id=>2, :inner_genres_id=>5, :xxx=>12}, {:id=>3, :band_id=>2, :inner_genres_id=>6, :xxx=>22}]).all
     as.must_equal [GraphAlbum.load(:id=>3, :band_id=>2)]
     as.first.inner_genres.must_equal [GraphGenre.load(:id=>5), GraphGenre.load(:id=>6)]
     GraphAlbum.set_primary_key :id
@@ -2014,8 +1999,9 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load schema qualified tables correctly with joins" do
     c1 = Class.new(GraphAlbum)
     c2 = Class.new(GraphGenre)
-    ds = c1.dataset = c1.dataset.from(:s__a)
-    def ds.columns() [:id] end
+    ds = c1.dataset.from(:s__a).with_extend{def columns; [:id] end}
+    c1.dataset = ds
+    ds = c1.dataset
     c2.dataset = c2.dataset.from(:s__g)
     c1.many_to_many :a_genres, :class=>c2, :left_primary_key=>:id, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:s__ag
     ds = c1.join(:s__t, [:b_id]).eager_graph(:a_genres)
@@ -2030,8 +2016,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_many :al_genres, :class=>GraphGenre, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :after_load=>proc{|o, os| os.each{|a| a.id *=2}}
     ds = GraphAlbum.eager_graph(:al_band, :al_tracks, :al_genres)
     ds.sql.must_equal "SELECT albums.id, albums.band_id, al_band.id AS al_band_id, al_band.vocalist_id, al_tracks.id AS al_tracks_id, al_tracks.album_id, al_genres.id AS al_genres_id FROM albums LEFT OUTER JOIN bands AS al_band ON (al_band.id = albums.band_id) LEFT OUTER JOIN tracks AS al_tracks ON (al_tracks.album_id = albums.id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS al_genres ON (al_genres.id = ag.genre_id)"
-    ds._fetch = {:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_tracks_id=>5, :album_id=>6, :al_genres_id=>7}
-    a = ds.all.first
+    a = ds.with_fetch(:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_tracks_id=>5, :album_id=>6, :al_genres_id=>7).all.first
     a.must_equal GraphAlbum.load(:id => 1, :band_id => 2)
     a.al_band.must_equal GraphBand.load(:id=>6, :vocalist_id=>4)
     a.al_tracks.must_equal [GraphTrack.load(:id=>10, :album_id=>6)]
@@ -2044,10 +2029,9 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_many :al_genres, :class=>GraphGenre, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>2
     ds = GraphAlbum.eager_graph(:al_band, :al_tracks, :al_genres)
     ds.sql.must_equal "SELECT albums.id, albums.band_id, al_band.id AS al_band_id, al_band.vocalist_id, al_tracks.id AS al_tracks_id, al_tracks.album_id, al_genres.id AS al_genres_id FROM albums LEFT OUTER JOIN bands AS al_band ON (al_band.id = albums.band_id) LEFT OUTER JOIN tracks AS al_tracks ON (al_tracks.album_id = albums.id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS al_genres ON (al_genres.id = ag.genre_id)"
-    ds._fetch = [{:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_tracks_id=>5, :album_id=>6, :al_genres_id=>7},
+    a = ds.with_fetch([{:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_tracks_id=>5, :album_id=>6, :al_genres_id=>7},
       {:id=>1, :band_id=>2, :al_band_id=>8, :vocalist_id=>9, :al_tracks_id=>10, :album_id=>11, :al_genres_id=>12},
-      {:id=>1, :band_id=>2, :al_band_id=>13, :vocalist_id=>14, :al_tracks_id=>15, :album_id=>16, :al_genres_id=>17}]
-    a = ds.all.first
+      {:id=>1, :band_id=>2, :al_band_id=>13, :vocalist_id=>14, :al_tracks_id=>15, :album_id=>16, :al_genres_id=>17}]).all.first
     a.must_equal GraphAlbum.load(:id => 1, :band_id => 2)
     a.al_band.must_equal GraphBand.load(:id=>3, :vocalist_id=>4)
     a.al_tracks.must_equal [GraphTrack.load(:id=>5, :album_id=>6), GraphTrack.load(:id=>10, :album_id=>11)]
@@ -2058,8 +2042,7 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.one_to_many :al_tracks, :class=>GraphTrack, :key=>:album_id, :limit=>[2, 1]
     ds = GraphAlbum.eager_graph(:al_tracks)
     ds.sql.must_equal "SELECT albums.id, albums.band_id, al_tracks.id AS al_tracks_id, al_tracks.album_id FROM albums LEFT OUTER JOIN tracks AS al_tracks ON (al_tracks.album_id = albums.id)"
-    ds._fetch = [{:id=>1, :band_id=>2, :al_tracks_id=>nil, :album_id=>nil}]
-    a = ds.all.first
+    a = ds.with_fetch([{:id=>1, :band_id=>2, :al_tracks_id=>nil, :album_id=>nil}]).all.first
     a.must_equal GraphAlbum.load(:id => 1, :band_id => 2)
     a.al_tracks.must_equal []
   end
@@ -2070,10 +2053,9 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.many_to_many :al_genres, :class=>GraphGenre, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>[1,1]
     ds = GraphAlbum.eager_graph(:al_band, :al_tracks, :al_genres)
     ds.sql.must_equal "SELECT albums.id, albums.band_id, al_band.id AS al_band_id, al_band.vocalist_id, al_tracks.id AS al_tracks_id, al_tracks.album_id, al_genres.id AS al_genres_id FROM albums LEFT OUTER JOIN bands AS al_band ON (al_band.id = albums.band_id) LEFT OUTER JOIN tracks AS al_tracks ON (al_tracks.album_id = albums.id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS al_genres ON (al_genres.id = ag.genre_id)"
-    ds._fetch = [{:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_tracks_id=>5, :album_id=>6, :al_genres_id=>7},
+    a = ds.with_fetch([{:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_tracks_id=>5, :album_id=>6, :al_genres_id=>7},
       {:id=>1, :band_id=>2, :al_band_id=>8, :vocalist_id=>9, :al_tracks_id=>10, :album_id=>11, :al_genres_id=>12},
-      {:id=>1, :band_id=>2, :al_band_id=>13, :vocalist_id=>14, :al_tracks_id=>15, :album_id=>16, :al_genres_id=>17}]
-    a = ds.all.first
+      {:id=>1, :band_id=>2, :al_band_id=>13, :vocalist_id=>14, :al_tracks_id=>15, :album_id=>16, :al_genres_id=>17}]).all.first
     a.must_equal GraphAlbum.load(:id => 1, :band_id => 2)
     a.al_band.must_equal GraphBand.load(:id=>3, :vocalist_id=>4)
     a.al_tracks.must_equal [GraphTrack.load(:id=>10, :album_id=>11)]
@@ -2086,10 +2068,9 @@ describe Sequel::Model, "#eager_graph" do
     GraphAlbum.one_through_one :al_genre, :class=>GraphGenre, :left_key=>:album_id, :right_key=>:genre_id, :join_table=>:ag, :limit=>[nil,1]
     ds = GraphAlbum.eager_graph(:al_band, :al_track, :al_genre)
     ds.sql.must_equal "SELECT albums.id, albums.band_id, al_band.id AS al_band_id, al_band.vocalist_id, al_track.id AS al_track_id, al_track.album_id, al_genre.id AS al_genre_id FROM albums LEFT OUTER JOIN bands AS al_band ON (al_band.id = albums.band_id) LEFT OUTER JOIN tracks AS al_track ON (al_track.album_id = albums.id) LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN genres AS al_genre ON (al_genre.id = ag.genre_id)"
-    ds._fetch = [{:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_track_id=>5, :album_id=>6, :al_genre_id=>7},
+    a = ds.with_fetch([{:id=>1, :band_id=>2, :al_band_id=>3, :vocalist_id=>4, :al_track_id=>5, :album_id=>6, :al_genre_id=>7},
       {:id=>1, :band_id=>2, :al_band_id=>8, :vocalist_id=>9, :al_track_id=>10, :album_id=>11, :al_genre_id=>12},
-      {:id=>1, :band_id=>2, :al_band_id=>13, :vocalist_id=>14, :al_track_id=>15, :album_id=>16, :al_genre_id=>17}]
-    a = ds.all.first
+      {:id=>1, :band_id=>2, :al_band_id=>13, :vocalist_id=>14, :al_track_id=>15, :album_id=>16, :al_genre_id=>17}]).all.first
     a.must_equal GraphAlbum.load(:id => 1, :band_id => 2)
     a.al_band.must_equal GraphBand.load(:id=>3, :vocalist_id=>4)
     a.al_track.must_equal GraphTrack.load(:id=>10, :album_id=>11)
@@ -2099,8 +2080,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a many_to_one association with a custom callback" do
     ds = GraphAlbum.eager_graph(:band => proc {|ds1| ds1.select(:id).columns(:id)})
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, band.id AS band_id_0 FROM albums LEFT OUTER JOIN (SELECT id FROM bands) AS band ON (band.id = albums.band_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :band_id_0=>2}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :band_id_0=>2).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.band.must_equal GraphBand.load(:id => 2)
   end
@@ -2108,8 +2088,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a one_to_one association with a custom callback" do
     ds = GraphAlbum.eager_graph(:track => proc {|ds1| ds1.select(:album_id).columns(:album_id)})
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, track.album_id FROM albums LEFT OUTER JOIN (SELECT album_id FROM tracks) AS track ON (track.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.track.must_equal GraphTrack.load(:album_id=>1)
   end
@@ -2117,8 +2096,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a one_to_many association with a custom callback" do
     ds = GraphAlbum.eager_graph(:tracks => proc {|ds1| ds1.select(:album_id).columns(:album_id)})
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, tracks.album_id FROM albums LEFT OUTER JOIN (SELECT album_id FROM tracks) AS tracks ON (tracks.album_id = albums.id)'
-    ds._fetch = {:id=>1, :band_id=>2, :album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :album_id=>1).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.tracks.must_equal [GraphTrack.load(:album_id=>1)]
   end
@@ -2126,8 +2104,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a one_through_one association with a custom callback" do
     ds = GraphAlbum.eager_graph(:genre => proc {|ds1| ds1.select(:id).columns(:id)})
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, genre.id AS genre_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN (SELECT id FROM genres) AS genre ON (genre.id = ag.genre_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :genre_id=>4}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :genre_id=>4).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.genre.must_equal GraphGenre.load(:id => 4)
   end
@@ -2135,8 +2112,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should eagerly load a many_to_many association with a custom callback" do
     ds = GraphAlbum.eager_graph(:genres => proc {|ds1| ds1.select(:id).columns(:id)})
     ds.sql.must_equal 'SELECT albums.id, albums.band_id, genres.id AS genres_id FROM albums LEFT OUTER JOIN ag ON (ag.album_id = albums.id) LEFT OUTER JOIN (SELECT id FROM genres) AS genres ON (genres.id = ag.genre_id)'
-    ds._fetch = {:id=>1, :band_id=>2, :genres_id=>4}
-    a = ds.all
+    a = ds.with_fetch(:id=>1, :band_id=>2, :genres_id=>4).all
     a.must_equal [GraphAlbum.load(:id => 1, :band_id => 2)]
     a.first.genres.must_equal [GraphGenre.load(:id => 4)]
   end
@@ -2144,8 +2120,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should allow cascading of eager loading with a custom callback with hash value" do
     ds = GraphTrack.eager_graph(:album=>{proc{|ds1| ds1.select(:id, :band_id).columns(:id, :band_id)}=>{:band=>:members}})
     ds.sql.must_equal 'SELECT tracks.id, tracks.album_id, album.id AS album_id_0, album.band_id, band.id AS band_id_0, band.vocalist_id, members.id AS members_id FROM tracks LEFT OUTER JOIN (SELECT id, band_id FROM albums) AS album ON (album.id = tracks.album_id) LEFT OUTER JOIN bands AS band ON (band.id = album.band_id) LEFT OUTER JOIN bm ON (bm.band_id = band.id) LEFT OUTER JOIN members ON (members.id = bm.member_id)'
-    ds._fetch = {:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :members_id=>5, :band_id_0=>2, :vocalist_id=>6}
-    a = ds.all
+    a = ds.with_fetch(:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :members_id=>5, :band_id_0=>2, :vocalist_id=>6).all
     a.must_equal [GraphTrack.load(:id => 3, :album_id => 1)]
     a = a.first
     a.album.must_equal GraphAlbum.load(:id => 1, :band_id => 2)
@@ -2156,8 +2131,7 @@ describe Sequel::Model, "#eager_graph" do
   it "should allow cascading of eager loading with a custom callback with array value" do
     ds = GraphTrack.eager_graph(:album=>{proc{|ds1| ds1.select(:id, :band_id).columns(:id, :band_id)}=>[:band, :tracks]})
     ds.sql.must_equal 'SELECT tracks.id, tracks.album_id, album.id AS album_id_0, album.band_id, band.id AS band_id_0, band.vocalist_id, tracks_0.id AS tracks_0_id, tracks_0.album_id AS tracks_0_album_id FROM tracks LEFT OUTER JOIN (SELECT id, band_id FROM albums) AS album ON (album.id = tracks.album_id) LEFT OUTER JOIN bands AS band ON (band.id = album.band_id) LEFT OUTER JOIN tracks AS tracks_0 ON (tracks_0.album_id = album.id)'
-    ds._fetch = {:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>6, :tracks_0_id=>3, :tracks_0_album_id=>1}
-    a = ds.all
+    a = ds.with_fetch(:id=>3, :album_id=>1, :album_id_0=>1, :band_id=>2, :band_id_0=>2, :vocalist_id=>6, :tracks_0_id=>3, :tracks_0_album_id=>1).all
     a.must_equal [GraphTrack.load(:id => 3, :album_id => 1)]
     a = a.first
     a.album.must_equal GraphAlbum.load(:id => 1, :band_id => 2)