sequel 4.41.0 → 4.42.0

data/spec/extensions/pg_array_ops_spec.rb

@@ -4,7 +4,8 @@ Sequel.extension :pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops
 
 describe "Sequel::Postgres::ArrayOp" do
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @a = Sequel.pg_array_op(:a)
   end
 

data/spec/extensions/pg_array_spec.rb

@@ -12,8 +12,12 @@ describe "pg_array extension" do
   end
 
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @db.extend_datasets(Module.new{def supports_timestamp_timezones?; false; end; def supports_timestamp_usecs?; false; end})
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets(Module.new do
+      def supports_timestamp_timezones?; false end
+      def supports_timestamp_usecs?; false; end
+      def quote_identifiers?; false end
+    end)
     @db.extension(:pg_array)
     @m = Sequel::Postgres
     @converter = @m::PG_TYPES

data/spec/extensions/pg_enum_spec.rb

@@ -4,14 +4,16 @@ Sequel.extension :migration
 
 describe "pg_enum extension" do
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @db.extend(Module.new do
       def schema_parse_table(*)
         [[:a, {:oid=>1}]]
       end
+      def _metadata_dataset
+        super.with_fetch([[{:v=>1, :enumlabel=>'a'}, {:v=>1, :enumlabel=>'b'}, {:v=>1, :enumlabel=>'c'}], [{:typname=>'enum1', :v=>212389}]])
+      end
     end)
-    @db.send(:metadata_dataset)._fetch = [[{:v=>1, :enumlabel=>'a'}, {:v=>1, :enumlabel=>'b'}, {:v=>1, :enumlabel=>'c'}],
-      [{:typname=>'enum1', :v=>212389}]]
     @db.extension(:pg_array, :pg_enum)
     @db.sqls
   end

data/spec/extensions/pg_hstore_ops_spec.rb

@@ -4,7 +4,9 @@ Sequel.extension :pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops
 
 describe "Sequel::Postgres::HStoreOp" do
   before do
-    @ds = Sequel.connect('mock://postgres', :quote_identifiers=>false).dataset
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
+    @ds = @db.dataset
     @h = Sequel.hstore_op(:h)
   end
 

data/spec/extensions/pg_hstore_spec.rb

@@ -3,7 +3,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "pg_hstore extension" do
   before do
     Sequel.extension :pg_array, :pg_hstore
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @m = Sequel::Postgres
     @c = @m::HStore
     @db.extension :pg_hstore
@@ -91,7 +92,7 @@ describe "pg_hstore extension" do
 
     if RUBY_VERSION >= '1.9.0'
       Sequel.hstore('foo'=>'bar').assoc(:foo).must_equal ['foo', 'bar']
-      Sequel.hstore('foo'=>'bar').assoc(:foo2).must_equal nil
+      Sequel.hstore('foo'=>'bar').assoc(:foo2).must_be_nil
     end
   end
 
@@ -116,23 +117,23 @@ describe "pg_hstore extension" do
   if RUBY_VERSION >= '1.9.0'
     it "should convert key lookups to string" do
       Sequel.hstore('foo'=>'bar').key(:bar).must_equal 'foo'
-      Sequel.hstore('foo'=>'bar').key(:bar2).must_equal nil
+      Sequel.hstore('foo'=>'bar').key(:bar2).must_be_nil
     end
 
     it "should handle nil values in key lookups" do
       Sequel.hstore('foo'=>'').key('').must_equal 'foo'
-      Sequel.hstore('foo'=>'').key(nil).must_equal nil
+      Sequel.hstore('foo'=>'').key(nil).must_be_nil
       Sequel.hstore('foo'=>nil).key(nil).must_equal 'foo'
     end
 
     it "should convert rassoc lookups to string" do
       Sequel.hstore('foo'=>'bar').rassoc(:bar).must_equal ['foo', 'bar']
-      Sequel.hstore('foo'=>'bar').rassoc(:bar2).must_equal nil
+      Sequel.hstore('foo'=>'bar').rassoc(:bar2).must_be_nil
     end
 
     it "should handle nil values in rassoc lookups" do
       Sequel.hstore('foo'=>'').rassoc('').must_equal ['foo', '']
-      Sequel.hstore('foo'=>'').rassoc(nil).must_equal nil
+      Sequel.hstore('foo'=>'').rassoc(nil).must_be_nil
       Sequel.hstore('foo'=>nil).rassoc(nil).must_equal ['foo', nil]
     end
   end

data/spec/extensions/pg_inet_ops_spec.rb

