sequel 3.29.0 → 3.30.0

data/spec/extensions/instance_filters_spec.rb

@@ -2,19 +2,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "instance_filters plugin" do
   before do
-    @c = Class.new(Sequel::Model(:people)) do
-    end
-    @sql = sql = ''
-    @v = v = [1]
+    @c = Class.new(Sequel::Model(:people))
     @c.dataset.quote_identifiers = false
-    @c.dataset.meta_def(:update) do |opts|
-      sql.replace(update_sql(opts))
-      return v.first
-    end
-    @c.dataset.meta_def(:delete) do
-      sql.replace(delete_sql)
-      return v.first
-    end
     @c.columns :id, :name, :num
     @c.plugin :instance_filters
     @p = @c.load(:id=>1, :name=>'John', :num=>1)
@@ -22,34 +11,34 @@ describe "instance_filters plugin" do
 
   specify "should raise an error when updating a stale record" do
     @p.update(:name=>'Bob')
-    @sql.should == "UPDATE people SET name = 'Bob' WHERE (id = 1)"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
     @p.instance_filter(:name=>'Jim')
-    @v.replace([0])
+    @p.this.numrows = 0
     proc{@p.update(:name=>'Joe')}.should raise_error(Sequel::Plugins::InstanceFilters::Error)
-    @sql.should == "UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Jim'))"]
   end 
 
   specify "should raise an error when destroying a stale record" do
     @p.destroy
-    @sql.should == "DELETE FROM people WHERE (id = 1)"
+    MODEL_DB.sqls.should == ["DELETE FROM people WHERE (id = 1)"]
     @p.instance_filter(:name=>'Jim')
-    @v.replace([0])
+    @p.this.numrows = 0
     proc{@p.destroy}.should raise_error(Sequel::Plugins::InstanceFilters::Error)
-    @sql.should == "DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"
+    MODEL_DB.sqls.should == ["DELETE FROM people WHERE ((id = 1) AND (name = 'Jim'))"]
   end 
   
   specify "should apply all instance filters" do
     @p.instance_filter(:name=>'Jim')
     @p.instance_filter{num > 2}
     @p.update(:name=>'Bob')
-    @sql.should == "UPDATE people SET name = 'Bob' WHERE ((id = 1) AND (name = 'Jim') AND (num > 2))"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Bob' WHERE ((id = 1) AND (name = 'Jim') AND (num > 2))"]
   end 
 
   specify "should drop instance filters after updating" do
     @p.instance_filter(:name=>'Joe')
     @p.update(:name=>'Joe')
-    @sql.should == "UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Joe'))"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Joe' WHERE ((id = 1) AND (name = 'Joe'))"]
     @p.update(:name=>'Bob')
-    @sql.should == "UPDATE people SET name = 'Bob' WHERE (id = 1)"
+    MODEL_DB.sqls.should == ["UPDATE people SET name = 'Bob' WHERE (id = 1)"]
   end
 end

data/spec/extensions/instance_hooks_spec.rb

@@ -180,29 +180,10 @@ end
 
 describe "InstanceHooks plugin with transactions" do
   before do
-    @logger = Object.new
-    def @logger.method_missing(meth, sql)
-      (@sqls ||= []) << sql
-    end
-    def @logger.sqls
-      @sqls
-    end
-    @db = Class.new(Sequel::Database) do
-      def connect(*)
-        Object.new
-      end
-      def log_connection_execute(conn, sql)
-        execute(sql)
-      end
-      def execute(sql, opts={})
-        @loggers.each{|l| l.info(sql)}
-      end
-    end.new(:loggers=>[@logger])
+    @db = Sequel.mock(:numrows=>1)
     pr = proc{|x| r(x)}
     @c = Class.new(Sequel::Model(@db[:items])) do
       attr_accessor :rb
-      def _delete
-      end
       def after_save
         db.execute('as')
         raise Sequel::Rollback if rb
@@ -218,33 +199,34 @@ describe "InstanceHooks plugin with transactions" do
     @or = @c.load({:id=>1})
     @or.rb = true
     @r = []
+    @db.sqls
   end
   
   it "should support after_commit_hook" do
     @o.after_commit_hook{@db.execute('ac1')}
     @o.after_commit_hook{@db.execute('ac2')}
     @o.save.should_not be_nil
-    @logger.sqls.should == ['BEGIN', 'as', 'COMMIT', 'ac1', 'ac2']
+    @db.sqls.should == ['BEGIN', 'as', 'COMMIT', 'ac1', 'ac2']
   end
   
   it "should support after_rollback_hook" do
     @or.after_rollback_hook{@db.execute('ar1')}
     @or.after_rollback_hook{@db.execute('ar2')}
     @or.save.should be_nil
-    @logger.sqls.should == ['BEGIN', 'as', 'ROLLBACK', 'ar1', 'ar2']
+    @db.sqls.should == ['BEGIN', 'as', 'ROLLBACK', 'ar1', 'ar2']
   end
   
   it "should support after_commit_hook" do
     @o.after_destroy_commit_hook{@db.execute('adc1')}
     @o.after_destroy_commit_hook{@db.execute('adc2')}
     @o.destroy.should_not be_nil
-    @logger.sqls.should == ['BEGIN', 'ad', 'COMMIT', 'adc1', 'adc2']
+    @db.sqls.should == ['BEGIN', "DELETE FROM items WHERE (id = 1)", 'ad', 'COMMIT', 'adc1', 'adc2']
   end
   
   it "should support after_rollback_hook" do
     @or.after_destroy_rollback_hook{@db.execute('adr1')}
     @or.after_destroy_rollback_hook{@db.execute('adr2')}
     @or.destroy.should be_nil
-    @logger.sqls.should == ['BEGIN', 'ad', 'ROLLBACK', 'adr1', 'adr2']
+    @db.sqls.should == ['BEGIN', "DELETE FROM items WHERE (id = 1)", 'ad', 'ROLLBACK', 'adr1', 'adr2']
   end
 end

data/spec/extensions/json_serializer_spec.rb

@@ -102,8 +102,8 @@ describe "Sequel::Plugins::JsonSerializer" do
   end
 
   it "should support a to_json class and dataset method" do
