sequel 4.41.0 → 4.42.0

data/spec/integration/prepared_statement_test.rb

@@ -371,7 +371,7 @@ describe "Bound Argument Types" do
   cspecify "should handle blob type with nil values", [:oracle], [:tinytds], [:jdbc, :mssql] do
     @ds.delete
     @ds.prepare(:insert, :ps_blob, {:file=>:$x}).call(:x=>nil)
-    @ds.get(:file).must_equal nil
+    @ds.get(:file).must_be_nil
   end
 
   cspecify "should handle blob type with embedded zeros", [:odbc] do
@@ -412,10 +412,10 @@ describe "Dataset#unbind" do
   it "should unbind values assigned to equality and inequality statements" do
     @ct[Integer, 10]
     @u[@ds.filter(:c=>10)].must_equal(:c=>10)
-    @u[@ds.exclude(:c=>10)].must_equal nil
-    @u[@ds.filter{c < 10}].must_equal nil
+    @u[@ds.exclude(:c=>10)].must_be_nil
+    @u[@ds.filter{c < 10}].must_be_nil
     @u[@ds.filter{c <= 10}].must_equal(:c=>10)
-    @u[@ds.filter{c > 10}].must_equal nil
+    @u[@ds.filter{c > 10}].must_be_nil
     @u[@ds.filter{c >= 10}].must_equal(:c=>10)
   end
 
@@ -456,12 +456,12 @@ describe "Dataset#unbind" do
     end
     @ds.insert(:a=>2, :b=>0, :c=>3, :d=>5)
     @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>4)=>1}, 0) => 1)].must_equal(:a=>2, :b=>0, :c=>3, :d=>5)
-    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>5)=>1}, 0) => 1)].must_equal nil
+    @u[@ds.filter{a > 1}.and{b < 2}.or(:c=>3).and(Sequel.case({~Sequel.expr(:d=>5)=>1}, 0) => 1)].must_be_nil
   end
 
   it "should handle case where the same variable has the same value in multiple places " do
     @ct[Integer, 1]
     @u[@ds.filter{c > 1}.or{c < 1}.invert].must_equal(:c=>1)
-    @u[@ds.filter{c > 1}.or{c < 1}].must_equal nil
+    @u[@ds.filter{c > 1}.or{c < 1}].must_be_nil
   end
 end    

data/spec/integration/schema_test.rb

@@ -1,50 +1,54 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "Database schema parser" do
-  before do
-    @iom = DB.identifier_output_method
-    @iim = DB.identifier_input_method
-    @qi = DB.quote_identifiers?
-  end
   after do
-    DB.identifier_output_method = @iom
-    DB.identifier_input_method = @iim
-    DB.quote_identifiers = @qi
     DB.drop_table?(:items)
   end
 
-  it "should handle a database with a identifier methods" do
-    DB.identifier_output_method = :reverse
-    DB.identifier_input_method = :reverse
-    DB.quote_identifiers = true
-    DB.create_table!(:items){Integer :number}
-    begin
-      DB.schema(:items, :reload=>true).must_be_kind_of(Array)
-      DB.schema(:items, :reload=>true).first.first.must_equal :number
-    ensure 
-      DB.drop_table(:items)
+  describe "with identifier mangling" do
+    before do
+      @iom = DB.identifier_output_method
+      @iim = DB.identifier_input_method
+      @qi = DB.quote_identifiers?
+    end
+    after do
+      DB.identifier_output_method = @iom
+      DB.identifier_input_method = @iim
+      DB.quote_identifiers = @qi
     end
-  end
 
-  it "should handle a dataset with identifier methods different than the database's" do
-    DB.identifier_output_method = :reverse
-    DB.identifier_input_method = :reverse
-    DB.quote_identifiers = true
-    DB.create_table!(:items){Integer :number}
-    DB.identifier_output_method = @iom
-    DB.identifier_input_method = @iim
-    ds = DB[:items].
-      with_identifier_output_method(:reverse).
-      with_identifier_input_method(:reverse)
-    begin
-      DB.schema(ds, :reload=>true).must_be_kind_of(Array)
-      DB.schema(ds, :reload=>true).first.first.must_equal :number
-    ensure 
+    it "should handle a database with a identifier methods" do
       DB.identifier_output_method = :reverse
       DB.identifier_input_method = :reverse
-      DB.drop_table(:items)
+      DB.quote_identifiers = true
+      DB.create_table!(:items){Integer :number}
+      begin
+        DB.schema(:items, :reload=>true).must_be_kind_of(Array)
+        DB.schema(:items, :reload=>true).first.first.must_equal :number
+      ensure 
+      end
     end
-  end
+
+    it "should handle a dataset with identifier methods different than the database's" do
+      DB.identifier_output_method = :reverse
+      DB.identifier_input_method = :reverse
+      DB.quote_identifiers = true
+      DB.create_table!(:items){Integer :number}
+      DB.identifier_output_method = @iom
+      DB.identifier_input_method = @iim
+      ds = DB[:items].
+        with_identifier_output_method(:reverse).
+        with_identifier_input_method(:reverse)
+      begin
+        DB.schema(ds, :reload=>true).must_be_kind_of(Array)
+        DB.schema(ds, :reload=>true).first.first.must_equal :number
+      ensure 
+        DB.identifier_output_method = :reverse
+        DB.identifier_input_method = :reverse
+        DB.drop_table(:items)
+      end
+    end
+  end if IDENTIFIER_MANGLING
 
   it "should not issue an sql query if the schema has been loaded unless :reload is true" do
     DB.create_table!(:items){Integer :number}
@@ -106,7 +110,7 @@ describe "Database schema parser" do
 
   it "should parse defaults from the schema properly" do
     DB.create_table!(:items){Integer :number}
-    DB.schema(:items).first.last[:ruby_default].must_equal nil
+    DB.schema(:items).first.last[:ruby_default].must_be_nil
     DB.create_table!(:items){Integer :number, :default=>0}
     DB.schema(:items).first.last[:ruby_default].must_equal 0
     DB.create_table!(:items){String :a, :default=>"blah"}
@@ -115,7 +119,7 @@ describe "Database schema parser" do
 
   it "should make :default nil for a NULL default" do
     DB.create_table!(:items){Integer :number}
-    DB.schema(:items).first.last[:default].must_equal nil
+    DB.schema(:items).first.last[:default].must_be_nil
     DB.create_table!(:items){Integer :number, :default=>0}
     DB.schema(:items).first.last[:default].wont_equal nil
   end
@@ -796,12 +800,8 @@ describe "Database#tables and #views" do
     @db.drop_table?(:sequel_test_table)
     @db.create_table(:sequel_test_table){Integer :a}
     @db.create_view :sequel_test_view, @db[:sequel_test_table]
-    @iom = @db.identifier_output_method
-    @iim = @db.identifier_input_method
   end
   after do
-    @db.identifier_output_method = @iom
-    @db.identifier_input_method = @iim
     @db.drop_view :sequel_test_view
     @db.drop_table :sequel_test_table
   end
