sequel 3.29.0 → 3.30.0

data/spec/extensions/optimistic_locking_spec.rb

@@ -6,11 +6,8 @@ describe "optimistic_locking plugin" do
     end
     h = {1=>{:id=>1, :name=>'John', :lock_version=>2}}
     lv = @lv = "lock_version"
-    @c.dataset.quote_identifiers = false
-    @c.dataset.meta_def(:h){h}
-    @c.dataset.meta_def(:lv){lv}
-    @c.dataset.meta_def(:update) do |opts|
-      case update_sql(opts)
+    @c.dataset.numrows = proc do |sql|
+      case sql
       when /UPDATE people SET (name|#{lv}) = ('Jim'|'Bob'|\d+), (?:name|#{lv}) = ('Jim'|'Bob'|\d+) WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
         name, nlv = $1 == 'name' ? [$2, $3] : [$3, $2]
         m = h[$4.to_i]
@@ -28,20 +25,6 @@ describe "optimistic_locking plugin" do
         else
           0
         end
-      else
-        puts update_sql(opts)
-      end
-    end
-    @c.dataset.instance_eval do
-      def fetch_rows(sql)
-        m = h[1].dup
-        v = m.delete(:lock_version)
-        m[lv.to_sym] = v
-        yield(m)
-      end
-    end
-    @c.dataset.meta_def(:delete) do
-      case delete_sql
       when /DELETE FROM people WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
         m = h[$1.to_i]
         if m && m[lv.to_sym] == $2.to_i
@@ -51,9 +34,15 @@ describe "optimistic_locking plugin" do
           0
         end
       else
-        puts delete_sql
+        puts sql
       end
     end
+    @c.dataset._fetch = proc do |sql|
+      m = h[1].dup
+      v = m.delete(:lock_version)
+      m[lv.to_sym] = v
+      m
+    end
     @c.columns :id, :name, :lock_version
     @c.plugin :optimistic_locking
   end

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -2,23 +2,14 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::AssociationPks" do
   before do
-    @db = MODEL_DB.clone
-    mod = Module.new do
-      def fetch_rows(sql)
-        db << (is_a?(Sequel::Dataset::PreparedStatementMethods) ? :prepared : :regular)
-        db << sql
+    @db = Sequel.mock
+    @db.extend_datasets do
+      def select_sql
+        sql = super
+        sql << ' -- prepared' if is_a?(Sequel::Dataset::PreparedStatementMethods)
+        sql
       end
     end
-    @db.meta_def(:dataset) do |*opts|
-      ds = super(*opts)
-      ds.extend mod
-      ds
-    end
-    def @db.transaction(opts)
-      execute('BEGIN')
-      yield
-      execute('COMMIT')
-    end
     @Artist = Class.new(Sequel::Model(@db[:artists]))
     @Artist.columns :id, :id2
     @Album= Class.new(Sequel::Model(@db[:albums]))
@@ -32,24 +23,21 @@ describe "Sequel::Plugins::AssociationPks" do
     @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
     @Artist.plugin :many_through_many
     @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
-    @db.reset
+    @db.sqls
   end
 
   specify "should run correct SQL for associations" do
     @Artist.load(:id=>1).albums
-    @db.sqls.should == [:prepared, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
-    @db.reset
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1) -- prepared"]
 
     @Album.load(:id=>1, :artist_id=>2).artist
-    @db.sqls.should == [:prepared, "SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1"]
-    @db.reset
+    @db.sqls.should == ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- prepared"]
 
     @Album.load(:id=>1, :artist_id=>2).tags
-    @db.sqls.should == [:prepared, "SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1))"]
-    @db.reset
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)) -- prepared"]
 
     @Artist.load(:id=>1).tags
-    @db.sqls.should == [:prepared, "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) AND (albums.artist_id = 1))"]
+    @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) AND (albums.artist_id = 1)) -- prepared"]
   end
 
   specify "should run correct SQL for composite key associations" do
@@ -59,19 +47,16 @@ describe "Sequel::Plugins::AssociationPks" do
     @Artist.many_through_many :tags, [[:albums, [:artist_id, :artist_id2], [:id, :id2]], [:albums_tags, [:album_id, :album_id2], [:tag_id, :tag_id2]]], :class=>@Tag, :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
 
     @Artist.load(:id=>1, :id2=>2).albums
-    @db.sqls.should == [:prepared, "SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2))"]
-    @db.reset
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
 
     @Album.load(:id=>1, :artist_id=>2, :artist_id2=>3).artist
