sequel 3.48.0 → 4.0.0

data/spec/model/hooks_spec.rb

@@ -1,22 +1,5 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-describe "Model#after_initialize" do
-  qspecify "should be called after initialization for both new object and objects retrieved from the database" do
-    
-    a = Class.new(Sequel::Model) do
-      self::Foo = []
-      columns :x, :y
-      def after_initialize
-        model::Foo << @values.clone
-      end
-    end
-    
-    a.new(:x => 1, :y => 2)
-    a.call(:x => 1, :y => 3)
-    a::Foo.should == [{:x => 1, :y => 2}, {:x => 1, :y => 3}]
-  end
-end
-
 describe "Model#before_create && Model#after_create" do
   before do
     @c = Class.new(Sequel::Model(:items)) do
@@ -25,22 +8,22 @@ describe "Model#before_create && Model#after_create" do
       unrestrict_primary_key
       
       def after_create
-        MODEL_DB << "BLAH after"
+        DB << "BLAH after"
       end
     end
-    MODEL_DB.reset
+    DB.reset
   end
   
   specify "should be called around new record creation" do
-    @c.send(:define_method, :before_create){MODEL_DB << "BLAH before"}
+    @c.send(:define_method, :before_create){DB << "BLAH before"}
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
+    DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
   end
 
   specify ".create should cancel the save and raise an error if before_create returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_create){false}
     proc{@c.create(:x => 2)}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
     proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
   end
 
@@ -48,7 +31,7 @@ describe "Model#before_create && Model#after_create" do
     @c.send(:define_method, :before_create){false}
     @c.raise_on_save_failure = false
     @c.create(:x => 2).should == nil
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 end
 
@@ -57,24 +40,24 @@ describe "Model#before_update && Model#after_update" do
     @c = Class.new(Sequel::Model(:items)) do
       columns :id, :x
       def after_update
-        MODEL_DB << "BLAH after"
+        DB << "BLAH after"
       end
     end
-    MODEL_DB.reset
+    DB.reset
   end
   
   specify "should be called around record update" do