@@ -4,7 +4,8 @@ Sequel.extension :pg_inet_ops
 
 describe "Sequel::Postgres::InetOp" do
   before do
-    db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    db = Sequel.connect('mock://postgres')
+    db.extend_datasets{def quote_identifiers?; false end}
     db.extension :pg_inet
     @ds = db.dataset
     @h = Sequel.pg_inet_op(:h)

data/spec/extensions/pg_inet_spec.rb

@@ -3,7 +3,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "pg_inet extension" do
   ipv6_broken = (IPAddr.new('::1'); false) rescue true
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @db.extension(:pg_array, :pg_inet)
   end
 

data/spec/extensions/pg_interval_spec.rb

@@ -7,7 +7,8 @@ rescue LoadError => exc
 else
 describe "pg_interval extension" do
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @db.extension(:pg_array, :pg_interval)
   end
 

data/spec/extensions/pg_json_ops_spec.rb

@@ -4,7 +4,8 @@ Sequel.extension :pg_array, :pg_array_ops, :pg_json, :pg_json_ops
 
 describe "Sequel::Postgres::JSONOp" do
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @j = Sequel.pg_json_op(:j)
     @jb = Sequel.pg_jsonb_op(:j)
     @l = proc{|o| @db.literal(o)}

data/spec/extensions/pg_json_spec.rb

@@ -12,7 +12,8 @@ describe "pg_json extension" do
     @bac = m::JSONBArray
   end
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @db.extension(:pg_array, :pg_json)
   end
 
@@ -53,15 +54,17 @@ describe "pg_json extension" do
       Sequel.instance_eval do
         alias pj parse_json
         def parse_json(v)
-          {'1'=>1, "'a'"=>'a', 'true'=>true, 'false'=>false, 'null'=>nil, 'o'=>Object.new}.fetch(v){pj(v)}
+          {'1'=>1, "'a'"=>'a', 'true'=>true, 'false'=>false, 'null'=>nil, 'o'=>Object.new, '[one]'=>[1]}.fetch(v){pj(v)}
         end
       end
       @m.parse_json('1').must_equal 1
       @m.parse_json("'a'").must_equal 'a'
       @m.parse_json('true').must_equal true
       @m.parse_json('false').must_equal false
-      @m.parse_json('null').must_equal nil
+      @m.parse_json('null').must_be_nil
       proc{@m.parse_json('o')}.must_raise(Sequel::InvalidValue)
+      @m.db_parse_json('one').must_equal 1
+      @m.db_parse_jsonb('one').must_equal 1
     ensure
       Sequel.instance_eval do
         alias parse_json pj

data/spec/extensions/pg_loose_count_spec.rb

@@ -3,6 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "pg_loose_count extension" do
   before do
     @db = Sequel.mock(:host=>'postgres', :fetch=>{:v=>1}).extension(:pg_loose_count)
+    @db.extend_datasets{def quote_identifiers?; false end}
   end
 
   it "should add loose_count method getting fast count for entire table using table statistics" do

data/spec/extensions/pg_range_ops_spec.rb

@@ -4,7 +4,9 @@ Sequel.extension :pg_array, :pg_range, :pg_range_ops
 
 describe "Sequel::Postgres::RangeOp" do
   before do
-    @ds = Sequel.connect('mock://postgres', :quote_identifiers=>false).dataset
+    db = Sequel.connect('mock://postgres')
+    db.extend_datasets{def quote_identifiers?; false end}
+    @ds = db.dataset
     @h = Sequel.pg_range_op(:h)
   end
 

data/spec/extensions/pg_range_spec.rb

@@ -11,9 +11,13 @@ describe "pg_range extension" do
   end
 
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
     @R = Sequel::Postgres::PGRange
-    @db.extend_datasets(Module.new{def supports_timestamp_timezones?; false; end; def supports_timestamp_usecs?; false; end})
+    @db.extend_datasets do
+      def supports_timestamp_timezones?; false end
+      def supports_timestamp_usecs?; false end
+      def quote_identifiers?; false end
+    end
     @db.extension(:pg_array, :pg_range)
   end
 
@@ -280,17 +284,17 @@ describe "pg_range extension" do
     it "should have #begin return the beginning of the range" do
       @r1.begin.must_equal 1
       @r2.begin.must_equal 3
-      @r3.begin.must_equal nil
+      @r3.begin.must_be_nil
     end
 
     it "should have #end return the end of the range" do
       @r1.end.must_equal 2
-      @r2.end.must_equal nil
+      @r2.end.must_be_nil
       @r3.end.must_equal 4
     end
 
     it "should have #db_type return the range's database type" do
