sequel 3.21.0 → 3.39.0

data/spec/extensions/caching_spec.rb

@@ -2,8 +2,6 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe Sequel::Model, "caching" do
   before do
-    MODEL_DB.reset
-    
     @cache_class = Class.new(Hash) do
       attr_accessor :ttl
       def set(k, v, ttl); self[k] = v; @ttl = ttl; end
@@ -44,31 +42,14 @@ describe Sequel::Model, "caching" do
       columns :name, :id
     end
    
-
-    $cache_dataset_row = {:name => 'sharon', :id => 1}
     @dataset = @c.dataset = @c3.dataset = @c4.dataset
-    $sqls = []
-    @dataset.extend(Module.new {
-      def fetch_rows(sql)
-        $sqls << sql
-        yield $cache_dataset_row
-      end
-      
-      def update(values)
-        $sqls << update_sql(values)
-        $cache_dataset_row.merge!(values)
-        1
-      end
-      
-      def delete
-        $sqls << delete_sql
-        1
-      end
-    })
+    @dataset._fetch = {:name => 'sharon', :id => 1}
+    @dataset.numrows = 1
     
     @c2 = Class.new(@c) do
       def self.name; 'SubItem' end
     end    
+    @c.db.reset
   end
   
   it "should set the model's cache store" do
@@ -101,7 +82,7 @@ describe Sequel::Model, "caching" do
     Class.new(@c).cache_ttl.should == 1234
   end
   
-  it "should generate a cache key appropriate to the class" do
+  it "should generate a cache key appropriate to the class via the Model#cache_key" do
     m = @c.new
     m.values[:id] = 1
     m.cache_key.should == "#{m.class}:1"
@@ -133,6 +114,11 @@ describe Sequel::Model, "caching" do
     m.values[:b] = 789
     m.cache_key.should == "#{m.class}:123,789,456"
   end
+
+  it "should generate a cache key via the Model.cache_key method" do
+    @c.cache_key(1).should == "#{@c}:1"
+    @c.cache_key([1, 2]).should == "#{@c}:1,2"
+  end
   
   it "should raise error if attempting to generate cache_key and primary key value is null" do
     m = @c.new
@@ -154,27 +140,31 @@ describe Sequel::Model, "caching" do
   end
   
   it "should set the cache when reading from the database" do