@@ -814,12 +814,6 @@ describe "Database#tables and #views" do
     ts.wont_include(:sequel_test_view)
   end if DB.supports_table_listing?
 
-  it "#tables should respect the database's identifier_output_method" do
-    @db.identifier_output_method = :xxxxx
-    @db.identifier_input_method = :xxxxx
-    @db.tables.each{|t| t.to_s.must_match(/\Ax{5}\d+\z/)}
-  end if DB.supports_table_listing?
-
   it "#views should return an array of symbols" do
     ts = @db.views
     ts.must_be_kind_of(Array)
@@ -828,9 +822,26 @@ describe "Database#tables and #views" do
     ts.must_include(:sequel_test_view)
   end if DB.supports_view_listing?
 
-  it "#views should respect the database's identifier_output_method" do
-    @db.identifier_output_method = :xxxxx
-    @db.identifier_input_method = :xxxxx
-    @db.views.each{|t| t.to_s.must_match(/\Ax{5}\d+\z/)}
-  end if DB.supports_view_listing?
+  describe "with identifier mangling" do
+    before do
+      @iom = @db.identifier_output_method
+      @iim = @db.identifier_input_method
+    end
+    after do
+      @db.identifier_output_method = @iom
+      @db.identifier_input_method = @iim
+    end
+
+    it "#tables should respect the database's identifier_output_method" do
+      @db.identifier_output_method = :xxxxx
+      @db.identifier_input_method = :xxxxx
+      @db.tables.each{|t| t.to_s.must_match(/\Ax{5}\d+\z/)}
+    end if DB.supports_table_listing?
+
+    it "#views should respect the database's identifier_output_method" do
+      @db.identifier_output_method = :xxxxx
+      @db.identifier_input_method = :xxxxx
+      @db.views.each{|t| t.to_s.must_match(/\Ax{5}\d+\z/)}
+    end if DB.supports_view_listing?
+  end if IDENTIFIER_MANGLING
 end

data/spec/integration/spec_helper.rb

@@ -25,8 +25,13 @@ Sequel.cache_anonymous_models = false
 
 require './spec/guards_helper'
 
+IDENTIFIER_MANGLING = !ENV['SEQUEL_NO_MANGLE'] unless defined?(IDENTIFIER_MANGLING)
+
 unless defined?(DB)
-  DB = Sequel.connect(ENV['SEQUEL_INTEGRATION_URL'])
+  opts = {}
+  opts[:identifier_mangling] = false unless IDENTIFIER_MANGLING
+  DB = Sequel.connect(ENV['SEQUEL_INTEGRATION_URL'], opts)
+  DB.extension(:freeze_datasets) if ENV['SEQUEL_FREEZE_DATASETS']
 end
 
 if DB.adapter_scheme == :ibmdb || (DB.adapter_scheme == :ado && DB.database_type == :access)

data/spec/integration/transaction_test.rb

@@ -40,7 +40,7 @@ describe "Database transactions" do
     @db.transaction do
       @d << {:name => 'abc', :value => 1}
       raise Sequel::Rollback
-    end.must_equal nil
+    end.must_be_nil
 
     proc do
       @db.transaction(:rollback=>:reraise) do
@@ -235,30 +235,30 @@ describe "Database transactions" do
   it "should support after_rollback outside transactions" do
     c = nil
     @db.after_rollback{c = 1}
-    c.must_equal nil
+    c.must_be_nil
   end
 
   it "should support after_commit inside transactions" do
     c = nil
-    @db.transaction{@db.after_commit{c = 1}; c.must_equal nil}
+    @db.transaction{@db.after_commit{c = 1}; c.must_be_nil}
     c.must_equal 1
   end
 
   it "should support after_rollback inside transactions" do
     c = nil
-    @db.transaction{@db.after_rollback{c = 1}; c.must_equal nil}
-    c.must_equal nil
+    @db.transaction{@db.after_rollback{c = 1}; c.must_be_nil}
+    c.must_be_nil
   end
 
   it "should not call after_commit if the transaction rolls back" do
     c = nil
-    @db.transaction{@db.after_commit{c = 1}; c.must_equal nil; raise Sequel::Rollback}
-    c.must_equal nil
+    @db.transaction{@db.after_commit{c = 1}; c.must_be_nil; raise Sequel::Rollback}
+    c.must_be_nil
   end
 
   it "should call after_rollback if the transaction rolls back" do
     c = nil
-    @db.transaction{@db.after_rollback{c = 1}; c.must_equal nil; raise Sequel::Rollback}
+    @db.transaction{@db.after_rollback{c = 1}; c.must_be_nil; raise Sequel::Rollback}
     c.must_equal 1
   end
 
@@ -276,26 +276,26 @@ describe "Database transactions" do
 
   it "should support after_commit inside nested transactions" do
     c = nil
-    @db.transaction{@db.transaction{@db.after_commit{c = 1}}; c.must_equal nil}
+    @db.transaction{@db.transaction{@db.after_commit{c = 1}}; c.must_be_nil}
     c.must_equal 1
   end
 
   it "should support after_rollback inside nested transactions" do
     c = nil
-    @db.transaction{@db.transaction{@db.after_rollback{c = 1}}; c.must_equal nil; raise Sequel::Rollback}
+    @db.transaction{@db.transaction{@db.after_rollback{c = 1}}; c.must_be_nil; raise Sequel::Rollback}
     c.must_equal 1
   end
 
   if DB.supports_savepoints?
     it "should support after_commit inside savepoints" do
       c = nil
-      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit{c = 1}}; c.must_equal nil}
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_commit{c = 1}}; c.must_be_nil}
       c.must_equal 1
     end
 
     it "should support after_rollback inside savepoints" do
       c = nil
-      @db.transaction{@db.transaction(:savepoint=>true){@db.after_rollback{c = 1}}; c.must_equal nil; raise Sequel::Rollback}
+      @db.transaction{@db.transaction(:savepoint=>true){@db.after_rollback{c = 1}}; c.must_be_nil; raise Sequel::Rollback}
       c.must_equal 1
     end
   end
@@ -315,7 +315,7 @@ describe "Database transactions" do
   end
 end
 
-if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby' or (RUBY_ENGINE == 'rbx' && !Sequel.guarded?([:do, :sqlite], [:tinytds, :mssql]))) and RUBY_VERSION < '1.9'
+if (! defined?(RUBY_ENGINE) or RUBY_ENGINE == 'ruby') and RUBY_VERSION < '1.9'
   describe "Database transactions and Thread#kill" do
     before do
       @db = DB

data/spec/model/association_reflection_spec.rb

@@ -208,10 +208,10 @@ describe Sequel::Model::Associations::AssociationReflection, "#select" do
   it "should be blank if :select is not present for a many_to_one and one_to_many associaiton" do
     @c.one_to_many :cs, :class=>'ParParent'
     @c.association_reflection(:cs).keys.wont_include(:select)
