sequel 3.9.0 → 3.10.0

data/lib/sequel/plugins/typecast_on_load.rb

@@ -46,14 +46,25 @@ module Sequel
         # ensuring the model object will have the correct typecasting even
         # if the database doesn't typecast the columns correctly.
         def load(values)
-          o = super
-          typecast_on_load_columns.each do |c|
+          super.load_typecast
+        end
+      end
+
+      module InstanceMethods
+        def load_typecast
+          model.typecast_on_load_columns.each do |c|
             if v = values[c]
-              o.send("#{c}=", v)
+              send("#{c}=", v)
             end
           end
-          o.changed_columns.clear
-          o
+          changed_columns.clear
+          self
+        end
+
+        private
+
+        def _refresh(dataset)
+          super.load_typecast
         end
       end
     end

data/lib/sequel/sql.rb

@@ -4,7 +4,17 @@ module Sequel
     # the Ruby 1.9 BasicObject class.  This is used in a few places where proxy
     # objects are needed that respond to any method call.
     class BasicObject
-      (instance_methods - %w"__id__ __send__ instance_eval == equal?").each{|m| undef_method(m)}
+      # The instance methods to not remove from the class when removing
+      # other methods.
+      KEEP_METHODS = %w"__id__ __send__ __metaclass__ instance_eval == equal? initialize"
+
+      # Remove all but the most basic instance methods from the class.  A separate
+      # method so that it can be called again if necessary if you load libraries
+      # after Sequel that add instance methods to Object.
+      def self.remove_methods!
+        ((private_instance_methods + instance_methods) - KEEP_METHODS).each{|m| undef_method(m)}
+      end
+      remove_methods!
     end
   else
     # If on 1.9, create a Sequel::BasicObject class that is just like the
@@ -18,6 +28,10 @@ module Sequel
       def self.const_missing(name)
         ::Object.const_get(name)
       end
+
+      # No-op method on ruby 1.9, which has a real BasicObject class.
+      def self.remove_methods!
+      end
     end
   end
 
@@ -132,6 +146,9 @@ module Sequel
         case op
         when *N_ARITY_OPERATORS
           raise(Error, "The #{op} operator requires at least 1 argument") unless args.length >= 1
+          old_args = args
+          args = []
+          old_args.each{|a| a.is_a?(self.class) && a.op == op ? args.concat(a.args) : args.push(a)}
         when *TWO_ARITY_OPERATORS
           raise(Error, "The #{op} operator requires precisely 2 arguments") unless args.length == 2
         when *ONE_ARITY_OPERATORS

data/lib/sequel/version.rb

@@ -1,6 +1,6 @@
 module Sequel
   MAJOR = 3
-  MINOR = 9
+  MINOR = 10
   TINY  = 0
   
   VERSION = [MAJOR, MINOR, TINY].join('.')

data/spec/adapters/mssql_spec.rb

@@ -53,6 +53,10 @@ context "A MSSQL database" do
     proc{@db.server_version}.should_not raise_error
     proc{@db.dataset.server_version}.should_not raise_error
   end
+  
+  specify "should work with NOLOCK" do
+    @db.transaction{@db[:test3].nolock.all.should == []}
+  end
 end
 
 context "MSSQL Dataset#join_table" do

data/spec/adapters/mysql_spec.rb

@@ -83,6 +83,10 @@ context "A MySQL database" do
   specify "should handle the creation and dropping of an InnoDB table with foreign keys" do
     proc{MYSQL_DB.create_table!(:test_innodb, :engine=>:InnoDB){primary_key :id; foreign_key :fk, :test_innodb, :key=>:id}}.should_not raise_error
   end
+  
+  specify "should support for_share" do
+    MYSQL_DB.transaction{MYSQL_DB[:test2].for_share.all.should == []}
+  end
 end
 
 if MYSQL_DB.class.adapter_scheme == :mysql

data/spec/adapters/postgres_spec.rb

@@ -130,11 +130,6 @@ context "A PostgreSQL dataset" do
     @d.filter(:name => /^bc/).count.should == 1
   end
   
-  specify "should support for_share and for_update" do
-    @d.for_share.all.should == []
-    @d.for_update.all.should == []
-  end
-  
   specify "#lock should lock tables and yield if a block is given" do
     @d.lock('EXCLUSIVE'){@d.insert(:name=>'a')}
   end
@@ -153,6 +148,61 @@ context "A PostgreSQL dataset" do
   end
 end
 