-    @db.sqls.should == [:prepared, "SELECT * FROM artists WHERE ((artists.id = 2) AND (artists.id2 = 3)) LIMIT 1"]
-    @db.reset
+    @db.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 2) AND (artists.id2 = 3)) LIMIT 1 -- prepared"]
 
     @Album.load(:id=>1, :artist_id=>2, :id2=>3).tags
-    @db.sqls.should == [:prepared, "SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2) AND (albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3))"]
-    @db.reset
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2) AND (albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) -- prepared"]
 
     @Artist.load(:id=>1, :id2=>2).tags
-    @db.sqls.should == [:prepared, "SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.id2 = albums_tags.album_id2) AND (albums.artist_id = 1) AND (albums.artist_id2 = 2))"]
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.id2 = albums_tags.album_id2) AND (albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
   end
 
   specify "should not run query if no objects can be associated" do
@@ -82,45 +67,45 @@ describe "Sequel::Plugins::AssociationPks" do
 
   specify "should run a regular query if there is a callback" do
     @Artist.load(:id=>1).albums(proc{|ds| ds})
-    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
   end
 
   specify "should run a regular query if :prepared_statement=>false option is used for the association" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :prepared_statement=>false
     @Artist.load(:id=>1).albums
-    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
   end
 
   specify "should run a regular query if unrecognized association is used" do
     a = @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
     a[:type] = :foo
     @Artist.load(:id=>1).albums
-    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
   end
 
   specify "should run a regular query if a block is used when defining the association" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id do |ds| ds end
     @Artist.load(:id=>1).albums
-    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
   end
 
   specify "should run a regular query if :conditions option is used when defining the association" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
     @Artist.load(:id=>1).albums
-    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
   end
 
   specify "should run a regular query if :dataset option is used when defining the association" do
     album = @Album
     @Artist.one_to_many :albums, :class=>@Album, :dataset=>proc{album.filter(:artist_id=>id)} 
     @Artist.load(:id=>1).albums
-    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE (artist_id = 1)"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE (artist_id = 1)"]
   end
 
   specify "should run a regular query if :cloning an association that doesn't used prepared statements" do
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
     @Artist.one_to_many :oalbums, :clone=>:albums
     @Artist.load(:id=>1).oalbums
