sequel 3.48.0 → 4.0.0

data/spec/extensions/auto_validations_spec.rb

@@ -43,6 +43,13 @@ describe "Sequel::Plugins::AutoValidations" do
     @m.errors.should == {[:name, :num]=>["is already taken"]}
   end
 
+  it "should handle databases that don't support index parsing" do
+    def (@m.db).supports_index_parsing?() false end
+    @m.model.send(:setup_auto_validations)
+    @m.set(:d=>Date.today, :num=>1, :name=>'1')
+    @m.valid?.should be_true
+  end
+
   it "should support :not_null=>:presence option" do
     @c.plugin :auto_validations, :not_null=>:presence
     @m.set(:d=>Date.today, :num=>'')

data/spec/extensions/blacklist_security_spec.rb

@@ -11,7 +11,7 @@ describe Sequel::Model, "#(set|update)_except" do
     end
     @c.strict_param_setting = false
     @o1 = @c.new
-    MODEL_DB.reset
+    DB.reset
   end
 
   it "should raise errors if not all hash fields can be set and strict_param_setting is true" do
@@ -31,9 +31,9 @@ describe Sequel::Model, "#(set|update)_except" do
 
   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.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    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.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
+    DB.sqls.should == ["INSERT INTO items (x) VALUES (1)", "SELECT * FROM items WHERE (id = 10) LIMIT 1"]
   end
 end
 
@@ -67,7 +67,7 @@ describe Sequel::Model, ".restricted_columns " do
     i = @c.new
     i.update(:x => 7, :z => 9)
     i.values.should == {:x => 7}