-      @r1.db_type.must_equal nil
+      @r1.db_type.must_be_nil
       @r2.db_type.must_equal 'int4range'
       @r3.db_type.must_equal 'int8range'
     end

data/spec/extensions/pg_row_ops_spec.rb

@@ -4,7 +4,8 @@ Sequel.extension :pg_array, :pg_array_ops, :pg_row, :pg_row_ops
 
 describe "Sequel::Postgres::PGRowOp" do
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @a = Sequel.pg_row_op(:a)
   end
 

data/spec/extensions/pg_row_plugin_spec.rb

@@ -1,8 +1,9 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::PgRow" do
-  before(:all) do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+  before do
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @db.extension(:pg_array)
     @c = Class.new(Sequel::Model(@db[:address]))
     @c.columns :street, :city
@@ -15,9 +16,6 @@ describe "Sequel::Plugins::PgRow" do
     @c2.columns :address
     @c2.db_schema[:address].merge!(:type=>:pg_row_address)
   end
-  after do
-    @c.dataset.opts[:from] = [:address]
-  end
 
   it "should have schema_type_class include Sequel::Model" do
     @c2.new.send(:schema_type_class, :address).must_equal @c
@@ -42,7 +40,7 @@ describe "Sequel::Plugins::PgRow" do
   end
 
   it "should handle literalizing model instances when model table is aliased" do
-    @c.dataset.opts[:from] = [Sequel.as(:address, :a)]
+    @c.dataset = @c.dataset.from(Sequel.as(:address, :a))
     @db.literal(@c.load(:street=>'123 Foo St', :city=>'Bar City')).must_equal "ROW('123 Foo St', 'Bar City')::address"
   end
 

data/spec/extensions/pg_row_spec.rb

@@ -2,7 +2,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "pg_row extension" do
   before do
-    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     @db.extension(:pg_array, :pg_row)
     @m = Sequel::Postgres::PGRow
     @db.sqls
@@ -14,7 +15,7 @@ describe "pg_row extension" do
     a.to_a.must_be_kind_of(Array)
     a[0].must_equal 'a'
     a.must_equal %w'a b c'
-    a.db_type.must_equal nil
+    a.db_type.must_be_nil
     @db.literal(a).must_equal "ROW('a', 'b', 'c')"
   end
 
@@ -24,7 +25,7 @@ describe "pg_row extension" do
     as.each do |a|
       a.class.must_equal(@m::ArrayRow)
       a.to_a.must_be_kind_of(Array)
-      a.db_type.must_equal nil
+      a.db_type.must_be_nil
     end
     @db.literal(as).must_equal "ARRAY[ROW('a', 'b', 'c'),ROW('d', 'e', 'f')]::record[]"
   end
@@ -136,6 +137,7 @@ describe "pg_row extension" do
 
   it "should reload registered row types when reseting conversion procs" do
     db = Sequel.mock(:host=>'postgres')
+    db.extend_datasets{def quote_identifiers?; false end}
     db.extension(:pg_row)
     db.conversion_procs[4] = proc{|s| s.to_i}
     db.conversion_procs[5] = proc{|s| s * 2}

data/spec/extensions/pg_static_cache_updater_spec.rb

@@ -2,7 +2,8 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "pg_static_cache_updater extension" do
   before do
-    @db = Sequel.mock(:host=>'postgres')
+    @db = Sequel.connect('mock://postgres')
+    @db.extend_datasets{def quote_identifiers?; false end}
     def @db.listen(chan, opts={})
       execute("LISTEN #{chan}")
       yield(*opts[:yield])

data/spec/extensions/pg_typecast_on_load_spec.rb

@@ -24,7 +24,7 @@ describe Sequel::Model, "PgTypecastOnLoad plugin" do
   end
 
   it "should call the database conversion proc with value when automatically reloading the object on creation via insert_select" do
-    @c.dataset.meta_def(:insert_select){|h| insert(h); first}
+    @c.dataset = @c.dataset.with_extend{def insert_select(h) insert(h); first end}
     @c.create.values.must_equal(:id=>1, :b=>true, :y=>0)
   end
 

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -86,7 +86,7 @@ describe "Sequel::Plugins::PreparedStatementsAssociations" do
 
   it "should not run query if no objects can be associated" do
     @Artist.new.albums.must_equal []
-    @Album.new.artist.must_equal nil
+    @Album.new.artist.must_be_nil
     @db.sqls.must_equal []
   end
 

data/spec/extensions/prepared_statements_spec.rb