-    $sqls.should == []
+    @c.db.sqls.should == []
     @cache.should be_empty
     
     m = @c[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
-    m.values.should == $cache_dataset_row
+    @c.db.sqls.should == ['SELECT * FROM items WHERE id = 1']
+    m.values.should == {:name=>"sharon", :id=>1}
     @cache[m.cache_key].should == m
     m2 = @c[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    @c.db.sqls.should == []
     m2.should == m
-    m2.values.should == $cache_dataset_row
+    m2.values.should == {:name=>"sharon", :id=>1}
 
-    $sqls.clear
     m = @c2[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
-    m.values.should == $cache_dataset_row
+    @c.db.sqls.should == ['SELECT * FROM items WHERE id = 1']
+    m.values.should == {:name=>"sharon", :id=>1}
     @cache[m.cache_key].should == m
     m2 = @c2[1]
-    $sqls.should == ['SELECT * FROM items WHERE (id = 1) LIMIT 1']
+    @c.db.sqls.should == []
     m2.should == m
-    m2.values.should == $cache_dataset_row
+    m2.values.should == {:name=>"sharon", :id=>1}
+  end
+
+  it "should handle lookups by nil primary keys" do
+    @c[nil].should == nil
+    @c.db.sqls.should == []
   end
   
   it "should delete the cache when writing to the database" do
@@ -183,14 +173,14 @@ describe Sequel::Model, "caching" do
     m.name = 'hey'
     m.save
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'hey' WHERE (id = 1)"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "UPDATE items SET name = 'hey' WHERE (id = 1)"]
 
     m = @c2[1]
     @cache[m.cache_key].should == m
     m.name = 'hey'
     m.save
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "UPDATE items SET name = 'hey' WHERE (id = 1)"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "UPDATE items SET name = 'hey' WHERE (id = 1)"]
   end
 
   it "should delete the cache when deleting the record" do
@@ -198,40 +188,33 @@ describe Sequel::Model, "caching" do
     @cache[m.cache_key].should == m
     m.delete
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE id = 1"]
 
     m = @c2[1]
     @cache[m.cache_key].should == m
     m.delete
     @cache.has_key?(m.cache_key).should be_false
-    $sqls.last.should == "DELETE FROM items WHERE (id = 1)"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1", "DELETE FROM items WHERE id = 1"]
   end
   
   it "should support #[] as a shortcut to #find with hash" do
     m = @c[:id => 3]
     @cache[m.cache_key].should be_nil
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
     m = @c[1]
     @cache[m.cache_key].should == m
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1"]
     @c[:id => 4]
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 4) LIMIT 1"]
 
-    $sqls.clear
     m = @c2[:id => 3]
     @cache[m.cache_key].should be_nil
-    $sqls.last.should == "SELECT * FROM items WHERE (id = 3) LIMIT 1"
+    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1"]
     m = @c2[1]
     @cache[m.cache_key].should == m
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE id = 1"]
     @c2[:id => 4]
-    $sqls.should == ["SELECT * FROM items WHERE (id = 3) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 1) LIMIT 1", \
-      "SELECT * FROM items WHERE (id = 4) LIMIT 1"]
+    @c.db.sqls.should == ["SELECT * FROM items WHERE (id = 4) LIMIT 1"]
   end
   
   it "should support ignore_exception option" do
@@ -245,6 +228,19 @@ describe Sequel::Model, "caching" do
   end
   
   it "should rescue an exception if cache_store is memcached and ignore_exception is enabled" do
-    @c4[1].values.should == $cache_dataset_row
+    @c4[1].values.should == {:name => 'sharon', :id => 1}
+  end
+  
+  it "should support Model.cache_get_pk for getting a value from the cache by primary key" do
+    @c.cache_get_pk(1).should == nil
+    m = @c[1]
+    @c.cache_get_pk(1).should == m
+  end
+  
+  it "should support Model.cache_delete_pk for removing a value from the cache by primary key" do
+    @c[1]
+    @c.cache_get_pk(1).should_not == nil
+    @c.cache_delete_pk(1).should == nil
+    @c.cache_get_pk(1).should == nil
   end
 end

data/spec/extensions/class_table_inheritance_spec.rb

@@ -2,17 +2,16 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "class_table_inheritance plugin" do
   before do
-    @db = db = MODEL_DB.clone
-    def db.schema(table, opts={})
+    @db = Sequel.mock(:autoid=>proc{|sql| 1})
+    def @db.schema(table, opts={})
       {:employees=>[[:id, {:primary_key=>true, :type=>:integer}], [:name, {:type=>:string}], [:kind, {:type=>:string}]],
        :managers=>[[:id, {:type=>:integer}], [:num_staff, {:type=>:integer}]],
        :executives=>[[:id, {:type=>:integer}], [:num_managers, {:type=>:integer}]],
        :staff=>[[:id, {:type=>:integer}], [:manager_id, {:type=>:integer}]],
-       }[table]
+       }[table.is_a?(Sequel::Dataset) ? table.first_source_table : table]
      end
-    def db.dataset(*args)
-      ds = super(*args)
-      def ds.columns
+    @db.extend_datasets do
+      def columns
         {[:employees]=>[:id, :name, :kind],
          [:managers]=>[:id, :num_staff],
          [:executives]=>[:id, :num_managers],
@@ -22,13 +21,8 @@ describe "class_table_inheritance plugin" do
          [:employees, :staff]=>[:id, :name, :kind, :manager_id],
         }[opts[:from] + (opts[:join] || []).map{|x| x.table}]
       end
-      def ds.insert(*args)
-        db << insert_sql(*args)
-        1
-      end
-      ds
     end
-    class ::Employee < Sequel::Model(db)
+    class ::Employee < Sequel::Model(@db)
       def _refresh(x); @values[:id] = 1 end
       def self.columns
         dataset.columns
@@ -44,7 +38,7 @@ describe "class_table_inheritance plugin" do
       many_to_one :manager
     end 
     @ds = Employee.dataset
-    @db.reset
+    @db.sqls
   end
   after do
     Object.send(:remove_const, :Executive)
@@ -53,8 +47,8 @@ describe "class_table_inheritance plugin" do
     Object.send(:remove_const, :Employee)
   end
 
-  specify "should have simple_table = nil" do
-    Employee.simple_table.should == nil
+  specify "should have simple_table = nil for subclasses" do
+    Employee.simple_table.should == "employees"
     Manager.simple_table.should == nil
     Executive.simple_table.should == nil
     Staff.simple_table.should == nil
@@ -68,33 +62,18 @@ describe "class_table_inheritance plugin" do
   end
   
   it "should return rows with the correct class based on the polymorphic_key value" do
-    def @ds.fetch_rows(sql)
-      yield({:kind=>'Employee'})
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-      yield({:kind=>'Staff'})
-    end 
+    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
     Employee.all.collect{|x| x.class}.should == [Employee, Manager, Executive, Staff]
   end 
   
   it "should return rows with the correct class based on the polymorphic_key value for subclasses" do
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-    end 
+    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}]
     Manager.all.collect{|x| x.class}.should == [Manager, Executive]
   end
   
   it "should return rows with the current class if cti_key is nil" do
     Employee.plugin(:class_table_inheritance)
