sequel 3.48.0 → 4.0.0

data/spec/core/deprecated_spec.rb

@@ -67,12 +67,4 @@ describe "Sequel::Deprecated" do
     @output.first.should == 'foo'
     @output.count.should == 4
   end
-
-  specify "should have deprecated_module return a module where all instance methods are marked deprecated" do
-    m = Module.new{def foo; 1 end}
-    dm = @d.deprecated_module(m){|meth| ["Module##{meth}", "Load the bar extension"]}
-    dm.should_not == m
-    c = Class.new{include dm}.new.foo.should == 1
-    @output.should == ['Module#foo is deprecated and will be removed in Sequel 4.0.  Load the bar extension.']
-  end
 end

data/spec/core/expression_filters_spec.rb

@@ -748,6 +748,10 @@ describe "Sequel core extension replacements" do
     Sequel.blob(o).should equal(o)
   end
 
+  it "Sequel.deep_qualify should do a deep qualification into nested structors" do
+    l(Sequel.deep_qualify(:t, Sequel.+(:c, 1)), "(t.c + 1)")
+  end
+
   it "Sequel.qualify should return a qualified identifier" do
     l(Sequel.qualify(:t, :c), "t.c")
   end
@@ -798,6 +802,8 @@ describe "Sequel core extension replacements" do
     l(Sequel.subscript(:a, 1), 'a[1]')
     l(Sequel.subscript(:a, 1, 2), 'a[1, 2]')
     l(Sequel.subscript(:a, [1, 2]), 'a[1, 2]')
+    l(Sequel.subscript(:a, 1..2), 'a[1:2]')
+    l(Sequel.subscript(:a, 1...3), 'a[1:2]')
   end
 
   it "Sequel.function should return an SQL function" do
@@ -1010,20 +1016,32 @@ describe "Sequel.delay" do
   end
 end
 
-describe "Sequel.parse_json" do
+describe Sequel do
   before do
-    Sequel::JSON = Object.new
-    def (Sequel::JSON).parse(json, opts={})
-      [json, opts]
+    Sequel::JSON = Class.new do
+      self::ParserError = Sequel
+      def self.parse(json, opts={})
+        [json, opts]
+      end
     end
   end
   after do
     Sequel.send(:remove_const, :JSON)
   end
 
-  specify "should parse json correctly" do
+  specify ".parse_json should parse json correctly" do
     Sequel.parse_json('[]').should == ['[]', {:create_additions=>false}]
   end
+
+  specify ".json_parser_error_class should return the related parser error class" do
+    Sequel.json_parser_error_class.should == Sequel
+  end
+
+  specify ".object_to_json should return a json version of the object" do
+    o = Object.new
+    def o.to_json(*args); [1, args]; end
+    Sequel.object_to_json(o, :foo).should == [1, [:foo]]
+  end
 end
 
 describe "Sequel::LiteralString" do

data/spec/core/object_graph_spec.rb

@@ -172,6 +172,10 @@ describe Sequel::Dataset, " graphing" do
     @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :q]).add_graph_aliases(:y=>[:lines, :r]).sql.should == 'SELECT points.q AS x, lines.r AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)'
   end
 
+  it "#add_graph_aliases should raise an error if called without existing graph aliases" do
+    proc{@ds1.add_graph_aliases(:y=>[:lines, :r])}.should raise_error(Sequel::Error)
+  end
+
   it "#set_graph_aliases should allow a third entry to specify an expression to use other than the default" do
     ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x, 1], :y=>[:lines, :y, Sequel.function(:random)])
     ['SELECT 1 AS x, random() AS y FROM points LEFT OUTER JOIN lines ON (lines.x = points.id)',
@@ -205,74 +209,8 @@ describe Sequel::Dataset, " graphing" do
     ].should(include(ds.sql))
   end
 
-  qspecify "#graph_each should split the result set into component tables" do
-    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}],
-      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}],
-      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graph_id_0=>8, :graph_x=>9, :graph_y=>10, :graph_graph_id=>11}]]
-
-    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds2, {:y=>:points__id}, :table_alias=>:graph).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graph=>{:id=>8, :x=>9, :y=>10, :graph_id=>11}}]
-  end
-
   it "#ungraphed should remove the splitting of result sets into component tables" do
     @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}
     @ds1.graph(@ds2, :x=>:id).ungraphed.all.should == [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}]
   end
