sequel 3.21.0 → 3.36.0

data/spec/model/record_spec.rb

@@ -1,36 +1,23 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Model#save server use" do
-  
-  before(:each) do
-    @c = Class.new(Sequel::Model(:items)) do
-      columns :id, :x, :y
-    end
-    @c.db = MockDatabase.new
-    db2 = @db2 = MockDatabase.new
-    @c.class_eval do
-      define_method(:after_save) do
-        model.db = db2
-        ds = model.dataset
-        def ds.fetch_rows(sql)
-          yield @db.execute(sql, @opts[:server])
-        end
-        @this = nil
-      end
-    end
+  before do
+    @db = Sequel.mock(:autoid=>proc{|sql| 10}, :fetch=>{:x=>1, :id=>10}, :servers=>{:blah=>{}, :read_only=>{}})
+    @c = Class.new(Sequel::Model(@db[:items]))
+    @c.columns :id, :x, :y
+    @c.dataset.columns(:id, :x, :y)
+    @db.sqls
   end
 
   it "should use the :default server if the model doesn't have one already specified" do
-    @c.db.should_receive(:execute).with("INSERT INTO items (x) VALUES (1)").and_return(10)
-    @db2.should_receive(:execute).with('SELECT * FROM items WHERE (id = 10) LIMIT 1', :default).and_return(:x=>1, :id=>10)
-    @c.new(:x=>1).save
+    @c.new(:x=>1).save.should == @c.load(:x=>1, :id=>10)
+    @db.sqls.should == ["INSERT INTO items (x) VALUES (1)", 'SELECT * FROM items WHERE (id = 10) LIMIT 1']
   end
 
   it "should use the model's server if the model has one already specified" do
     @c.dataset = @c.dataset.server(:blah)
-    @c.db.should_receive(:execute).with("INSERT INTO items (x) VALUES (1)").and_return(10)
-    @db2.should_receive(:execute).with('SELECT * FROM items WHERE (id = 10) LIMIT 1', :blah).and_return(:x=>1, :id=>10)
-    @c.new(:x=>1).save
+    @c.new(:x=>1).save.should == @c.load(:x=>1, :id=>10)
+    @db.sqls.should == ["INSERT INTO items (x) VALUES (1) -- blah", 'SELECT * FROM items WHERE (id = 10) LIMIT 1 -- blah']
   end
 end
 
@@ -39,32 +26,37 @@ describe "Model#save" do
     @c = Class.new(Sequel::Model(:items)) do
       columns :id, :x, :y
     end
-    @c.dataset.meta_def(:insert){|h| super(h); 1}
+    @c.instance_dataset.autoid = @c.dataset.autoid = 13
     MODEL_DB.reset
   end
   
   it "should insert a record for a new model instance" do
     o = @c.new(:x => 1)
     o.save
-    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)",
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 13) LIMIT 1"]
   end
 
   it "should use dataset's insert_select method if present" do
-    ds = @c.dataset = @c.dataset.clone
+    ds = @c.instance_dataset
+    ds._fetch = {:y=>2}
+    def ds.supports_insert_select?() true end
     def ds.insert_select(hash)
-      execute("INSERT INTO items (y) VALUES (2)")
-      {:y=>2}
+      execute("INSERT INTO items (y) VALUES (2) RETURNING *"){|r| return r}
     end
     o = @c.new(:x => 1)
     o.save
     
     o.values.should == {:y=>2}
-    MODEL_DB.sqls.should == ["INSERT INTO items (y) VALUES (2)"]
+    MODEL_DB.sqls.should == ["INSERT INTO items (y) VALUES (2) RETURNING *"]
+  end
+
+  it "should not use dataset's insert_select method if specific columns are selected" do
+    ds = @c.dataset = @c.dataset.select(:y)
+    ds.should_not_receive(:insert_select)
+    @c.new(:x => 1).save
   end
 
   it "should use value returned by insert as the primary key and refresh the object" do
-    @c.dataset.meta_def(:insert){|h| super(h); 13}
     o = @c.new(:x => 11)
     o.save
     MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (11)",
@@ -72,14 +64,12 @@ describe "Model#save" do
   end
 
   it "should allow you to skip refreshing by overridding _save_refresh" do
-    @c.dataset.meta_def(:insert){|h| super(h); 13}
     @c.send(:define_method, :_save_refresh){}
     @c.create(:x => 11)
     MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (11)"]
   end
 
   it "should work correctly for inserting a record without a primary key" do
-    @c.dataset.meta_def(:insert){|h| super(h); 13}
     @c.no_primary_key
     o = @c.new(:x => 11)
     o.save
@@ -87,15 +77,15 @@ describe "Model#save" do
   end
 
   it "should set the autoincrementing_primary_key value to the value returned by insert" do
-    @c.dataset.meta_def(:insert){|h| super(h); 13}
     @c.unrestrict_primary_key
     @c.set_primary_key [:x, :y]
     o = @c.new(:x => 11)
     o.meta_def(:autoincrementing_primary_key){:y}
     o.save
-    MODEL_DB.sqls.length.should == 2
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (11)"
-    MODEL_DB.sqls.last.should =~ %r{SELECT \* FROM items WHERE \(\([xy] = 1[13]\) AND \([xy] = 1[13]\)\) LIMIT 1}
+    sqls = MODEL_DB.sqls
+    sqls.length.should == 2
+    sqls.first.should == "INSERT INTO items (x) VALUES (11)"
+    sqls.last.should =~ %r{SELECT \* FROM items WHERE \(\([xy] = 1[13]\) AND \([xy] = 1[13]\)\) LIMIT 1}
   end
 
   it "should update a record for an existing model instance" do
@@ -106,17 +96,18 @@ describe "Model#save" do
   
   it "should raise a NoExistingObject exception if the dataset update call doesn't return 1, unless require_modification is false" do
     o = @c.load(:id => 3, :x => 1)
-    o.this.meta_def(:update){|*a| 0}
+    t = o.this
+    t.numrows = 0
     proc{o.save}.should raise_error(Sequel::NoExistingObject)
-    o.this.meta_def(:update){|*a| 2}
+    t.numrows = 2
     proc{o.save}.should raise_error(Sequel::NoExistingObject)
-    o.this.meta_def(:update){|*a| 1}
+    t.numrows = 1
     proc{o.save}.should_not raise_error
     
     o.require_modification = false
-    o.this.meta_def(:update){|*a| 0}
+    t.numrows = 0
     proc{o.save}.should_not raise_error
-    o.this.meta_def(:update){|*a| 2}
+    t.numrows = 2
     proc{o.save}.should_not raise_error
   end
   
@@ -185,22 +176,18 @@ describe "Model#save" do
     @c.use_transactions = true
     @c.load(:id => 3, :x => 1, :y => nil).save(:y)
     MODEL_DB.sqls.should == ["BEGIN", "UPDATE items SET y = NULL WHERE (id = 3)", "COMMIT"]
-    MODEL_DB.reset
     @c.use_transactions = false
     @c.load(:id => 3, :x => 1, :y => nil).save(:y)
     MODEL_DB.sqls.should == ["UPDATE items SET y = NULL WHERE (id = 3)"]