-    album = @album
-    Album.dataset.meta_def(:all){[album]}
+    Album.dataset._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
+    Artist.dataset._fetch = {:id=>2, :name=>'YJM'}
     JSON.parse(Album.to_json).should == [@album]
     JSON.parse(Album.to_json(:include=>:artist)).map{|x| x.artist}.should == [@artist]
     JSON.parse(Album.dataset.to_json(:only=>:name)).should == [Album.load(:name=>@album.name)]
@@ -112,7 +112,7 @@ describe "Sequel::Plugins::JsonSerializer" do
   it "should have dataset to_json method work with naked datasets" do
     album = @album
     ds = Album.dataset.naked
-    ds.meta_def(:all){[album.values]}
+    ds._fetch = {:id=>1, :name=>'RF', :artist_id=>2}
     JSON.parse(ds.to_json).should == [@album.values.inject({}){|h, (k, v)| h[k.to_s] = v; h}]
   end
 
@@ -137,8 +137,7 @@ describe "Sequel::Plugins::JsonSerializer" do
   end
   
   it "should handle the :root option to qualify a dataset of records" do
-    album = @album
-    Album.dataset.meta_def(:all){[album, album]}
+    Album.dataset._fetch = [{:id=>1, :name=>'RF'}, {:id=>1, :name=>'RF'}]
     Album.dataset.to_json(:root=>true, :only => :id).to_s.should == '{"albums":[{"album":{"id":1}},{"album":{"id":1}}]}'
   end
 

data/spec/extensions/lazy_attributes_spec.rb

@@ -1,8 +1,9 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+require 'yaml'
 
 describe "Sequel::Plugins::LazyAttributes" do
   before do
-    @db = MockDatabase.new
+    @db = Sequel.mock
     @db.meta_def(:schema){|*a| [[:id, {:type=>:integer}], [:name,{:type=>:string}]]}
     class ::LazyAttributesModel < Sequel::Model(@db[:la])
       plugin :lazy_attributes
@@ -10,27 +11,23 @@ describe "Sequel::Plugins::LazyAttributes" do
       meta_def(:columns){[:id, :name]}
       lazy_attributes :name
       meta_def(:columns){[:id]}
-      ds = dataset
-      def ds.fetch_rows(sql)
-        execute(sql)
-        select = @opts[:select]
-        where = @opts[:where]
-        block = @mod_block || proc{|s| s}
-        if !where
-          if select.include?(:name)
-            yield(block[:id=>1, :name=>'1'])
-            yield(block[:id=>2, :name=>'2'])
+      dataset._fetch = proc do |sql|
+        if sql !~ /WHERE/
+          if sql =~ /name/
+            [{:id=>1, :name=>'1'}, {:id=>2, :name=>'2'}]
           else
-            yield(:id=>1)
-            yield(:id=>2)
+            [{:id=>1}, {:id=>2}]
           end
         else
-          i = where.args.last
-          Array(i).each do |x|
+          if sql =~ /id IN \(([\d, ]+)\)/
+            $1.split(', ')
+          elsif sql =~ /id = (\d)/
+            [$1]
+          end.map do |x|
             if sql =~ /SELECT name FROM/
-              yield(block[:name=>x.to_s])
+              {:name=>x.to_s}
             else
-              yield(block[:id=>x, :name=>x.to_s])
+              {:id=>x.to_i, :name=>x.to_s}
             end
           end
         end
@@ -38,7 +35,7 @@ describe "Sequel::Plugins::LazyAttributes" do
     end
     @c = ::LazyAttributesModel
     @ds = LazyAttributesModel.dataset
-    @db.reset
+    @db.sqls
   end
   after do
     Object.send(:remove_const, :LazyAttributesModel)
@@ -136,7 +133,7 @@ describe "Sequel::Plugins::LazyAttributes" do
 
   it "should work with the serialization plugin" do
     @c.plugin :serialization, :yaml, :name
-    @ds.instance_variable_set(:@mod_block, proc{|s| s.merge(:name=>"--- #{s[:name].to_i*3}\n")})
+    @ds._fetch = [[{:id=>1}, {:id=>2}], [{:id=>1, :name=>"--- 3\n"}, {:id=>2, :name=>"--- 6\n"}], [{:id=>1}], [{:name=>"--- 3\n"}]]
     @c.with_identity_map do
       ms = @ds.all
       ms.map{|m| m.values}.should == [{:id=>1}, {:id=>2}]
@@ -146,7 +143,6 @@ describe "Sequel::Plugins::LazyAttributes" do
       ms.map{|m| m.name}.should == [3,6]
       @db.sqls.should == ['SELECT id FROM la', 'SELECT id, name FROM la WHERE (id IN (1, 2))']
     end
-    @db.reset
     @c.with_identity_map do
       m = @ds.first
       m.values.should == {:id=>1}

data/spec/extensions/list_spec.rb

@@ -8,32 +8,10 @@ describe "List plugin" do
       columns :id, :position, :scope_id, :pos
       plugin :list, opts
       self.use_transactions = false
-
-      class << self
-        attr_accessor :rows
-      end
-
-      def checked_transaction(opts={})
-        return super if @in_transaction || !use_transaction?(opts)
-        @in_transaction = true
-        db.execute 'BEGIN'
-        super
-        db.execute 'COMMIT'
-        @in_transaction = false
-      end
     end
     c
   end
 
-  def y(c, *hs)
-    c.rows = hs
-    ds = c.dataset
-    def ds.fetch_rows(sql)
-      db.execute(sql)
-      yield model.rows.shift
-    end
-  end
-
   before do
     @c = klass
     @o = @c.load(:id=>7, :position=>3)
@@ -89,18 +67,18 @@ describe "List plugin" do
   end
 
   it "should have at_position return the model object at the given position" do
-    y(@c, :id=>1, :position=>1)
+    @c.dataset._fetch = {:id=>1, :position=>1}
     @o.at_position(10).should == @c.load(:id=>1, :position=>1)