+if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
+  describe "Dataset#for_update support" do
+    before do
+      @db = POSTGRES_DB.create_table!(:items) do
+        primary_key :id
+        Integer :number
+        String :name
+      end
+      @ds = POSTGRES_DB[:items]
+      clear_sqls
+    end
+    after do
+      POSTGRES_DB.drop_table(:items)
+      POSTGRES_DB.disconnect
+    end
+    
+    specify "should handle FOR UPDATE" do
+      @ds.insert(:number=>20)
+      c = nil
+      t = nil
+      POSTGRES_DB.transaction do
+        @ds.for_update.first(:id=>1)
+        t = Thread.new do
+          POSTGRES_DB.transaction do
+            @ds.filter(:id=>1).update(:name=>'Jim')
+            c = @ds.first(:id=>1)
+          end
+        end
+        sleep 0.01
+        @ds.filter(:id=>1).update(:number=>30)
+      end
+      t.join
+      c.should == {:id=>1, :number=>30, :name=>'Jim'}
+    end
+  
+    specify "should handle FOR SHARE" do
+      @ds.insert(:number=>20)
+      c = nil
+      t = nil
+      POSTGRES_DB.transaction do
+        @ds.for_share.first(:id=>1)
+        t = Thread.new do
+          POSTGRES_DB.transaction do
+            c = @ds.for_share.filter(:id=>1).first
+          end
+        end
+        sleep 0.05
+        @ds.filter(:id=>1).update(:name=>'Jim')
+        c.should == {:id=>1, :number=>20, :name=>nil}
+      end
+      t.join
+    end
+  end
+end
+
 context "A PostgreSQL dataset with a timestamp field" do
   before do
     @d = POSTGRES_DB[:test3]

data/spec/core/database_spec.rb

@@ -794,6 +794,7 @@ context "A Database adapter with a scheme" do
     x = nil
     y = nil
     z = nil
+    returnValue = 'anything'
 
     p = proc do |c|
       c.should be_a_kind_of(CCC)
@@ -802,15 +803,16 @@ context "A Database adapter with a scheme" do
       z = y
       y = x
       x = c
+      returnValue
     end
-    Sequel::Database.connect('ccc://localhost/db', &p).should == nil
+    Sequel::Database.connect('ccc://localhost/db', &p).should == returnValue
     CCC::DISCONNECTS.should == [x]
 
-    Sequel.connect('ccc://localhost/db', &p).should == nil
+    Sequel.connect('ccc://localhost/db', &p).should == returnValue
     CCC::DISCONNECTS.should == [y, x]
 
     Sequel.send(:def_adapter_method, :ccc)
-    Sequel.ccc('db', :host=>'localhost', &p).should == nil
+    Sequel.ccc('db', :host=>'localhost', &p).should == returnValue
     CCC::DISCONNECTS.should == [z, y, x]
   end
 

data/spec/core/dataset_spec.rb

@@ -702,9 +702,9 @@ context "Dataset#exclude" do
   
   specify "should allow the use of blocks and arguments simultaneously" do
     @dataset.exclude(:id => (7..11)){:id.sql_number < 6}.sql.should == 
-      'SELECT * FROM test WHERE (((id < 7) OR (id > 11)) OR (id >= 6))'
+      'SELECT * FROM test WHERE ((id < 7) OR (id > 11) OR (id >= 6))'
     @dataset.exclude([:id, 1], [:x, 3]){:id.sql_number < 6}.sql.should == 
-      'SELECT * FROM test WHERE (((id != 1) OR (x != 3)) OR (id >= 6))'
+      'SELECT * FROM test WHERE ((id != 1) OR (x != 3) OR (id >= 6))'
   end
 end
 
@@ -1580,36 +1580,36 @@ context "Dataset#group_and_count" do
   
   specify "should format SQL properly" do
     @ds.group_and_count(:name).sql.should == 
-      "SELECT name, count(*) AS count FROM test GROUP BY name ORDER BY count"
+      "SELECT name, count(*) AS count FROM test GROUP BY name"
   end
 
   specify "should accept multiple columns for grouping" do
     @ds.group_and_count(:a, :b).sql.should == 
-      "SELECT a, b, count(*) AS count FROM test GROUP BY a, b ORDER BY count"
+      "SELECT a, b, count(*) AS count FROM test GROUP BY a, b"
   end
 
   specify "should format column aliases in the select clause but not in the group clause" do
     @ds.group_and_count(:name___n).sql.should ==