-    MODEL_DB.reset
   end
 
   it "should inherit Model's use_transactions setting" do
     @c.use_transactions = true
     Class.new(@c).load(:id => 3, :x => 1, :y => nil).save(:y)
     MODEL_DB.sqls.should == ["BEGIN", "UPDATE items SET y = NULL WHERE (id = 3)", "COMMIT"]
-    MODEL_DB.reset
     @c.use_transactions = false
     Class.new(@c).load(:id => 3, :x => 1, :y => nil).save(:y)
     MODEL_DB.sqls.should == ["UPDATE items SET y = NULL WHERE (id = 3)"]
-    MODEL_DB.reset
   end
 
   it "should use object's use_transactions setting" do
@@ -209,13 +196,11 @@ describe "Model#save" do
     @c.use_transactions = true
     o.save(:y)
     MODEL_DB.sqls.should == ["UPDATE items SET y = NULL WHERE (id = 3)"]
-    MODEL_DB.reset
     o = @c.load(:id => 3, :x => 1, :y => nil)
     o.use_transactions = true
     @c.use_transactions = false 
     o.save(:y)
     MODEL_DB.sqls.should == ["BEGIN", "UPDATE items SET y = NULL WHERE (id = 3)", "COMMIT"]
-    MODEL_DB.reset
   end
 
   it "should use :transaction option if given" do
@@ -223,12 +208,10 @@ describe "Model#save" do
     o.use_transactions = true
     o.save(:y, :transaction=>false)
     MODEL_DB.sqls.should == ["UPDATE items SET y = NULL WHERE (id = 3)"]
-    MODEL_DB.reset
     o = @c.load(:id => 3, :x => 1, :y => nil)
     o.use_transactions = false
     o.save(:y, :transaction=>true)
     MODEL_DB.sqls.should == ["BEGIN", "UPDATE items SET y = NULL WHERE (id = 3)", "COMMIT"]
-    MODEL_DB.reset
   end
 
   it "should rollback if before_save returns false and raise_on_save_failure = true" do
@@ -240,7 +223,6 @@ describe "Model#save" do
     end
     proc { o.save(:y) }.should raise_error(Sequel::BeforeHookFailed)
     MODEL_DB.sqls.should == ["BEGIN", "ROLLBACK"]
-    MODEL_DB.reset
   end
 
   it "should rollback if before_save returns false and :raise_on_failure option is true" do
@@ -252,7 +234,6 @@ describe "Model#save" do
     end
     proc { o.save(:y, :raise_on_failure => true) }.should raise_error(Sequel::BeforeHookFailed)
     MODEL_DB.sqls.should == ["BEGIN", "ROLLBACK"]
-    MODEL_DB.reset
   end
 
   it "should not rollback outer transactions if before_save returns false and raise_on_save_failure = false" do
@@ -267,7 +248,6 @@ describe "Model#save" do
       MODEL_DB.run "BLAH"
     end
     MODEL_DB.sqls.should == ["BEGIN", "BLAH", "COMMIT"]
-    MODEL_DB.reset
   end
 
   it "should rollback if before_save returns false and raise_on_save_failure = false" do
@@ -279,7 +259,6 @@ describe "Model#save" do
     end
     o.save(:y).should == nil
     MODEL_DB.sqls.should == ["BEGIN", "ROLLBACK"]
-    MODEL_DB.reset
   end
 
   it "should not rollback if before_save throws Rollback and use_transactions = false" do
@@ -290,7 +269,118 @@ describe "Model#save" do
     end
     proc { o.save(:y) }.should raise_error(Sequel::Rollback)
     MODEL_DB.sqls.should == []
-    MODEL_DB.reset
+  end
+
+  it "should support a :server option to set the server/shard to use" do
+    db = Sequel.mock(:fetch=>{:id=>13, :x=>1}, :autoid=>proc{13}, :numrows=>1, :servers=>{:s1=>{}})
+    c = Class.new(Sequel::Model(db[:items]))
+    c.columns :id, :x
+    db.sqls
+    o = c.new(:x => 1)
+    o.save(:server=>:s1)
+    db.sqls.should == ["INSERT INTO items (x) VALUES (1) -- s1", "SELECT * FROM items WHERE (id = 13) LIMIT 1 -- s1"]
+    o.save(:server=>:s1, :transaction=>true)
+    db.sqls.should == ["BEGIN -- s1", "UPDATE items SET x = 1 WHERE (id = 13) -- s1", 'COMMIT -- s1']
+  end
+end
+
+describe "Model#set_server" do
+  before do
+    @db = Sequel.mock(:fetch=>{:id=>13, :x=>1}, :autoid=>proc{13}, :numrows=>1, :servers=>{:s1=>{}})
+    @c = Class.new(Sequel::Model(@db[:items])) do
+      columns :id, :x
+    end
+    @db.sqls
+  end
+
+  it "should set the server to use when inserting" do
+    @c.new(:x => 1).set_server(:s1).save
+    @db.sqls.should == ["INSERT INTO items (x) VALUES (1) -- s1", "SELECT * FROM items WHERE (id = 13) LIMIT 1 -- s1"]
+  end
+
+  it "should set the server to use when updating" do
+     @c.load(:id=>13, :x => 1).set_server(:s1).save
+    @db.sqls.should == ["UPDATE items SET x = 1 WHERE (id = 13) -- s1"]
+  end
+
+  it "should set the server to use for transactions when saving" do
+    @c.load(:id=>13, :x => 1).set_server(:s1).save(:transaction=>true)
+    @db.sqls.should == ["BEGIN -- s1", "UPDATE items SET x = 1 WHERE (id = 13) -- s1", 'COMMIT -- s1']
+  end
+
+  it "should set the server to use when deleting" do
+    @c.load(:id=>13).set_server(:s1).delete
+    @db.sqls.should == ["DELETE FROM items WHERE (id = 13) -- s1"]
+  end
+
+  it "should set the server to use for transactions when destroying" do
+    o = @c.load(:id=>13).set_server(:s1)
+    o.use_transactions = true
+    o.destroy
+    @db.sqls.should == ["BEGIN -- s1", "DELETE FROM items WHERE (id = 13) -- s1", 'COMMIT -- s1']
+  end
+
+  it "should set the server on this if this is already loaded" do
+    o = @c.load(:id=>13, :x => 1)
+    o.this
+    o.set_server(:s1)
+    o.this.opts[:server].should == :s1
+  end
+
+  it "should set the server on this if this is not already loaded" do
+    @c.load(:id=>13, :x => 1).set_server(:s1).this.opts[:server].should == :s1
+  end
+end
+
+describe "Model#freeze" do
+  before do
+    class ::Album < Sequel::Model
+      columns :id
+      class B < Sequel::Model
+        columns :id, :album_id
+      end
+    end
+    @o = Album.load(:id=>1).freeze
+    MODEL_DB.sqls
+  end
+  after do
+    Object.send(:remove_const, :Album)
+  end
+
+  it "should freeze the object" do
+    @o.frozen?.should be_true
+  end
+
+  it "should freeze the object's values, associations, changed_columns, errors, and this" do
+    @o.values.frozen?.should be_true
+    @o.changed_columns.frozen?.should be_true
+    @o.errors.frozen?.should be_true
+    @o.this.frozen?.should be_true
+  end
+
+  it "should still have working class attr overriddable methods" do
+    Sequel::Model::BOOLEAN_SETTINGS.each{|m| @o.send(m) == Album.send(m)}
+  end
+
+  it "should have working new? method" do
+    @o.new?.should be_false
+    Album.new.freeze.new?.should be_true
+  end
+
+  it "should have working valid? method" do
+    @o.valid?.should be_true
+    o = Album.new
+    def o.validate() errors.add(:foo, '') end
+    o.freeze
+    o.valid?.should be_false
+  end
+
+  it "should raise an Error if trying to save/destroy/delete/refresh" do
+    proc{@o.save}.should raise_error(Sequel::Error)
+    proc{@o.destroy}.should raise_error(Sequel::Error)
+    proc{@o.delete}.should raise_error(Sequel::Error)
+    proc{@o.refresh}.should raise_error(Sequel::Error)
+    @o.db.sqls.should == []
   end
 end
 