@@ -49,7 +49,7 @@ describe "prepared_statements plugin" do
           true
         end
         def insert_select(h)
-          self._fetch = {:id=>1, :name=>'foo', :i => 2}
+          cache_set(:_fetch, :id=>1, :name=>'foo', :i => 2)
           server(:default).with_sql_first(insert_select_sql(h))
         end
         def insert_select_sql(*v)
@@ -80,7 +80,7 @@ describe "prepared_statements plugin" do
 
   describe " with placeholder type specifiers" do 
     before do
-      @ds.meta_def(:requires_placeholder_type_specifiers?){true}
+      @ds = @ds.with_extend{def requires_placeholder_type_specifiers?; true end}
     end
 
     it "should correctly handle without schema type" do
@@ -90,17 +90,18 @@ describe "prepared_statements plugin" do
 
     it "should correctly handle with schema type" do
       @c.db_schema[:id][:type] = :integer
-      ds = @c.send(:prepared_lookup)
-      def ds.literal_symbol_append(sql, v)
-        if @opts[:bind_vars] and match = /\A\$(.*)\z/.match(v.to_s)
-          s = match[1].split('__')[0].to_sym
-          if prepared_arg?(s)
-            literal_append(sql, prepared_arg(s))
+      ds = @c.send(:prepared_lookup).with_extend do
+        def literal_symbol_append(sql, v)
+          if @opts[:bind_vars] and match = /\A\$(.*)\z/.match(v.to_s)
+            s = match[1].split('__')[0].to_sym
+            if prepared_arg?(s)
+              literal_append(sql, prepared_arg(s))
+            else
+              sql << v.to_s
+            end
           else
-            sql << v.to_s
+            super
           end
-        else
-          super
         end
       end
       @c[1].must_equal @p

data/spec/extensions/pretty_table_spec.rb

@@ -23,7 +23,7 @@ describe "Dataset#print" do
   end
 
   it "should default to the dataset's columns" do
-    @dataset.meta_def(:columns) {[:a, :b]}
+    @dataset.columns(:a, :b)
     @dataset.print
     @output.rewind
     @output.read.must_equal \

data/spec/extensions/query_spec.rb

@@ -87,12 +87,15 @@ describe "Dataset#query" do
     q.sql.must_equal "SELECT * FROM xyz"
   end
   
-  it "should have an appropriate mutation method" do
-    @d.query! do
-      select :a, :b___mongo
-      from :yyy
+  # SEQUEL5: Remove
+  unless Sequel.mock.dataset.frozen?
+    it "should have an appropriate mutation method" do
+      @d.query! do
+        select :a, :b___mongo
+        from :yyy
+      end
+      @d.sql.must_equal "SELECT a, b AS mongo FROM yyy"
     end
-    @d.sql.must_equal "SELECT a, b AS mongo FROM yyy"
   end
 
   it "should raise on non-chainable method calls" do

data/spec/extensions/rcte_tree_spec.rb

@@ -35,7 +35,7 @@ describe Sequel::Model, "rcte_tree" do
   end
   
   it "should use the correct SQL for lazy associations when recursive CTEs require column aliases" do
-    @c.dataset.meta_def(:recursive_cte_requires_column_aliases?){true}
+    @c.dataset = @c.dataset.with_extend{def recursive_cte_requires_column_aliases?; true end}
     @c.plugin :rcte_tree
     @o.parent_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.id = 1) LIMIT 1'
     @o.children_dataset.sql.must_equal 'SELECT * FROM nodes WHERE (nodes.parent_id = 2)'
@@ -44,13 +44,13 @@ describe Sequel::Model, "rcte_tree" do
   end
   
   it "should use the correct SQL for eager loading when recursive CTEs require column aliases" do
-    @c.dataset.meta_def(:recursive_cte_requires_column_aliases?){true}
+    @c.dataset = @c.dataset.with_extend{def recursive_cte_requires_column_aliases?; true end}
     @c.plugin :rcte_tree
-    @ds._fetch = [[{:id=>1, :name=>'A', :parent_id=>3}]]
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :name=>'A', :parent_id=>3}]])
     @c.eager(:ancestors).all
     @db.sqls.must_equal ["SELECT * FROM nodes", "WITH t(x_root_x, id, name, parent_id, i, pi) AS (SELECT id AS x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes WHERE (id IN (3)) UNION ALL SELECT t.x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.parent_id = nodes.id)) SELECT * FROM t AS nodes"]
 