-    MODEL_DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+    DB.sqls.should == ["INSERT INTO blahblah (x) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 
   it "should have allowed take precedence over restricted" do
@@ -82,6 +82,6 @@ describe Sequel::Model, ".restricted_columns " do
     i = @c.new
     i.update(:y => 7, :z => 9)
     i.values.should == {:y => 7}
-    MODEL_DB.sqls.should == ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
+    DB.sqls.should == ["INSERT INTO blahblah (y) VALUES (7)", "SELECT * FROM blahblah WHERE (id = 10) LIMIT 1"]
   end
 end

data/spec/extensions/blank_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
+Sequel.extension :blank
+
 describe "Object#blank?" do
   specify "it should be true if the object responds true to empty?" do
     [].blank?.should == true

data/spec/extensions/class_table_inheritance_spec.rb

@@ -24,7 +24,7 @@ describe "class_table_inheritance plugin" do
       end
     end
     class ::Employee < Sequel::Model(@db)
-      def _refresh(x); @values[:id] = 1 end
+      def _save_refresh; @values[:id] = 1 end
       def self.columns
         dataset.columns
       end
@@ -204,7 +204,7 @@ describe "class_table_inheritance plugin" do
   it "should handle many_to_one relationships correctly" do
     Manager.dataset._fetch = {:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3}
     Staff.load(:manager_id=>3).manager.should == Executive.load(:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3)
-    @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (managers.id = 3) LIMIT 1']
+    @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (id = 3) LIMIT 1']
   end
   
   it "should handle one_to_many relationships correctly" do

data/spec/extensions/columns_introspection_spec.rb

@@ -1,33 +1,11 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper')
 
-describe "Sequel::Dataset.introspect_all_columns" do
-  before do
-    @db = MODEL_DB
-    @ds = @db[:a]
-    class Sequel::Dataset
-      # Handle case where introspect_all_columns has already been called
-      alias columns columns_without_introspection unless instance_methods(false).map{|x| x.to_s}.include?('columns')
-    end
-  end
-  after do
-    class Sequel::Dataset
-      alias columns columns_without_introspection
-    end
-  end
-
-  qspecify "should turn on column introspection by default" do
-    Sequel::Dataset.introspect_all_columns
-    @db.reset
-    @ds.select(:x).columns.should == [:x]
-    @db.sqls.length.should == 0
-  end
-end
+Sequel.extension :columns_introspection
 
 describe "columns_introspection extension" do
   before do
-    @db = Sequel.mock
+    @db = Sequel.mock.extension(:columns_introspection)
     @ds = @db[:a]
-    @ds.extend(Sequel::ColumnsIntrospection.dup) # dup to allow multiple places in class hierarchy
     @db.sqls
   end
 
@@ -109,9 +87,4 @@ describe "columns_introspection extension" do
     @ds.select(1).columns
     @db.sqls.length.should == 1
   end
-
-  specify "should not have column introspection on by default" do
-    @db[:a].select(:x).columns
-    @db.sqls.length.should == 1
-  end
 end

data/spec/extensions/composition_spec.rb

@@ -6,7 +6,7 @@ describe "Composition plugin" do
     @c.plugin :composition
     @c.columns :id, :year, :month, :day
     @o = @c.load(:id=>1, :year=>1, :month=>2, :day=>3)
-    MODEL_DB.reset
+    DB.reset
   end
   
   it ".composition should add compositions" do
@@ -48,7 +48,7 @@ describe "Composition plugin" do
     @c.composition :date, :composer=>proc{Date.new(year+1, month+2, day+3)}, :decomposer=>proc{[:year, :month, :day].each{|s| self.send("#{s}=", date.send(s) * 2)}}
     @o.date.should == Date.new(2, 4, 6)
     @o.save
-    sql = MODEL_DB.sqls.last
+    sql = DB.sqls.last
     sql.should include("year = 4")
     sql.should include("month = 8")
     sql.should include("day = 12")
@@ -90,13 +90,6 @@ describe "Composition plugin" do
     called.should == true
   end
 
-  it "should clear compositions cache when using set_values" do
-    @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @o.date = Date.new(3, 4, 5)
-    @o.set_values(:id=>1)
-    @o.compositions.should == {}
-  end
-
   it "should clear compositions cache when refreshing" do
     @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
     @o.date = Date.new(3, 4, 5)
@@ -104,16 +97,16 @@ describe "Composition plugin" do
     @o.compositions.should == {}
   end
 
-  it "should clear compositions cache when refreshing after save" do
+  it "should not clear compositions cache when refreshing after save" do
     @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {}
+    @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {:date=>Date.new(3, 4, 5)}
   end
 
-  it "should clear compositions cache when saving with insert_select" do
+  it "should not clear compositions cache when saving with insert_select" do
     def (@c.instance_dataset).supports_insert_select?() true end
     def (@c.instance_dataset).insert_select(*) {:id=>1} end
     @c.composition :date, :composer=>proc{}, :decomposer=>proc{}
-    @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {}
+    @c.create(:date=>Date.new(3, 4, 5)).compositions.should == {:date=>Date.new(3, 4, 5)}
   end
 
   it "should instantiate compositions lazily" do
@@ -159,7 +152,7 @@ describe "Composition plugin" do
     @o.date.month.should == 6
     @o.date = c.new(3, 4)
     @o.save
-    sql = MODEL_DB.sqls.last
+    sql = DB.sqls.last
     sql.should include("year = 6")
     sql.should include("month = 12")
   end
@@ -181,7 +174,7 @@ describe "Composition plugin" do
     @o.date.m.should == 6
     @o.date = c.new(3, 4)
     @o.save
-    sql = MODEL_DB.sqls.last
+    sql = DB.sqls.last
     sql.should include("year = 6")
     sql.should include("month = 12")
   end
@@ -195,7 +188,7 @@ describe "Composition plugin" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @o.date = nil
     @o.save
-    sql = MODEL_DB.sqls.last
+    sql = DB.sqls.last
     sql.should include("year = NULL")
     sql.should include("month = NULL")
     sql.should include("day = NULL")
@@ -214,7 +207,7 @@ describe "Composition plugin" do
     o = c.load(:id=>1, :year=>1, :month=>2, :day=>3)
     o.date.should == Date.new(1, 2, 3)
     o.save
-    sql = MODEL_DB.sqls.last
+    sql = DB.sqls.last
     sql.should include("year = 1")
     sql.should include("month = 2")
     sql.should include("day = 3")

data/spec/extensions/core_refinements_spec.rb

@@ -1,6 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 if RUBY_VERSION >= '2.0.0'
+Sequel.extension :core_refinements, :pg_array, :pg_hstore, :pg_row, :pg_range, :pg_row_ops, :pg_range_ops, :pg_array_ops, :pg_hstore_ops, :pg_json, :pg_json_ops
 using Sequel::CoreRefinements
 
 describe "Core refinements" do
@@ -451,7 +452,6 @@ end
 describe "Postgres extensions integration" do
   before do
     @db = Sequel.mock
-    Sequel.extension(:pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops, :pg_json, :pg_range, :pg_range_ops, :pg_row, :pg_row_ops)
   end
 
   it "Symbol#pg_array should return an ArrayOp" do
@@ -466,6 +466,10 @@ describe "Postgres extensions integration" do
     @db.literal(:a.hstore['a']).should == "(a -> 'a')"
   end
 
+  it "Symbol#pg_json should return an JSONOp" do
+    @db.literal(:a.pg_json[%w'a b']).should == "(a #> ARRAY['a','b'])"
+  end
+
   it "Symbol#pg_range should return a RangeOp" do
     @db.literal(:a.pg_range.lower).should == "lower(a)"
   end

data/spec/extensions/dataset_associations_spec.rb

@@ -23,11 +23,15 @@ describe "Sequel::Plugins::DatasetAssociations" do
     @Tag.columns :id, :name
 
     @Artist.plugin :many_through_many
+    @Artist.plugin :pg_array_associations
+    @Tag.plugin :pg_array_associations
     @Artist.one_to_many :albums, :class=>@Album
     @Artist.one_to_one :first_album, :class=>@Album
     @Album.many_to_one :artist, :class=>@Artist
     @Album.many_to_many :tags, :class=>@Tag
     @Tag.many_to_many :albums, :class=>@Album
+    @Artist.pg_array_to_many :artist_tags, :class=>@Tag, :key=>:tag_ids
+    @Tag.many_to_pg_array :artists, :class=>@Artist
     @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
   end
 
@@ -66,6 +70,20 @@ describe "Sequel::Plugins::DatasetAssociations" do
     ds.sql.should == "SELECT tags.* FROM tags WHERE (tags.id IN (SELECT albums_tags.tag_id FROM artists INNER JOIN albums ON (albums.artist_id = artists.id) INNER JOIN albums_tags ON (albums_tags.album_id = albums.id)))"
   end
 
+  it "should work for pg_array_to_many associations" do
+    ds = @Artist.artist_tags
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Tag
+    ds.sql.should == "SELECT * FROM tags WHERE (id IN (SELECT unnest(artists.tag_ids) FROM artists))"
+  end
+
+  it "should work for many_to_pg_array associations" do
+    ds = @Tag.artists
+    ds.should be_a_kind_of(Sequel::Dataset)
+    ds.model.should == @Artist
+    ds.sql.should == "SELECT * FROM artists WHERE coalesce((tag_ids && (SELECT array_agg(tags.id) FROM tags)), 'f')"
+  end
+
   it "should have an associated method that takes an association symbol" do
     ds = @Album.associated(:artist)
     ds.should be_a_kind_of(Sequel::Dataset)

data/spec/extensions/date_arithmetic_spec.rb

@@ -142,9 +142,9 @@ describe "date_arithmetic extension" do
     db.literal(Sequel.date_add(:a, @h2)).should == "(CAST(a AS timestamp) + 1 years + 1 months + 1 days + 1 hours + 1 minutes + 1 seconds)"
   end
 
-  qspecify "should raise error if literalizing on an unsupported database" do
+  specify "should raise error if literalizing on an unsupported database" do
     db = Sequel.mock
     db.extension :date_arithmetic
-    lambda{db.literal(Sequel.date_add(:a, @h0))}.should raise_error(Sequel::NotImplemented)
+    lambda{db.literal(Sequel.date_add(:a, @h0))}.should raise_error(Sequel::Error)
   end
 end

data/spec/extensions/defaults_setter_spec.rb

@@ -15,7 +15,7 @@ describe "Sequel::Plugins::DefaultsSetter" do
   end
 
   it "should set default value upon initialization" do
-    @pr.call(2).new.values.should == {:a=>2}
+    @pr.call(2).new.a.should == 2
   end
 
   it "should not mark the column as modified" do
@@ -23,11 +23,11 @@ describe "Sequel::Plugins::DefaultsSetter" do
   end
 
   it "should not set a default of nil" do
-    @pr.call(nil).new.values.should == {}
+    @pr.call(nil).new.class.default_values.should == {}
   end
 
   it "should set a default of false" do
-    @pr.call(false).new.values.should == {:a=>false}
+    @pr.call(false).new.a.should == false
   end
 
   it "should handle Sequel::CURRENT_DATE default by using the current Date" do
@@ -49,12 +49,12 @@ describe "Sequel::Plugins::DefaultsSetter" do
 
   it "should not override a given value" do
     @pr.call(2)
-    @c.new('a'=>3).values.should == {:a=>3}
-    @c.new('a'=>nil).values.should == {:a=>nil}
+    @c.new('a'=>3).a.should == 3
+    @c.new('a'=>nil).a.should == nil
   end
 
   it "should work correctly when subclassing" do
-    Class.new(@pr.call(2)).new.values.should == {:a=>2}
+    Class.new(@pr.call(2)).new.a.should == 2
   end
 
   it "should contain the default values in default_values" do
@@ -65,19 +65,19 @@ describe "Sequel::Plugins::DefaultsSetter" do
   it "should allow modifications of default values" do
     @pr.call(2)
     @c.default_values[:a] = 3
-    @c.new.values.should == {:a => 3}
+    @c.new.a.should == 3
   end
 
   it "should allow proc default values" do
     @pr.call(2)
     @c.default_values[:a] = proc{3}
-    @c.new.values.should == {:a => 3}
+    @c.new.a.should == 3
   end
 
   it "should have procs that set default values set them to nil" do
     @pr.call(2)
     @c.default_values[:a] = proc{nil}
-    @c.new.values.should == {:a => nil}
+    @c.new.a.should == nil
   end
 
   it "should work correctly on a model without a dataset" do

data/spec/extensions/dirty_spec.rb

@@ -88,11 +88,6 @@ describe "Sequel::Plugins::Dirty" do
       @o.values.has_key?(:missing_changed).should == false
     end
     
-    it "set_values should clear the cached initial values" do
-      @o.set_values(:id=>1)
-      @o.column_changes.should == {}
-    end
-    
     it "refresh should clear the cached initial values" do
       @o.refresh
       @o.column_changes.should == {}

data/spec/extensions/eval_inspect_spec.rb

@@ -1,5 +1,7 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
+Sequel.extension :eval_inspect
+
 describe "eval_inspect extension" do
   before do
     @ds = Sequel.mock.dataset

data/spec/extensions/force_encoding_spec.rb

@@ -83,7 +83,7 @@ describe "force_encoding plugin" do
   
   specify "should work when saving new model instances" do
     o = @c.new
-    ds = MODEL_DB[:a]
+    ds = DB[:a]
     def ds.first
       s = 'blah'
       s.force_encoding('US-ASCII')
@@ -97,7 +97,7 @@ describe "force_encoding plugin" do
   
   specify "should work when refreshing model instances" do
     o = @c.load(:id=>1, :x=>'as')
-    ds = MODEL_DB[:a]
+    ds = DB[:a]
     def ds.first
       s = 'blah'
       s.force_encoding('US-ASCII')
@@ -108,22 +108,6 @@ describe "force_encoding plugin" do
     o.x.should == 'blah'
     o.x.encoding.should == @e1
   end
-  
-  specify "should work when used with the identity_map plugin if the identity_map plugin is setup first" do
-    @c = Class.new(Sequel::Model) do
-    end
-    @c.columns :id, :x
-    @c.plugin :identity_map
-    @c.plugin :force_encoding, 'UTF-8'
-    @c.with_identity_map do
-      o = @c.load(:id=>1)
-      s = 'blah'
-      s.force_encoding('US-ASCII')
-      @c.load(:id=>1, :x=>s)
-      o.x.should == 'blah'
-      o.x.encoding.should == @e1
-    end
-  end
 end 
 else
   skip_warn "force_encoding plugin: only works on ruby 1.9+"

data/spec/extensions/hash_aliases_spec.rb

@@ -9,8 +9,16 @@ describe "hash_aliases extension" do
     @ds.from(:a=>:b).sql.should == "SELECT * FROM a AS b"
   end
 
+  it "should not affect other arguments to from" do
+    @ds.from(:a, :b).sql.should == "SELECT * FROM a, b"
+  end
+
   it "should make select treat hash arguments as alias specifiers" do
     @ds.select(:a=>:b).sql.should == "SELECT a AS b"
     @ds.select{{:a=>:b}}.sql.should == "SELECT a AS b"
   end
+
+  it "should not affect other arguments to select" do
+    @ds.select(:a, :b).sql.should == "SELECT a, b"
+  end
 end

data/spec/extensions/hook_class_methods_spec.rb

@@ -9,7 +9,7 @@ end
 
 describe Sequel::Model, "hook_class_methods plugin" do
   before do
-    MODEL_DB.reset
+    DB.reset
   end
   
   specify "should be definable using a block" do
@@ -164,165 +164,146 @@ describe Sequel::Model, "hook_class_methods plugin" do
   end
 end
 
-describe "Model#after_initialize" do
-  qspecify "should be called after initialization" do
-    values1 = nil
-    reached_after_initialized = false
-    
-    a = model_class.call Sequel::Model do
-      columns :x, :y
-      after_initialize do
-        values1 = @values.clone
-        reached_after_initialized = true
-      end
-    end
-    
-    a.new(:x => 1, :y => 2)
-    values1.should == {:x => 1, :y => 2}
-    reached_after_initialized.should == true
-  end
-end
-
 describe "Model#before_create && Model#after_create" do
   before do
-    MODEL_DB.reset
+    DB.reset
 
     @c = model_class.call Sequel::Model(:items)  do
       columns :x
       no_primary_key
       
-      after_create {MODEL_DB << "BLAH after"}
+      after_create {DB << "BLAH after"}
     end
   end
   
   specify "should be called around new record creation" do
-    @c.before_create {MODEL_DB << "BLAH before"}
+    @c.before_create {DB << "BLAH before"}
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
+    DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
   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.before_create{false}
     proc{@c.load(:id => 2233).save}.should_not raise_error(Sequel::ValidationFailed)
     proc{@c.create(:x => 2)}.should raise_error(Sequel::BeforeHookFailed)
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 
   specify ".create should cancel the save and return nil if before_create returns false and raise_on_save_failure is false" do
     @c.before_create{false}
     @c.raise_on_save_failure = false
     @c.create(:x => 2).should == nil
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 end
 
 describe "Model#before_update && Model#after_update" do
   before do
-    MODEL_DB.reset
+    DB.reset
 
     @c = model_class.call(Sequel::Model(:items)) do
-      after_update {MODEL_DB << "BLAH after"}
+      after_update {DB << "BLAH after"}
     end
   end
   
   specify "should be called around record update" do
-    @c.before_update {MODEL_DB << "BLAH before"}
+    @c.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.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 return nil if before_update returns false and raise_on_save_failure is false" do
     @c.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
 
 describe "Model#before_save && Model#after_save" do
   before do
-    MODEL_DB.reset
+    DB.reset
 
     @c = model_class.call(Sequel::Model(:items)) do
       columns :x
-      after_save {MODEL_DB << "BLAH after"}
+      after_save {DB << "BLAH after"}
     end
   end
   
   specify "should be called around record update" do
-    @c.before_save {MODEL_DB << "BLAH before"}
+    @c.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.before_save {MODEL_DB << "BLAH before"}
+    @c.before_save {DB << "BLAH before"}
     @c.no_primary_key
     @c.create(:x => 2)
-    MODEL_DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
+    DB.sqls.should == ['BLAH before', 'INSERT INTO items (x) VALUES (2)', 'BLAH after']
   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.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 return nil if before_save returns false and raise_on_save_failure is false" do
     @c.before_save{false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).save.should == nil
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 end
 
 describe "Model#before_destroy && Model#after_destroy" do
   before do
-    MODEL_DB.reset
+    DB.reset
 
     @c = model_class.call(Sequel::Model(:items)) do
-      after_destroy {MODEL_DB << "BLAH after"}
+      after_destroy {DB << "BLAH after"}
     end
   end
   
   specify "should be called around record destruction" do
-    @c.before_destroy {MODEL_DB << "BLAH before"}
+    @c.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.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 return nil if before_destroy returns false and raise_on_save_failure is false" do
     @c.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
 
 describe "Model#before_validation && Model#after_validation" do
   before do
-    MODEL_DB.reset
+    DB.reset
 
     @c = model_class.call(Sequel::Model(:items)) do
       plugin :validation_class_methods
-      after_validation{MODEL_DB << "BLAH after"}
+      after_validation{DB << "BLAH after"}
 
       def self.validate(o)
         o.errors.add(:id, 'not valid') unless o[:id] == 2233
@@ -332,42 +313,42 @@ describe "Model#before_validation && Model#after_validation" do
   end
   
   specify "should be called around validation" do
-    @c.before_validation{MODEL_DB << "BLAH before"}
+    @c.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']
 
-    MODEL_DB.sqls.clear
+    DB.sqls.clear
     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.before_validation{MODEL_DB << "BLAH before"}
+    @c.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)']
 
-    MODEL_DB.sqls.clear
+    DB.sqls.clear
     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.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 return nil if before_validation returns false and raise_on_save_failure is false" do
     @c.before_validation{false}
     @c.raise_on_save_failure = false
     @c.load(:id => 2233).save.should == nil
-    MODEL_DB.sqls.should == []
+    DB.sqls.should == []
   end
 end