-      "SELECT name AS n, count(*) AS count FROM test GROUP BY name ORDER BY count"
+      "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
     @ds.group_and_count(:name__n).sql.should ==
-      "SELECT name.n, count(*) AS count FROM test GROUP BY name.n ORDER BY count"
+      "SELECT name.n, count(*) AS count FROM test GROUP BY name.n"
   end
 
   specify "should handle identifiers" do
     @ds.group_and_count(:name___n.identifier).sql.should ==
-      "SELECT name___n, count(*) AS count FROM test GROUP BY name___n ORDER BY count"
+      "SELECT name___n, count(*) AS count FROM test GROUP BY name___n"
   end
 
   specify "should handle literal strings" do
     @ds.group_and_count("name".lit).sql.should ==
-      "SELECT name, count(*) AS count FROM test GROUP BY name ORDER BY count"
+      "SELECT name, count(*) AS count FROM test GROUP BY name"
   end
 
   specify "should handle aliased expressions" do
     @ds.group_and_count(:name.as(:n)).sql.should ==
-      "SELECT name AS n, count(*) AS count FROM test GROUP BY name ORDER BY count"
+      "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
     @ds.group_and_count(:name.identifier.as(:n)).sql.should ==
-      "SELECT name AS n, count(*) AS count FROM test GROUP BY name ORDER BY count"
+      "SELECT name AS n, count(*) AS count FROM test GROUP BY name"
   end
 end
 
@@ -1632,6 +1632,59 @@ context "Dataset#empty?" do
   end
 end
 
+context "Dataset#first_source_alias" do
+  before do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should be the entire first source if not aliased" do
+    @ds.from(:t).first_source_alias.should == :t
+    @ds.from(:t__a.identifier).first_source_alias.should == :t__a.identifier
+    @ds.from(:s__t).first_source_alias.should == :s__t
+    @ds.from(:t.qualify(:s)).first_source_alias.should == :t.qualify(:s)
+  end
+  
+  specify "should be the alias if aliased" do
+    @ds.from(:t___a).first_source_alias.should == :a
+    @ds.from(:s__t___a).first_source_alias.should == :a
+    @ds.from(:t.as(:a)).first_source_alias.should == :a
+  end
+  
+  specify "should be aliased as first_source" do
+    @ds.from(:t).first_source.should == :t
+    @ds.from(:t__a.identifier).first_source.should == :t__a.identifier
+    @ds.from(:s__t___a).first_source.should == :a
+    @ds.from(:t.as(:a)).first_source.should == :a
+  end
+  
+  specify "should raise exception if table doesn't have a source" do
+    proc{@ds.first_source_alias.should == :t}.should raise_error(Sequel::Error)
+  end
+end
+
+context "Dataset#first_source_table" do
+  before do
+    @ds = Sequel::Dataset.new(nil)
+  end
+  
+  specify "should be the entire first source if not aliased" do
+    @ds.from(:t).first_source_table.should == :t
+    @ds.from(:t__a.identifier).first_source_table.should == :t__a.identifier
+    @ds.from(:s__t).first_source_table.should == :s__t
+    @ds.from(:t.qualify(:s)).first_source_table.should == :t.qualify(:s)
+  end
+  
+  specify "should be the unaliased part if aliased" do
+    @ds.from(:t___a).first_source_table.should == :t.identifier
+    @ds.from(:s__t___a).first_source_table.should == :t.qualify(:s)
+    @ds.from(:t.as(:a)).first_source_table.should == :t
+  end
+  
+  specify "should raise exception if table doesn't have a source" do
+    proc{@ds.first_source_table.should == :t}.should raise_error(Sequel::Error)
+  end
+end
+
 context "Dataset#from_self" do
   before do
     @ds = Sequel::Dataset.new(nil).from(:test).select(:name).limit(1)
@@ -1673,7 +1726,7 @@ context "Dataset#join_table" do
   
   specify "should handle multiple conditions on the same join table column" do
     @d.join_table(:left_outer, :categories, [[:category_id, :id], [:category_id, 0..100]]).sql.should ==
-      'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON (("categories"."category_id" = "items"."id") AND (("categories"."category_id" >= 0) AND ("categories"."category_id" <= 100)))'
+      'SELECT * FROM "items" LEFT OUTER JOIN "categories" ON (("categories"."category_id" = "items"."id") AND ("categories"."category_id" >= 0) AND ("categories"."category_id" <= 100))'
   end
   
   specify "should include WHERE clause if applicable" do