-    @db.sqls.should == [:regular, "SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
   end
 end

data/spec/extensions/prepared_statements_safe_spec.rb

@@ -2,29 +2,13 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "prepared_statements_safe plugin" do
   before do
-    @c = Class.new(Sequel::Model(:people))
+    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
+    @c = Class.new(Sequel::Model(@db[:people]))
     @c.columns :id, :name, :i
-    @ds = ds = @c.dataset
     @c.instance_variable_set(:@db_schema, {:i=>{}, :name=>{}, :id=>{:primary_key=>true}})
-    def ds.fetch_rows(sql)
-      db << {:server=>@opts[:server] || :read_only}.merge(opts)[:server]
-      super{|h|}
-      yield(:id=>1, :name=>'foo', :i=>2)
-    end
-    def ds.update(*)
-      db << default_server_opts(opts)[:server]
-      super
-    end
-    def ds.insert(*)
-      db << default_server_opts(opts)[:server]
-      super
-      1
-    end
     @c.plugin :prepared_statements_safe
     @p = @c.load(:id=>1, :name=>'foo', :i=>2)
-    @c.db.execute 'foo'
-    @sqls = @c.db.sqls
-    @sqls.clear
+    @db.sqls
   end
 
   specify "should load the prepared_statements plugin" do
@@ -39,32 +23,30 @@ describe "prepared_statements_safe plugin" do
 
   specify "should set default values when creating" do
     @c.create
-    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \(NULL, NULL\)/
-    @sqls.clear
+    @db.sqls.first.should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \(NULL, NULL\)/
     @c.create(:name=>'foo')
-    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((NULL|'foo'), (NULL|'foo')\)/
-    @sqls.clear
+    @db.sqls.first.should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((NULL|'foo'), (NULL|'foo')\)/
     @c.create(:name=>'foo', :i=>2)
-    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
+    @db.sqls.first.should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
   end 
 
   specify "should use database default values" do
     @c.instance_variable_set(:@db_schema, {:i=>{:ruby_default=>2}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
     c = Class.new(@c)
     c.create
-    @sqls[1].should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
+    @db.sqls.first.should =~ /INSERT INTO people \((i|name), (i|name)\) VALUES \((2|'foo'), (2|'foo')\)/
   end
 
   specify "should not set defaults for unparseable dataset default values" do
     @c.instance_variable_set(:@db_schema, {:i=>{:default=>'f(x)'}, :name=>{:ruby_default=>'foo'}, :id=>{:primary_key=>true}})
     c = Class.new(@c)
     c.create
-    @sqls[1].should == "INSERT INTO people (name) VALUES ('foo')"
+    @db.sqls.first.should == "INSERT INTO people (name) VALUES ('foo')"
   end
 
   specify "should save all fields when updating" do
     @p.update(:i=>3)
-    @sqls[1].should =~ /UPDATE people SET (name = 'foo'|i = 3), (name = 'foo'|i = 3) WHERE \(id = 1\)/
+    @db.sqls.first.should =~ /UPDATE people SET (name = 'foo'|i = 3), (name = 'foo'|i = 3) WHERE \(id = 1\)/
   end
 
   specify "should work with abstract classes" do

data/spec/extensions/prepared_statements_spec.rb

@@ -2,52 +2,33 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "prepared_statements plugin" do
   before do
-    @c = Class.new(Sequel::Model(:people))
+    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
+    @c = Class.new(Sequel::Model(@db[:people]))
     @c.columns :id, :name, :i
-    @ds = ds = @c.dataset
-    def ds.fetch_rows(sql)
-      db << {:server=>@opts[:server] || :read_only}.merge(opts)[:server]
-      super{|h|}
-      yield(:id=>1, :name=>'foo', :i=>2)
-    end
-    def ds.update(*)
-      db << default_server_opts(opts)[:server]
-      super
-    end
-    def ds.insert(*)
-      db << default_server_opts(opts)[:server]
-      super
-      1
-    end
-    def ds.delete(*)
-      db << default_server_opts(opts)[:server]
-      super
-    end
     @c.plugin :prepared_statements
     @p = @c.load(:id=>1, :name=>'foo', :i=>2)
-    @c.db.execute 'foo'
-    @sqls = @c.db.sqls
-    @sqls.clear
+    @ds = @c.dataset
+    @db.sqls
   end
 
   specify "should correctly lookup by primary key" do
     @c[1].should == @p
-    @sqls.should == [:read_only, "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
+    @db.sqls.should == ["SELECT * FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
   end 
 
   specify "should correctly delete instance" do
     @p.destroy.should == @p
-    @sqls.should == [:default, "DELETE FROM people WHERE (id = 1)"]
+    @db.sqls.should == ["DELETE FROM people WHERE (id = 1)"]
   end
 
   specify "should correctly update instance" do
     @p.update(:name=>'bar').should == @c.load(:id=>1, :name=>'bar', :i => 2)
-    @sqls.should == [:default, "UPDATE people SET name = 'bar' WHERE (id = 1)"]
+    @db.sqls.should == ["UPDATE people SET name = 'bar' WHERE (id = 1)"]
   end
 
   specify "should correctly create instance" do
     @c.create(:name=>'foo').should == @c.load(:id=>1, :name=>'foo', :i => 2)
-    @sqls.should == [:default, "INSERT INTO people (name) VALUES ('foo')", :default, "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
+    @db.sqls.should == ["INSERT INTO people (name) VALUES ('foo')", "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
   end
 
   specify "should correctly create instance if dataset supports insert_select" do
@@ -55,18 +36,18 @@ describe "prepared_statements plugin" do
       true
     end
     def @ds.insert_select(h)
-      return {:id=>1, :name=>'foo', :i => 2}
+      {:id=>1, :name=>'foo', :i => 2}
     end
     def @ds.insert_sql(*)
       "#{super}#{' RETURNING *' if opts.has_key?(:returning)}"
     end
     @c.create(:name=>'foo').should == @c.load(:id=>1, :name=>'foo', :i => 2)
-    @sqls.should == [:default, "INSERT INTO people (name) VALUES ('foo') RETURNING *"]
+    @db.sqls.should == ["INSERT INTO people (name) VALUES ('foo') RETURNING *"]
   end
 
   specify "should work correctly when subclassing" do
     c = Class.new(@c)
     c[1].should == c.load(:id=>1, :name=>'foo', :i=>2)
-    @sqls.should == [:read_only, "SELECT * FROM people WHERE (id = 1) LIMIT 1"]
+    @db.sqls.should == ["SELECT * FROM people WHERE (id = 1) LIMIT 1 -- read_only"]
   end 
 end

data/spec/extensions/prepared_statements_with_pk_spec.rb

@@ -2,19 +2,12 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "prepared_statements_with_pk plugin" do
   before do
-    @c = Class.new(Sequel::Model(:people))
+    @db = Sequel.mock(:fetch=>{:id=>1, :name=>'foo', :i=>2}, :autoid=>proc{|sql| 1}, :numrows=>1, :servers=>{:read_only=>{}})
+    @c = Class.new(Sequel::Model(@db[:people]))
     @c.columns :id, :name, :i
-    @ds = ds = @c.dataset
-    def ds.fetch_rows(sql)
-      db << {:server=>@opts[:server] || :read_only}.merge(opts)[:server]
-      super{|h|}
-      yield(:id=>1, :name=>'foo', :i=>2)
-    end
     @c.plugin :prepared_statements_with_pk
     @p = @c.load(:id=>1, :name=>'foo', :i=>2)
-    @c.db.execute 'foo'
-    @sqls = @c.db.sqls
-    @sqls.clear
+    @db.sqls
   end
 
   specify "should load the prepared_statements plugin" do
@@ -23,16 +16,16 @@ describe "prepared_statements_with_pk plugin" do
 
   specify "should correctly lookup by primary key from dataset" do
     @c.dataset.filter(:name=>'foo')[1].should == @p
-    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((name = 'foo') AND (people.id = 1)) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM people WHERE ((name = 'foo') AND (people.id = 1)) LIMIT 1 -- read_only"]
   end
 
   specify "should still work correctly if there are multiple conflicting variables" do
     @c.dataset.filter(:name=>'foo').or(:name=>'bar')[1].should == @p
-    @sqls.should == [:read_only, "SELECT * FROM people WHERE (((name = 'foo') OR (name = 'bar')) AND (people.id = 1)) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM people WHERE (((name = 'foo') OR (name = 'bar')) AND (people.id = 1)) LIMIT 1 -- read_only"]
   end
 
   specify "should still work correctly if the primary key is used elsewhere in the query" do
     @c.dataset.filter{id > 2}[1].should == @p
-    @sqls.should == [:read_only, "SELECT * FROM people WHERE ((id > 2) AND (people.id = 1)) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM people WHERE ((id > 2) AND (people.id = 1)) LIMIT 1 -- read_only"]
   end
 end

data/spec/extensions/pretty_table_spec.rb

@@ -7,12 +7,7 @@ describe "Dataset#print" do
     @output = StringIO.new
     @orig_stdout = $stdout
     $stdout = @output
-    @dataset = Sequel::Dataset.new(nil).from(:items)
-    def @dataset.fetch_rows(sql)
-      yield({:a=>1, :b=>2})
-      yield({:a=>3, :b=>4})
-      yield({:a=>5, :b=>6})
-    end
+    @dataset = Sequel.mock(:fetch=>[{:a=>1, :b=>2}, {:a=>3, :b=>4}, {:a=>5, :b=>6}])[:items]
   end
 
   after do

data/spec/extensions/rcte_tree_spec.rb

@@ -8,13 +8,6 @@ describe Sequel::Model, "rcte_tree" do
       columns :id, :name, :parent_id, :i, :pi
     end
     @ds = @c.dataset
-    class << @ds
-      attr_accessor :row_sets
-      def fetch_rows(sql)
-        @db << sql
-        row_sets.shift.each{|row| yield row}
-      end
-    end
     @o = @c.load(:id=>2, :parent_id=>1, :name=>'AA', :i=>3, :pi=>4)
     MODEL_DB.reset
   end
@@ -55,7 +48,7 @@ describe Sequel::Model, "rcte_tree" do
   
   it "should add all parent associations when lazily loading ancestors" do
     @c.plugin :rcte_tree
-    @ds.row_sets = [[{:id=>1, :name=>'A', :parent_id=>3}, {:id=>4, :name=>'B', :parent_id=>nil}, {:id=>3, :name=>'?', :parent_id=>4}]]
+    @ds._fetch = [[{:id=>1, :name=>'A', :parent_id=>3}, {:id=>4, :name=>'B', :parent_id=>nil}, {:id=>3, :name=>'?', :parent_id=>4}]]
     @o.ancestors.should == [@c.load(:id=>1, :name=>'A', :parent_id=>3), @c.load(:id=>4, :name=>'B', :parent_id=>nil), @c.load(:id=>3, :name=>'?', :parent_id=>4)]
     @o.associations[:parent].should == @c.load(:id=>1, :name=>'A', :parent_id=>3)
     @o.associations[:parent].associations[:parent].should == @c.load(:id=>3, :name=>'?', :parent_id=>4)
@@ -65,7 +58,7 @@ describe Sequel::Model, "rcte_tree" do
   
   it "should add all parent associations when lazily loading ancestors and giving options" do
     @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :ancestors=>{:name=>:as}, :parent=>{:name=>:p}
-    @ds.row_sets = [[{:i=>4, :name=>'A', :pi=>5}, {:i=>6, :name=>'B', :pi=>nil}, {:i=>5, :name=>'?', :pi=>6}]]
+    @ds._fetch = [[{:i=>4, :name=>'A', :pi=>5}, {:i=>6, :name=>'B', :pi=>nil}, {:i=>5, :name=>'?', :pi=>6}]]
     @o.as.should == [@c.load(:i=>4, :name=>'A', :pi=>5), @c.load(:i=>6, :name=>'B', :pi=>nil), @c.load(:i=>5, :name=>'?', :pi=>6)]
     @o.associations[:p].should == @c.load(:i=>4, :name=>'A', :pi=>5)
     @o.associations[:p].associations[:p].should == @c.load(:i=>5, :name=>'?', :pi=>6)
@@ -75,7 +68,7 @@ describe Sequel::Model, "rcte_tree" do
   
   it "should add all children associations when lazily loading descendants" do
     @c.plugin :rcte_tree
-    @ds.row_sets = [[{:id=>3, :name=>'??', :parent_id=>1}, {:id=>1, :name=>'A', :parent_id=>2}, {:id=>4, :name=>'B', :parent_id=>2}, {:id=>5, :name=>'?', :parent_id=>3}]]
+    @ds._fetch = [[{:id=>3, :name=>'??', :parent_id=>1}, {:id=>1, :name=>'A', :parent_id=>2}, {:id=>4, :name=>'B', :parent_id=>2}, {:id=>5, :name=>'?', :parent_id=>3}]]
     @o.descendants.should == [@c.load(:id=>3, :name=>'??', :parent_id=>1), @c.load(:id=>1, :name=>'A', :parent_id=>2), @c.load(:id=>4, :name=>'B', :parent_id=>2), @c.load(:id=>5, :name=>'?', :parent_id=>3)]
     @o.associations[:children].should == [@c.load(:id=>1, :name=>'A', :parent_id=>2), @c.load(:id=>4, :name=>'B', :parent_id=>2)]
     @o.associations[:children].map{|c1| c1.associations[:children]}.should == [[@c.load(:id=>3, :name=>'??', :parent_id=>1)], []]
@@ -85,7 +78,7 @@ describe Sequel::Model, "rcte_tree" do
   
   it "should add all children associations when lazily loading descendants and giving options" do
     @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}
-    @ds.row_sets = [[{:i=>7, :name=>'??', :pi=>5}, {:i=>5, :name=>'A', :pi=>3}, {:i=>6, :name=>'B', :pi=>3}, {:i=>8, :name=>'?', :pi=>7}]]
+    @ds._fetch = [[{:i=>7, :name=>'??', :pi=>5}, {:i=>5, :name=>'A', :pi=>3}, {:i=>6, :name=>'B', :pi=>3}, {:i=>8, :name=>'?', :pi=>7}]]
     @o.ds.should == [@c.load(:i=>7, :name=>'??', :pi=>5), @c.load(:i=>5, :name=>'A', :pi=>3), @c.load(:i=>6, :name=>'B', :pi=>3), @c.load(:i=>8, :name=>'?', :pi=>7)]
     @o.associations[:cs].should == [@c.load(:i=>5, :name=>'A', :pi=>3), @c.load(:i=>6, :name=>'B', :pi=>3)]
     @o.associations[:cs].map{|c1| c1.associations[:cs]}.should == [[@c.load(:i=>7, :name=>'??', :pi=>5)], []]
@@ -95,13 +88,14 @@ describe Sequel::Model, "rcte_tree" do
   
   it "should eagerly load ancestors" do
     @c.plugin :rcte_tree
-    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}, {:id=>9, :parent_id=>nil, :name=>'E'}],
+    @ds._fetch = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}, {:id=>9, :parent_id=>nil, :name=>'E'}],
       [{:id=>2, :name=>'AA', :parent_id=>1, :x_root_x=>2},
        {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>1}, {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>2},
        {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]]
     os = @ds.eager(:ancestors).all
-    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(id IN \([12], [12]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\)\) SELECT \* FROM t AS nodes/
+    sqls = MODEL_DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(id IN \([12], [12]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D'), @c.load(:id=>9, :parent_id=>nil, :name=>'E')]
     os.map{|o| o.ancestors}.should == [[@c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil)],
       [@c.load(:id=>2, :name=>'AA', :parent_id=>1), @c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil)],
@@ -111,18 +105,19 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.parent.parent if o.parent}.should == [@c.load(:id=>8, :name=>'?', :parent_id=>nil), @c.load(:id=>1, :name=>'00', :parent_id=>8), @c.load(:id=>8, :name=>'?', :parent_id=>nil), nil]
     os.map{|o| o.parent.parent.parent if o.parent and o.parent.parent}.should == [nil, @c.load(:id=>8, :name=>'?', :parent_id=>nil), nil, nil]
     os.map{|o| o.parent.parent.parent.parent if o.parent and o.parent.parent and o.parent.parent.parent}.should == [nil, nil, nil, nil]
-    MODEL_DB.new_sqls.should == []
+    MODEL_DB.sqls.should == []
   end
   
   it "should eagerly load ancestors when giving options" do
     @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :key_alias=>:kal, :cte_name=>:cte, :ancestors=>{:name=>:as}, :parent=>{:name=>:p}
-    @ds.row_sets = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}, {:i=>9, :pi=>nil, :name=>'E'}],
+    @ds._fetch = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}, {:i=>9, :pi=>nil, :name=>'E'}],
       [{:i=>2, :name=>'AA', :pi=>1, :kal=>2},
        {:i=>1, :name=>'00', :pi=>8, :kal=>1}, {:i=>1, :name=>'00', :pi=>8, :kal=>2},
        {:i=>8, :name=>'?', :pi=>nil, :kal=>2}, {:i=>8, :name=>'?', :pi=>nil, :kal=>1}]]
     os = @ds.eager(:as).all