-    y(@sc, :id=>2, :position=>2, :scope_id=>5)
+    @sc.dataset._fetch = {:id=>2, :position=>2, :scope_id=>5}
     @so.at_position(20).should == @sc.load(:id=>2, :position=>2, :scope_id=>5)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 10) ORDER BY position LIMIT 1",
       "SELECT * FROM items WHERE ((scope_id = 5) AND (position = 20)) ORDER BY scope_id, position LIMIT 1"]
   end
 
   it "should have last_position return the last position in the list" do
-    y(@c, :max=>10)
+    @c.dataset._fetch  = {:max=>10}
     @o.last_position.should == 10
-    y(@sc, :max=>20)
+    @sc.dataset._fetch = {:max=>20}
     @so.last_position.should == 20
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
       "SELECT max(position) FROM items WHERE (scope_id = 5) LIMIT 1"]
@@ -115,7 +93,7 @@ describe "List plugin" do
   end
 
   it "should have move_down without an argument move down a single position" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_down.should == @o
     @o.position.should == 4
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
@@ -124,7 +102,7 @@ describe "List plugin" do
   end
 
   it "should have move_down with an argument move down the given number of positions" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_down(3).should == @o
     @o.position.should == 6
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
@@ -141,11 +119,11 @@ describe "List plugin" do
 
   it "should have move_to raise an error if an invalid target is used" do
     proc{@o.move_to(0)}.should raise_error(Sequel::Error)
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     proc{@o.move_to(11)}.should raise_error(Sequel::Error)
   end
 
-  it "should have move_to use a transaction is the instance is configured to use transactions" do
+  it "should have move_to use a transaction if the instance is configured to use transactions" do
     @o.use_transactions = true
     @o.move_to(2)
     @db.sqls.should == ["BEGIN",
@@ -167,13 +145,13 @@ describe "List plugin" do
   end
 
   it "should have move to shift entries correctly between current and target if moving down" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_to(4)
     @db.sqls[1].should == "UPDATE items SET position = (position - 1) WHERE ((position >= 4) AND (position <= 4))"
   end
 
   it "should have move_to_bottom move the item to the last position" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_to_bottom
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
       "UPDATE items SET position = (position - 1) WHERE ((position >= 4) AND (position <= 10))",
@@ -201,7 +179,7 @@ describe "List plugin" do
   end
 
   it "should have move_up with a negative argument move down the given number of positions" do
-    y(@c, :max=>10)
+    @c.dataset._fetch = {:max=>10}
     @o.move_up(-1).should == @o
     @o.position.should == 4
     @db.sqls.should == ["SELECT max(position) FROM items LIMIT 1",
@@ -210,19 +188,19 @@ describe "List plugin" do
   end
 
   it "should have next return the next entry in the list if not given an argument" do
-    y(@c, :id=>9, :position=>4)
+    @c.dataset._fetch = {:id=>9, :position=>4}
     @o.next.should == @c.load(:id=>9, :position=>4)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 4) ORDER BY position LIMIT 1"]
   end
 
   it "should have next return the entry the given number of positions below the instance if given an argument" do
-    y(@c, :id=>9, :position=>5)
+    @c.dataset._fetch = {:id=>9, :position=>5}
     @o.next(2).should == @c.load(:id=>9, :position=>5)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 5) ORDER BY position LIMIT 1"]
   end
 
   it "should have next return a previous entry if given a negative argument" do
-    y(@c, :id=>9, :position=>2)
+    @c.dataset._fetch = {:id=>9, :position=>2}
     @o.next(-1).should == @c.load(:id=>9, :position=>2)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 2) ORDER BY position LIMIT 1"]
   end
@@ -232,19 +210,19 @@ describe "List plugin" do
   end
 
   it "should have prev return the previous entry in the list if not given an argument" do
-    y(@c, :id=>9, :position=>2)
+    @c.dataset._fetch = {:id=>9, :position=>2}
     @o.prev.should == @c.load(:id=>9, :position=>2)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 2) ORDER BY position LIMIT 1"]
   end
 
   it "should have prev return the entry the given number of positions above the instance if given an argument" do
-    y(@c, :id=>9, :position=>1)
+    @c.dataset._fetch = {:id=>9, :position=>1}
     @o.prev(2).should == @c.load(:id=>9, :position=>1)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 1) ORDER BY position LIMIT 1"]
   end
 
   it "should have prev return a following entry if given a negative argument" do
-    y(@c, :id=>9, :position=>4)
+    @c.dataset._fetch = {:id=>9, :position=>4}
     @o.prev(-1).should == @c.load(:id=>9, :position=>4)
     @db.sqls.should == ["SELECT * FROM items WHERE (position = 4) ORDER BY position LIMIT 1"]
   end

data/spec/extensions/many_through_many_spec.rb

@@ -10,14 +10,11 @@ describe Sequel::Model, "many_through_many" do
     class ::Tag < Sequel::Model
       columns :id, :h1, :h2
     end
-    MODEL_DB.reset
     @c1 = Artist
     @c2 = Tag
     @dataset = @c2.dataset
-    def @dataset.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1})
-    end
+    @dataset._fetch = {:id=>1}
+    MODEL_DB.reset
   end
   after do
     Object.send(:remove_const, :Artist)
@@ -25,16 +22,20 @@ describe Sequel::Model, "many_through_many" do
   end
 
   it "should default to associating to other models in the same scope" do
-    class ::AssociationModuleTest
-      class Artist < Sequel::Model
-        plugin :many_through_many
-        many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
-      end  
-      class Tag < Sequel::Model
+    begin
+      class ::AssociationModuleTest
+        class Artist < Sequel::Model
+          plugin :many_through_many
+          many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
+        end  
+        class Tag < Sequel::Model
+        end  
       end  
-    end  
-    
-    ::AssociationModuleTest::Artist.association_reflection(:tags).associated_class.should == ::AssociationModuleTest::Tag
+      
+      ::AssociationModuleTest::Artist.association_reflection(:tags).associated_class.should == ::AssociationModuleTest::Tag
+    ensure
+      Object.send(:remove_const, :AssociationModuleTest)
+    end
   end 
 
   it "should raise an error if in invalid form of through is used" do