@@ -2955,12 +3008,12 @@ context "Dataset#grep" do
   
   specify "should support multiple search terms" do
     @ds.grep(:title, ['abc', 'def']).sql.should == 
-      "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (title LIKE 'def')))"
+      "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def'))"
   end
   
   specify "should support multiple columns and search terms" do
     @ds.grep([:title, :body], ['abc', 'def']).sql.should ==
-      "SELECT * FROM posts WHERE (((title LIKE 'abc') OR (title LIKE 'def')) OR ((body LIKE 'abc') OR (body LIKE 'def')))"
+      "SELECT * FROM posts WHERE ((title LIKE 'abc') OR (title LIKE 'def') OR (body LIKE 'abc') OR (body LIKE 'def'))"
   end
   
   specify "should support regexps though the database may not support it" do
@@ -2968,7 +3021,7 @@ context "Dataset#grep" do
       "SELECT * FROM posts WHERE ((title ~ 'ruby'))"
 
     @ds.grep(:title, [/^ruby/, 'ruby']).sql.should ==
-      "SELECT * FROM posts WHERE (((title ~ '^ruby') OR (title LIKE 'ruby')))"
+      "SELECT * FROM posts WHERE ((title ~ '^ruby') OR (title LIKE 'ruby'))"
   end
 
   specify "should support searching against other columns" do
@@ -3093,7 +3146,7 @@ context "Dataset prepared statements and bound variables " do
     
   specify "should handle subselects" do
     @ds.filter(:$b).filter(:num=>@ds.select(:num).filter(:num=>:$n)).filter(:$c).call(:select, :n=>1, :b=>0, :c=>2)
-    @db.sqls.should == ['SELECT * FROM items WHERE ((0 AND (num IN (SELECT num FROM items WHERE (num = 1)))) AND 2)']
+    @db.sqls.should == ['SELECT * FROM items WHERE (0 AND (num IN (SELECT num FROM items WHERE (num = 1))) AND 2)']
   end
     
   specify "should handle subselects in subselects" do
@@ -3716,3 +3769,21 @@ context "Modifying joined datasets" do
     @ds.db.sqls.should == ['UPDATE b, c INNER JOIN d USING (id) SET a = 1 WHERE (id = 2)']
   end
 end
+
+context "Dataset#lock_style and for_update" do
+  before do
+    @ds = MockDatabase.new[:t]
+  end
+  
+  specify "#for_update should use FOR UPDATE" do
+    @ds.for_update.sql.should == "SELECT * FROM t FOR UPDATE"
+  end
+  
+  specify "#lock_style should accept symbols" do
+    @ds.lock_style(:update).sql.should == "SELECT * FROM t FOR UPDATE"
+  end
+  
+  specify "#lock_style should accept strings for arbitrary SQL" do
+    @ds.lock_style("FOR SHARE").sql.should == "SELECT * FROM t FOR SHARE"
+  end
+end

data/spec/core/expression_filters_spec.rb

@@ -216,7 +216,7 @@ context "Blockless Ruby Filters" do
   it "should support AND conditions via &" do
     @d.l(:x & :y).should == '(x AND y)'
     @d.l(:x.sql_boolean & :y).should == '(x AND y)'
-    @d.l(:x & :y & :z).should == '((x AND y) AND z)'
+    @d.l(:x & :y & :z).should == '(x AND y AND z)'
     @d.l(:x & {:y => :z}).should == '(x AND (y = z))'
     @d.l({:y => :z} & :x).should == '((y = z) AND x)'
     @d.l({:x => :a} & {:y => :z}).should == '((x = a) AND (y = z))'
@@ -229,7 +229,7 @@ context "Blockless Ruby Filters" do
   it "should support OR conditions via |" do
     @d.l(:x | :y).should == '(x OR y)'
     @d.l(:x.sql_boolean | :y).should == '(x OR y)'
-    @d.l(:x | :y | :z).should == '((x OR y) OR z)'
+    @d.l(:x | :y | :z).should == '(x OR y OR z)'
     @d.l(:x | {:y => :z}).should == '(x OR (y = z))'
     @d.l({:y => :z} | :x).should == '((y = z) OR x)'
     @d.l({:x => :a} | {:y => :z}).should == '((x = a) OR (y = z))'