@@ -299,7 +389,6 @@ describe "Model#marshallable" do
     class ::Album < Sequel::Model
       columns :id, :x
     end
-    Album.dataset.meta_def(:insert){|h| super(h); 1}
   end
   after do
     Object.send(:remove_const, :Album)
@@ -381,7 +470,6 @@ describe "Model#modified[!?]" do
 end
 
 describe "Model#save_changes" do
-  
   before do
     @c = Class.new(Sequel::Model(:items)) do
       unrestrict_primary_key
@@ -426,15 +514,14 @@ describe "Model#save_changes" do
     MODEL_DB.sqls.should == ["UPDATE items SET x = 2 WHERE (id = 3)"]
     o.save_changes
     o.save_changes
-    MODEL_DB.sqls.should == ["UPDATE items SET x = 2 WHERE (id = 3)"]
-    MODEL_DB.reset
+    MODEL_DB.sqls.should == []
 
     o.y = 4
     o.save_changes
     MODEL_DB.sqls.should == ["UPDATE items SET y = 4 WHERE (id = 3)"]
     o.save_changes
     o.save_changes
-    MODEL_DB.sqls.should == ["UPDATE items SET y = 4 WHERE (id = 3)"]
+    MODEL_DB.sqls.should == []
   end
   
   it "should not consider columns changed if the values did not change" do
@@ -446,7 +533,6 @@ describe "Model#save_changes" do
     o.x = 3
     o.save_changes
     MODEL_DB.sqls.should == ["UPDATE items SET x = 3 WHERE (id = 3)"]
-    MODEL_DB.reset
 
     o[:y] = nil
     o.save_changes
@@ -472,13 +558,11 @@ describe "Model#save_changes" do
     o.x = 2
     o.save_changes
     MODEL_DB.sqls.should == ["UPDATE items SET x = 3 WHERE (id = 3)"]
-    MODEL_DB.reset
     o.save_changes
     MODEL_DB.sqls.should == []
     o.x = 4
     o.save_changes
     MODEL_DB.sqls.should == ["UPDATE items SET x = 5 WHERE (id = 3)"]
-    MODEL_DB.reset
   end
 
   it "should update columns changed in a before_save hook" do
@@ -489,25 +573,21 @@ describe "Model#save_changes" do
     o.x = 2
     o.save_changes
     MODEL_DB.sqls.should == ["UPDATE items SET x = 3 WHERE (id = 3)"]
-    MODEL_DB.reset
     o.save_changes
     MODEL_DB.sqls.should == []
     o.x = 4
     o.save_changes
     MODEL_DB.sqls.should == ["UPDATE items SET x = 5 WHERE (id = 3)"]
-    MODEL_DB.reset
   end
 end
 
 describe "Model#new?" do
-  
-  before(:each) do
-    MODEL_DB.reset
-
+  before do
     @c = Class.new(Sequel::Model(:items)) do
       unrestrict_primary_key
       columns :x
     end
+    MODEL_DB.reset
   end
   
   it "should be true for a new instance" do
@@ -523,74 +603,65 @@ describe "Model#new?" do
 end
 
 describe Sequel::Model, "w/ primary key" do
-  
   it "should default to ':id'" do
     model_a = Class.new Sequel::Model
-    model_a.primary_key.should be_equal(:id)
+    model_a.primary_key.should == :id
   end
 
   it "should be changed through 'set_primary_key'" do
-    model_a = Class.new(Sequel::Model) { set_primary_key :a }
-    model_a.primary_key.should be_equal(:a)
+    model_a = Class.new(Sequel::Model){ set_primary_key :a }
+    model_a.primary_key.should == :a
   end
 
   it "should support multi argument composite keys" do
-    model_a = Class.new(Sequel::Model) { set_primary_key :a, :b }
-    model_a.primary_key.should be_eql([:a, :b])
+    model_a = Class.new(Sequel::Model){ set_primary_key :a, :b }
+    model_a.primary_key.should == [:a, :b]
   end
 
   it "should accept single argument composite keys" do
-    model_a = Class.new(Sequel::Model) { set_primary_key [:a, :b] }
-    model_a.primary_key.should be_eql([:a, :b])
+    model_a = Class.new(Sequel::Model){ set_primary_key [:a, :b] }
+    model_a.primary_key.should == [:a, :b]
   end
-  
 end
 
 describe Sequel::Model, "w/o primary key" do
   it "should return nil for primary key" do
-    Class.new(Sequel::Model) { no_primary_key }.primary_key.should be_nil
+    Class.new(Sequel::Model){no_primary_key}.primary_key.should be_nil
   end
 
   it "should raise a Sequel::Error on 'this'" do
-    instance = Class.new(Sequel::Model) { no_primary_key }.new
-    proc { instance.this }.should raise_error(Sequel::Error)
+    instance = Class.new(Sequel::Model){no_primary_key}.new
+    proc{instance.this}.should raise_error(Sequel::Error)
   end
 end
 
 describe Sequel::Model, "with this" do
-
-  before { @example = Class.new Sequel::Model(:examples); @example.columns :id, :a, :x, :y }
+  before do
+    @example = Class.new(Sequel::Model(:examples))
+    @example.columns :id, :a, :x, :y
+  end
 
   it "should return a dataset identifying the record" do
-    instance = @example.load :id => 3
-    instance.this.sql.should be_eql("SELECT * FROM examples WHERE (id = 3) LIMIT 1")
+    instance = @example.load(:id => 3)
+    instance.this.sql.should == "SELECT * FROM examples WHERE (id = 3) LIMIT 1"
   end
 
   it "should support arbitary primary keys" do
     @example.set_primary_key :a
 
-    instance = @example.load :a => 3
-    instance.this.sql.should be_eql("SELECT * FROM examples WHERE (a = 3) LIMIT 1")
+    instance = @example.load(:a => 3)
+    instance.this.sql.should == "SELECT * FROM examples WHERE (a = 3) LIMIT 1"
   end
 
   it "should support composite primary keys" do
     @example.set_primary_key :x, :y
-    instance = @example.load :x => 4, :y => 5
-
-    parts = [
-      'SELECT * FROM examples WHERE %s LIMIT 1',
-      '((x = 4) AND (y = 5))', 
-      '((y = 5) AND (x = 4))'
-    ].map { |expr| Regexp.escape expr }
-    regexp = Regexp.new parts.first % "(?:#{parts[1]}|#{parts[2]})"
-
-    instance.this.sql.should match(regexp)
+    instance = @example.load(:x => 4, :y => 5)
+    instance.this.sql.should =~ /SELECT \* FROM examples WHERE \(\([xy] = [45]\) AND \([xy] = [45]\)\) LIMIT 1/
   end