@@ -46,9 +47,7 @@ describe Sequel::Model, "many_through_many" do
   it "should allow only two arguments with the :through option" do
     @c1.many_through_many :tags, :through=>[[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
     n.tags.should == [@c2.load(:id=>1)]
   end
 
@@ -56,18 +55,14 @@ describe Sequel::Model, "many_through_many" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     @c1.many_through_many :other_tags, :clone=>:tags
     n = @c1.load(:id => 1234)
-    a = n.other_tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
+    n.other_tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
     n.tags.should == [@c2.load(:id=>1)]
   end
 
   it "should use join tables given" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]]
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
     n.tags.should == [@c2.load(:id=>1)]
   end
 
@@ -76,9 +71,7 @@ describe Sequel::Model, "many_through_many" do
     end
     @c1.many_through_many :albums, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_artists, :album_id, :artist_id], [:artists, :id, :id], [:albums_artists, :artist_id, :album_id]]
     n = @c1.load(:id => 1234)
-    a = n.albums_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT albums.* FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) INNER JOIN artists ON (artists.id = albums_artists.artist_id) INNER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) INNER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id) INNER JOIN albums_artists AS albums_artists_1 ON ((albums_artists_1.album_id = albums_0.id) AND (albums_artists_1.artist_id = 1234))'
+    n.albums_dataset.sql.should == 'SELECT albums.* FROM albums INNER JOIN albums_artists ON (albums_artists.album_id = albums.id) INNER JOIN artists ON (artists.id = albums_artists.artist_id) INNER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) INNER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id) INNER JOIN albums_artists AS albums_artists_1 ON ((albums_artists_1.album_id = albums_0.id) AND (albums_artists_1.artist_id = 1234))'
     n.albums.should == [Album.load(:id=>1, :x=>1)]
     Object.send(:remove_const, :Album)
   end
@@ -86,9 +79,7 @@ describe Sequel::Model, "many_through_many" do
   it "should use explicit class if given" do
     @c1.many_through_many :albums_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag
     n = @c1.load(:id => 1234)
-    a = n.albums_tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
+    n.albums_tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
     n.albums_tags.should == [@c2.load(:id=>1)]
   end
 
@@ -96,9 +87,7 @@ describe Sequel::Model, "many_through_many" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :right_primary_key=>:tag_id, :left_primary_key=>:yyy
     n = @c1.load(:id => 1234)
     n.yyy = 85
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.tag_id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 85))'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.tag_id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 85))'
     n.tags.should == [@c2.load(:id=>1)]
   end
   
@@ -106,9 +95,7 @@ describe Sequel::Model, "many_through_many" do
     @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
     n = @c1.load(:id => 1234)
     n.yyy = 85
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2) AND (albums_artists.b1 = 1234) AND (albums_artists.b2 = 85))'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2) AND (albums_artists.b1 = 1234) AND (albums_artists.b2 = 85))'
     n.tags.should == [@c2.load(:id=>1)]
   end
   
@@ -191,52 +178,40 @@ describe Sequel::Model, "many_through_many" do
   it "should support a :conditions option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>{:a=>32}
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) WHERE (a = 32)'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) WHERE (a = 32)'
     n.tags.should == [@c2.load(:id=>1)]
 
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :conditions=>['a = ?', 42]
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) WHERE (a = 42)'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) WHERE (a = 42)'
     n.tags.should == [@c2.load(:id=>1)]
   end
   
   it "should support an :order option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :order=>:blah
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) ORDER BY blah'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) ORDER BY blah'
     n.tags.should == [@c2.load(:id=>1)]
   end
   
   it "should support an array for the :order option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :order=>[:blah1, :blah2]
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) ORDER BY blah1, blah2'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) ORDER BY blah1, blah2'
     n.tags.should == [@c2.load(:id=>1)]
   end
 
   it "should support a select option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>:blah
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT blah FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
+    n.tags_dataset.sql.should == 'SELECT blah FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
     n.tags.should == [@c2.load(:id=>1)]
   end
   
   it "should support an array for the select option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[:tags.*, :albums__name]
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.*, albums.name FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
+    n.tags_dataset.sql.should == 'SELECT tags.*, albums.name FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
     n.tags.should == [@c2.load(:id=>1)]
   end
   
@@ -244,9 +219,7 @@ describe Sequel::Model, "many_through_many" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]] do |ds| ds.filter(:yyy=>@yyy) end
     n = @c1.load(:id => 1234)
     n.yyy = 85
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) WHERE (yyy = 85)'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) WHERE (yyy = 85)'
     n.tags.should == [@c2.load(:id=>1)]
   end
 
@@ -254,34 +227,26 @@ describe Sequel::Model, "many_through_many" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :order=>:blah do |ds| ds.filter(:yyy=>@yyy) end
     n = @c1.load(:id => 1234)
     n.yyy = 85
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) WHERE (yyy = 85) ORDER BY blah'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) WHERE (yyy = 85) ORDER BY blah'
     n.tags.should == [@c2.load(:id=>1)]
   end
 
   it "should support a :dataset option that is used instead of the default" do
     @c1.many_through_many :tags, [[:a, :b, :c]], :dataset=>proc{Tag.join(:albums_tags, [:tag_id]).join(:albums, [:album_id]).join(:albums_artists, [:album_id]).filter(:albums_artists__artist_id=>id)}
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags USING (tag_id) INNER JOIN albums USING (album_id) INNER JOIN albums_artists USING (album_id) WHERE (albums_artists.artist_id = 1234)'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags USING (tag_id) INNER JOIN albums USING (album_id) INNER JOIN albums_artists USING (album_id) WHERE (albums_artists.artist_id = 1234)'
     n.tags.should == [@c2.load(:id=>1)]
   end
 
   it "should support a :limit option" do
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :limit=>10
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) LIMIT 10'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) LIMIT 10'
     n.tags.should == [@c2.load(:id=>1)]
 
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :limit=>[10, 10]
     n = @c1.load(:id => 1234)
-    a = n.tags_dataset
-    a.should be_a_kind_of(Sequel::Dataset)
-    a.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) LIMIT 10 OFFSET 10'
+    n.tags_dataset.sql.should == 'SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234)) LIMIT 10 OFFSET 10'
     n.tags.should == [@c2.load(:id=>1)]
   end
 