-
-  qspecify "#graph_each should give a nil value instead of a hash when all values for a table are nil" do
-    @db.fetch = [[{:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil}],
-      [{:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
-      {:id=>2,:x=>4,:y=>5,:lines_id=>nil,:lines_x=>nil,:lines_y=>nil,:graph_id=>nil, :graphs_id=>nil, :name=>nil, :graphs_x=>nil, :graphs_y=>nil, :graphs_lines_x=>nil},
-      {:id=>3,:x=>5,:y=>6,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7, :graphs_id=>7, :name=>8, :graphs_x=>9, :graphs_y=>10, :graphs_lines_x=>11},
-      {:id=>3,:x=>5,:y=>6,:lines_id=>7,:lines_x=>5,:lines_y=>8,:graph_id=>9, :graphs_id=>9, :name=>10, :graphs_x=>10, :graphs_y=>11, :graphs_lines_x=>12}]]
-
-    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>nil}]
-    @ds1.graph(@ds2, :x=>:id).graph(@ds3, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>nil},
-      {:points=>{:id=>2, :x=>4, :y=>5}, :lines=>nil, :graphs=>nil},
-      {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>4, :x=>5, :y=>6, :graph_id=>7}, :graphs=>{:id=>7, :name=>8, :x=>9, :y=>10, :lines_x=>11}},
-      {:points=>{:id=>3, :x=>5, :y=>6}, :lines=>{:id=>7, :x=>5, :y=>8, :graph_id=>9}, :graphs=>{:id=>9, :name=>10, :x=>10, :y=>11, :lines_x=>12}}]
-  end
-
-  qspecify "#graph_each should not give a nil value instead of a hash when any value for a table is false" do
-    @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>nil,:lines_x=>false,:lines_y=>nil,:graph_id=>nil}
-    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :lines=>{:id=>nil, :x=>false, :y=>nil, :graph_id=>nil}}]
-  end
-
-  qspecify "#graph_each should not included tables graphed with the :select => false option in the result set" do
-    @db.fetch = {:id=>1,:x=>2,:y=>3,:graphs_id=>8, :name=>9, :graphs_x=>10, :graphs_y=>11, :lines_x=>12}
-    @ds1.graph(:lines, {:x=>:id}, :select=>false).graph(:graphs, :id=>:graph_id).all.should == [{:points=>{:id=>1, :x=>2, :y=>3}, :graphs=>{:id=>8, :name=>9, :x=>10, :y=>11, :lines_x=>12}}]
-  end
-
-  qspecify "#graph_each should only include the columns selected with #set_graph_aliases and #add_graph_aliases, if called" do
-    @db.fetch = [nil, [{:x=>2,:y=>3}], nil, [{:x=>2}], [{:x=>2, :q=>18}]]
-
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x], :y=>[:lines, :y]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
-    ds = @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :x])
-    ds.all.should == [{:points=>{:x=>2}, :lines=>nil}]
-    ds = ds.add_graph_aliases(:q=>[:points, :r, 18])
-    ds.all.should == [{:points=>{:x=>2, :r=>18}, :lines=>nil}]
-  end
-
-  qspecify "#graph_each should correctly map values when #set_graph_aliases is used with a third argument for each entry" do
-    @db.fetch = [nil, {:x=>2,:y=>3}]
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points, :z1, 2], :y=>[:lines, :z2, Sequel.function(:random)]).all.should == [{:points=>{:z1=>2}, :lines=>{:z2=>3}}]
-  end
-
-  qspecify "#graph_each should correctly map values when #set_graph_aliases is used with a single argument for each entry" do
-    @db.fetch = [nil, {:x=>2,:y=>3}]
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>[:points], :y=>[:lines]).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
-  end
-
-  qspecify "#graph_each should correctly map values when #set_graph_aliases is used with a symbol for each entry" do
-    @db.fetch = [nil, {:x=>2,:y=>3}]
-    @ds1.graph(:lines, :x=>:id).set_graph_aliases(:x=>:points, :y=>:lines).all.should == [{:points=>{:x=>2}, :lines=>{:y=>3}}]
-  end
-
-  qspecify "#graph_each should run the row_proc for graphed datasets" do
-    @ds1.row_proc = proc{|h| h.keys.each{|k| h[k] *= 2}; h}
-    @ds2.row_proc = proc{|h| h.keys.each{|k| h[k] *= 3}; h}
-    @db.fetch = {:id=>1,:x=>2,:y=>3,:lines_id=>4,:lines_x=>5,:lines_y=>6,:graph_id=>7}
-    @ds1.graph(@ds2, :x=>:id).all.should == [{:points=>{:id=>2, :x=>4, :y=>6}, :lines=>{:id=>12, :x=>15, :y=>18, :graph_id=>21}}]
-  end
 end