-    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH cte AS \(SELECT i AS kal, nodes\.\* FROM nodes WHERE \(i IN \([12], [12]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.pi = nodes\.i\)\) SELECT \* FROM cte/
+    sqls = MODEL_DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH cte AS \(SELECT i AS kal, nodes\.\* FROM nodes WHERE \(i IN \([12], [12]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.pi = nodes\.i\)\) SELECT \* FROM cte/
     os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D'), @c.load(:i=>9, :pi=>nil, :name=>'E')]
     os.map{|o| o.as}.should == [[@c.load(:i=>1, :name=>'00', :pi=>8), @c.load(:i=>8, :name=>'?', :pi=>nil)],
       [@c.load(:i=>2, :name=>'AA', :pi=>1), @c.load(:i=>1, :name=>'00', :pi=>8), @c.load(:i=>8, :name=>'?', :pi=>nil)],
@@ -132,30 +127,30 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.p.p if o.p}.should == [@c.load(:i=>8, :name=>'?', :pi=>nil), @c.load(:i=>1, :name=>'00', :pi=>8), @c.load(:i=>8, :name=>'?', :pi=>nil), nil]
     os.map{|o| o.p.p.p if o.p and o.p.p}.should == [nil, @c.load(:i=>8, :name=>'?', :pi=>nil), nil, nil]
     os.map{|o| o.p.p.p.p if o.p and o.p.p and o.p.p.p}.should == [nil, nil, nil, nil]
-    MODEL_DB.new_sqls.should == []
   end
 
   it "should eagerly load ancestors respecting association option :conditions" do
     @c.plugin :rcte_tree, :conditions => {:i => 1}
-    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}, {:id=>9, :parent_id=>nil, :name=>'E'}],
+    @ds._fetch = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}, {:id=>9, :parent_id=>nil, :name=>'E'}],
       [{:id=>2, :name=>'AA', :parent_id=>1, :x_root_x=>2},
        {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>1}, {:id=>1, :name=>'00', :parent_id=>8, :x_root_x=>2},
        {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]]
     os = @ds.eager(:ancestors).all