@@ -263,7 +263,7 @@ context "Blockless Ruby Filters" do
     @d.l('x'.lit + 1 > 100).should == '((x + 1) > 100)'
     @d.l(('x'.lit * :y) < 100.01).should == '((x * y) < 100.01)'
     @d.l(('x'.lit - :y/2) >= 100000000000000000000000000000000000).should == '((x - (y / 2)) >= 100000000000000000000000000000000000)'
-    @d.l(('z'.lit * (('x'.lit / :y)/(:x + :y))) <= 100).should == '((z * ((x / y) / (x + y))) <= 100)'
+    @d.l(('z'.lit * (('x'.lit / :y)/(:x + :y))) <= 100).should == '((z * (x / y / (x + y))) <= 100)'
     @d.l(~(((('x'.lit - :y)/(:x + :y))*:z) <= 100)).should == '((((x - y) / (x + y)) * z) > 100)'
   end
 
@@ -350,13 +350,13 @@ context "Blockless Ruby Filters" do
     @d.lit([:x, 1, :y].sql_string_join(:y__z)).should == "(x || y.z || '1' || y.z || y)"
     @d.lit([:x, 1, :y].sql_string_join(1)).should == "(x || '1' || '1' || '1' || y)"
     @d.lit([:x, :y].sql_string_join('y.x || x.y'.lit)).should == "(x || y.x || x.y || y)"
-    @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).should == "((x || y) || (a || b))"
+    @d.lit([[:x, :y].sql_string_join, [:a, :b].sql_string_join].sql_string_join).should == "(x || y || a || b)"
   end
 
   it "should support StringExpression#+ for concatenation of SQL strings" do
     @d.lit(:x.sql_string + :y).should == '(x || y)'
-    @d.lit([:x].sql_string_join + :y).should == '((x) || y)'
-    @d.lit([:x, :z].sql_string_join(' ') + :y).should == "((x || ' ' || z) || y)"
+    @d.lit([:x].sql_string_join + :y).should == '(x || y)'
+    @d.lit([:x, :z].sql_string_join(' ') + :y).should == "(x || ' ' || z || y)"
   end
 
   it "should be supported inside blocks" do
@@ -575,4 +575,21 @@ context Sequel::SQL::VirtualRow do
     @d.l{date < Sequel::CURRENT_DATE}.should == "(\"date\" < CURRENT_DATE)"
     @d.l{num < Math::PI.to_i}.should == "(\"num\" < 3)"
   end
+  
+  it "should deal with methods added to Object after requiring Sequel" do
+    class Object
+      def adsoiwemlsdaf; 42; end
+    end
+    Sequel::BasicObject.remove_methods!
+    @d.l{a > adsoiwemlsdaf}.should == '("a" > "adsoiwemlsdaf")'
+  end
+  
+  it "should deal with private methods added to Kernel after requiring Sequel" do
+    module Kernel
+      private
+      def adsoiwemlsdaf2; 42; end
+    end
+    Sequel::BasicObject.remove_methods!
+    @d.l{a > adsoiwemlsdaf2}.should == '("a" > "adsoiwemlsdaf2")'
+  end
 end

data/spec/extensions/association_dependencies_spec.rb

@@ -20,7 +20,8 @@ describe "AssociationDependencies plugin" do
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
-    @Artist.many_to_many :other_artists, :class=>@artist, :join_table=>:aoa, :left_key=>:l, :right_key=>:r
+    @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
   end
@@ -28,7 +29,7 @@ describe "AssociationDependencies plugin" do
   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)', 'DELETE FROM artists WHERE (id = 2)']
+    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)']
   end
 
   specify "should allow deleting associated many_to_one associated object" do
@@ -36,6 +37,18 @@ describe "AssociationDependencies plugin" do
     @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)']
   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 ((albums.artist_id = 2) AND (position = 1)) 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 ((albums.artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE (id = 2)']
+  end
 
   specify "should allow destroying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:destroy
@@ -48,6 +61,12 @@ describe "AssociationDependencies plugin" do
     @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)']
   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 ((artist_id = 2) AND (position = 1))', 'DELETE FROM artists WHERE (id = 2)']
+  end
 
   specify "should allow nullifying associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:nullify
@@ -86,14 +105,14 @@ 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)', 'DELETE FROM artists WHERE (id = 2)']
+    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)']
   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)', 'DELETE FROM artists WHERE (id = 2)']
+    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)']
     MODEL_DB.reset
 
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
@@ -103,6 +122,6 @@ describe "AssociationDependencies plugin" do
     @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)', 'DELETE FROM artists WHERE (id = 2)']
+    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)']
   end
 end