data/spec/core/schema_spec.rb

@@ -502,11 +502,19 @@ describe "DB#create_table" do
   specify "should accept unnamed constraint definitions with blocks" do
     @db.create_table(:cats) do
       integer :score
-      check{(x.sql_number > 0) & (y.sql_number < 1)}
+      check{(x > 0) & (y < 1)}
     end
     @db.sqls.should == ["CREATE TABLE cats (score integer, CHECK ((x > 0) AND (y < 1)))"]
   end
 
+  specify "should accept unnamed constraint definitions with function calls" do
+    @db.create_table(:cats) do
+      integer :score
+      check{f(x)}
+    end
+    @db.sqls.should == ["CREATE TABLE cats (score integer, CHECK (f(x)))"]
+  end
+
   specify "should accept unnamed constraint definitions" do
     @db.create_table(:cats) do
       check 'price < ?', 100
@@ -514,6 +522,13 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (CHECK (price < 100))"]
   end
 
+  specify "should accept arrays of pairs constraints" do
+    @db.create_table(:cats) do
+      check [[:price, 100]]
+    end
+    @db.sqls.should == ["CREATE TABLE cats (CHECK (price = 100))"]
+  end
+
   specify "should accept hash constraints" do
     @db.create_table(:cats) do
       check :price=>100
@@ -521,6 +536,13 @@ describe "DB#create_table" do
     @db.sqls.should == ["CREATE TABLE cats (CHECK (price = 100))"]
   end
 
+  specify "should accept array constraints" do
+    @db.create_table(:cats) do
+      check [Sequel.expr(:x) > 0, Sequel.expr(:y) < 1]
+    end
+    @db.sqls.should == ["CREATE TABLE cats (CHECK ((x > 0) AND (y < 1)))"]
+  end
+
   specify "should accept named constraint definitions" do
     @db.create_table(:cats) do
       integer :score
@@ -1124,14 +1146,6 @@ describe "Database#create_table" do
     @db.sqls.should == ['CREATE TEMPORARY TABLE test_tmp (id integer NOT NULL PRIMARY KEY AUTOINCREMENT, name text)',
       'CREATE UNIQUE INDEX test_tmp_name_index ON test_tmp (name)']
   end
-
-  qspecify "should not use default schema when creating a temporary table" do
-    @db.default_schema = :foo
-    @db.create_table :test_tmp, :temp => true do
-      column :name, :text
-    end
-    @db.sqls.should == ['CREATE TEMPORARY TABLE test_tmp (name text)']
-  end
 end
 
 describe "Database#alter_table" do