@@ -305,7 +270,7 @@ describe Sequel::Model, "many_through_many" do
     n.tags.should == [@c2.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))']
     n.associations[:tags].should == n.tags
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should use cached instance variable if available" do
@@ -324,7 +289,7 @@ describe Sequel::Model, "many_through_many" do
     n.tags(true).should == [@c2.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))']
     n.associations[:tags].should == n.tags
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should not add associations methods directly to class" do
@@ -341,18 +306,13 @@ describe Sequel::Model, "many_through_many" do
     h = []
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :after_load=>:al
     @c1.class_eval do
-      class_variable_set(:@@blah, h)
+      self::Foo = h
       def al(v)
-        v.each{|x| self.class.send(:class_variable_get, :@@blah) << x.pk * 20}
-      end
-    end
-    @c2.class_eval do
-      def @dataset.fetch_rows(sql)
-        yield({:id=>20})
-        yield({:id=>30})
+        v.each{|x| model::Foo << x.pk * 20}
       end
     end
-    p =  @c1.load(:id=>10, :parent_id=>20)
+    @c2.dataset._fetch = [{:id=>20}, {:id=>30}]
+    p = @c1.load(:id=>10, :parent_id=>20)
     p.tags
     h.should == [400, 600]
     p.tags.collect{|a| a.pk}.should == [20, 30]
@@ -361,14 +321,7 @@ describe Sequel::Model, "many_through_many" do
   it "should support a :uniq option that removes duplicates from the association" do
     h = []
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :uniq=>true
-    @c2.class_eval do
-      def @dataset.fetch_rows(sql)
-        yield({:id=>20})
-        yield({:id=>30})
-        yield({:id=>20})
-        yield({:id=>30})
-      end
-    end
+    @c2.dataset._fetch = [{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}]
     @c1.load(:id=>10).tags.should == [@c2.load(:id=>20), @c2.load(:id=>30)]
   end
 end
@@ -429,57 +382,40 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     end
     class ::Track < Sequel::Model
     end
-
-    Artist.dataset.extend(Module.new {
-      def columns
-        [:id]
-      end
-
-      def fetch_rows(sql)
-        @db << sql
-        h = {:id => 1}
-        if sql =~ /FROM artists LEFT OUTER JOIN albums_artists/
-          h[:tags_id] = 2
-          h[:albums_0_id] = 3 if sql =~ /LEFT OUTER JOIN albums AS albums_0/
-          h[:tracks_id] = 4 if sql =~ /LEFT OUTER JOIN tracks/
-          h[:other_tags_id] = 9 if sql =~ /other_tags\.id AS other_tags_id/
-          h[:artists_0_id] = 10 if sql =~ /artists_0\.id AS artists_0_id/
-        end
-        yield h
-      end
-    })
-
-    Tag.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        h = {:id => 2}
-        if sql =~ /albums_artists.artist_id IN \(([18])\)/
-          h.merge!(:x_foreign_key_x=>$1.to_i)
-        elsif sql =~ /\(\(albums_artists.b1, albums_artists.b2\) IN \(\(1, 8\)\)\)/
-          h.merge!(:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>8)
-        end
-        h[:tag_id] = h.delete(:id) if sql =~ /albums_artists.artist_id IN \(8\)/
-        yield h
+    Artist.dataset.columns(:id)._fetch = proc do |sql|
+      h = {:id => 1}
+      if sql =~ /FROM artists LEFT OUTER JOIN albums_artists/
+        h[:tags_id] = 2
+        h[:albums_0_id] = 3 if sql =~ /LEFT OUTER JOIN albums AS albums_0/
+        h[:tracks_id] = 4 if sql =~ /LEFT OUTER JOIN tracks/
+        h[:other_tags_id] = 9 if sql =~ /other_tags\.id AS other_tags_id/
+        h[:artists_0_id] = 10 if sql =~ /artists_0\.id AS artists_0_id/
       end
-    })
+      h
+    end
     
-    Album.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        h = {:id => 3}
-        h.merge!(:x_foreign_key_x=>1) if sql =~ /albums_artists.artist_id IN \(1\)/
-        yield h
+    Tag.dataset._fetch = proc do |sql|
+      h = {:id => 2}
+      if sql =~ /albums_artists.artist_id IN \(([18])\)/
+        h[:x_foreign_key_x] = $1.to_i 
+      elsif sql =~ /\(\(albums_artists.b1, albums_artists.b2\) IN \(\(1, 8\)\)\)/
+        h.merge!(:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>8)
       end
-    })
+      h[:tag_id] = h.delete(:id) if sql =~ /albums_artists.artist_id IN \(8\)/
+      h
+    end
     
-    Track.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        @db << sql
-        h = {:id => 4}
-        h.merge!(:x_foreign_key_x=>2) if sql =~ /albums_tags.tag_id IN \(2\)/
-        yield h
-      end
-    })
+    Album.dataset._fetch = proc do |sql|
+      h = {:id => 3}
+      h[:x_foreign_key_x] = 1 if sql =~ /albums_artists.artist_id IN \(1\)/
+      h
+    end
+    
+    Track.dataset._fetch = proc do |sql|
+      h = {:id => 4}
+      h[:x_foreign_key_x] = 2 if sql =~ /albums_tags.tag_id IN \(2\)/
+      h
+    end
 
     @c1 = Artist
     MODEL_DB.reset