-
 end
 
 describe "Model#pk" do
-  before(:each) do
+  before do
     @m = Class.new(Sequel::Model)
     @m.columns :id, :x, :y
   end
@@ -624,7 +695,7 @@ describe "Model#pk" do
 end
 
 describe "Model#pk_hash" do
-  before(:each) do
+  before do
     @m = Class.new(Sequel::Model)
     @m.columns :id, :x, :y
   end
@@ -659,16 +730,14 @@ end
 
 describe Sequel::Model, "#set" do
   before do
-    MODEL_DB.reset
-    
     @c = Class.new(Sequel::Model(:items)) do
       set_primary_key :id
       columns :x, :y, :id
     end
     @c.strict_param_setting = false
-    @c.instance_variable_set(:@columns, true)
     @o1 = @c.new
     @o2 = @c.load(:id => 5)
+    MODEL_DB.reset
   end
 
   it "should filter the given params using the model columns" do
@@ -716,6 +785,29 @@ describe Sequel::Model, "#set" do
     MODEL_DB.sqls.should == []
   end
 
+  it "should raise error if strict_param_setting is true and method does not exist" do
+    @o1.strict_param_setting = true
+    proc{@o1.set('foo' => 1)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise error if strict_param_setting is true and column is a primary key" do
+    @o1.strict_param_setting = true
+    proc{@o1.set('id' => 1)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise error if strict_param_setting is true and column is restricted" do
+    @o1.strict_param_setting = true
+    @c.set_restricted_columns :x
+    proc{@o1.set('x' => 1)}.should raise_error(Sequel::Error)
+  end
+
+  it "should not create a symbol if strict_param_setting is true and string is given" do
+    @o1.strict_param_setting = true
+    l = Symbol.all_symbols.length
+    proc{@o1.set('sadojafdso' => 1)}.should raise_error(Sequel::Error)
+    Symbol.all_symbols.length.should == l
+  end
+
   it "#set should correctly handle cases where an instance method is added to the class" do
     @o1.set(:x => 1)
     @o1.values.should == {:x => 1}
@@ -739,51 +831,74 @@ describe Sequel::Model, "#set" do
     @o1.set(:x => 2, :z => 3)
     @o1.values.should == {:x => 2, :z=>3}
   end
+
+  it "#set should correctly handle cases where a module with a setter method is included in the class" do
+    @o1.set(:x => 1)
+    @o1.values.should == {:x => 1}
+
+    @c.send(:include, Module.new do
+      def z=(v)
+        self[:z] = v
+      end
+    end)
+    @o1.set(:x => 2, :z => 3)
+    @o1.values.should == {:x => 2, :z=>3}
+  end
+
+  it "#set should correctly handle cases where the object extends a module with a setter method " do
+    @o1.set(:x => 1)
+    @o1.values.should == {:x => 1}
+
+    @o1.extend(Module.new do
+      def z=(v)
+        self[:z] = v
+      end
+    end)
+    @o1.set(:x => 2, :z => 3)
+    @o1.values.should == {:x => 2, :z=>3}
+  end
 end
 
 describe Sequel::Model, "#update" do
   before do
-    MODEL_DB.reset
-    
     @c = Class.new(Sequel::Model(:items)) do
       set_primary_key :id
       columns :x, :y, :id
     end
     @c.strict_param_setting = false
-    @c.instance_variable_set(:@columns, true)
     @o1 = @c.new
     @o2 = @c.load(:id => 5)
+    MODEL_DB.reset
   end
   
   it "should filter the given params using the model columns" do
     @o1.update(:x => 1, :z => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
 
     MODEL_DB.reset
     @o2.update(:y => 1, :abc => 2)
-    MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)"
+    MODEL_DB.sqls.should == ["UPDATE items SET y = 1 WHERE (id = 5)"]
   end
   
   it "should support virtual attributes" do
     @c.send(:define_method, :blah=){|v| self.x = v}
     @o1.update(:blah => 333)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (333)"
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (333)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
   
   it "should not modify the primary key" do
     @o1.update(:x => 1, :id => 2)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
     MODEL_DB.reset
     @o2.update('y'=> 1, 'id'=> 2)
     @o2.values.should == {:y => 1, :id=> 5}
-    MODEL_DB.sqls.first.should == "UPDATE items SET y = 1 WHERE (id = 5)"
+    MODEL_DB.sqls.should == ["UPDATE items SET y = 1 WHERE (id = 5)"]
   end
 end
 
 describe Sequel::Model, "#set_fields" do
   before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = Class.new(Sequel::Model(:items)) do
       set_primary_key :id
       columns :x, :y, :z, :id
     end
@@ -799,15 +914,50 @@ describe Sequel::Model, "#set_fields" do
     @o1.values.should == {:x => 9, :y => 8, :id=>7}
     MODEL_DB.sqls.should == []
   end
+
+  it "should lookup into the hash without checking if the entry exists" do
+    @o1.set_fields({:x => 1}, [:x, :y])
+    @o1.values.should == {:x => 1, :y => nil}
+    @o1.set_fields(Hash.new(2), [:x, :y])
+    @o1.values.should == {:x => 2, :y => 2}
+  end
+
+  it "should skip missing fields if :missing=>:skip option is used" do
+    @o1.set_fields({:x => 3}, [:x, :y], :missing=>:skip)
+    @o1.values.should == {:x => 3}
+    @o1.set_fields({"x" => 4}, [:x, :y], :missing=>:skip)
+    @o1.values.should == {:x => 4}
+    @o1.set_fields(Hash.new(2).merge(:x=>2), [:x, :y], :missing=>:skip)
+    @o1.values.should == {:x => 2}
+    @o1.set_fields({:x => 1, :y => 2, :z=>3, :id=>4}, [:x, :y], :missing=>:skip)
+    @o1.values.should == {:x => 1, :y => 2}
+  end
+
+  it "should raise for missing fields if :missing=>:raise option is used" do
+    proc{@o1.set_fields({:x => 1}, [:x, :y], :missing=>:raise)}.should raise_error(Sequel::Error)
+    proc{@o1.set_fields(Hash.new(2).merge(:x=>2), [:x, :y], :missing=>:raise)}.should raise_error(Sequel::Error)
+    proc{@o1.set_fields({"x" => 1}, [:x, :y], :missing=>:raise)}.should raise_error(Sequel::Error)
+    @o1.set_fields({:x => 5, "y"=>2}, [:x, :y], :missing=>:raise)
+    @o1.values.should == {:x => 5, :y => 2}
+    @o1.set_fields({:x => 1, :y => 3, :z=>3, :id=>4}, [:x, :y], :missing=>:raise)
+    @o1.values.should == {:x => 1, :y => 3}
+  end
+
+  it "should use default behavior for an unrecognized :missing option" do
+    @o1.set_fields({:x => 1, :y => 2, :z=>3, :id=>4}, [:x, :y], :missing=>:foo)
+    @o1.values.should == {:x => 1, :y => 2}
+    @o1.set_fields({:x => 9, :y => 8, :z=>6, :id=>7}, [:x, :y, :id], :missing=>:foo)
+    @o1.values.should == {:x => 9, :y => 8, :id=>7}
+    MODEL_DB.sqls.should == []
+  end
+
 end
 
 describe Sequel::Model, "#update_fields" do
   before do
-    @c = Class.new(Sequel::Model(:items))
-    @c.class_eval do
+    @c = Class.new(Sequel::Model(:items)) do
       set_primary_key :id
       columns :x, :y, :z, :id
-      def _refresh(ds); end
     end
     @c.strict_param_setting = true 
     @o1 = @c.load(:id=>1)
@@ -817,21 +967,28 @@ describe Sequel::Model, "#update_fields" do
   it "should set only the given fields, and then save the changes to the record" do
     @o1.update_fields({:x => 1, :y => 2, :z=>3, :id=>4}, [:x, :y])
     @o1.values.should == {:x => 1, :y => 2, :id=>1}
-    MODEL_DB.sqls.first.should =~ /UPDATE items SET [xy] = [12], [xy] = [12] WHERE \(id = 1\)/
-    MODEL_DB.sqls.length.should == 1
-    MODEL_DB.reset
+    sqls = MODEL_DB.sqls
+    sqls.pop.should =~ /UPDATE items SET [xy] = [12], [xy] = [12] WHERE \(id = 1\)/
+    sqls.should == []
 
     @o1.update_fields({:x => 1, :y => 5, :z=>6, :id=>7}, [:x, :y])
     @o1.values.should == {:x => 1, :y => 5, :id=>1}
     MODEL_DB.sqls.should == ["UPDATE items SET y = 5 WHERE (id = 1)"]
-    MODEL_DB.reset
+  end
+
+  it "should support :missing=>:skip option" do
+    @o1.update_fields({:x => 1, :z=>3, :id=>4}, [:x, :y], :missing=>:skip)
+    @o1.values.should == {:x => 1, :id=>1}
+    MODEL_DB.sqls.should == ["UPDATE items SET x = 1 WHERE (id = 1)"]
+  end
+
+  it "should support :missing=>:raise option" do
+    proc{@o1.update_fields({:x => 1}, [:x, :y], :missing=>:raise)}.should raise_error(Sequel::Error)
   end
 end
 
 describe Sequel::Model, "#(set|update)_(all|except|only)" do
   before do
-    MODEL_DB.reset
-    
     @c = Class.new(Sequel::Model(:items)) do
       set_primary_key :id
       columns :x, :y, :z, :id
@@ -839,8 +996,8 @@ describe Sequel::Model, "#(set|update)_(all|except|only)" do
       set_restricted_columns :y
     end
     @c.strict_param_setting = false
-    @c.instance_variable_set(:@columns, true)
     @o1 = @c.new
+    MODEL_DB.reset
   end
 
   it "should raise errors if not all hash fields can be set and strict_param_setting is true" do
@@ -884,40 +1041,63 @@ describe Sequel::Model, "#(set|update)_(all|except|only)" do
 
   it "#update_all should update all attributes" do
     @c.new.update_all(:x => 1, :id=>4)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-    MODEL_DB.reset
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
     @c.new.update_all(:y => 1, :id=>4)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (y) VALUES (1)"
-    MODEL_DB.reset
+    MODEL_DB.sqls.should == ["INSERT INTO items (y) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
     @c.new.update_all(:z => 1, :id=>4)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (z) VALUES (1)"
+    MODEL_DB.sqls.should == ["INSERT INTO items (z) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "#update_only should only update given attributes" do
     @o1.update_only({:x => 1, :y => 2, :z=>3, :id=>4}, [:x])
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-    MODEL_DB.reset
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
     @c.new.update_only({:x => 1, :y => 2, :z=>3, :id=>4}, :x)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "#update_except should not update given attributes" do
     @o1.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, [:y, :z])
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
-    MODEL_DB.reset
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
     @c.new.update_except({:x => 1, :y => 2, :z=>3, :id=>4}, :y, :z)
-    MODEL_DB.sqls.first.should == "INSERT INTO items (x) VALUES (1)"
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 end
 
-describe Sequel::Model, "#destroy" do
+describe Sequel::Model, "#destroy with filtered dataset" do
   before do
+    @model = Class.new(Sequel::Model(MODEL_DB[:items].where(:a=>1)))
+    @model.columns :id, :a
+    @instance = @model.load(:id => 1234)
     MODEL_DB.reset
+  end
+
+  it "should raise a NoExistingObject exception if the dataset delete call doesn't return 1" do
+    @instance.this.meta_def(:execute_dui){|*a| 0}
+    proc{@instance.delete}.should raise_error(Sequel::NoExistingObject)
+    @instance.this.meta_def(:execute_dui){|*a| 2}
+    proc{@instance.delete}.should raise_error(Sequel::NoExistingObject)
+    @instance.this.meta_def(:execute_dui){|*a| 1}
+    proc{@instance.delete}.should_not raise_error
+    
+    @instance.require_modification = false
+    @instance.this.meta_def(:execute_dui){|*a| 0}
+    proc{@instance.delete}.should_not raise_error
+    @instance.this.meta_def(:execute_dui){|*a| 2}
+    proc{@instance.delete}.should_not raise_error
+  end
+
+  it "should include WHERE clause when deleting" do
+    @instance.destroy
+    MODEL_DB.sqls.should == ["DELETE FROM items WHERE ((a = 1) AND (id = 1234))"]
+  end
+end
+
+describe Sequel::Model, "#destroy" do
+  before do
     @model = Class.new(Sequel::Model(:items))
     @model.columns :id
-    @model.dataset.meta_def(:delete){MODEL_DB.execute delete_sql;1}
-    
     @instance = @model.load(:id => 1234)
+    MODEL_DB.reset
   end
 
   it "should return self" do
@@ -926,65 +1106,56 @@ describe Sequel::Model, "#destroy" do
   end
   
   it "should raise a NoExistingObject exception if the dataset delete call doesn't return 1" do
-    @instance.this.meta_def(:delete){|*a| 0}
+    @model.dataset.meta_def(:execute_dui){|*a| 0}
     proc{@instance.delete}.should raise_error(Sequel::NoExistingObject)
-    @instance.this.meta_def(:delete){|*a| 2}
+    @model.dataset.meta_def(:execute_dui){|*a| 2}
     proc{@instance.delete}.should raise_error(Sequel::NoExistingObject)
-    @instance.this.meta_def(:delete){|*a| 1}
+    @model.dataset.meta_def(:execute_dui){|*a| 1}
     proc{@instance.delete}.should_not raise_error
     
     @instance.require_modification = false
-    @instance.this.meta_def(:delete){|*a| 0}
+    @model.dataset.meta_def(:execute_dui){|*a| 0}
     proc{@instance.delete}.should_not raise_error
-    @instance.this.meta_def(:delete){|*a| 2}
+    @model.dataset.meta_def(:execute_dui){|*a| 2}
     proc{@instance.delete}.should_not raise_error
   end
 
   it "should run within a transaction if use_transactions is true" do
     @instance.use_transactions = true
-    @model.db.should_receive(:transaction)
     @instance.destroy
+    MODEL_DB.sqls.should == ["BEGIN", "DELETE FROM items WHERE id = 1234", "COMMIT"]
   end
 
   it "should not run within a transaction if use_transactions is false" do
     @instance.use_transactions = false
-    @model.db.should_not_receive(:transaction)
     @instance.destroy
+    MODEL_DB.sqls.should == ["DELETE FROM items WHERE id = 1234"]
   end
 
   it "should run within a transaction if :transaction option is true" do
     @instance.use_transactions = false
-    @model.db.should_receive(:transaction)
     @instance.destroy(:transaction => true)
+    MODEL_DB.sqls.should == ["BEGIN", "DELETE FROM items WHERE id = 1234", "COMMIT"]
   end
 
   it "should not run within a transaction if :transaction option is false" do
     @instance.use_transactions = true
-    @model.db.should_not_receive(:transaction)
     @instance.destroy(:transaction => false)
+    MODEL_DB.sqls.should == ["DELETE FROM items WHERE id = 1234"]
   end
 
   it "should run before_destroy and after_destroy hooks" do
     @model.send(:define_method, :before_destroy){MODEL_DB.execute('before blah')}
     @model.send(:define_method, :after_destroy){MODEL_DB.execute('after blah')}
     @instance.destroy
-    
-    MODEL_DB.sqls.should == [
-      "before blah",
-      "DELETE FROM items WHERE (id = 1234)",
-      "after blah"
-    ]
+    MODEL_DB.sqls.should == ["before blah", "DELETE FROM items WHERE id = 1234", "after blah"]
   end
 end
 
 describe Sequel::Model, "#exists?" do
-  before(:each) do
+  before do
     @model = Class.new(Sequel::Model(:items))
-    @ds = @model.dataset
-    def @ds.fetch_rows(sql)
-      db.execute(sql)
-      yield(:x=>1) if sql =~ /id = 1/
-    end
+    @model.instance_dataset._fetch = @model.dataset._fetch = proc{|sql| {:x=>1} if sql =~ /id = 1/}
     MODEL_DB.reset
   end
 
@@ -997,6 +1168,11 @@ describe Sequel::Model, "#exists?" do
     @model.load(:id=>2).exists?.should be_false
     MODEL_DB.sqls.should == ['SELECT 1 FROM items WHERE (id = 2) LIMIT 1']
   end
+
+  it "should return false without issuing a query if the model object is new" do
+    @model.new.exists?.should be_false
+    MODEL_DB.sqls.should == []
+  end
 end
 
 describe Sequel::Model, "#each" do
@@ -1008,7 +1184,7 @@ describe Sequel::Model, "#each" do
   
   specify "should iterate over the values" do
     h = {}
-    @m.each {|k, v| h[k] = v}
+    @m.each{|k, v| h[k] = v}
     h.should == {:a => 1, :b => 2, :id => 4444}
   end
 end
@@ -1021,11 +1197,8 @@ describe Sequel::Model, "#keys" do
   end
   
   specify "should return the value keys" do
-    @m.keys.size.should == 3
-    @m.keys.should include(:a, :b, :id)
-    
-    @m = @model.new()
-    @m.keys.should == []
+    @m.keys.sort_by{|k| k.to_s}.should == [:a, :b, :id]
+    @model.new.keys.should == []
   end
 end
 
@@ -1094,13 +1267,10 @@ describe Sequel::Model, "#hash" do
     y = Class.new(Sequel::Model)
     y.columns :id, :x
     a = z.load(:id => 1, :x => 3)
-    b = z.load(:id => 1, :x => 4)
-    c = z.load(:id => 2, :x => 3)
-    d = y.load(:id => 1, :x => 3)
     
-    a.hash.should == b.hash
-    a.hash.should_not == c.hash
-    a.hash.should_not == d.hash
+    a.hash.should == z.load(:id => 1, :x => 4).hash
+    a.hash.should_not == z.load(:id => 2, :x => 3).hash
+    a.hash.should_not == y.load(:id => 1, :x => 3).hash
   end
 
   specify "should be the same only for objects with the same class and values if the pk is nil" do
@@ -1109,14 +1279,71 @@ describe Sequel::Model, "#hash" do
     y = Class.new(Sequel::Model)
     y.columns :id, :x
     a = z.new(:x => 3)
-    b = z.new(:x => 4)
-    c = z.new(:x => 3)
-    d = y.new(:x => 3)
     
-    a.hash.should_not == b.hash
-    a.hash.should == c.hash
-    a.hash.should_not == d.hash
+    a.hash.should_not == z.new(:x => 4).hash
+    a.hash.should == z.new(:x => 3).hash
+    a.hash.should_not == y.new(:x => 3).hash
+  end
+
+  specify "should be the same only for objects with the same class and pk if pk is composite and all values are non-NULL" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :id2, :x
+    z.set_primary_key(:id, :id2)
+    y = Class.new(Sequel::Model)
+    y.columns :id, :id2, :x
+    y.set_primary_key(:id, :id2)
+    a = z.load(:id => 1, :id2=>2, :x => 3)
+    
+    a.hash.should == z.load(:id => 1, :id2=>2, :x => 4).hash
+    a.hash.should_not == z.load(:id => 2, :id2=>1, :x => 3).hash
+    a.hash.should_not == y.load(:id => 1, :id2=>1, :x => 3).hash
+  end
+
+  specify "should be the same only for objects with the same class and value if pk is composite and one values is NULL" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :id2, :x
+    z.set_primary_key(:id, :id2)
+    y = Class.new(Sequel::Model)
+    y.columns :id, :id2, :x
+    y.set_primary_key(:id, :id2)
+
+    a = z.load(:id => 1, :id2 => nil, :x => 3)
+    a.hash.should == z.load(:id => 1, :id2=>nil, :x => 3).hash
+    a.hash.should_not == z.load(:id => 1, :id2=>nil, :x => 4).hash
+    a.hash.should_not == y.load(:id => 1, :id2=>nil, :x => 3).hash
+
+    a = z.load(:id =>nil, :id2 => nil, :x => 3)
+    a.hash.should == z.load(:id => nil, :id2=>nil, :x => 3).hash
+    a.hash.should_not == z.load(:id => nil, :id2=>nil, :x => 4).hash
+    a.hash.should_not == y.load(:id => nil, :id2=>nil, :x => 3).hash
+
+    a = z.load(:id => 1, :x => 3)
+    a.hash.should == z.load(:id => 1, :x => 3).hash
+    a.hash.should_not == z.load(:id => 1, :id2=>nil, :x => 3).hash
+    a.hash.should_not == z.load(:id => 1, :x => 4).hash
+    a.hash.should_not == y.load(:id => 1, :x => 3).hash
+
+    a = z.load(:x => 3)
+    a.hash.should == z.load(:x => 3).hash
+    a.hash.should_not == z.load(:id => nil, :id2=>nil, :x => 3).hash
+    a.hash.should_not == z.load(:x => 4).hash
+    a.hash.should_not == y.load(:x => 3).hash
+  end
+
+  specify "should be the same only for objects with the same class and values if the no primary key" do
+    z = Class.new(Sequel::Model)
+    z.columns :id, :x
+    z.no_primary_key
+    y = Class.new(Sequel::Model)
+    y.columns :id, :x
+    y.no_primary_key
+    a = z.new(:x => 3)
+    
+    a.hash.should_not == z.new(:x => 4).hash
+    a.hash.should == z.new(:x => 3).hash
+    a.hash.should_not == y.new(:x => 3).hash
   end
+
 end
 
 describe Sequel::Model, "#initialize" do
@@ -1161,10 +1388,32 @@ describe Sequel::Model, "#initialize" do
     m.values.should == {:x => 2}
   end
 end
+  
+describe Sequel::Model, "#initialize_set" do
+  before do
+    @c = Class.new(Sequel::Model){columns :id, :x, :y}
+  end
 
-describe Sequel::Model, ".create" do
+  specify "should be called by initialize to set the column values" do
+    @c.send(:define_method, :initialize_set){|h| set(:y => 3)}
+    @c.new(:x => 2).values.should == {:y => 3}
+  end
+
+  specify "should be called with the hash given to initialize " do
+    x = nil
+    @c.send(:define_method, :initialize_set){|y| x = y}
+    @c.new(:x => 2)
+    x.should == {:x => 2}
+  end
 
-  before(:each) do
+  specify "should not cause columns modified by the method to be considered as changed" do
+    @c.send(:define_method, :initialize_set){|h| set(:y => 3)}
+    @c.new(:x => 2).changed_columns.should == []
+  end
+end
+
+describe Sequel::Model, ".create" do
+  before do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       unrestrict_primary_key
@@ -1175,13 +1424,13 @@ describe Sequel::Model, ".create" do
   it "should be able to create rows in the associated table" do
     o = @c.create(:x => 1)
     o.class.should == @c
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)',  "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (1)')) LIMIT 1"]
+    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "should be able to create rows without any values specified" do
     o = @c.create
     o.class.should == @c