@@ -1287,11 +1301,20 @@ describe "Database#create_view" do
   specify "should construct proper SQL with dataset" do
     @db.create_view :test, @db[:items].select(:a, :b).order(:c)
     @db.sqls.should == ['CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
-    @db.create_or_replace_view :sch__test, "SELECT * FROM xyz"
-    @db.sqls.should == ['DROP VIEW sch.test', 'CREATE VIEW sch.test AS SELECT * FROM xyz']
   end
 
-  specify "should construct proper SQL with dataset" do
+  specify "should handle :columns option" do
+    @db.create_view :test, @db[:items].select(:a, :b).order(:c), :columns=>[:d, :e]
+    @db.sqls.should == ['CREATE VIEW test (d, e) AS SELECT a, b FROM items ORDER BY c']
+    @db.create_view :test, @db[:items].select(:a, :b).order(:c), :columns=>%w'd e'
+    @db.sqls.should == ['CREATE VIEW test (d, e) AS SELECT a, b FROM items ORDER BY c']
+    @db.create_view :test, @db[:items].select(:a, :b).order(:c), :columns=>[Sequel.identifier('d'), Sequel.lit('e')]
+    @db.sqls.should == ['CREATE VIEW test (d, e) AS SELECT a, b FROM items ORDER BY c']
+  end
+
+  specify "should handle create_or_replace_view" do
+    @db.create_or_replace_view :sch__test, "SELECT * FROM xyz"
+    @db.sqls.should == ['DROP VIEW sch.test', 'CREATE VIEW sch.test AS SELECT * FROM xyz']
     @db.create_or_replace_view :test, @db[:items].select(:a, :b).order(:c)
     @db.sqls.should == ['DROP VIEW test', 'CREATE VIEW test AS SELECT a, b FROM items ORDER BY c']
     @db.create_or_replace_view Sequel.identifier(:test), @db[:items].select(:a, :b).order(:c)

data/spec/core/spec_helper.rb

@@ -7,7 +7,6 @@ end
 
 unless Object.const_defined?('Sequel')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  SEQUEL_NO_CORE_EXTENSIONS = true
   require 'sequel/core'
 end
 Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_spec\.rb/}
@@ -38,7 +37,9 @@ end
 
 if ENV['SEQUEL_COLUMNS_INTROSPECTION']
   Sequel.extension :columns_introspection
-  Sequel::Dataset.introspect_all_columns
+  Sequel::Database.extension :columns_introspection
+  Sequel.require 'adapters/mock'
+  Sequel::Mock::Dataset.send(:include, Sequel::ColumnsIntrospection)
 end
 
 Sequel.quote_identifiers = false

data/spec/core_extensions_spec.rb

@@ -7,12 +7,8 @@ end
 
 unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
   $:.unshift(File.join(File.dirname(File.expand_path(__FILE__)), "../../lib/"))
-  if dep_core_extensions = ENV['SEQUEL_DEPRECATED_CORE_EXTENSIONS']
-    require 'sequel'
-  else
-    require 'sequel/no_core_ext'
-  end
-  Sequel::Deprecation.backtrace_filter = false
+  require 'sequel'
+  Sequel::Deprecation.backtrace_filter = true
 end
 
 Sequel.quote_identifiers = false
@@ -21,10 +17,8 @@ Sequel.identifier_output_method = nil
 
 Regexp.send(:include, Sequel::SQL::StringMethods)
 String.send(:include, Sequel::SQL::StringMethods)
-if dep_core_extensions.nil? || dep_core_extensions =~ /OVERRIDDEN/
-  Sequel.extension :core_extensions
-end
-if RUBY_VERSION < '1.9.0' && (dep_core_extensions.nil? || dep_core_extensions =~ /SYMBOL18/)
+Sequel.extension :core_extensions
+if RUBY_VERSION < '1.9.0'
   Sequel.extension :ruby18_symbol_extensions
 end
 
@@ -264,7 +258,7 @@ end
 
 describe "Array#case and Hash#case" do
   before do
-    @d = Sequel::Dataset.new(nil)
+    @d = Sequel.mock.dataset
   end
 
   specify "should return SQL CASE expression" do
@@ -296,7 +290,7 @@ end
 
 describe "Array#sql_value_list and #sql_array" do
   before do
-    @d = Sequel::Dataset.new(nil)
+    @d = Sequel.mock.dataset
   end
 
   specify "should treat the array as an SQL value list instead of conditions when used as a placeholder value" do
@@ -391,7 +385,7 @@ end
   
 describe "#desc" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
   end
   
   specify "should format a DESC clause for a column ref" do
@@ -407,7 +401,7 @@ end
 
 describe "#asc" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
   end
   
   specify "should format a ASC clause for a column ref" do
@@ -423,7 +417,7 @@ end
 
 describe "#as" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
   end
   
   specify "should format a AS clause for a column ref" do
@@ -488,7 +482,7 @@ end
 if RUBY_VERSION < '1.9.0'
   describe "Symbol#[]" do
     specify "should format an SQL Function" do