-    @ds._fetch = [[{:id=>1, :name=>'A', :parent_id=>3}]]
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :name=>'A', :parent_id=>3}]])
     @c.eager(:descendants).all
     @db.sqls.must_equal ["SELECT * FROM nodes", "WITH t(x_root_x, id, name, parent_id, i, pi) AS (SELECT parent_id AS x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes WHERE (parent_id IN (1)) UNION ALL SELECT t.x_root_x, nodes.id, nodes.name, nodes.parent_id, nodes.i, nodes.pi FROM nodes INNER JOIN t ON (t.id = nodes.parent_id)) SELECT * FROM t AS nodes"]
   end
@@ -73,27 +73,27 @@ describe Sequel::Model, "rcte_tree" do
   
   it "should add all parent associations when lazily loading ancestors" do
     @c.plugin :rcte_tree
-    @ds._fetch = [[{:id=>1, :name=>'A', :parent_id=>3}, {:id=>4, :name=>'B', :parent_id=>nil}, {:id=>3, :name=>'?', :parent_id=>4}]]
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :name=>'A', :parent_id=>3}, {:id=>4, :name=>'B', :parent_id=>nil}, {:id=>3, :name=>'?', :parent_id=>4}]])
     @o.ancestors.must_equal [@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].must_equal @c.load(:id=>1, :name=>'A', :parent_id=>3)
     @o.associations[:parent].associations[:parent].must_equal @c.load(:id=>3, :name=>'?', :parent_id=>4)
     @o.associations[:parent].associations[:parent].associations[:parent].must_equal @c.load(:id=>4, :name=>'B', :parent_id=>nil)
-    @o.associations[:parent].associations[:parent].associations[:parent].associations.fetch(:parent, 1).must_equal nil
+    @o.associations[:parent].associations[:parent].associations[:parent].associations.fetch(:parent, 1).must_be_nil
   end
   
   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._fetch = [[{:i=>4, :name=>'A', :pi=>5}, {:i=>6, :name=>'B', :pi=>nil}, {:i=>5, :name=>'?', :pi=>6}]]
+    @c.dataset = @c.dataset.with_fetch([[{:i=>4, :name=>'A', :pi=>5}, {:i=>6, :name=>'B', :pi=>nil}, {:i=>5, :name=>'?', :pi=>6}]])
     @o.as.must_equal [@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].must_equal @c.load(:i=>4, :name=>'A', :pi=>5)
     @o.associations[:p].associations[:p].must_equal @c.load(:i=>5, :name=>'?', :pi=>6)
     @o.associations[:p].associations[:p].associations[:p].must_equal @c.load(:i=>6, :name=>'B', :pi=>nil)
-    @o.associations[:p].associations[:p].associations[:p].associations.fetch(:p, 1).must_equal nil
+    @o.associations[:p].associations[:p].associations[:p].associations.fetch(:p, 1).must_be_nil
   end
   
   it "should add all parent and children associations when lazily loading descendants" do
     @c.plugin :rcte_tree
-    @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}]]
+    @c.dataset = @c.dataset.with_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.must_equal [@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].must_equal [@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]}.must_equal [[@c.load(:id=>3, :name=>'??', :parent_id=>1)], []]
@@ -106,7 +106,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._fetch = [[{:i=>7, :name=>'??', :pi=>5}, {:i=>5, :name=>'A', :pi=>3}, {:i=>6, :name=>'B', :pi=>3}, {:i=>8, :name=>'?', :pi=>7}]]
+    @c.dataset = @c.dataset.with_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.must_equal [@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].must_equal [@c.load(:i=>5, :name=>'A', :pi=>3), @c.load(:i=>6, :name=>'B', :pi=>3)]
     @o.associations[:cs].map{|c1| c1.associations[:cs]}.must_equal [[@c.load(:i=>7, :name=>'??', :pi=>5)], []]
@@ -116,10 +116,10 @@ describe Sequel::Model, "rcte_tree" do
   
   it "should eagerly load ancestors" do
     @c.plugin :rcte_tree
-    @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'}],
+    @ds = @c.dataset = @c.dataset.with_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}]]
+       {: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
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -138,10 +138,10 @@ describe Sequel::Model, "rcte_tree" do
   
   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._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'}],
+    @ds = @c.dataset = @c.dataset.with_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}]]
+       {:i=>8, :name=>'?', :pi=>nil, :kal=>2}, {:i=>8, :name=>'?', :pi=>nil, :kal=>1}]])
     os = @ds.eager(:as).all
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -159,10 +159,10 @@ describe Sequel::Model, "rcte_tree" do
 
   it "should eagerly load ancestors respecting association option :conditions" do
     @c.plugin :rcte_tree, :conditions => {:i => 1}