-    @c.association_reflection(:cs).select.must_equal nil
+    @c.association_reflection(:cs).select.must_be_nil
     @c.many_to_one :c, :class=>'ParParent'
     @c.association_reflection(:c).keys.wont_include(:select)
-    @c.association_reflection(:c).select.must_equal nil
+    @c.association_reflection(:c).select.must_be_nil
   end
 end
 
@@ -319,11 +319,11 @@ describe Sequel::Model::Associations::AssociationReflection, "#filter_by_associa
 
   it "should be nil by default for *_one associations" do
     @c.many_to_one :c, :class=>@c
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_be_nil
     @c.one_to_one :c, :class=>@c
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_be_nil
     @c.one_through_one :c, :class=>@c
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_be_nil
   end
 
   it "should be :correlated_subquery by default for one_to_many and one_to_one with :order associations" do
@@ -342,11 +342,11 @@ describe Sequel::Model::Associations::AssociationReflection, "#filter_by_associa
 
   it "should be nil for many_to_one associations even if :eager_limit_strategy or :filter_limit_strategy is used" do
     @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>true
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_be_nil
     @c.many_to_one :c, :class=>@c, :eager_limit_strategy=>:distinct_on
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_be_nil
     @c.many_to_one :c, :class=>@c, :filter_limit_strategy=>true
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_be_nil
   end
 
   it "should be a symbol for other associations if given a symbol" do
@@ -357,13 +357,13 @@ describe Sequel::Model::Associations::AssociationReflection, "#filter_by_associa
   end
 
   it "should use :distinct_on for one_to_one associations if picking and the association dataset supports ordered distinct on" do
-    def (@c.dataset).supports_ordered_distinct_on?() true end
+    @c.dataset = @c.dataset.with_extend{def supports_ordered_distinct_on?; true end}
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
     @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal :distinct_on
   end
 
   it "should use :window_function for associations if picking and the association dataset supports window functions" do
-    def (@c.dataset).supports_window_functions?() true end
+    @c.dataset = @c.dataset.with_extend{def supports_window_functions?; true end}
     @c.one_to_one :c, :class=>@c, :eager_limit_strategy=>true
     @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal :window_function
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
@@ -373,21 +373,21 @@ describe Sequel::Model::Associations::AssociationReflection, "#filter_by_associa
   end
 
   it "should use :ruby for one_to_many associations if the database doesn't support limits in subqueries" do
-    def (@c.dataset).supports_limits_in_correlated_subqueries?; false; end
+    @c.dataset = @c.dataset.with_extend{def supports_limits_in_correlated_subqueries?; false end}
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
     @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :ruby
   end
 
   it "should use :ruby for one_to_many associations if offset doesn't work in correlated subqueries and an offset is used" do
-    def (@c.dataset).supports_offsets_in_correlated_subqueries?; false; end
+    @c.dataset = @c.dataset.with_extend{def supports_offsets_in_correlated_subqueries?; false end}
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1
     @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :correlated_subquery
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>[1, 1]
     @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :ruby
   end
 
-  it "should use :ruby for one_to_many associations if composite primary key is used and database does not multiple columns in IN" do
-    def (@c.dataset).supports_multiple_column_in?; false; end
+  it "should use :ruby for one_to_many associations if composite primary key is used and database does not support multiple columns in IN" do
+    @c.dataset = @c.dataset.with_extend{def supports_multiple_column_in?; false end}
     @c.set_primary_key [:id, :id2]
     @c.one_to_many :cs, :class=>@c, :eager_limit_strategy=>true, :limit=>1, :key=>[:id, :id2]
     @c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :ruby
@@ -414,7 +414,7 @@ describe Sequel::Model::Associations::AssociationReflection, "#filter_by_associa
     c.dataset = :a
     c.one_to_many :cs, :class=>c, :limit=>1
     c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :correlated_subquery
-    def (c.dataset).supports_window_functions?() true end
+    c.dataset = c.dataset.with_extend{def supports_window_functions?; true end}
     c.many_to_many :cs, :class=>c, :limit=>1
     c.association_reflection(:cs).send(:filter_by_associations_limit_strategy).must_equal :window_function
   end
@@ -422,7 +422,7 @@ describe Sequel::Model::Associations::AssociationReflection, "#filter_by_associa
   it "should ignore Model.default_eager_limit_strategy for one_to_one associations" do
     @c.default_eager_limit_strategy = :window_function
     @c.one_to_one :c, :class=>@c
-    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_equal nil
+    @c.association_reflection(:c).send(:filter_by_associations_limit_strategy).must_be_nil
   end
 end
 
@@ -459,7 +459,7 @@ describe Sequel::Model, " association reflection methods" do
   end
 
   it "#association_reflection should return nil for nonexistent association" do
-    @c1.association_reflection(:blah).must_equal nil
+    @c1.association_reflection(:blah).must_be_nil
   end
 
   it "#association_reflection should return association reflection hash if association exists" do

data/spec/model/associations_spec.rb

@@ -118,7 +118,7 @@ describe Sequel::Model, "associate" do
       klass.association_reflection(:par)[:eager_block].call.must_equal 1
       klass.association_reflection(:par1s)[:limit].must_equal 10
       klass.association_reflection(:par1s)[:order].must_equal :b
-      klass.association_reflection(:par1s)[:block].must_equal nil
+      klass.association_reflection(:par1s)[:block].must_be_nil
       klass.association_reflection(:par2s)[:after_load].length.must_equal 1
       klass.association_reflection(:par2s)[:order].must_equal :c
       klass.association_reflection(:par2s)[:block].call.must_equal 3
@@ -177,9 +177,10 @@ describe Sequel::Model, "associate" do
   end
 
   it "should not clear associations cache when saving with insert_select" do
-    ds = Sequel::Model.db[:c]
-    def ds.supports_insert_select?() true end
-    def ds.insert_select(*) {:id=>1} end
+    ds = Sequel::Model.db[:c].with_extend do
+      def supports_insert_select?; true end
+      def insert_select(*) {:id=>1} end
+    end
     c = Class.new(Sequel::Model(ds))
     c.many_to_one :c
     o = c.new
@@ -297,7 +298,7 @@ describe Sequel::Model, "many_to_one" do
   
   it "should not issue query if not all keys have values" do
     @c2.many_to_one :parent, :class => @c2, :key=>[:id, :parent_id], :primary_key=>[:parent_id, :id]
-    @c2.new(:id => 1, :parent_id => nil).parent.must_equal nil
+    @c2.new(:id => 1, :parent_id => nil).parent.must_be_nil
     DB.sqls.must_equal []
   end
   
@@ -334,18 +335,18 @@ describe Sequel::Model, "many_to_one" do
 
   it "should return nil if key value is nil" do
     @c2.many_to_one :parent, :class => @c2
-    @c2.new(:id => 1).parent.must_equal nil
+    @c2.new(:id => 1).parent.must_be_nil
     DB.sqls.must_equal []
   end
 
   it "should cache negative lookup" do
     @c2.many_to_one :parent, :class => @c2