-    MODEL_DB.sqls.should == ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id IN ('INSERT INTO items DEFAULT VALUES')) LIMIT 1"]
+    MODEL_DB.sqls.should == ["INSERT INTO items DEFAULT VALUES", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   it "should accept a block and run it" do
@@ -1191,7 +1440,7 @@ describe Sequel::Model, ".create" do
     o1.should === o
     o3.should === o
     o2.should == :blah
-    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (333)", "SELECT * FROM items WHERE (id IN ('INSERT INTO items (x) VALUES (333)')) LIMIT 1"]
+    MODEL_DB.sqls.should == ["INSERT INTO items (x) VALUES (333)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
   
   it "should create a row for a model with custom primary key" do
@@ -1204,49 +1453,45 @@ end
 
 describe Sequel::Model, "#refresh" do
   before do
-    MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       unrestrict_primary_key
       columns :id, :x
     end
+    MODEL_DB.reset
   end
 
   specify "should reload the instance values from the database" do
     @m = @c.new(:id => 555)
     @m[:x] = 'blah'
-    @m.this.should_receive(:first).and_return({:x => 'kaboom', :id => 555})
+    @c.instance_dataset._fetch = @c.dataset._fetch = {:x => 'kaboom', :id => 555}
     @m.refresh
     @m[:x].should == 'kaboom'
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id = 555) LIMIT 1"]
   end
   
   specify "should raise if the instance is not found" do
     @m = @c.new(:id => 555)
-    @m.this.should_receive(:first).and_return(nil)
+    @c.instance_dataset._fetch =@c.dataset._fetch = []
     proc {@m.refresh}.should raise_error(Sequel::Error)
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id = 555) LIMIT 1"]
   end
   
   specify "should be aliased by #reload" do
     @m = @c.new(:id => 555)