-    @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'}],
+    @ds = @c.dataset = @c.dataset.with_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}]]
+       {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>2}, {:id=>8, :name=>'?', :parent_id=>nil, :x_root_x=>1}]])
     @ds.eager(:ancestors).all
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -171,10 +171,10 @@ describe Sequel::Model, "rcte_tree" do
 
   it "should eagerly load descendants" do
     @c.plugin :rcte_tree
-    @ds._fetch = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
+    @ds = @c.dataset = @c.dataset.with_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}]]
+       {: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
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -193,10 +193,10 @@ describe Sequel::Model, "rcte_tree" do
   
   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._fetch = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}],
+    @ds = @c.dataset = @c.dataset.with_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}]]
+       {:i=>4, :name=>'?', :pi=>7, :kal=>7}, {:i=>5, :name=>'?', :pi=>4, :kal=>7}]])
     os = @ds.eager(:ds).all
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -213,10 +213,10 @@ describe Sequel::Model, "rcte_tree" do
   
   it "should eagerly load descendants to a given level" do
     @c.plugin :rcte_tree
-    @ds._fetch = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
+    @ds = @c.dataset = @c.dataset.with_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}]]
+       {: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
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -233,10 +233,10 @@ describe Sequel::Model, "rcte_tree" do
   
   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._fetch = [[{:i=>2, :pi=>1, :name=>'AA'}, {:i=>6, :pi=>2, :name=>'C'}, {:i=>7, :pi=>1, :name=>'D'}],
+    @ds = @c.dataset = @c.dataset.with_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}]]
+       {:i=>4, :name=>'?', :pi=>7, :kal=>7, :lal=>0}, {:i=>5, :name=>'?', :pi=>4, :kal=>7, :lal=>1}]])
     os = @ds.eager(:ds=>2).all
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -253,10 +253,10 @@ describe Sequel::Model, "rcte_tree" do
 
   it "should eagerly load descendants respecting association option :conditions" do
     @c.plugin :rcte_tree, :conditions => {:i => 1}
-    @ds._fetch = [[{:id=>2, :parent_id=>1, :name=>'AA'}, {:id=>6, :parent_id=>2, :name=>'C'}, {:id=>7, :parent_id=>1, :name=>'D'}],
+    @ds = @c.dataset = @c.dataset.with_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}]]
+       {:id=>4, :name=>'?', :parent_id=>7, :x_root_x=>7}, {:id=>5, :name=>'?', :parent_id=>4, :x_root_x=>7}]])
     @ds.eager(:descendants).all
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -290,37 +290,37 @@ describe Sequel::Model, "rcte_tree with composite keys" do
   end
   
   it "should use the correct SQL for lazy associations when recursive CTEs require column aliases" do
-    @c.dataset.meta_def(:recursive_cte_requires_column_aliases?){true}
+    @c.dataset = @c.dataset.with_extend{def recursive_cte_requires_column_aliases?; true end}
     @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
     @o.ancestors_dataset.sql.must_equal 'WITH t(id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT id, id2, name, parent_id, parent_id2, i, pi FROM nodes WHERE ((id = 1) AND (id2 = 6)) UNION ALL SELECT nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.parent_id = nodes.id) AND (t.parent_id2 = nodes.id2))) SELECT * FROM t AS nodes'
     @o.descendants_dataset.sql.must_equal 'WITH t(id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT id, id2, name, parent_id, parent_id2, i, pi FROM nodes WHERE ((parent_id = 2) AND (parent_id2 = 5)) UNION ALL SELECT nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.id = nodes.parent_id) AND (t.id2 = nodes.parent_id2))) SELECT * FROM t AS nodes'
   end
   
   it "should use the correct SQL for eager loading when recursive CTEs require column aliases" do
-    @c.dataset.meta_def(:recursive_cte_requires_column_aliases?){true}
+    @c.dataset = @c.dataset.with_extend{def recursive_cte_requires_column_aliases?; true end}
     @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
-    @ds._fetch = [[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]]
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]])
     @c.eager(:ancestors).all
     @db.sqls.must_equal ["SELECT * FROM nodes", "WITH t(x_root_x_0, x_root_x_1, id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT id AS x_root_x_0, id2 AS x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes WHERE ((id, id2) IN ((3, 4))) UNION ALL SELECT t.x_root_x_0, t.x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.parent_id = nodes.id) AND (t.parent_id2 = nodes.id2))) SELECT * FROM t AS nodes"]
 