-    @c2.dataset._fetch = []
+    @c2.dataset = @c2.dataset.with_fetch([])
     d = @c2.new(:id => 1, :parent_id=>555)
     DB.sqls.must_equal []
-    d.parent.must_equal nil
+    d.parent.must_be_nil
     DB.sqls.must_equal ['SELECT * FROM nodes WHERE id = 555']
-    d.parent.must_equal nil
+    d.parent.must_be_nil
     DB.sqls.must_equal []
   end
 
@@ -410,8 +411,8 @@ describe Sequel::Model, "many_to_one" do
 
     d = @c2.load(:id => 1)
     d.parent_id = 234
-    d.associations[:parent].must_equal nil
-    @c2.dataset._fetch = {:id=>234}
+    d.associations[:parent].must_be_nil
+    @c2.dataset = @c2.dataset.with_fetch(:id=>234)
     e = d.parent 
     DB.sqls.must_equal ["SELECT * FROM nodes WHERE id = 234"]
     d.associations[:parent].must_equal e
@@ -422,7 +423,7 @@ describe Sequel::Model, "many_to_one" do
 
     d = @c2.create(:id => 1)
     DB.reset
-    d.associations[:parent].must_equal nil
+    d.associations[:parent].must_be_nil
     d.parent = @c2.new(:id => 234)
     e = d.parent 
     d.associations[:parent].must_equal e
@@ -479,7 +480,7 @@ describe Sequel::Model, "many_to_one" do
   it "should have the setter add to the reciprocal one_to_many cached association array if it exists" do
     @c2.many_to_one :parent, :class => @c2
     @c2.one_to_many :children, :class => @c2, :key=>:parent_id
-    @c2.dataset._fetch = []
+    @c2.dataset = @c2.dataset.with_fetch([])
 
     d = @c2.new(:id => 1)
     e = @c2.new(:id => 2)
@@ -507,13 +508,13 @@ describe Sequel::Model, "many_to_one" do
     d.parent = e
     e.child.must_equal d
     d.parent = nil
-    e.child.must_equal nil
+    e.child.must_be_nil
     d.parent = e
     e.child.must_equal d
 
     f = @c2.new(:id => 3)
     d.parent = nil
-    e.child.must_equal nil
+    e.child.must_be_nil
     e.associations[:child] = f
     d.parent = e
     e.child.must_equal d
@@ -522,7 +523,7 @@ describe Sequel::Model, "many_to_one" do
   it "should have the setter remove the object from the previous associated object's reciprocal one_to_many cached association array if it exists" do
     @c2.many_to_one :parent, :class => @c2
     @c2.one_to_many :children, :class => @c2, :key=>:parent_id
-    @c2.dataset._fetch = []
+    @c2.dataset = @c2.dataset.with_fetch([])
 
     d = @c2.new(:id => 1)
     e = @c2.new(:id => 2)
@@ -555,9 +556,10 @@ describe Sequel::Model, "many_to_one" do
   end
 
   it "should get all matching records and only return the first if :key option is set to nil" do
+    @c2.dataset = @c2.dataset.with_fetch([{:id=>1, :parent_id=>0, :par_parent_id=>3, :blah=>4, :children_id=>2, :children_parent_id=>1, :children_par_parent_id=>5, :children_blah=>6}, {}])
+    @c2.dataset.columns(:id, :parent_id, :par_parent_id, :blah)
     @c2.one_to_many :children, :class => @c2, :key=>:parent_id
     @c2.many_to_one :first_grand_parent, :class => @c2, :key=>nil, :eager_graph=>:children, :dataset=>proc{model.filter(:children_id=>parent_id)}
-    @c2.dataset.columns(:id, :parent_id, :par_parent_id, :blah)._fetch = [{:id=>1, :parent_id=>0, :par_parent_id=>3, :blah=>4, :children_id=>2, :children_parent_id=>1, :children_par_parent_id=>5, :children_blah=>6}, {}]
     p = @c2.new(:parent_id=>2)
     fgp = p.first_grand_parent
     DB.sqls.must_equal ["SELECT nodes.id, nodes.parent_id, nodes.par_parent_id, nodes.blah, children.id AS children_id, children.parent_id AS children_parent_id, children.par_parent_id AS children_par_parent_id, children.blah AS children_blah FROM nodes LEFT OUTER JOIN nodes AS children ON (children.parent_id = nodes.id) WHERE (children_id = 2)"]
@@ -655,7 +657,7 @@ describe Sequel::Model, "many_to_one" do
       def al(v)
         model::Foo << v.pk
       end
-      dataset._fetch = {:id=>20}
+      set_dataset dataset.with_fetch(:id=>20)
     end
     p = @c2.load(:id=>10, :parent_id=>20)
     parent = p.parent
@@ -684,7 +686,7 @@ describe Sequel::Model, "many_to_one" do
     def p._parent=; raise; end
     proc{p.parent = c}.must_raise(Sequel::HookFailed)
     
-    p.parent.must_equal nil
+    p.parent.must_be_nil
     p.associations[:parent] = c
     p.parent.must_equal c
     proc{p.parent = nil}.must_raise(Sequel::HookFailed)
@@ -699,7 +701,7 @@ describe Sequel::Model, "many_to_one" do
     def p._parent=; raise; end
     proc{p.parent = c}.must_raise(Sequel::HookFailed)
     
-    p.parent.must_equal nil
+    p.parent.must_be_nil
     p.associations[:parent] = c
     p.parent.must_equal c
     proc{p.parent = nil}.must_raise(Sequel::HookFailed)
@@ -732,8 +734,8 @@ describe Sequel::Model, "one_to_one" do
       columns :id, :x, :parent_id, :par_parent_id, :blah, :node_id
     end
     @dataset = @c2.dataset
-    @dataset._fetch = {}
-    @c1.dataset._fetch = {}
+    @dataset = @dataset.with_fetch({})
+    @c1.dataset = @c1.dataset.with_fetch({})
     DB.reset
   end
   
@@ -755,7 +757,7 @@ describe Sequel::Model, "one_to_one" do
   it "should add a setter method" do
     @c2.one_to_one :attribute, :class => @c1
     attrib = @c1.new(:id=>3)
-    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:id=>3}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>3)
     @c2.new(:id => 1234).attribute = attrib
     sqls = DB.sqls
     ['INSERT INTO attributes (node_id, id) VALUES (1234, 3)',
@@ -794,7 +796,7 @@ describe Sequel::Model, "one_to_one" do
   it "should have the setter method respect the :primary_key option" do
     @c2.one_to_one :attribute, :class => @c1, :primary_key=>:xxx
     attrib = @c1.new(:id=>3)
-    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:id=>3}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>3)
     @c2.new(:id => 1234, :xxx=>5).attribute = attrib
     sqls = DB.sqls
     ['INSERT INTO attributes (node_id, id) VALUES (5, 3)',
@@ -812,7 +814,7 @@ describe Sequel::Model, "one_to_one" do
   it "should have the setter method respect composite keys" do
     @c2.one_to_one :attribute, :class => @c1, :key=>[:node_id, :y], :primary_key=>[:id, :x]
     attrib = @c1.load(:id=>3, :y=>6)
-    @c1.dataset._fetch = {:id=>3, :y=>6}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>3, :y=>6)
     @c2.load(:id => 1234, :x=>5).attribute = attrib
     sqls = DB.sqls
     sqls.last.must_match(/UPDATE attributes SET (node_id = 1234|y = 5), (node_id = 1234|y = 5) WHERE \(id = 3\)/)