-    @m.this.should_receive(:first).and_return({:x => 'kaboom', :id => 555})
+    @c.instance_dataset._fetch =@c.dataset._fetch = {:x => 'kaboom', :id => 555}
     @m.reload
     @m[:x].should == 'kaboom'
-  end
-
-  specify "should remove cached associations" do
-    @c.many_to_one :node, :class=>@c
-    @m = @c.new(:id => 555)
-    @m.associations[:node] = 15
-    @m.reload
-    @m.associations.should == {}
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id = 555) LIMIT 1"]
   end
 end
 
 describe Sequel::Model, "typecasting" do
   before do
-    MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       columns :x
     end
+    @c.db_schema = {:x=>{:type=>:integer}}
+    MODEL_DB.reset
   end
 
   after do
@@ -1255,14 +1500,13 @@ describe Sequel::Model, "typecasting" do
 
   specify "should not convert if typecasting is turned off" do
     @c.typecast_on_assignment = false
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
     m = @c.new
     m.x = '1'
     m.x.should == '1'
   end
 
   specify "should convert to integer for an integer field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
+    @c.db_schema = {:x=>{:type=>:integer}}
     m = @c.new
     m.x = '1'
     m.x.should == 1
@@ -1274,13 +1518,13 @@ describe Sequel::Model, "typecasting" do
 
   specify "should typecast '' to nil unless type is string or blob" do
     [:integer, :float, :decimal, :boolean, :date, :time, :datetime].each do |x|