-    @ds._fetch = [[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]]
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :id2=>2, :name=>'A', :parent_id=>3, :parent_id2=>4}]])
     @c.eager(:descendants).all
     @db.sqls.must_equal ["SELECT * FROM nodes", "WITH t(x_root_x_0, x_root_x_1, id, id2, name, parent_id, parent_id2, i, pi) AS (SELECT parent_id AS x_root_x_0, parent_id2 AS x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes WHERE ((parent_id, parent_id2) IN ((1, 2))) UNION ALL SELECT t.x_root_x_0, t.x_root_x_1, nodes.id, nodes.id2, nodes.name, nodes.parent_id, nodes.parent_id2, nodes.i, nodes.pi FROM nodes INNER JOIN t ON ((t.id = nodes.parent_id) AND (t.id2 = nodes.parent_id2))) SELECT * FROM t AS nodes"]
   end
   
   it "should add all parent associations when lazily loading ancestors" do
     @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
-    @ds._fetch = [[{:id=>1, :id2=>6, :name=>'A', :parent_id=>3, :parent_id2=>5}, {:id=>4, :id2=>8, :name=>'B', :parent_id=>nil, :parent_id2=>nil}, {:id=>3, :id2=>5, :name=>'?', :parent_id=>4, :parent_id2=>8}]]
+    @c.dataset = @c.dataset.with_fetch([[{:id=>1, :id2=>6, :name=>'A', :parent_id=>3, :parent_id2=>5}, {:id=>4, :id2=>8, :name=>'B', :parent_id=>nil, :parent_id2=>nil}, {:id=>3, :id2=>5, :name=>'?', :parent_id=>4, :parent_id2=>8}]])
     @o.ancestors.must_equal [@c.load(:id=>1, :id2=>6, :name=>'A', :parent_id=>3, :parent_id2=>5), @c.load(:id=>4, :id2=>8, :name=>'B', :parent_id=>nil, :parent_id2=>nil), @c.load(:id=>3, :id2=>5, :name=>'?', :parent_id=>4, :parent_id2=>8)]
     @o.associations[:parent].must_equal @c.load(:id=>1, :id2=>6, :name=>'A', :parent_id=>3, :parent_id2=>5)
     @o.associations[:parent].associations[:parent].must_equal @c.load(:id=>3, :id2=>5, :name=>'?', :parent_id=>4, :parent_id2=>8)
     @o.associations[:parent].associations[:parent].associations[:parent].must_equal @c.load(:id=>4, :id2=>8, :name=>'B', :parent_id=>nil, :parent_id2=>nil)
-    @o.associations[:parent].associations[:parent].associations[:parent].associations.fetch(:parent, 1).must_equal nil
+    @o.associations[:parent].associations[:parent].associations[:parent].associations.fetch(:parent, 1).must_be_nil
   end
   
   it "should add all children associations when lazily loading descendants" do
     @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
-    @ds._fetch = [[{:id=>3, :id2=>4, :name=>'??', :parent_id=>1, :parent_id2=>2}, {:id=>1, :id2=>2, :name=>'A', :parent_id=>2, :parent_id2=>5}, {:id=>4, :id2=>5, :name=>'B', :parent_id=>2, :parent_id2=>5}, {:id=>5, :id2=>7, :name=>'?', :parent_id=>3, :parent_id2=>4}]]
+    @c.dataset = @c.dataset.with_fetch([[{:id=>3, :id2=>4, :name=>'??', :parent_id=>1, :parent_id2=>2}, {:id=>1, :id2=>2, :name=>'A', :parent_id=>2, :parent_id2=>5}, {:id=>4, :id2=>5, :name=>'B', :parent_id=>2, :parent_id2=>5}, {:id=>5, :id2=>7, :name=>'?', :parent_id=>3, :parent_id2=>4}]])
     @o.descendants.must_equal [@c.load(:id=>3, :id2=>4, :name=>'??', :parent_id=>1, :parent_id2=>2), @c.load(:id=>1, :id2=>2, :name=>'A', :parent_id=>2, :parent_id2=>5), @c.load(:id=>4, :id2=>5, :name=>'B', :parent_id=>2, :parent_id2=>5), @c.load(:id=>5, :id2=>7, :name=>'?', :parent_id=>3, :parent_id2=>4)]
     @o.associations[:children].must_equal [@c.load(:id=>1, :id2=>2, :name=>'A', :parent_id=>2, :parent_id2=>5), @c.load(:id=>4, :id2=>5, :name=>'B', :parent_id=>2, :parent_id2=>5)]
     @o.associations[:children].map{|c1| c1.associations[:children]}.must_equal [[@c.load(:id=>3, :id2=>4, :name=>'??', :parent_id=>1, :parent_id2=>2)], []]