@@ -821,6 +823,7 @@ describe Sequel::Model, "one_to_one" do
   end
 
   it "should use implicit key if omitted" do
+    @c2.dataset = @c2.dataset.with_fetch({})
     @c2.one_to_one :parent, :class => @c2
 
     d = @c2.new(:id => 234)
@@ -856,6 +859,7 @@ describe Sequel::Model, "one_to_one" do
   end
 
   it "should use explicit key if given" do
+    @c2.dataset = @c2.dataset.with_fetch({})
     @c2.one_to_one :parent, :class => @c2, :key => :blah
 
     d = @c2.new(:id => 234)
@@ -880,7 +884,7 @@ describe Sequel::Model, "one_to_one" do
   
   it "should not issue query if not all keys have values" do
     @c2.one_to_one :parent, :class => @c2, :key=>[:id, :parent_id], :primary_key=>[:parent_id, :id]
-    @c2.new(:id => 1, :parent_id => nil).parent.must_equal nil
+    @c2.new(:id => 1, :parent_id => nil).parent.must_be_nil
     DB.sqls.must_equal []
   end
   
@@ -918,18 +922,18 @@ describe Sequel::Model, "one_to_one" do
   it "should return nil if primary_key value is nil" do
     @c2.one_to_one :parent, :class => @c2, :primary_key=>:node_id
 
-    @c2.new(:id => 1).parent.must_equal nil
+    @c2.new(:id => 1).parent.must_be_nil
     DB.sqls.must_equal []
   end
 
   it "should cache negative lookup" do
     @c2.one_to_one :parent, :class => @c2
-    @c2.dataset._fetch = []
+    @c2.dataset = @c2.dataset.with_fetch([])
     d = @c2.new(:id => 555)
     DB.sqls.must_equal []
-    d.parent.must_equal nil
+    d.parent.must_be_nil
     DB.sqls.must_equal ['SELECT * FROM nodes WHERE (nodes.node_id = 555) LIMIT 1']
-    d.parent.must_equal nil
+    d.parent.must_be_nil
     DB.sqls.must_equal []
   end
 
@@ -937,7 +941,7 @@ describe Sequel::Model, "one_to_one" do
     @c2.one_to_one :parent, :class => @c2, :key=>:blah
     d = @c2.new(:id => 3)
     e = @c2.new(:id => 4321, :blah=>444)
-    @c2.dataset._fetch = @c2.instance_dataset._fetch = {:id => 4321, :blah => 3}
+    @c2.dataset = @c2.dataset.with_fetch(:id => 4321, :blah => 3)
     d.parent = e
     e.values.must_equal(:id => 4321, :blah => 3)
     sqls = DB.sqls
@@ -958,8 +962,8 @@ describe Sequel::Model, "one_to_one" do
     @c2.one_to_one :parent, :class => @c2
 
     d = @c2.load(:id => 1)
-    d.associations[:parent].must_equal nil
-    @c2.dataset._fetch = {:id=>234}
+    d.associations[:parent].must_be_nil
+    @c2.dataset = @c2.dataset.with_fetch(:id=>234)
     e = d.parent 
     DB.sqls.must_equal ["SELECT * FROM nodes WHERE (nodes.node_id = 1) LIMIT 1"]
     d.parent
@@ -971,7 +975,7 @@ describe Sequel::Model, "one_to_one" do
     @c2.one_to_one :parent, :class => @c2
 
     d = @c2.load(:id => 1)
-    d.associations[:parent].must_equal nil
+    d.associations[:parent].must_be_nil
     e = @c2.load(:id => 234)
     d.parent = e
     f = d.parent 
@@ -1006,27 +1010,27 @@ describe Sequel::Model, "one_to_one" do
     DB.sqls.must_equal ["UPDATE nodes SET parent_id = NULL WHERE ((parent_id = 1) AND (id != 2))",
       "UPDATE nodes SET parent_id = 1 WHERE (id = 2)"]
     d.parent = nil
-    e.child.must_equal nil
+    e.child.must_be_nil
     DB.sqls.must_equal ["UPDATE nodes SET parent_id = NULL WHERE (parent_id = 1)"]
   end
 
   it "should have the setter remove the object from the previous associated object's reciprocal many_to_one cached association array if it exists" do
     @c2.one_to_one :parent, :class => @c2, :key=>:parent_id
     @c2.many_to_one :child, :class => @c2, :key=>:parent_id
-    @c2.dataset._fetch = []
+    @c2.dataset = @c2.dataset.with_fetch([])
 
     d = @c2.load(:id => 1)
     e = @c2.load(:id => 2)
     f = @c2.load(:id => 3)
-    e.child.must_equal nil
-    f.child.must_equal nil
+    e.child.must_be_nil
+    f.child.must_be_nil
     d.parent = e
     e.child.must_equal d
     d.parent = f
     f.child.must_equal d
-    e.child.must_equal nil
+    e.child.must_be_nil
     d.parent = nil
-    f.child.must_equal nil
+    f.child.must_be_nil
   end
 
   it "should have the setter not modify the reciprocal if set to same value as current" do
@@ -1108,7 +1112,7 @@ describe Sequel::Model, "one_to_one" do
       def al(v)
         model::Foo << v.pk
       end
-      @dataset._fetch = {:id=>20}
+      @dataset = @dataset.with_fetch(:id=>20)
     end
     p = @c2.load(:id=>10)
     parent = p.parent
@@ -1125,7 +1129,7 @@ describe Sequel::Model, "one_to_one" do
     def p._parent=; raise; end
     proc{p.parent = c}.must_raise(Sequel::HookFailed)
     
-    p.associations[:parent].must_equal nil
+    p.associations[:parent].must_be_nil
     p.associations[:parent] = c
     p.parent.must_equal c
     proc{p.parent = nil}.must_raise(Sequel::HookFailed)
@@ -1145,6 +1149,7 @@ describe Sequel::Model, "one_to_one" do
   end
 
   it "should work_correctly when used with associate" do
+    @c2.dataset = @c2.dataset.with_fetch({})
     @c2.associate :one_to_one, :parent, :class => @c2
     @c2.load(:id => 567).parent.must_equal @c2.load({})
     DB.sqls.must_equal ["SELECT * FROM nodes WHERE (nodes.node_id = 567) LIMIT 1"]
@@ -1172,9 +1177,8 @@ describe Sequel::Model, "one_to_many" do
       def self.to_s; 'Node'; end
       columns :id, :x
     end