-    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(id IN \([12], [12]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
-    MODEL_DB.new_sqls.should == []
+    sqls = MODEL_DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH t AS \(SELECT id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(id IN \([12], [12]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.parent_id = nodes\.id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
   end
 
   it "should eagerly load descendants" do
     @c.plugin :rcte_tree
-    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
+    @ds._fetch = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
       [{:id=>6, :parent_id=>2, :name=>'C', :x_root_x=>2}, {:id=>9, :parent_id=>2, :name=>'E', :x_root_x=>2},
        {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2},
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]]
     os = @ds.eager(:descendants).all
-    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\)\) SELECT \* FROM t AS nodes/
+    sqls = MODEL_DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
     os.map{|o| o.descendants}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E'), @c.load(:id=>3, :name=>'00', :parent_id=>6)],
       [@c.load(:id=>3, :name=>'00', :parent_id=>6)],
@@ -163,18 +158,19 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.children}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E')], [@c.load(:id=>3, :name=>'00', :parent_id=>6)], [@c.load(:id=>4, :name=>'?', :parent_id=>7)]]
     os.map{|o1| o1.children.map{|o2| o2.children}}.should == [[[@c.load(:id=>3, :name=>'00', :parent_id=>6)], []], [[]], [[@c.load(:id=>5, :name=>'?', :parent_id=>4)]]]
     os.map{|o1| o1.children.map{|o2| o2.children.map{|o3| o3.children}}}.should == [[[[]], []], [[]], [[[]]]]
-    MODEL_DB.new_sqls.should == []
+    MODEL_DB.sqls.should == []
   end
   
   it "should eagerly load descendants when giving options" do
     @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :key_alias=>:kal, :cte_name=>:cte, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}