-    ds = Employee.dataset
-    def ds.fetch_rows(sql)
-      yield({:kind=>'Employee'})
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-      yield({:kind=>'Staff'})
-    end 
+    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Staff'}]
     Employee.all.collect{|x| x.class}.should == [Employee, Employee, Employee, Employee]
   end
   
@@ -102,35 +81,19 @@ describe "class_table_inheritance plugin" do
     Employee.plugin(:class_table_inheritance)
     Object.send(:remove_const, :Executive)
     Object.send(:remove_const, :Manager)
-    class ::Manager < Employee
-    end 
-    class ::Executive < Manager
-    end 
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-    end 
+    class ::Manager < Employee; end 
+    class ::Executive < Manager; end 
+    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}]
     Manager.all.collect{|x| x.class}.should == [Manager, Manager]
   end
   
   it "should fallback to the main class if the given class does not exist" do
-    def @ds.fetch_rows(sql)
-      yield({:kind=>'Employee'})
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Blah'})
-      yield({:kind=>'Staff'})
-    end 
+    @ds._fetch = [{:kind=>'Employee'}, {:kind=>'Manager'}, {:kind=>'Blah'}, {:kind=>'Staff'}]
     Employee.all.collect{|x| x.class}.should == [Employee, Manager, Employee, Staff]
   end
   
   it "should fallback to the main class if the given class does not exist in subclasses" do
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      yield({:kind=>'Manager'})
-      yield({:kind=>'Executive'})
-      yield({:kind=>'Blah'})
-    end 
+    Manager.dataset._fetch = [{:kind=>'Manager'}, {:kind=>'Executive'}, {:kind=>'Blah'}]
     Manager.all.collect{|x| x.class}.should == [Manager, Executive, Manager]
   end
 
@@ -167,19 +130,10 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should lazily load attributes for columns in subclass tables" do
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2})
-    end
+    Manager.instance_dataset._fetch = Manager.dataset._fetch = {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2}
     m = Manager[1]
     @db.sqls.should == ['SELECT * FROM employees INNER JOIN managers USING (id) WHERE (id = 1) LIMIT 1']
-    @db.reset
-    ds = Executive.dataset
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:num_managers=>3})
-    end
+    Executive.instance_dataset._fetch = Executive.dataset._fetch = {:num_managers=>3}
     m.num_managers.should == 3
     @db.sqls.should == ['SELECT num_managers FROM employees INNER JOIN managers USING (id) INNER JOIN executives USING (id) WHERE (id = 1) LIMIT 1']
     m.values.should == {:id=>1, :name=>'J', :kind=>'Executive', :num_staff=>2, :num_managers=>3}
@@ -210,20 +164,22 @@ describe "class_table_inheritance plugin" do
 
   it "should insert the correct rows into all tables when inserting" do
     Executive.create(:num_managers=>3, :num_staff=>2, :name=>'E')
-    @db.sqls.length.should == 3
-    @db.sqls[0].should =~ /INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Executive)', '(E|Executive)'\)/
-    @db.sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/
-    @db.sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/
+    sqls = @db.sqls
+    sqls.length.should == 3
+    sqls[0].should =~ /INSERT INTO employees \((name|kind), (name|kind)\) VALUES \('(E|Executive)', '(E|Executive)'\)/
+    sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \([12], [12]\)/
+    sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([13], [13]\)/
     end
     
   it "should insert the correct rows into all tables with a given primary key" do
     e = Executive.new(:num_managers=>3, :num_staff=>2, :name=>'E')
     e.id = 2
     e.save
-    @db.sqls.length.should == 3
-    @db.sqls[0].should =~ /INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Executive'|2), ('E'|'Executive'|2), ('E'|'Executive'|2)\)/
-    @db.sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/
-    @db.sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/
+    sqls = @db.sqls
+    sqls.length.should == 3
+    sqls[0].should =~ /INSERT INTO employees \((name|kind|id), (name|kind|id), (name|kind|id)\) VALUES \(('E'|'Executive'|2), ('E'|'Executive'|2), ('E'|'Executive'|2)\)/
+    sqls[1].should =~ /INSERT INTO managers \((num_staff|id), (num_staff|id)\) VALUES \(2, 2\)/
+    sqls[2].should =~ /INSERT INTO executives \((num_managers|id), (num_managers|id)\) VALUES \([23], [23]\)/
   end
 
   it "should update the correct rows in all tables when updating" do
@@ -232,21 +188,13 @@ describe "class_table_inheritance plugin" do
   end
 
   it "should handle many_to_one relationships correctly" do
