sequel 3.28.0 → 3.29.0

data/spec/model/plugins_spec.rb

@@ -125,24 +125,21 @@ describe Sequel::Model, ".plugin" do
       def self.configure(model, *args, &block)
         @args << :configure
       end
-      im = Module.new do
+      self::InstanceMethods = Module.new do
         def self.included(model)
           model.plugins.last.args << :im
         end
       end
-      cm = Module.new do
+      self::ClassMethods = Module.new do
         def self.extended(model)
           model.plugins.last.args << :cm
         end
       end
-      dm = Module.new do
+      self::DatasetMethods = Module.new do
         def self.extended(dataset)
           dataset.model.plugins.last.args << :dm
         end
       end
-      const_set(:InstanceMethods, im)
-      const_set(:ClassMethods, cm)
-      const_set(:DatasetMethods, dm)
     end
     
     b = lambda{44}
@@ -192,11 +189,10 @@ describe Sequel::Model, ".plugin" do
 
   it "should define class methods for all public instance methods in DatasetMethod" do
     m = Module.new do
-      dm = Module.new do
+      self::DatasetMethods = Module.new do
         def a; 1; end
         def b; 2; end
       end
-      const_set(:DatasetMethods, dm)
     end
     @c.plugin m
     @c.dataset.a.should == 1
@@ -205,14 +201,13 @@ describe Sequel::Model, ".plugin" do
     @c.b.should == 2
   end
   
-  it "should define class methods for all public instance methods in DatasetMethod" do
+  it "should not define class methods for private instance methods in DatasetMethod" do
     m = Module.new do
-      dm = Module.new do
+      self::DatasetMethods = Module.new do
         def b; 2; end
         private
         def a; 1; end
       end
-      const_set(:DatasetMethods, dm)
     end
     @c.plugin m
     @c.dataset.b.should == 2
@@ -225,11 +220,10 @@ describe Sequel::Model, ".plugin" do
 
   it "should not raise an error if the DatasetMethod module has no public instance methods" do
     m = Module.new do
-      dm = Module.new do
+      self::DatasetMethods = Module.new do
         private
         def a; 1; end
       end
-      const_set(:DatasetMethods, dm)
     end
     lambda{@c.plugin m}.should_not raise_error
   end

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,29 +26,28 @@ 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.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._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
@@ -71,7 +57,6 @@ describe "Model#save" do
   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)",
@@ -79,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
@@ -94,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
@@ -113,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
   
@@ -192,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
@@ -216,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
@@ -230,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
@@ -247,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
@@ -259,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
@@ -274,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
@@ -286,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
@@ -297,7 +269,6 @@ describe "Model#save" do
     end
     proc { o.save(:y) }.should raise_error(Sequel::Rollback)
     MODEL_DB.sqls.should == []
-    MODEL_DB.reset
   end
 end
 
@@ -306,7 +277,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)
@@ -388,7 +358,6 @@ describe "Model#modified[!?]" do
 end
 
 describe "Model#save_changes" do
-  
   before do
     @c = Class.new(Sequel::Model(:items)) do
       unrestrict_primary_key
@@ -433,15 +402,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
@@ -453,7 +421,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
@@ -479,13 +446,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
@@ -496,25 +461,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
@@ -530,74 +491,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
@@ -631,7 +583,7 @@ describe "Model#pk" do
 end
 
 describe "Model#pk_or_nil" do
-  before(:each) do
+  before do
     @m = Class.new(Sequel::Model)
     @m.columns :id, :x, :y
   end
@@ -665,7 +617,7 @@ describe "Model#pk_or_nil" do
 end
 
 describe "Model#pk_hash" do
-  before(:each) do
+  before do
     @m = Class.new(Sequel::Model)
     @m.columns :id, :x, :y
   end
@@ -700,16 +652,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
@@ -833,47 +783,44 @@ 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
@@ -893,11 +840,9 @@ 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)
@@ -907,21 +852,18 @@ 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
 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
@@ -929,8 +871,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
@@ -974,40 +916,34 @@ 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
   before do
-    MODEL_DB.reset
     @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
@@ -1032,49 +968,40 @@ describe Sequel::Model, "#destroy" do
 
   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.dataset._fetch = proc{|sql| {:x=>1} if sql =~ /id = 1/}
     MODEL_DB.reset
   end
 
@@ -1103,7 +1030,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
@@ -1116,11 +1043,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
 
@@ -1335,8 +1259,7 @@ describe Sequel::Model, "#initialize_set" do
 end
 
 describe Sequel::Model, ".create" do
-
-  before(:each) do
+  before do
     MODEL_DB.reset
     @c = Class.new(Sequel::Model(:items)) do
       unrestrict_primary_key
@@ -1347,13 +1270,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
@@ -1363,7 +1286,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
@@ -1376,32 +1299,35 @@ 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.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.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.dataset._fetch = {:x => 'kaboom', :id => 555}
     @m.reload
     @m[:x].should == 'kaboom'
+    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id = 555) LIMIT 1"]
   end
 
   specify "should remove cached associations" do
@@ -1415,10 +1341,11 @@ 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
@@ -1427,14 +1354,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
@@ -1446,13 +1372,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 == ''
@@ -1460,7 +1386,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
@@ -1469,21 +1394,21 @@ describe Sequel::Model, "typecasting" do
   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
@@ -1492,7 +1417,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
@@ -1501,20 +1425,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
@@ -1525,20 +1447,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'
@@ -1552,13 +1474,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
@@ -1566,7 +1488,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'
@@ -1577,7 +1499,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
@@ -1589,6 +1511,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
@@ -1605,6 +1531,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
@@ -1614,7 +1548,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'
@@ -1628,7 +1562,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}
@@ -1638,32 +1572,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}
@@ -1673,7 +1608,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)
@@ -1681,14 +1616,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)
@@ -1713,7 +1648,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}
@@ -1729,7 +1664,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)
@@ -1738,7 +1673,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'
@@ -1756,11 +1691,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