-    @dataset = @c2.dataset
-    @dataset._fetch = {}
-    @c1.dataset._fetch = proc{|sql| sql =~ /SELECT 1/ ? {:a=>1} : {}}
+    @dataset = @c2.dataset = @c2.dataset.with_fetch({})
+    @c1.dataset = @c1.dataset.with_fetch(proc{|sql| sql =~ /SELECT 1/ ? {:a=>1} : {}})
     DB.reset
   end
 
@@ -1267,7 +1271,7 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.load(:id => 1234)
     a = @c1.new(:id => 234)
-    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:node_id => 1234, :id => 234}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>234, :node_id=>1234)
     a.must_equal n.add_attribute(a)
     sqls = DB.sqls
     sqls.shift.must_match(/INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/)
@@ -1290,7 +1294,7 @@ describe Sequel::Model, "one_to_many" do
     
     n = @c2.new(:id => 1234)
     a = @c1.load(:id => 2345, :node_id => 1234)
-    @c1.dataset._fetch = []
+    @c1.dataset = @c1.dataset.with_fetch([])
     proc{n.remove_attribute(a)}.must_raise(Sequel::Error)
     DB.sqls.must_equal ["SELECT 1 AS one FROM attributes WHERE ((attributes.node_id = 1234) AND (id = 2345)) LIMIT 1"]
   end
@@ -1299,7 +1303,7 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
     DB.reset
-    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:node_id => 1234, :id => 234}
+    @c1.dataset = @c1.dataset.with_fetch(:node_id => 1234, :id => 234)
     n.add_attribute(:id => 234).must_equal @c1.load(:node_id => 1234, :id => 234)
     sqls = DB.sqls
     sqls.shift.must_match(/INSERT INTO attributes \((node_)?id, (node_)?id\) VALUES \(1?234, 1?234\)/)
@@ -1309,7 +1313,7 @@ describe Sequel::Model, "one_to_many" do
   it "should accept a primary key for the add_ method" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
-    @c1.dataset._fetch = {:id=>234, :node_id=>nil}
+    @c1.dataset = @c1.dataset.with_fetch(:node_id => nil, :id => 234)
     n.add_attribute(234).must_equal @c1.load(:node_id => 1234, :id => 234)
     DB.sqls.must_equal ["SELECT * FROM attributes WHERE id = 234", "UPDATE attributes SET node_id = 1234 WHERE (id = 234)"]
   end
@@ -1317,7 +1321,7 @@ describe Sequel::Model, "one_to_many" do
   it "should raise an error if the primary key passed to the add_ method does not match an existing record" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
-    @c1.dataset._fetch = []
+    @c1.dataset = @c1.dataset.with_fetch([])
     proc{n.add_attribute(234)}.must_raise(Sequel::NoMatchingRow)
     DB.sqls.must_equal ["SELECT * FROM attributes WHERE id = 234"]
   end
@@ -1330,7 +1334,7 @@ describe Sequel::Model, "one_to_many" do
   it "should accept a primary key for the remove_ method and remove an existing record" do
     @c2.one_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
-    @c1.dataset._fetch = {:id=>234, :node_id=>1234}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>234, :node_id=>1234)
     n.remove_attribute(234).must_equal @c1.load(:node_id => nil, :id => 234)
     DB.sqls.must_equal ['SELECT * FROM attributes WHERE ((attributes.node_id = 1234) AND (attributes.id = 234)) LIMIT 1',
       'UPDATE attributes SET node_id = NULL WHERE (id = 234)']
@@ -1375,9 +1379,9 @@ describe Sequel::Model, "one_to_many" do
   end
 
   it "should have add_ method accept a composite key" do
+    @c1.dataset = @c1.dataset.with_fetch(:id=>2345, :node_id=>1234, :z=>8, :y=>5)
     @c1.set_primary_key [:id, :z]
     @c2.one_to_many :attributes, :class => @c1, :key =>[:node_id, :y], :primary_key=>[:id, :x]
-    @c1.dataset._fetch = {:id => 2345, :z => 8, :node_id => 1234, :y=>5}
     
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345, :z => 8, :node_id => 1234, :y=>5)
@@ -1400,10 +1404,10 @@ describe Sequel::Model, "one_to_many" do
   end
   
   it "should accept a array of composite primary key values for the remove_ method and remove an existing record" do
+    @c1.dataset = @c1.dataset.with_fetch(:id=>234, :node_id=>123, :y=>5)
     @c1.set_primary_key [:id, :y]
     @c2.one_to_many :attributes, :class => @c1, :key=>:node_id, :primary_key=>:id
     n = @c2.new(:id => 123)
-    @c1.dataset._fetch = {:id=>234, :node_id=>123, :y=>5}
     n.remove_attribute([234, 5]).must_equal @c1.load(:node_id => nil, :y => 5, :id => 234)
     sqls = DB.sqls
     sqls.length.must_equal 2
@@ -1435,9 +1439,9 @@ describe Sequel::Model, "one_to_many" do
     a = @c1.new(:id => 2345)
     def a.validate() errors.add(:id, 'foo') end
     n.associations[:attributes] = []
-    n.add_attribute(a).must_equal nil
+    n.add_attribute(a).must_be_nil
     n.associations[:attributes].must_equal []
-    n.remove_attribute(a).must_equal nil
+    n.remove_attribute(a).must_be_nil
     n.associations[:attributes].must_equal []
   end
 
@@ -1506,6 +1510,7 @@ describe Sequel::Model, "one_to_many" do
   
   it "should support a :dataset option that is used instead of the default" do
     c1 = @c1
+    @c1.dataset = @c1.dataset.with_fetch({})
     @c2.one_to_many :all_other_attributes, :class => @c1, :dataset=>proc{c1.exclude(:nodeid=>pk)}, :order=>:a, :limit=>10 do |ds|
       ds.filter(:xxx => 5)
     end
@@ -1591,7 +1596,7 @@ describe Sequel::Model, "one_to_many" do
     att.associations[:node] = n
     att.node.must_equal n
     n.remove_attribute(att)
-    att.node.must_equal nil
+    att.node.must_be_nil
   end
 
   it "should not create the add_, remove_, or remove_all_ methods if :read_only option is used" do
@@ -1682,7 +1687,7 @@ describe Sequel::Model, "one_to_many" do
     @c2.one_to_many :attributes, :class => @c1
     attrib = @c1.new(:id=>3)
     node = @c2.new(:id => 1234)
-    @c1.dataset._fetch = [[], [{:id=>3, :node_id=>1234}]]
+    @c1.dataset = @c1.dataset.with_fetch([[], [{:id=>3, :node_id=>1234}]])
     node.attributes.must_equal []
     node.add_attribute(attrib)
     node.associations[:attributes].must_equal [attrib]
@@ -1691,22 +1696,22 @@ describe Sequel::Model, "one_to_many" do
 
   it "remove_all should return nil if the cache is not populated" do
     @c2.one_to_many :attributes, :class => @c1