-    @ds.row_sets = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}],
+    @ds._fetch = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}],
       [{:i=>6, :pi=>2, :name=>'C', :kal=>2}, {:i=>9, :pi=>2, :name=>'E', :kal=>2},
        {:i=>3, :name=>'00', :pi=>6, :kal=>6}, {:i=>3, :name=>'00', :pi=>6, :kal=>2},
        {:i=>4, :name=>'?', :pi=>7, :kal=>7}, {:i=>5, :name=>'?', :pi=>4, :kal=>7}]]
     os = @ds.eager(:ds).all
-    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\* FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\)\) SELECT \* FROM cte/
+    sqls = MODEL_DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\* FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\* FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\)\) SELECT \* FROM cte/
     os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D')]
     os.map{|o| o.ds}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E'), @c.load(:i=>3, :name=>'00', :pi=>6)],
       [@c.load(:i=>3, :name=>'00', :pi=>6)],
@@ -182,18 +178,19 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.cs}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E')], [@c.load(:i=>3, :name=>'00', :pi=>6)], [@c.load(:i=>4, :name=>'?', :pi=>7)]]
     os.map{|o1| o1.cs.map{|o2| o2.cs}}.should == [[[@c.load(:i=>3, :name=>'00', :pi=>6)], []], [[]], [[@c.load(:i=>5, :name=>'?', :pi=>4)]]]
     os.map{|o1| o1.cs.map{|o2| o2.cs.map{|o3| o3.cs}}}.should == [[[[]], []], [[]], [[[]]]]