@@ -493,33 +429,35 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists', 'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']
     a.first.tags.should == [Tag.load(:id=>2)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should eagerly load multiple associations in a single call" do
     a = @c1.eager(:tags, :albums).all
     a.should == [@c1.load(:id=>1)]
-    MODEL_DB.sqls.length.should == 3
-    MODEL_DB.sqls[0].should == 'SELECT * FROM artists'
-    MODEL_DB.sqls[1..-1].should(include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))
-    MODEL_DB.sqls[1..-1].should(include('SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))
+    sqls = MODEL_DB.sqls
+    sqls.length.should == 3
+    sqls[0].should == 'SELECT * FROM artists'
+    sqls[1..-1].should(include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))
+    sqls[1..-1].should(include('SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.albums.should == [Album.load(:id=>3)]
-    MODEL_DB.sqls.length.should == 3
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should eagerly load multiple associations in separate" do
     a = @c1.eager(:tags).eager(:albums).all
     a.should == [@c1.load(:id=>1)]
-    MODEL_DB.sqls.length.should == 3
-    MODEL_DB.sqls[0].should == 'SELECT * FROM artists'
-    MODEL_DB.sqls[1..-1].should(include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))
-    MODEL_DB.sqls[1..-1].should(include('SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))
+    sqls = MODEL_DB.sqls
+    sqls.length.should == 3
+    sqls[0].should == 'SELECT * FROM artists'
+    sqls[1..-1].should(include('SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))
+    sqls[1..-1].should(include('SELECT albums.*, albums_artists.artist_id AS x_foreign_key_x FROM albums INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))'))
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.albums.should == [Album.load(:id=>3)]
-    MODEL_DB.sqls.length.should == 3
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should allow cascading of eager loading for associations of associated models" do
@@ -531,7 +469,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.tags.first.tracks.should == [Track.load(:id=>4)]
-    MODEL_DB.sqls.length.should == 3
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should cascade eagerly loading when the :eager association option is used" do
@@ -544,7 +482,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.tags.first.tracks.should == [Track.load(:id=>4)]
-    MODEL_DB.sqls.length.should == 3
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should respect :eager when lazily loading an association" do
@@ -554,7 +492,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.should == ['SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1))',
       'SELECT tracks.*, albums_tags.tag_id AS x_foreign_key_x FROM tracks INNER JOIN albums ON (albums.id = tracks.album_id) INNER JOIN albums_tags ON ((albums_tags.album_id = albums.id) AND (albums_tags.tag_id IN (2)))']
     a.tags.first.tracks.should == [Track.load(:id=>4)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should cascade eagerly loading when the :eager_graph association option is used" do
@@ -563,14 +501,11 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
   end
   
   it "should respect :eager_graph when lazily loading an association" do
+    Tag.dataset._fetch = {:id=>2, :tracks_id=>4}
     Tag.dataset.extend(Module.new {
       def columns
         [:id]
       end
-      def fetch_rows(sql)
-        @db << sql
-        yield({:id=>2, :tracks_id=>4})
-      end
     })
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :eager_graph=>:tracks
     a = @c1.load(:id=>1)
@@ -578,7 +513,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.should == [ 'SELECT tags.id, tracks.id AS tracks_id FROM (SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1))) AS tags LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums ON (albums.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums.id)']
     a.tags.should == [Tag.load(:id=>2)]
     a.tags.first.tracks.should == [Track.load(:id=>4)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should respect :conditions when eagerly loading" do
@@ -588,7 +523,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE (a = 32)']
     a.first.tags.should == [Tag.load(:id=>2)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should respect :order when eagerly loading" do
@@ -598,7 +533,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) ORDER BY blah']
     a.first.tags.should == [Tag.load(:id=>2)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should use the association's block when eager loading by default" do
@@ -608,7 +543,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE a']
     a.first.tags.should == [Tag.load(:id=>2)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should use the :eager_block option when eager loading if given" do
@@ -618,121 +553,87 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE b']
     a.first.tags.should == [Tag.load(:id=>2)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should respect the :limit option on a many_through_many association" do
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2
-    Tag.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        MODEL_DB.sqls << sql
-        yield({:x_foreign_key_x=>1, :id=>5})
-        yield({:x_foreign_key_x=>1, :id=>6})
-        yield({:x_foreign_key_x=>1, :id=>7})
-      end
-    })
+    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}, {:x_foreign_key_x=>1, :id=>7}]
     a = @c1.eager(:first_two_tags).all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']
     a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
 
-    MODEL_DB.reset
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1]
     a = @c1.eager(:first_two_tags).all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']
     a.first.first_two_tags.should == [Tag.load(:id=>6), Tag.load(:id=>7)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should respect the :limit option on a many_through_many association using a :window_function strategy" do
     Tag.dataset.meta_def(:supports_window_functions?){true}
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>true, :order=>:name
-    Tag.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        MODEL_DB.sqls << sql
-        yield({:x_foreign_key_x=>1, :id=>5})
-        yield({:x_foreign_key_x=>1, :id=>6})
-      end
-    })
+    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}]
     a = @c1.eager(:first_two_tags).all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT * FROM (SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x, row_number() OVER (PARTITION BY albums_artists.artist_id ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))) AS t1 WHERE (x_sequel_row_number_x <= 2)']
     a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
 
-    MODEL_DB.reset
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :eager_limit_strategy=>true, :order=>:name
     a = @c1.eager(:first_two_tags).all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT * FROM (SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x, row_number() OVER (PARTITION BY albums_artists.artist_id ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))']
     a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should respect the :limit option on a many_through_many association with composite primary keys on the main table using a :window_function strategy" do
     Tag.dataset.meta_def(:supports_window_functions?){true}
     @c1.set_primary_key([:id1, :id2])
     @c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>true, :order=>:name
-    @c1.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        MODEL_DB.sqls << sql
-        yield({:id1=>1, :id2=>2})
-      end
-    })
-    Tag.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        MODEL_DB.sqls << sql
-        yield({:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5})
-        yield({:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>6})
-      end
-    })
+    @c1.dataset._fetch = [{:id1=>1, :id2=>2}]
+    Tag.dataset._fetch = [{:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>5}, {:x_foreign_key_0_x=>1, :x_foreign_key_1_x=>2, :id=>6}]
     a = @c1.eager(:first_two_tags).all
     a.should == [@c1.load(:id1=>1, :id2=>2)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT * FROM (SELECT tags.*, albums_artists.artist_id1 AS x_foreign_key_0_x, albums_artists.artist_id2 AS x_foreign_key_1_x, row_number() OVER (PARTITION BY albums_artists.artist_id1, albums_artists.artist_id2 ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND ((albums_artists.artist_id1, albums_artists.artist_id2) IN ((1, 2))))) AS t1 WHERE (x_sequel_row_number_x <= 2)']
     a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
 
-    MODEL_DB.reset
     @c1.many_through_many :first_two_tags, [[:albums_artists, [:artist_id1, :artist_id2], :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :eager_limit_strategy=>true, :order=>:name
     a = @c1.eager(:first_two_tags).all
     a.should == [@c1.load(:id1=>1, :id2=>2)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT * FROM (SELECT tags.*, albums_artists.artist_id1 AS x_foreign_key_0_x, albums_artists.artist_id2 AS x_foreign_key_1_x, row_number() OVER (PARTITION BY albums_artists.artist_id1, albums_artists.artist_id2 ORDER BY name) AS x_sequel_row_number_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND ((albums_artists.artist_id1, albums_artists.artist_id2) IN ((1, 2))))) AS t1 WHERE ((x_sequel_row_number_x >= 2) AND (x_sequel_row_number_x < 4))']
     a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should respect the :limit option on a many_through_many association using a :correlated_subquery strategy" do
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>2, :eager_limit_strategy=>:correlated_subquery, :order=>:name
-    Tag.dataset.extend(Module.new {
-      def fetch_rows(sql)
-        MODEL_DB.sqls << sql
-        yield({:x_foreign_key_x=>1, :id=>5})
-        yield({:x_foreign_key_x=>1, :id=>6})
-      end
-    })
+    Tag.dataset._fetch = [{:x_foreign_key_x=>1, :id=>5},{:x_foreign_key_x=>1, :id=>6}]
     a = @c1.eager(:first_two_tags).all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE (tags.id IN (SELECT t1.id FROM tags AS t1 INNER JOIN albums_tags ON (albums_tags.tag_id = t1.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists AS t2 ON ((t2.album_id = albums.id) AND (t2.artist_id = albums_artists.artist_id)) ORDER BY name LIMIT 2)) ORDER BY name']
     a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
 
-    MODEL_DB.reset
     @c1.many_through_many :first_two_tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :class=>Tag, :limit=>[2,1], :eager_limit_strategy=>:correlated_subquery, :order=>:name
     a = @c1.eager(:first_two_tags).all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1))) WHERE (tags.id IN (SELECT t1.id FROM tags AS t1 INNER JOIN albums_tags ON (albums_tags.tag_id = t1.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists AS t2 ON ((t2.album_id = albums.id) AND (t2.artist_id = albums_artists.artist_id)) ORDER BY name LIMIT 2 OFFSET 1)) ORDER BY name']
     a.first.first_two_tags.should == [Tag.load(:id=>5), Tag.load(:id=>6)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should raise an error when attempting to eagerly load an association with the :allow_eager option set to false" do
@@ -748,47 +649,33 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.name, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']
     a.first.tags.should == [Tag.load(:id=>2)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should respect many_through_many association's :left_primary_key and :right_primary_key options" do
     @c1.send(:define_method, :yyy){values[:yyy]}
-    @c1.dataset.extend(Module.new {
-      def columns
-        [:id, :yyy]
-      end
-      def fetch_rows(sql)
-        @db << sql
-        yield({:id=>1, :yyy=>8})
-      end
-    })
+    @c1.dataset._fetch = {:id=>1, :yyy=>8}
+    @c1.dataset.meta_def(:columns){[:id, :yyy]}
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :left_primary_key=>:yyy, :right_primary_key=>:tag_id
     a = @c1.eager(:tags).all
     a.should == [@c1.load(:id=>1, :yyy=>8)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.tag_id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (8)))']
     a.first.tags.should == [Tag.load(:tag_id=>2)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should handle composite keys" do
     @c1.send(:define_method, :yyy){values[:yyy]}
-    @c1.dataset.extend(Module.new {
-      def columns
-        [:id, :yyy]
-      end
-      def fetch_rows(sql)
-        @db << sql
-        yield({:id=>1, :yyy=>8})
-      end
-    })
+    @c1.dataset._fetch = {:id=>1, :yyy=>8}
+    @c1.dataset.meta_def(:columns){[:id, :yyy]}
     @c1.many_through_many :tags, [[:albums_artists, [:b1, :b2], [:c1, :c2]], [:albums, [:d1, :d2], [:e1, :e2]], [:albums_tags, [:f1, :f2], [:g1, :g2]]], :right_primary_key=>[:h1, :h2], :left_primary_key=>[:id, :yyy]
     a = @c1.eager(:tags).all
     a.should == [@c1.load(:id=>1, :yyy=>8)]
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.b1 AS x_foreign_key_0_x, albums_artists.b2 AS x_foreign_key_1_x FROM tags INNER JOIN albums_tags ON ((albums_tags.g1 = tags.h1) AND (albums_tags.g2 = tags.h2)) INNER JOIN albums ON ((albums.e1 = albums_tags.f1) AND (albums.e2 = albums_tags.f2)) INNER JOIN albums_artists ON ((albums_artists.c1 = albums.d1) AND (albums_artists.c2 = albums.d2) AND ((albums_artists.b1, albums_artists.b2) IN ((1, 8))))']
     a.first.tags.should == [Tag.load(:id=>2)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should respect :after_load callbacks on associations when eager loading" do
@@ -798,7 +685,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     MODEL_DB.sqls.should == ['SELECT * FROM artists',
       'SELECT tags.*, albums_artists.artist_id AS x_foreign_key_x FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id IN (1)))']
     a.first.tags.should == [Tag.load(:id=>6)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
     
   it "should raise an error if called without a symbol or hash" do
@@ -810,7 +697,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']
     a.first.tags.should == [Tag.load(:id=>2)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should eagerly graph multiple associations in a single call" do 
@@ -820,7 +707,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.albums.should == [Album.load(:id=>3)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should eagerly graph multiple associations in separate calls" do 
@@ -830,7 +717,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.albums.should == [Album.load(:id=>3)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should allow cascading of eager graphing for associations of associated models" do
@@ -840,24 +727,18 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.tags.first.tracks.should == [Track.load(:id=>4)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "eager graphing should eliminate duplicates caused by cartesian products" do
     ds = @c1.eager_graph(:tags)
-    def ds.fetch_rows(sql, &block)
-      @db << sql
-      # Assume artist has 2 albums each with 2 tags
-      yield({:id=>1, :tags_id=>2})
-      yield({:id=>1, :tags_id=>3})
-      yield({:id=>1, :tags_id=>2})
-      yield({:id=>1, :tags_id=>3})
-    end
+    # Assume artist has 2 albums each with 2 tags
+    ds._fetch = [{:id=>1, :tags_id=>2}, {:id=>1, :tags_id=>3}, {:id=>1, :tags_id=>2}, {:id=>1, :tags_id=>3}]
     a = ds.all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']
     a.first.tags.should == [Tag.load(:id=>2), Tag.load(:id=>3)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "should eager graph multiple associations from the same table" do
@@ -867,7 +748,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.other_tags.should == [Tag.load(:id=>9)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should eager graph a self_referential association" do
@@ -877,7 +758,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.artists.should == [@c1.load(:id=>10)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "eager graphing should give you a plain hash when called without .all" do 
@@ -892,31 +773,22 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a = a.first
     a.tags.should == [Tag.load(:id=>2)]
     a.albums.should == [Album.load(:id=>3)]
-    MODEL_DB.sqls.length.should == 2
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should handle no associated records when eagerly graphing a single many_through_many association" do
     ds = @c1.eager_graph(:tags)
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :tags_id=>nil})
-    end
+    ds._fetch = {:id=>1, :tags_id=>nil}
     a = ds.all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']
     a.first.tags.should == []
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should handle no associated records when eagerly graphing multiple many_through_many associations" do
     ds = @c1.eager_graph(:tags, :albums)
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :tags_id=>nil, :albums_0_id=>3})
-      yield({:id=>1, :tags_id=>2, :albums_0_id=>nil})
-      yield({:id=>1, :tags_id=>5, :albums_0_id=>6})
-      yield({:id=>7, :tags_id=>nil, :albums_0_id=>nil})
-    end
+    ds._fetch = [{:id=>1, :tags_id=>nil, :albums_0_id=>3}, {:id=>1, :tags_id=>2, :albums_0_id=>nil}, {:id=>1, :tags_id=>5, :albums_0_id=>6}, {:id=>7, :tags_id=>nil, :albums_0_id=>nil}]
     a = ds.all
     a.should == [@c1.load(:id=>1), @c1.load(:id=>7)]
     MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, albums_0.id AS albums_0_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_artists AS albums_artists_0 ON (albums_artists_0.artist_id = artists.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_artists_0.album_id)']
@@ -924,17 +796,12 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a.first.albums.should == [Album.load(:id=>3), Album.load(:id=>6)]
     a.last.tags.should == []
     a.last.albums.should == []
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should handle missing associated records when cascading eager graphing for associations of associated models" do
     ds = @c1.eager_graph(:tags=>:tracks)
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :tags_id=>2, :tracks_id=>4})
-      yield({:id=>1, :tags_id=>3, :tracks_id=>nil})
-      yield({:id=>2, :tags_id=>nil, :tracks_id=>nil})
-    end
+    ds._fetch = [{:id=>1, :tags_id=>2, :tracks_id=>4}, {:id=>1, :tags_id=>3, :tracks_id=>nil}, {:id=>2, :tags_id=>nil, :tracks_id=>nil}]
     a = ds.all
     a.should == [@c1.load(:id=>1), @c1.load(:id=>2)]
     MODEL_DB.sqls.should == ['SELECT artists.id, tags.id AS tags_id, tracks.id AS tracks_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) LEFT OUTER JOIN albums_tags AS albums_tags_0 ON (albums_tags_0.tag_id = tags.id) LEFT OUTER JOIN albums AS albums_0 ON (albums_0.id = albums_tags_0.album_id) LEFT OUTER JOIN tracks ON (tracks.album_id = albums_0.id)']
@@ -943,7 +810,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     a.tags.should == [Tag.load(:id=>2), Tag.load(:id=>3)]
     a.tags.first.tracks.should == [Track.load(:id=>4)]
     a.tags.last.tracks.should == []
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "eager graphing should respect :left_primary_key and :right_primary_key options" do 
@@ -951,15 +818,12 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     @c1.dataset.meta_def(:columns){[:id, :yyy]}
     Tag.dataset.meta_def(:columns){[:id, :tag_id]}
     ds = @c1.eager_graph(:tags)
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4})
-    end
+    ds._fetch = {:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4}
     a = ds.all
     a.should == [@c1.load(:id=>1, :yyy=>8)]
     MODEL_DB.sqls.should == ['SELECT artists.id, artists.yyy, tags.id AS tags_id, tags.tag_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.yyy) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.tag_id = albums_tags.tag_id)']
     a.first.tags.should == [Tag.load(:id=>2, :tag_id=>4)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
   
   it "eager graphing should respect composite keys" do 
@@ -967,29 +831,23 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
     @c1.dataset.meta_def(:columns){[:id, :yyy]}
     Tag.dataset.meta_def(:columns){[:id, :tag_id]}
     ds = @c1.eager_graph(:tags)
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4})
-    end
+    ds._fetch = {:id=>1, :yyy=>8, :tags_id=>2, :tag_id=>4}
     a = ds.all
     a.should == [@c1.load(:id=>1, :yyy=>8)]
     MODEL_DB.sqls.should == ['SELECT artists.id, artists.yyy, tags.id AS tags_id, tags.tag_id FROM artists LEFT OUTER JOIN albums_artists ON ((albums_artists.b1 = artists.id) AND (albums_artists.b2 = artists.yyy)) LEFT OUTER JOIN albums ON ((albums.d1 = albums_artists.c1) AND (albums.d2 = albums_artists.c2)) LEFT OUTER JOIN albums_tags ON ((albums_tags.f1 = albums.e1) AND (albums_tags.f2 = albums.e2)) LEFT OUTER JOIN tags ON ((tags.id = albums_tags.g1) AND (tags.tag_id = albums_tags.g2))']
     a.first.tags.should == [Tag.load(:id=>2, :tag_id=>4)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should respect the association's :graph_select option" do 
     @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :graph_select=>:b
     ds = @c1.eager_graph(:tags)
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :b=>2})
-    end
+    ds._fetch = {:id=>1, :b=>2}
     a = ds.all
     a.should == [@c1.load(:id=>1)]
     MODEL_DB.sqls.should == ['SELECT artists.id, tags.b FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)']
     a.first.tags.should == [Tag.load(:b=>2)]
-    MODEL_DB.sqls.length.should == 1
+    MODEL_DB.sqls.length.should == 0
   end
 
   it "should respect the association's :graph_join_type option" do