-      ds = Sequel::Dataset.new(nil)
+      ds = Sequel.mock.dataset
       ds.literal(:xyz[]).should == 'xyz()'
       ds.literal(:xyz[1]).should == 'xyz(1)'
       ds.literal(:xyz[1, 2, :abc[3]]).should == 'xyz(1, 2, abc(3))'
@@ -498,7 +492,7 @@ end
 
 describe "Symbol#*" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
   end
   
   specify "should format a qualified wildcard if no argument" do
@@ -518,7 +512,7 @@ end
 
 describe "Symbol" do
   before do
-    @ds = Sequel::Dataset.new(nil)
+    @ds = Sequel.mock.dataset
     @ds.quote_identifiers = true
     @ds.identifier_input_method = :upcase
   end
@@ -634,7 +628,7 @@ 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)
+    Sequel.extension(:pg_array, :pg_array_ops, :pg_hstore, :pg_hstore_ops, :pg_json, :pg_json_ops, :pg_range, :pg_range_ops, :pg_row, :pg_row_ops)
   end
 
   it "Symbol#pg_array should return an ArrayOp" do
@@ -649,6 +643,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/arbitrary_servers_spec.rb

@@ -65,7 +65,7 @@ describe "arbtirary servers" do
   end
 
   specify "should work correctly with server_block plugin" do
-    @db.extend Sequel::ServerBlock
+    @db.extension :server_block
     @db.with_server(:host=>'host1', :database=>'db1') do
       @db.synchronize do |c|
         c.opts[:host].should == 'host1'
@@ -77,9 +77,8 @@ describe "arbtirary servers" do
     end
   end
 
-
   specify "should respect multithreaded access with server block plugin" do
-    @db.extend Sequel::ServerBlock
+    @db.extension :server_block
     q, q1 = Queue.new, Queue.new
     
     t = nil

data/spec/extensions/association_dependencies_spec.rb

@@ -15,61 +15,61 @@ describe "AssociationDependencies plugin" do
     @Artist.one_to_one :first_album, :class=>@Album, :key=>:artist_id, :conditions=>{:position=>1}
     @Artist.many_to_many :other_artists, :class=>@Artist, :join_table=>:aoa, :left_key=>:l, :right_key=>:r
     @Album.many_to_one :artist, :class=>@Artist
-    MODEL_DB.reset
+    DB.reset
   end
 
   specify "should allow destroying associated many_to_one associated object" do
     @Album.add_association_dependencies :artist=>:destroy
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated many_to_one associated object" do
     @Album.add_association_dependencies :artist=>:delete
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE (artists.id = 2)']
+    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE (artists.id = 2)']
   end
   
   specify "should allow destroying associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:destroy
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE ((position = 1) AND (albums.artist_id = 2)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['SELECT * FROM albums WHERE ((position = 1) AND (albums.artist_id = 2)) LIMIT 1', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated one_to_one associated object" do
     @Artist.add_association_dependencies :first_album=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE ((position = 1) AND (albums.artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['DELETE FROM albums WHERE ((position = 1) AND (albums.artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow destroying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:destroy
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
   end
   
   specify "should allow nullifying associated one_to_one objects" do
     @Artist.add_association_dependencies :first_album=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((position = 1) AND (artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE ((position = 1) AND (artist_id = 2))', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow nullifying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow nullifying associated many_to_many associations" do
     @Artist.add_association_dependencies :other_artists=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should raise an error if attempting to nullify a many_to_one association" do
@@ -97,21 +97,21 @@ describe "AssociationDependencies plugin" do
   specify "should allow specifying association dependencies in the plugin call" do
     @Album.plugin :association_dependencies, :artist=>:destroy
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should work with subclasses" do
     c = Class.new(@Album)
     c.add_association_dependencies :artist=>:destroy
     c.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
 
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1']
+    DB.sqls.should == ['DELETE FROM albums WHERE id = 1']
 
     @Album.add_association_dependencies :artist=>:destroy
     c2 = Class.new(@Album)
     c2.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
+    DB.sqls.should == ['DELETE FROM albums WHERE id = 1', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE id = 2']
   end
 end