-    ds = Manager.dataset
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>3, :name=>'E', :kind=>'Executive', :num_managers=>3})
-    end
+    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']
   end
   
   it "should handle one_to_many relationships correctly" do
-    ds = Staff.dataset
-    def ds.fetch_rows(sql)
-      @db << sql
-      yield({:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3})
-    end
+    Staff.dataset._fetch = {:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3}
     Executive.load(:id=>3).staff_members.should == [Staff.load(:id=>1, :name=>'S', :kind=>'Staff', :manager_id=>3)]
     @db.sqls.should == ['SELECT * FROM employees INNER JOIN staff USING (id) WHERE (staff.manager_id = 3)']
   end

data/spec/extensions/columns_introspection_spec.rb

@@ -0,0 +1,91 @@
+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
+    Sequel::Dataset.introspect_all_columns
+    @db.reset
+  end
+  after do
+    class Sequel::Dataset
+      alias columns columns_without_introspection
+    end
+  end
+
+  specify "should turn on column introspection by default" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+end
+
+describe "columns_introspection extension" do
+  before do
+    @db = MODEL_DB
+    @ds = @db[:a]
+    @ds.extend(Sequel::ColumnsIntrospection.dup) # dup to allow multiple places in class hierarchy
+    @db.reset
+  end
+
+  specify "should not issue a database query if the columns are already loaded" do
+    @ds.instance_variable_set(:@columns, [:x])
+    @ds.columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+  
+  specify "should handle plain symbols without a database query" do
+    @ds.select(:x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified symbols without a database query" do
+    @ds.select(:t__x).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle aliased symbols without a database query" do
+    @ds.select(:x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle qualified and aliased symbols without a database query" do
+    @ds.select(:t__x___a).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::Identifiers " do
+    @ds.select(Sequel.identifier(:x)).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::QualifiedIdentifiers" do
+    @ds.select(Sequel.qualify(:t, :x)).columns.should == [:x]
+    @ds.select(Sequel.identifier(:x).qualify(:t)).columns.should == [:x]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should handle SQL::AliasedExpressions" do
+    @ds.select(Sequel.as(:x, :a)).columns.should == [:a]
+    @ds.select(Sequel.as(:x, Sequel.identifier(:a))).columns.should == [:a]
+    @db.sqls.length.should == 0
+  end
+
+  specify "should issue a database query if the wildcard is selected" do
+    @ds.columns
+    @db.sqls.length.should == 1
+  end
+
+  specify "should issue a database query if an unsupported type is used" 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

@@ -48,9 +48,10 @@ 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
-    MODEL_DB.sqls.last.should include("year = 4")
-    MODEL_DB.sqls.last.should include("month = 8")
-    MODEL_DB.sqls.last.should include("day = 12")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = 4")
+    sql.should include("month = 8")
+    sql.should include("day = 12")
   end
 
   it "should allow call super in composition getter and setter method definition in class" do
@@ -139,8 +140,9 @@ describe "Composition plugin" do
     @o.date.month.should == 6
     @o.date = c.new(3, 4)
     @o.save
-    MODEL_DB.sqls.last.should include("year = 6")
-    MODEL_DB.sqls.last.should include("month = 12")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = 6")
+    sql.should include("month = 12")
   end
 
   it ":mapping option should work with an array of two pairs of symbols" do
@@ -160,8 +162,9 @@ describe "Composition plugin" do
     @o.date.m.should == 6
     @o.date = c.new(3, 4)
     @o.save
-    MODEL_DB.sqls.last.should include("year = 6")
-    MODEL_DB.sqls.last.should include("month = 12")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = 6")
+    sql.should include("month = 12")
   end
 
   it ":mapping option :composer should return nil if all values are nil" do
@@ -173,9 +176,10 @@ describe "Composition plugin" do
     @c.composition :date, :mapping=>[:year, :month, :day]
     @o.date = nil
     @o.save
-    MODEL_DB.sqls.last.should include("year = NULL")
-    MODEL_DB.sqls.last.should include("month = NULL")
-    MODEL_DB.sqls.last.should include("day = NULL")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = NULL")
+    sql.should include("month = NULL")
+    sql.should include("day = NULL")
   end
 
   it "should work correctly with subclasses" do
@@ -184,8 +188,9 @@ 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
-    MODEL_DB.sqls.last.should include("year = 1")
-    MODEL_DB.sqls.last.should include("month = 2")
-    MODEL_DB.sqls.last.should include("day = 3")
+    sql = MODEL_DB.sqls.last
+    sql.should include("year = 1")
+    sql.should include("month = 2")
+    sql.should include("day = 3")
   end
 end