-      @c.instance_variable_set(:@db_schema, {:x=>{:type=>x}})
+      @c.db_schema = {:x=>{:type=>x}}
       m = @c.new
       m.x = ''
       m.x.should == nil
     end
    [:string, :blob].each do |x|
-      @c.instance_variable_set(:@db_schema, {:x=>{:type=>x}})
+      @c.db_schema = {:x=>{:type=>x}}
       m = @c.new
       m.x = ''
       m.x.should == ''
@@ -1288,7 +1532,6 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should not typecast '' to nil if typecast_empty_string_to_nil is false" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
     m = @c.new
     m.typecast_empty_string_to_nil = false
     proc{m.x = ''}.should raise_error
@@ -1296,22 +1539,31 @@ describe Sequel::Model, "typecasting" do
     proc{@c.new.x = ''}.should raise_error
   end
 
+  specify "should handle typecasting where == raises an error on the object" do
+    m = @c.new
+    o = Object.new
+    def o.==(v) raise ArgumentError end
+    def o.to_i() 4 end
+    m.x = o
+    m.x.should == 4
+  end
+
   specify "should not typecast nil if NULLs are allowed" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer,:allow_null=>true}})
+    @c.db_schema[:x][:allow_null] = true
     m = @c.new
     m.x = nil
     m.x.should == nil
   end
 
   specify "should raise an error if attempting to typecast nil and NULLs are not allowed" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer,:allow_null=>false}})
+    @c.db_schema[:x][:allow_null] = false
     proc{@c.new.x = nil}.should raise_error(Sequel::Error)
     proc{@c.new.x = ''}.should raise_error(Sequel::Error)
   end
 
   specify "should not raise an error if NULLs are not allowed and typecasting is turned off" do
     @c.typecast_on_assignment = false
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer,:allow_null=>false}})
+    @c.db_schema[:x][:allow_null] = false
     m = @c.new
     m.x = nil
     m.x.should == nil
@@ -1320,7 +1572,6 @@ describe Sequel::Model, "typecasting" do
   specify "should not raise when typecasting nil to NOT NULL column but raise_on_typecast_failure is off" do
     @c.raise_on_typecast_failure = false
     @c.typecast_on_assignment = true
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer,:allow_null=>false}})
     m = @c.new
     m.x = ''
     m.x.should == nil