-    MODEL_DB.new_sqls.should == []
+    MODEL_DB.sqls.should == []
   end
   
   it "should eagerly load descendants to a given level" do
     @c.plugin :rcte_tree
-    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
+    @ds._fetch = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
       [{:id=>6, :parent_id=>2, :name=>'C', :x_root_x=>2, :x_level_x=>0}, {:id=>9, :parent_id=>2, :name=>'E', :x_root_x=>2, :x_level_x=>0},
        {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6, :x_level_x=>0}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2, :x_level_x=>1},
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7, :x_level_x=>0}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7, :x_level_x=>1}]]
     os = @ds.eager(:descendants=>2).all
-    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\*, 0 AS x_level_x FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\*, \(t\.x_level_x \+ 1\) AS x_level_x FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(t\.x_level_x < 1\)\) SELECT \* FROM t AS nodes/
+    sqls = MODEL_DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\*, 0 AS x_level_x FROM nodes WHERE \(parent_id IN \([267], [267], [267]\)\) UNION ALL SELECT t\.x_root_x, nodes\.\*, \(t\.x_level_x \+ 1\) AS x_level_x FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(t\.x_level_x < 1\)\) SELECT \* FROM t AS nodes/
     os.should == [@c.load(:id=>2, :parent_id=>1, :name=>'AA'), @c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>7, :parent_id=>1, :name=>'D')]
     os.map{|o| o.descendants}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E'), @c.load(:id=>3, :name=>'00', :parent_id=>6)],
       [@c.load(:id=>3, :name=>'00', :parent_id=>6)],
@@ -201,18 +198,19 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.associations[:children]}.should == [[@c.load(:id=>6, :parent_id=>2, :name=>'C'), @c.load(:id=>9, :parent_id=>2, :name=>'E')], [@c.load(:id=>3, :name=>'00', :parent_id=>6)], [@c.load(:id=>4, :name=>'?', :parent_id=>7)]]
     os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children]}}.should == [[[@c.load(:id=>3, :name=>'00', :parent_id=>6)], []], [[]], [[@c.load(:id=>5, :name=>'?', :parent_id=>4)]]]
     os.map{|o1| o1.associations[:children].map{|o2| o2.associations[:children].map{|o3| o3.associations[:children]}}}.should == [[[[]], []], [[]], [[nil]]]