-    @c2.new(:id => 1234).remove_all_attributes.must_equal nil
+    @c2.new(:id => 1234).remove_all_attributes.must_be_nil
   end
 
   it "remove_all should remove the current item from all reciprocal association caches if they are populated" do
     @c2.one_to_many :attributes, :class => @c1
     @c1.many_to_one :node, :class => @c2
-    @c2.dataset._fetch = []
-    @c1.dataset._fetch = [[], [{:id=>3, :node_id=>1234}]]
+    @c2.dataset = @c2.dataset.with_fetch([])
+    @c1.dataset = @c1.dataset.with_fetch([[], [{:id=>3, :node_id=>1234}]])
     attrib = @c1.new(:id=>3)
     node = @c2.load(:id => 1234)
     node.attributes.must_equal []
-    attrib.node.must_equal nil
+    attrib.node.must_be_nil
     node.add_attribute(attrib)
     attrib.associations[:node].must_equal node 
     node.remove_all_attributes
-    attrib.associations.fetch(:node, 2).must_equal nil
+    attrib.associations.fetch(:node, 2).must_be_nil
   end
 
   it "should call an _add_ method internally to add attributes" do
@@ -1847,7 +1852,7 @@ describe Sequel::Model, "one_to_many" do
         v.each{|x| model::Foo << x.pk}
       end
     end
-    @c1.dataset._fetch = [{:id=>20}, {:id=>30}]
+    @c1.dataset = @c1.dataset.with_fetch([{:id=>20}, {:id=>30}])
     p = @c2.load(:id=>10, :parent_id=>20)
     attributes = p.attributes
     h.must_equal [[10, [20, 30]], 20, 30]
@@ -1879,11 +1884,11 @@ describe Sequel::Model, "one_to_many" do
     def p._add_attribute; raise; end
     def p._remove_attribute; raise; end
     p.associations[:attributes] = []
-    p.add_attribute(c).must_equal nil
+    p.add_attribute(c).must_be_nil
     p.attributes.must_equal []
     p.associations[:attributes] = [c]
     def p.br(c) false end
-    p.remove_attribute(c).must_equal nil
+    p.remove_attribute(c).must_be_nil
     p.attributes.must_equal [c]
   end
 
@@ -1912,11 +1917,11 @@ describe Sequel::Model, "one_to_many" do
     def p._add_attribute; raise; end
     def p._remove_attribute; raise; end
     p.associations[:attributes] = []
-    p.add_attribute(c).must_equal nil
+    p.add_attribute(c).must_be_nil
     p.attributes.must_equal []
     p.associations[:attributes] = [c]
     def p.br(o); cancel_action; end
-    p.remove_attribute(c).must_equal nil
+    p.remove_attribute(c).must_be_nil
     p.attributes.must_equal [c]
   end
 
@@ -1945,9 +1950,9 @@ describe Sequel::Model, "many_to_many" do
       columns :id, :x
     end
     @dataset = @c2.dataset
-    @c1.dataset.autoid = 1
+    @c1.dataset = @c1.dataset.with_autoid(1)
 
-    [@c1, @c2].each{|c| c.dataset._fetch = {}}
+    [@c1, @c2].each{|c| c.dataset = c.dataset.with_fetch({})}
     DB.reset
   end
 
@@ -2181,7 +2186,7 @@ describe Sequel::Model, "many_to_many" do
     
     n = @c2.load(:id => 1234)
     a = @c1.load(:id => 2345)
-    @c1.dataset._fetch = {:id=>2345}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>2345)
     n.add_attribute(2345).must_equal a
     sqls = DB.sqls
     ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 2345)',
@@ -2193,7 +2198,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
     
     n = @c2.load(:id => 1234)
-    @c1.dataset._fetch = []
+    @c1.dataset = @c1.dataset.with_fetch([])
     proc{n.add_attribute(2345)}.must_raise(Sequel::NoMatchingRow)
     DB.sqls.must_equal ["SELECT * FROM attributes WHERE id = 2345"]
   end
@@ -2202,7 +2207,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
     
     n = @c2.load(:id => 1234)
-    @c1.dataset._fetch = @c1.instance_dataset._fetch = {:id=>1}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1)
     n.add_attribute(:id => 1).must_equal @c1.load(:id => 1)
     sqls = DB.sqls
     ['INSERT INTO attributes_nodes (node_id, attribute_id) VALUES (1234, 1)',
@@ -2228,7 +2233,7 @@ describe Sequel::Model, "many_to_many" do
   it "should accept a primary key for the remove_ method and remove an existing record" do
     @c2.many_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
-    @c1.dataset._fetch = {:id=>234}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>234)
     n.remove_attribute(234).must_equal @c1.load(:id => 234)
     DB.sqls.must_equal ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (attributes.id = 234)) LIMIT 1",
       "DELETE FROM attributes_nodes WHERE ((node_id = 1234) AND (attribute_id = 234))"]
@@ -2287,10 +2292,10 @@ describe Sequel::Model, "many_to_many" do
   
   it "should have the add_ method respect composite keys" do
     @c2.many_to_many :attributes, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :z]
+    @c1.dataset = @c1.dataset.with_fetch(:id=>2345, :z=>8)
     @c1.set_primary_key [:id, :z]
     n = @c2.load(:id => 1234, :x=>5)
     a = @c1.load(:id => 2345, :z=>8)
-    @c1.dataset._fetch = {:id => 2345, :z=>8}
     n.add_attribute([2345, 8]).must_equal a
     sqls = DB.sqls
     sqls.shift.must_match(/SELECT \* FROM attributes WHERE \(\((id|z) = (8|2345)\) AND \((id|z) = (8|2345)\)\) LIMIT 1/)
@@ -2316,10 +2321,10 @@ describe Sequel::Model, "many_to_many" do
   end
 
   it "should accept a array of composite primary key values for the remove_ method and remove an existing record" do
+    @c1.dataset = @c1.dataset.with_fetch(:id=>234, :y=>8)
     @c1.set_primary_key [:id, :y]
     @c2.many_to_many :attributes, :class => @c1
     n = @c2.new(:id => 1234)
-    @c1.dataset._fetch = {:id=>234, :y=>8}
     @c1.load(:id => 234, :y=>8).must_equal n.remove_attribute([234, 8])
     sqls = DB.sqls
     ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1234) AND (attributes.id = 234) AND (attributes.y = 8)) LIMIT 1",
@@ -2342,7 +2347,7 @@ describe Sequel::Model, "many_to_many" do
     n = @c1.new
     a = @c2.load(:id=>123)
     n.new?.must_equal true
-    @c1.dataset._fetch = {:id=>1}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1)
     a.add_attribute(n)
     n.new?.must_equal false
   end
@@ -2369,7 +2374,7 @@ describe Sequel::Model, "many_to_many" do
     n = @c1.new
     a = @c2.load(:id=>123)
     def n.validate() errors.add(:id, 'foo') end
-    @c1.dataset._fetch = {:id=>1}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>1)
     a.add_attribute(n)
     n.new?.must_equal false
   end