@@ -1329,20 +1580,18 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should raise an error if invalid data is used in an integer field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
     proc{@c.new.x = 'a'}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid integer" do
     @c.raise_on_typecast_failure = false
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:integer}})
     model = @c.new
     model.x = '1d'
     model.x.should == '1d'
   end
 
   specify "should convert to float for a float field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:float}})
+    @c.db_schema = {:x=>{:type=>:float}}
     m = @c.new
     m.x = '1.3'
     m.x.should == 1.3
@@ -1353,20 +1602,20 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should raise an error if invalid data is used in an float field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:float}})
+    @c.db_schema = {:x=>{:type=>:float}}
     proc{@c.new.x = 'a'}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid float" do
     @c.raise_on_typecast_failure = false
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:float}})
+    @c.db_schema = {:x=>{:type=>:float}}
     model = @c.new
     model.x = '1d'
     model.x.should == '1d'
   end
 
   specify "should convert to BigDecimal for a decimal field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:decimal}})
+    @c.db_schema = {:x=>{:type=>:decimal}}
     m = @c.new
     bd = BigDecimal.new('1.0')
     m.x = '1.0'
@@ -1380,13 +1629,13 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should raise an error if invalid data is used in an decimal field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:decimal}})
+    @c.db_schema = {:x=>{:type=>:decimal}}
     proc{@c.new.x = Date.today}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid decimal" do
     @c.raise_on_typecast_failure = false
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:decimal}})
+    @c.db_schema = {:x=>{:type=>:decimal}}
     model = @c.new
     time = Time.now
     model.x = time
@@ -1394,7 +1643,7 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should convert to string for a string field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:string}})
+    @c.db_schema = {:x=>{:type=>:string}}
     m = @c.new
     m.x = '1.3'
     m.x.should == '1.3'
@@ -1405,7 +1654,7 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should convert to boolean for a boolean field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:boolean}})
+    @c.db_schema = {:x=>{:type=>:boolean}}
     m = @c.new
     m.x = '1.3'
     m.x.should == true
@@ -1417,6 +1666,10 @@ describe Sequel::Model, "typecasting" do
     m.x.should == true
     m.x = 'T'
     m.x.should == true
+    m.x = 'y'
+    m.x.should == true
+    m.x = 'Y'
+    m.x.should == true
     m.x = true
     m.x.should == true
     m.x = nil
@@ -1433,6 +1686,14 @@ describe Sequel::Model, "typecasting" do
     m.x.should == false
     m.x = 'FALSE'
     m.x.should == false
+    m.x = 'n'
+    m.x.should == false
+    m.x = 'N'
+    m.x.should == false
+    m.x = 'no'
+    m.x.should == false
+    m.x = 'NO'
+    m.x.should == false
     m.x = '0'
     m.x.should == false
     m.x = 0
@@ -1442,7 +1703,7 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should convert to date for a date field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:date}})
+    @c.db_schema = {:x=>{:type=>:date}}
     m = @c.new
     y = Date.new(2007,10,21)
     m.x = '2007-10-21'
@@ -1456,7 +1717,7 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should accept a hash with symbol or string keys for a date field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:date}})
+    @c.db_schema = {:x=>{:type=>:date}}
     m = @c.new
     y = Date.new(2007,10,21)
     m.x = {:year=>2007, :month=>10, :day=>21}
@@ -1466,32 +1727,33 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should raise an error if invalid data is used in a date field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:date}})
+    @c.db_schema = {:x=>{:type=>:date}}
     proc{@c.new.x = 'a'}.should raise_error(Sequel::InvalidValue)
     proc{@c.new.x = 100}.should raise_error(Sequel::InvalidValue)
   end
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid date" do
     @c.raise_on_typecast_failure = false
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:date}})
+    @c.db_schema = {:x=>{:type=>:date}}
     model = @c.new
     model.x = 4
     model.x.should == 4
   end
 
-  specify "should convert to time for a time field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:time}})
+  specify "should convert to Sequel::SQLTime for a time field" do
+    @c.db_schema = {:x=>{:type=>:time}}
     m = @c.new
     x = '10:20:30'
-    y = Time.parse(x)
+    y = Sequel::SQLTime.parse(x)
     m.x = x
     m.x.should == y
     m.x = y
     m.x.should == y
+    m.x.should be_a_kind_of(Sequel::SQLTime)
   end
 
   specify "should accept a hash with symbol or string keys for a time field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:time}})
+    @c.db_schema = {:x=>{:type=>:time}}
     m = @c.new
     y = Time.parse('10:20:30')
     m.x = {:hour=>10, :minute=>20, :second=>30}
@@ -1501,7 +1763,7 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should raise an error if invalid data is used in a time field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:time}})
+    @c.db_schema = {:x=>{:type=>:time}}
     proc{@c.new.x = '0000'}.should raise_error
     proc{@c.new.x = Date.parse('2008-10-21')}.should raise_error(Sequel::InvalidValue)
     proc{@c.new.x = DateTime.parse('2008-10-21')}.should raise_error(Sequel::InvalidValue)
@@ -1509,14 +1771,14 @@ describe Sequel::Model, "typecasting" do
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid time" do
     @c.raise_on_typecast_failure = false
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:time}})
+    @c.db_schema = {:x=>{:type=>:time}}
     model = @c.new
     model.x = '0000'
     model.x.should == '0000'
   end
 
   specify "should convert to the Sequel.datetime_class for a datetime field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:datetime}})
+    @c.db_schema = {:x=>{:type=>:datetime}}
     m = @c.new
     x = '2007-10-21T10:20:30-07:00'
     y = Time.parse(x)
@@ -1541,7 +1803,7 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should accept a hash with symbol or string keys for a datetime field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:datetime}})
+    @c.db_schema = {:x=>{:type=>:datetime}}
     m = @c.new
     y = Time.parse('2007-10-21 10:20:30')
     m.x = {:year=>2007, :month=>10, :day=>21, :hour=>10, :minute=>20, :second=>30}
@@ -1557,7 +1819,7 @@ describe Sequel::Model, "typecasting" do
   end
 
   specify "should raise an error if invalid data is used in a datetime field" do
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:datetime}})
+    @c.db_schema = {:x=>{:type=>:datetime}}
     proc{@c.new.x = '0000'}.should raise_error(Sequel::InvalidValue)
     Sequel.datetime_class = DateTime
     proc{@c.new.x = '0000'}.should raise_error(Sequel::InvalidValue)
@@ -1566,7 +1828,7 @@ describe Sequel::Model, "typecasting" do
 
   specify "should assign value if raise_on_typecast_failure is off and assigning invalid datetime" do
     @c.raise_on_typecast_failure = false
-    @c.instance_variable_set(:@db_schema, {:x=>{:type=>:datetime}})
+    @c.db_schema = {:x=>{:type=>:datetime}}
     model = @c.new
     model.x = '0000'
     model.x.should == '0000'
@@ -1584,11 +1846,7 @@ describe "Model#lock!" do
     @c = Class.new(Sequel::Model(:items)) do
       columns :id
     end
-    ds = @c.dataset
-    def ds.fetch_rows(sql)
-      db.execute(sql)
-      yield({:id=>1})
-    end
+    @c.dataset._fetch = {:id=>1}
     MODEL_DB.reset
   end