-    MODEL_DB.new_sqls.should == []
+    MODEL_DB.sqls.should == []
   end
   
   it "should eagerly load descendants to a given level when giving options" do
     @c.plugin :rcte_tree, :primary_key=>:i, :key=>:pi, :key_alias=>:kal, :level_alias=>:lal, :cte_name=>:cte, :children=>{:name=>:cs}, :descendants=>{:name=>:ds}
-    @ds.row_sets = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}],
+    @ds._fetch = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}],
       [{:i=>6, :pi=>2, :name=>'C', :kal=>2, :lal=>0}, {:i=>9, :pi=>2, :name=>'E', :kal=>2, :lal=>0},
        {:i=>3, :name=>'00', :pi=>6, :kal=>6, :lal=>0}, {:i=>3, :name=>'00', :pi=>6, :kal=>2, :lal=>1},
        {:i=>4, :name=>'?', :pi=>7, :kal=>7, :lal=>0}, {:i=>5, :name=>'?', :pi=>4, :kal=>7, :lal=>1}]]
     os = @ds.eager(:ds=>2).all
-    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\*, 0 AS lal FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\*, \(cte\.lal \+ 1\) AS lal FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\) WHERE \(cte\.lal < 1\)\) SELECT \* FROM cte/
+    sqls = MODEL_DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH cte AS \(SELECT pi AS kal, nodes\.\*, 0 AS lal FROM nodes WHERE \(pi IN \([267], [267], [267]\)\) UNION ALL SELECT cte\.kal, nodes\.\*, \(cte\.lal \+ 1\) AS lal FROM nodes INNER JOIN cte ON \(cte\.i = nodes\.pi\) WHERE \(cte\.lal < 1\)\) SELECT \* FROM cte/
     os.should == [@c.load(:i=>2, :pi=>1, :name=>'AA'), @c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>7, :pi=>1, :name=>'D')]
     os.map{|o| o.ds}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E'), @c.load(:i=>3, :name=>'00', :pi=>6)],
       [@c.load(:i=>3, :name=>'00', :pi=>6)],
@@ -220,18 +218,18 @@ describe Sequel::Model, "rcte_tree" do
     os.map{|o| o.associations[:cs]}.should == [[@c.load(:i=>6, :pi=>2, :name=>'C'), @c.load(:i=>9, :pi=>2, :name=>'E')], [@c.load(:i=>3, :name=>'00', :pi=>6)], [@c.load(:i=>4, :name=>'?', :pi=>7)]]
     os.map{|o1| o1.associations[:cs].map{|o2| o2.associations[:cs]}}.should == [[[@c.load(:i=>3, :name=>'00', :pi=>6)], []], [[]], [[@c.load(:i=>5, :name=>'?', :pi=>4)]]]
     os.map{|o1| o1.associations[:cs].map{|o2| o2.associations[:cs].map{|o3| o3.associations[:cs]}}}.should == [[[[]], []], [[]], [[nil]]]
-    MODEL_DB.new_sqls.should == []
+    MODEL_DB.sqls.should == []
   end
 
   it "should eagerly load descendants respecting association option :conditions" do
     @c.plugin :rcte_tree, :conditions => {:i => 1}
-    @ds.row_sets = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
+    @ds._fetch = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
       [{:id=>6, :parent_id=>2, :name=>'C', :x_root_x=>2}, {:id=>9, :parent_id=>2, :name=>'E', :x_root_x=>2},
        {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>6}, {:id=>3, :name=>'00', :parent_id=>6, :x_root_x=>2},
        {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]]
     os = @ds.eager(:descendants).all
-    MODEL_DB.sqls.first.should == "SELECT * FROM nodes"
-    MODEL_DB.new_sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(parent_id IN \([267], [267], [267]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
-    MODEL_DB.new_sqls.should == []
+    sqls = MODEL_DB.sqls
+    sqls.first.should == "SELECT * FROM nodes"
+    sqls.last.should =~ /WITH t AS \(SELECT parent_id AS x_root_x, nodes\.\* FROM nodes WHERE \(\(parent_id IN \([267], [267], [267]\)\) AND \(i = 1\)\) UNION ALL SELECT t\.x_root_x, nodes\.\* FROM nodes INNER JOIN t ON \(t\.id = nodes\.parent_id\) WHERE \(i = 1\)\) SELECT \* FROM t AS nodes WHERE \(i = 1\)/
   end
 end