@@ -2514,7 +2519,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1
     attrib = @c1.load(:id=>3)
     node = @c2.load(:id => 1234)
-    @c1.dataset._fetch = []
+    @c1.dataset = @c1.dataset.with_fetch([])
     node.attributes.must_equal []
     node.add_attribute(attrib)
     node.associations[:attributes].must_equal [attrib]
@@ -2523,14 +2528,14 @@ describe Sequel::Model, "many_to_many" do
 
   it "remove_all should return nil if the cached instance variable does not exist" do
     @c2.many_to_many :attributes, :class => @c1
-    @c2.new(:id => 1234).remove_all_attributes.must_equal nil
+    @c2.new(:id => 1234).remove_all_attributes.must_be_nil
   end
 
   it "remove_all should remove the current item from all reciprocal instance varaibles if it cached instance variable exists" do
     @c2.many_to_many :attributes, :class => @c1
     @c1.many_to_many :nodes, :class => @c2
-    @c1.dataset._fetch = []
-    @c2.dataset._fetch = []
+    @c1.dataset = @c1.dataset.with_fetch([])
+    @c2.dataset = @c2.dataset.with_fetch([])
     attrib = @c1.load(:id=>3)
     node = @c2.new(:id => 1234)
     node.attributes.must_equal []
@@ -2689,7 +2694,7 @@ describe Sequel::Model, "many_to_many" do
         v.each{|x| model::Foo << x.pk}
       end
     end
-    @c1.dataset._fetch = [{:id=>20}, {:id=>30}]
+    @c1.dataset = @c1.dataset.with_fetch([{:id=>20}, {:id=>30}])
     p = @c2.load(:id=>10, :parent_id=>20)
     attributes = p.attributes
     h.must_equal [[10, [20, 30]], 20, 30]
@@ -2722,11 +2727,11 @@ describe Sequel::Model, "many_to_many" do
     def p._add_attribute; raise; end
     def p._remove_attribute; raise; end
     p.associations[:attributes] = []
-    p.add_attribute(c).must_equal nil
+    p.add_attribute(c).must_be_nil
     p.attributes.must_equal []
     p.associations[:attributes] = [c]
     def p.br(c) false end
-    p.remove_attribute(c).must_equal nil
+    p.remove_attribute(c).must_be_nil
     p.attributes.must_equal [c]
   end
 
@@ -2756,17 +2761,17 @@ describe Sequel::Model, "many_to_many" do
     def p._add_attribute; raise; end
     def p._remove_attribute; raise; end
     p.associations[:attributes] = []
-    p.add_attribute(c).must_equal nil
+    p.add_attribute(c).must_be_nil
     p.attributes.must_equal []
     p.associations[:attributes] = [c]
     def p.br(o) cancel_action end
-    p.remove_attribute(c).must_equal nil
+    p.remove_attribute(c).must_be_nil
     p.attributes.must_equal [c]
   end
 
   it "should support a :uniq option that removes duplicates from the association" do
     @c2.many_to_many :attributes, :class => @c1, :uniq=>true
-    @c1.dataset._fetch = [{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}]
+    @c1.dataset = @c1.dataset.with_fetch([{:id=>20}, {:id=>30}, {:id=>20}, {:id=>30}])
     @c2.load(:id=>10, :parent_id=>20).attributes.must_equal [@c1.load(:id=>20), @c1.load(:id=>30)]
   end
   
@@ -2787,7 +2792,7 @@ describe Sequel::Model, "many_to_many" do
     @c2.many_to_many :attributes, :class => @c1 do |ds|
       ds.filter(:join_table_att=>3)
     end
-    @c1.dataset._fetch = {:id=>2}
+    @c1.dataset = @c1.dataset.with_fetch(:id=>2)
     @c2.load(:id=>1).remove_attribute(2)
     DB.sqls.must_equal ["SELECT attributes.* FROM attributes INNER JOIN attributes_nodes ON (attributes_nodes.attribute_id = attributes.id) WHERE ((attributes_nodes.node_id = 1) AND (join_table_att = 3) AND (attributes.id = 2)) LIMIT 1",
       "DELETE FROM attributes_nodes WHERE ((node_id = 1) AND (attribute_id = 2))"] 
@@ -2818,9 +2823,9 @@ describe Sequel::Model, "one_through_one" do
       columns :id, :x
     end
     @dataset = @c2.dataset
-    @c1.dataset.autoid = 1
+    @c1.dataset = @c1.dataset.with_autoid(1)
 
-    [@c1, @c2].each{|c| c.dataset._fetch = {}}
+    [@c1, @c2].each{|c| c.dataset = c.dataset.with_fetch({})}
     DB.reset
   end
   after do
@@ -2873,7 +2878,7 @@ describe Sequel::Model, "one_through_one" do
   
   it "should not issue query if not all keys have values" do
     @c2.one_through_one :attribute, :class => @c1, :left_key=>[:l1, :l2], :right_key=>[:r1, :r2], :left_primary_key=>[:id, :x], :right_primary_key=>[:id, :y]
-    @c2.load(:id => 1234, :x=>nil).attribute.must_equal nil
+    @c2.load(:id => 1234, :x=>nil).attribute.must_be_nil
     DB.sqls.must_equal []
   end
   
@@ -3022,7 +3027,7 @@ describe Sequel::Model, "one_through_one" do
         model::Foo << v.pk
       end
     end
-    @c1.dataset._fetch = [{:id=>20}]
+    @c1.dataset = @c1.dataset.with_fetch([{:id=>20}])
     p = @c2.load(:id=>10, :parent_id=>20)
     attribute = p.attribute
     h.must_equal [[10, 20], 20]
@@ -4493,9 +4498,9 @@ describe "Model#freeze" do
   end
 
   it "should not break associations getters" do
-    Album::B.dataset._fetch = {:album_id=>1, :id=>2}
+    Album::B.dataset = Album::B.dataset.with_fetch(:album_id=>1, :id=>2)
     @o.b.must_equal Album::B.load(:id=>2, :album_id=>1)
-    @o.associations[:b].must_equal nil
+    @o.associations[:b].must_be_nil
 
     @o = @o.dup
     @o.b.must_equal Album::B.load(:id=>2, :album_id=>1)
@@ -4505,7 +4510,7 @@ describe "Model#freeze" do
   it "should not break reciprocal associations" do
     b = Album::B.load(:id=>2, :album_id=>nil)
     b.album = @o
-    @o.associations[:b].must_equal nil
+    @o.associations[:b].must_be_nil
 
     @o = @o.dup
     b = Album::B.load(:id=>2, :album_id=>nil)
@@ -4518,7 +4523,7 @@ describe "association autoreloading" do
   before do
     @c = Class.new(Sequel::Model)
     @Artist = Class.new(@c).set_dataset(:artists)
-    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
+    @Artist.dataset = @Artist.dataset.with_fetch(:id=>2, :name=>'Ar')
     @Album = Class.new(@c).set_dataset(:albums)
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id