-    @c.send(:define_method, :before_update){MODEL_DB << "BLAH before"}
+    @c.send(:define_method, :before_update){DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    MODEL_DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
+    DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
 
   specify "#save should cancel the save and raise an error if before_update returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_update){false}
     proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
     proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   specify "#save should cancel the save and raise an error if before_update returns false and raise_on_failure option is true" do
@@ -82,14 +65,14 @@ describe "Model#before_update && Model#after_update" do
     @c.raise_on_save_failure = false
     proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should_not raise_error(Sequel::ValidationFailed)
     proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   specify "#save should cancel the save and return nil if before_update returns false and raise_on_save_failure is false" do
     @c.send(:define_method, :before_update){false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).save.should == nil
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 end
 
@@ -98,32 +81,32 @@ describe "Model#before_save && Model#after_save" do
     @c = Class.new(Sequel::Model(:items)) do
       columns :x
       def after_save
-        MODEL_DB << "BLAH after"
+        DB << "BLAH after"
       end
     end
-    MODEL_DB.reset
+    DB.reset
   end
   
   specify "should be called around record update" do
-    @c.send(:define_method, :before_save){MODEL_DB << "BLAH before"}
+    @c.send(:define_method, :before_save){DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save
-    MODEL_DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
+    DB.sqls.should == ['BLAH before', 'UPDATE items SET x = 123 WHERE (id = 2233)', 'BLAH after']
   end
   
   specify "should be called around record creation" do
-    @c.send(:define_method, :before_save){MODEL_DB << "BLAH before"}
+    @c.send(:define_method, :before_save){DB << "BLAH before"}
     @c.set_primary_key :x
     @c.unrestrict_primary_key
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
+    DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after', 'SELECT * FROM items WHERE (x = 2) LIMIT 1']
   end
 
   specify "#save should cancel the save and raise an error if before_save returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_save){false}
     proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
     proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   specify "#save should cancel the save and raise an error if before_save returns false and raise_on_failure option is true" do
@@ -131,20 +114,20 @@ describe "Model#before_save && Model#after_save" do
     @c.raise_on_save_failure = false
     proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should_not raise_error(Sequel::ValidationFailed)
     proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   specify "#save should cancel the save and return nil if before_save returns false and raise_on_save_failure is false" do
     @c.send(:define_method, :before_save){false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).save.should == nil
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   specify "#save should have a raised exception reference the model instance" do
     @c.send(:define_method, :before_save){false}
     proc{@c.create(:x => 2233)}.should raise_error(Sequel::HookFailed){|e| e.model.should == @c.load(:x=>2233)}
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 end
 
@@ -152,37 +135,37 @@ describe "Model#before_destroy && Model#after_destroy" do
   before do
     @c = Class.new(Sequel::Model(:items)) do
       def after_destroy
-        MODEL_DB << "BLAH after"
+        DB << "BLAH after"
       end
     end
-    MODEL_DB.reset
+    DB.reset
   end
   
   specify "should be called around record destruction" do
-    @c.send(:define_method, :before_destroy){MODEL_DB << "BLAH before"}
+    @c.send(:define_method, :before_destroy){DB << "BLAH before"}
     m = @c.load(:id => 2233)
     m.destroy
-    MODEL_DB.sqls.should == ['BLAH before', 'DELETE FROM items WHERE id = 2233', 'BLAH after']
+    DB.sqls.should == ['BLAH before', 'DELETE FROM items WHERE id = 2233', 'BLAH after']
   end
 
   specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_destroy){false}
     proc{@c.load(:id => 2233).destroy}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   specify "#destroy should cancel the destroy and raise an error if before_destroy returns false and raise_on_failure option is true" do
     @c.send(:define_method, :before_destroy){false}
     @c.raise_on_save_failure = false
     proc{@c.load(:id => 2233).destroy(:raise_on_failure => true)}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   specify "#destroy should cancel the destroy and return nil if before_destroy returns false and raise_on_save_failure is false" do
     @c.send(:define_method, :before_destroy){false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).destroy.should == nil
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 end
 
@@ -191,7 +174,7 @@ describe "Model#before_validation && Model#after_validation" do
     @c = Class.new(Sequel::Model(:items)) do
       columns :id
       def after_validation
-        MODEL_DB << "BLAH after"
+        DB << "BLAH after"
       end
 
       def validate
@@ -201,33 +184,33 @@ describe "Model#before_validation && Model#after_validation" do
   end
   
   specify "should be called around validation" do
-    @c.send(:define_method, :before_validation){MODEL_DB << "BLAH before"}
+    @c.send(:define_method, :before_validation){DB << "BLAH before"}
     m = @c.load(:id => 2233)
     m.should be_valid
-    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+    DB.sqls.should == ['BLAH before', 'BLAH after']
 
     m = @c.load(:id => 22)
     m.should_not be_valid
-    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+    DB.sqls.should == ['BLAH before', 'BLAH after']
   end
 
   specify "should be called when calling save" do
-    @c.send(:define_method, :before_validation){MODEL_DB << "BLAH before"}
+    @c.send(:define_method, :before_validation){DB << "BLAH before"}
     m = @c.load(:id => 2233, :x=>123)
     m.save.should == m
-    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after', 'UPDATE items SET x = 123 WHERE (id = 2233)']
+    DB.sqls.should == ['BLAH before', 'BLAH after', 'UPDATE items SET x = 123 WHERE (id = 2233)']
 
     m = @c.load(:id => 22)
     m.raise_on_save_failure = false
     m.save.should == nil
-    MODEL_DB.sqls.should == ['BLAH before', 'BLAH after']
+    DB.sqls.should == ['BLAH before', 'BLAH after']
   end
 
   specify "#save should cancel the save and raise an error if before_validation returns false and raise_on_save_failure is true" do
     @c.send(:define_method, :before_validation){false}
     proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
     proc{@c.load(:id => 2233).save}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   specify "#save should cancel the save and raise an error if before_validation returns false and raise_on_failure option is true" do
@@ -235,14 +218,14 @@ describe "Model#before_validation && Model#after_validation" do
     @c.raise_on_save_failure = false
     proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should_not raise_error(Sequel::ValidationFailed)
     proc{@c.load(:id => 2233).save(:raise_on_failure => true)}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   specify "#save should cancel the save and return nil if before_validation returns false and raise_on_save_failure is false" do
     @c.send(:define_method, :before_validation){false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).save.should == nil
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
   
   specify "#valid? should return false if before_validation returns false" do
@@ -256,82 +239,82 @@ describe "Model around filters" do
     @c = Class.new(Sequel::Model(:items)) do
       columns :id, :x
     end
-    MODEL_DB.reset
+    DB.reset
   end
   
   specify "around_create should be called around new record creation" do
     @c.class_eval do
       def around_create
-        MODEL_DB << 'ac_before'
+        DB << 'ac_before'
         super
-        MODEL_DB << 'ac_after'
+        DB << 'ac_after'
       end
     end
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == ['ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    DB.sqls.should == ['ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 
   specify "around_delete should be called around record destruction" do
     @c.class_eval do
       def around_destroy
-        MODEL_DB << 'ad_before'
+        DB << 'ad_before'
         super
-        MODEL_DB << 'ad_after'
+        DB << 'ad_after'
       end
     end
     @c.load(:id=>1, :x => 2).destroy
-    MODEL_DB.sqls.should == ['ad_before', 'DELETE FROM items WHERE id = 1', 'ad_after']
+    DB.sqls.should == ['ad_before', 'DELETE FROM items WHERE id = 1', 'ad_after']
   end
   
   specify "around_update should be called around updating existing records" do
     @c.class_eval do
       def around_update
-        MODEL_DB << 'au_before'
+        DB << 'au_before'
         super
-        MODEL_DB << 'au_after'
+        DB << 'au_after'
       end
     end
     @c.load(:id=>1, :x => 2).save
-    MODEL_DB.sqls.should == ['au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after']
+    DB.sqls.should == ['au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after']
   end
 
   specify "around_save should be called around saving both new and existing records, around either after_create and after_update" do
     @c.class_eval do
       def around_update
-        MODEL_DB << 'au_before'
+        DB << 'au_before'
         super
-        MODEL_DB << 'au_after'
+        DB << 'au_after'
       end
       def around_create
-        MODEL_DB << 'ac_before'
+        DB << 'ac_before'
         super
-        MODEL_DB << 'ac_after'
+        DB << 'ac_after'
       end
       def around_save
-        MODEL_DB << 'as_before'
+        DB << 'as_before'
         super
-        MODEL_DB << 'as_after'
+        DB << 'as_after'
       end
     end
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == ['as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', 'as_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    DB.sqls.should == ['as_before', 'ac_before', 'INSERT INTO items (x) VALUES (2)', 'ac_after', 'as_after', "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
     @c.load(:id=>1, :x => 2).save
-    MODEL_DB.sqls.should == ['as_before', 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after', 'as_after']
+    DB.sqls.should == ['as_before', 'au_before', 'UPDATE items SET x = 2 WHERE (id = 1)', 'au_after', 'as_after']
   end
 
   specify "around_validation should be called around validating records" do
     @c.class_eval do
       def around_validation
-        MODEL_DB << 'av_before'
+        DB << 'av_before'
         super
-        MODEL_DB << 'av_after'
+        DB << 'av_after'
       end
       def validate
-        MODEL_DB << 'validate'
+        DB << 'validate'
       end
     end
     @c.new(:x => 2).valid?.should == true
-    MODEL_DB.sqls.should == [ 'av_before', 'validate', 'av_after' ]
+    DB.sqls.should == [ 'av_before', 'validate', 'av_after' ]
   end
 
   specify "around_validation should be able to catch validation errors and modify them" do

data/spec/model/model_spec.rb

@@ -150,12 +150,12 @@ describe Sequel::Model do
   end
 
   it "should be associated with a dataset" do
-    model_a = Class.new(Sequel::Model) { set_dataset MODEL_DB[:as] }
+    model_a = Class.new(Sequel::Model) { set_dataset DB[:as] }
 
     model_a.dataset.should be_a_kind_of(Sequel::Mock::Dataset)
     model_a.dataset.opts[:from].should == [:as]
 
-    model_b = Class.new(Sequel::Model) { set_dataset MODEL_DB[:bs] }
+    model_b = Class.new(Sequel::Model) { set_dataset DB[:bs] }
 
     model_b.dataset.should be_a_kind_of(Sequel::Mock::Dataset)
     model_b.dataset.opts[:from].should == [:bs]
@@ -183,36 +183,36 @@ describe Sequel::Model do
   end
 
   it "allows dataset change" do
-    @model.set_dataset(MODEL_DB[:foo])
+    @model.set_dataset(DB[:foo])
     @model.table_name.should == :foo
   end
 
   it "allows set_dataset to accept a Symbol" do
-    @model.db = MODEL_DB
+    @model.db = DB
     @model.set_dataset(:foo)
     @model.table_name.should == :foo
   end
 
   it "allows set_dataset to accept a LiteralString" do
-    @model.db = MODEL_DB
+    @model.db = DB
     @model.set_dataset(Sequel.lit('foo'))
     @model.table_name.should == Sequel.lit('foo')
   end
 
   it "allows set_dataset to acceptan SQL::Identifier" do
-    @model.db = MODEL_DB
+    @model.db = DB
     @model.set_dataset(Sequel.identifier(:foo))
     @model.table_name.should == Sequel.identifier(:foo)
   end
 
   it "allows set_dataset to acceptan SQL::QualifiedIdentifier" do
-    @model.db = MODEL_DB
+    @model.db = DB
     @model.set_dataset(Sequel.qualify(:bar, :foo))
     @model.table_name.should == Sequel.qualify(:bar, :foo)
   end
 
   it "allows set_dataset to acceptan SQL::AliasedExpression" do
-    @model.db = MODEL_DB
+    @model.db = DB
     @model.set_dataset(Sequel.as(:foo, :bar))
     @model.table_name.should == :bar
   end
@@ -227,14 +227,14 @@ describe Sequel::Model do
   end
 
   it "set_dataset should add the destroy method to the dataset that destroys each object" do
-    ds = MODEL_DB[:foo]
+    ds = DB[:foo]
     ds.should_not respond_to(:destroy)
     @model.set_dataset(ds)
     ds.should respond_to(:destroy)
-    MODEL_DB.sqls
+    DB.sqls
     ds._fetch = [{:id=>1}, {:id=>2}]
     ds.destroy.should == 2
-    MODEL_DB.sqls.should == ["SELECT * FROM foo", "DELETE FROM foo WHERE id = 1", "DELETE FROM foo WHERE id = 2"]
+    DB.sqls.should == ["SELECT * FROM foo", "DELETE FROM foo WHERE id = 1", "DELETE FROM foo WHERE id = 2"]
   end
 
   it "set_dataset should add the destroy method that respects sharding with transactions" do
@@ -254,12 +254,12 @@ describe Sequel::Model do
 
   it "should not raise an error if there is a problem getting the columns for a dataset" do
     def @model.columns() raise Sequel::Error end
-    proc{@model.set_dataset(MODEL_DB[:foo].join(:blah))}.should_not raise_error
+    proc{@model.set_dataset(DB[:foo].join(:blah))}.should_not raise_error
   end
 
   it "doesn't raise an error on set_dataset if there is an error raised getting the schema" do
     def @model.get_db_schema(*) raise Sequel::Error end
-    proc{@model.set_dataset(MODEL_DB[:foo])}.should_not raise_error
+    proc{@model.set_dataset(DB[:foo])}.should_not raise_error
   end
 
   it "doesn't raise an error on inherited if there is an error setting the dataset" do
@@ -328,19 +328,12 @@ describe Sequel::Model, "constructors" do
     o.values.should == {:a=>1}
     o.new?.should be_false
   end
-  
-  qspecify "should have .new with a second true argument create an existing object" do
-    o = @m.new({:a=>1}, true)
-    o.should be_a_kind_of(@m)
-    o.values.should == {:a=>1}
-    o.new?.should be_false
-  end
 end
 
 describe Sequel::Model, "new" do
   before do
     @m = Class.new(Sequel::Model) do
-      set_dataset MODEL_DB[:items]
+      set_dataset DB[:items]
       columns :x, :id
     end
   end
@@ -374,7 +367,7 @@ end
 describe Sequel::Model, ".subset" do
   before do
     @c = Class.new(Sequel::Model(:items))
-    MODEL_DB.reset
+    DB.reset
   end
 
   specify "should create a filter on the underlying dataset" do
@@ -405,29 +398,29 @@ describe Sequel::Model, ".find" do
   before do
     @c = Class.new(Sequel::Model(:items))
     @c.dataset._fetch = {:name => 'sharon', :id => 1}
-    MODEL_DB.reset
+    DB.reset
   end
   
   it "should return the first record matching the given filter" do
     @c.find(:name => 'sharon').should be_a_kind_of(@c)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM items WHERE (name = 'sharon') LIMIT 1"]
 
     @c.find(Sequel.expr(:name).like('abc%')).should be_a_kind_of(@c)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (name LIKE 'abc%' ESCAPE '\\') LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM items WHERE (name LIKE 'abc%' ESCAPE '\\') LIMIT 1"]
   end
   
   specify "should accept filter blocks" do
     @c.find{id > 1}.should be_a_kind_of(@c)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (id > 1) LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM items WHERE (id > 1) LIMIT 1"]
 
     @c.find{(x > 1) & (y < 2)}.should be_a_kind_of(@c)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE ((x > 1) AND (y < 2)) LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM items WHERE ((x > 1) AND (y < 2)) LIMIT 1"]
   end
 end
 
 describe Sequel::Model, ".fetch" do
   before do
-    MODEL_DB.reset
+    DB.reset
     @c = Class.new(Sequel::Model(:items))
   end
   
@@ -448,19 +441,19 @@ describe Sequel::Model, ".find_or_create" do
       set_primary_key :id
       columns :x
     end
-    MODEL_DB.reset
+    DB.reset
   end
 
   it "should find the record" do
     @c.find_or_create(:x => 1).should == @c.load(:x=>1, :id=>1)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1"]
   end
   
   it "should create the record if not found" do
     @c.instance_dataset._fetch = @c.dataset._fetch = [[], {:x=>1, :id=>1}]
     @c.instance_dataset.autoid = @c.dataset.autoid = 1
     @c.find_or_create(:x => 1).should == @c.load(:x=>1, :id=>1)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1",
+    DB.sqls.should == ["SELECT * FROM items WHERE (x = 1) LIMIT 1",
       "INSERT INTO items (x) VALUES (1)",
       "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
   end
@@ -469,7 +462,7 @@ describe Sequel::Model, ".find_or_create" do
     @c.instance_dataset._fetch = @c.dataset._fetch = [[], {:x=>1, :id=>1}]
     @c.instance_dataset.autoid = @c.dataset.autoid = 1
     @c.find_or_create(:x => 1){|x| x[:y] = 2}.should == @c.load(:x=>1, :id=>1)
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.first.should == "SELECT * FROM items WHERE (x = 1) LIMIT 1"
     ["INSERT INTO items (x, y) VALUES (1, 2)", "INSERT INTO items (y, x) VALUES (2, 1)"].should include(sqls[1])
     sqls.last.should == "SELECT * FROM items WHERE (id = 1) LIMIT 1"
@@ -489,7 +482,7 @@ describe Sequel::Model, "A model class without a primary key" do
       columns :x
       no_primary_key
     end
-    MODEL_DB.reset
+    DB.reset
   end
 
   it "should be able to insert records without selecting them back" do
@@ -498,7 +491,7 @@ describe Sequel::Model, "A model class without a primary key" do
     i.class.should be(@c)
     i.values.to_hash.should == {:x => 1}
 
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (1)']
+    DB.sqls.should == ['INSERT INTO items (x) VALUES (1)']
   end
 
   it "should raise when deleting" do
@@ -513,7 +506,7 @@ describe Sequel::Model, "A model class without a primary key" do
     o = @c.new(:x => 2)
     o.should be_new
     o.save
-    MODEL_DB.sqls.should == ['INSERT INTO items (x) VALUES (2)']
+    DB.sqls.should == ['INSERT INTO items (x) VALUES (2)']
   end
 end
 
@@ -526,7 +519,7 @@ describe Sequel::Model, "attribute accessors" do
     end
     @dataset = db[:items].columns(:x, :z)
     @c = Class.new(Sequel::Model)
-    MODEL_DB.reset
+    DB.reset
   end
 
   it "should be created on set_dataset" do
@@ -581,46 +574,38 @@ describe Sequel::Model, ".[]" do
   before do
     @c = Class.new(Sequel::Model(:items))
     @c.dataset._fetch = {:name => 'sharon', :id => 1}
-    MODEL_DB.reset
+    DB.reset
   end
 
   it "should return the first record for the given pk" do
     @c[1].should == @c.load(:name => 'sharon', :id => 1)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE id = 1"]
+    DB.sqls.should == ["SELECT * FROM items WHERE id = 1"]
     @c[9999].should == @c.load(:name => 'sharon', :id => 1)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE id = 9999"]
+    DB.sqls.should == ["SELECT * FROM items WHERE id = 9999"]
   end
 
   it "should have #[] return nil if no rows match" do
     @c.dataset._fetch = []
     @c[1].should == nil
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE id = 1"]
+    DB.sqls.should == ["SELECT * FROM items WHERE id = 1"]
   end
 
   it "should work correctly for custom primary key" do
     @c.set_primary_key :name
     @c['sharon'].should == @c.load(:name => 'sharon', :id => 1)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE name = 'sharon'"]
+    DB.sqls.should == ["SELECT * FROM items WHERE name = 'sharon'"]
   end
 
   it "should return the first record for the given pk for a filtered dataset" do
     @c.dataset = @c.dataset.filter(:active=>true)
     @c[1].should == @c.load(:name => 'sharon', :id => 1)
-    MODEL_DB.sqls.should == ["SELECT * FROM items WHERE ((active IS TRUE) AND (id = 1)) LIMIT 1"]
+    DB.sqls.should == ["SELECT * FROM items WHERE ((active IS TRUE) AND (id = 1)) LIMIT 1"]
   end
 
   it "should work correctly for composite primary key specified as array" do
     @c.set_primary_key [:node_id, :kind]
     @c[3921, 201].should be_a_kind_of(@c)
-    sqls = MODEL_DB.sqls
-    sqls.length.should == 1
-    sqls.first.should =~ /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
-  end
-  
-  qspecify "should work correctly for composite primary key specified as separate arguments" do
-    @c.set_primary_key :node_id, :kind
-    @c[3921, 201].should be_a_kind_of(@c)
-    sqls = MODEL_DB.sqls
+    sqls = DB.sqls
     sqls.length.should == 1
     sqls.first.should =~ /^SELECT \* FROM items WHERE \((\(node_id = 3921\) AND \(kind = 201\))|(\(kind = 201\) AND \(node_id = 3921\))\) LIMIT 1$/
   end