@@ -330,10 +330,10 @@ describe Sequel::Model, "rcte_tree with composite keys" do
   
   it "should eagerly load ancestors" do
     @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
-    @ds._fetch = [[{:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'}, {:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'}, {:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'}, {:id=>9, :id2=>10, :parent_id=>nil, :parent_id2=>nil, :name=>'E'}],
+    @ds = @c.dataset = @c.dataset.with_fetch([[{:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'}, {:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'}, {:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'}, {:id=>9, :id2=>10, :parent_id=>nil, :parent_id2=>nil, :name=>'E'}],
       [{:id=>2, :id2=>3, :name=>'AA', :parent_id=>1, :parent_id2=>2, :x_root_x_0=>2, :x_root_x_1=>3},
        {:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9, :x_root_x_0=>1, :x_root_x_1=>2}, {:id=>1, :id2=>2, :name=>'00', :parent_id=>8, :parent_id2=>9, :x_root_x_0=>2, :x_root_x_1=>3},
-       {:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil, :x_root_x_0=>2, :x_root_x_1=>3}, {:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil, :x_root_x_0=>1, :x_root_x_1=>2}]]
+       {:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil, :x_root_x_0=>2, :x_root_x_1=>3}, {:id=>8, :id2=>9, :name=>'?', :parent_id=>nil, :parent_id2=>nil, :x_root_x_0=>1, :x_root_x_1=>2}]])
     os = @ds.eager(:ancestors).all
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -352,10 +352,10 @@ describe Sequel::Model, "rcte_tree with composite keys" do
   
   it "should eagerly load descendants" do
     @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
-    @ds._fetch = [[{:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'}, {:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'}, {:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'}],
+    @ds = @c.dataset = @c.dataset.with_fetch([[{:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'}, {:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'}, {:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'}],
       [{:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C', :x_root_x_0=>2, :x_root_x_1=>3}, {:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E', :x_root_x_0=>2, :x_root_x_1=>3},
        {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>6, :x_root_x_1=>7}, {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>2, :x_root_x_1=>3},
-       {:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8, :x_root_x_0=>7, :x_root_x_1=>8}, {:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5, :x_root_x_0=>7, :x_root_x_1=>8}]]
+       {:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8, :x_root_x_0=>7, :x_root_x_1=>8}, {:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5, :x_root_x_0=>7, :x_root_x_1=>8}]])
     os = @ds.eager(:descendants).all
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"
@@ -372,10 +372,10 @@ describe Sequel::Model, "rcte_tree with composite keys" do
   
   it "should eagerly load descendants to a given level" do
     @c.plugin :rcte_tree, :key=>[:parent_id, :parent_id2]
-    @ds._fetch = [[{:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'}, {:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'}, {:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'}],
+    @ds = @c.dataset = @c.dataset.with_fetch([[{:id=>2, :id2=>3, :parent_id=>1, :parent_id2=>2, :name=>'AA'}, {:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C'}, {:id=>7, :id2=>8, :parent_id=>1, :parent_id2=>2, :name=>'D'}],
       [{:id=>6, :id2=>7, :parent_id=>2, :parent_id2=>3, :name=>'C', :x_root_x_0=>2, :x_root_x_1=>3, :x_level_x=>0}, {:id=>9, :id2=>10, :parent_id=>2, :parent_id2=>3, :name=>'E', :x_root_x_0=>2, :x_root_x_1=>3, :x_level_x=>0},
        {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>6, :x_root_x_1=>7, :x_level_x=>0}, {:id=>3, :id2=>4, :name=>'00', :parent_id=>6, :parent_id2=>7, :x_root_x_0=>2, :x_root_x_1=>3, :x_level_x=>1},
-       {:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8, :x_root_x_0=>7, :x_root_x_1=>8, :x_level_x=>0}, {:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5, :x_root_x_0=>7, :x_root_x_1=>8, :x_level_x=>1}]]
+       {:id=>4, :id2=>5, :name=>'?', :parent_id=>7, :parent_id2=>8, :x_root_x_0=>7, :x_root_x_1=>8, :x_level_x=>0}, {:id=>5, :id2=>6, :name=>'?', :parent_id=>4, :parent_id2=>5, :x_root_x_0=>7, :x_root_x_1=>8, :x_level_x=>1}]])
     os = @ds.eager(:descendants=>2).all
     sqls = @db.sqls
     sqls.first.must_equal "SELECT * FROM nodes"