sequel 3.47.0 → 3.48.0

data/spec/extensions/static_cache_spec.rb

@@ -76,7 +76,7 @@ describe "Sequel::Plugins::StaticCache" do
     @db.fetch = [[{:count=>1}], [{:count=>2}]]
     @c.count(:a).should == 1
     @c.count{b}.should == 2
-    @db.sqls.should == ["SELECT COUNT(a) AS count FROM t LIMIT 1", "SELECT COUNT(b) AS count FROM t LIMIT 1"]
+    @db.sqls.should == ["SELECT count(a) AS count FROM t LIMIT 1", "SELECT count(b) AS count FROM t LIMIT 1"]
   end
 
   it "should have map not send a query if given an argument" do

data/spec/extensions/string_stripper_spec.rb

@@ -2,7 +2,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::StringStripper" do
   before do
-    @db = Sequel::Database.new
+    @db = Sequel.mock
     @c = Class.new(Sequel::Model(@db[:test]))
     @c.columns :name, :b
     @c.db_schema[:b][:type] = :blob
@@ -53,6 +53,7 @@ describe "Sequel::Plugins::StringStripper" do
   it "should work correctly for dataset changes" do
     c = Class.new(Sequel::Model(@db[:test]))
     c.plugin :string_stripper
+    def @db.supports_schema_parsing?() true end
     def @db.schema(*) [[:name, {}], [:b, {:type=>:blob}]] end
     c.set_dataset(@db[:test2])
     o = c.new

data/spec/extensions/to_dot_spec.rb

@@ -11,7 +11,7 @@ describe Sequel::Model, "to_dot extension" do
   end
 
   it "should output a string suitable for input to the graphviz dot program" do
-    @ds.to_dot.should == (<<END).strip
+    @ds.extension(:to_dot).to_dot.should == (<<END).strip
 digraph G {
 0 [label="self"];
 0 -> 1 [label=""];

data/spec/extensions/typecast_on_load_spec.rb

@@ -3,6 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe Sequel::Model, "TypecastOnLoad plugin" do
   before do
     @db = Sequel.mock(:fetch=>{:id=>1, :b=>"1", :y=>"0"}, :columns=>[:id, :b, :y], :numrows=>1)
+    def @db.supports_schema_parsing?() true end
     def @db.schema(*args)
       [[:id, {}], [:y, {:type=>:boolean, :db_type=>'tinyint(1)'}], [:b, {:type=>:integer, :db_type=>'integer'}]]
     end
@@ -24,7 +25,7 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
 
   specify "should call setter method with value when reloading the object, for all given columns" do
     @c.plugin :typecast_on_load, :b
-    o = @c.new({:id=>1, :b=>"1", :y=>"0"}, true)
+    o = @c.load(:id=>1, :b=>"1", :y=>"0")
     o.refresh
     o.values.should == {:id=>1, :b=>1, :y=>"0"}
     o.bset.should == true
@@ -33,7 +34,7 @@ describe Sequel::Model, "TypecastOnLoad plugin" do
   specify "should call setter method with value when automatically reloading the object on creation via insert_select" do
     @c.plugin :typecast_on_load, :b
     @c.dataset.meta_def(:insert_select){|h| insert(h); first}
-    o = @c.new({:id=>1, :b=>"1", :y=>"0"}, true)
+    o = @c.load(:id=>1, :b=>"1", :y=>"0")
     o.save.values.should == {:id=>1, :b=>1, :y=>"0"}
     o.bset.should == true
   end

data/spec/extensions/update_primary_key_spec.rb

@@ -19,7 +19,7 @@ describe "Sequel::Plugins::UpdatePrimaryKey" do
     @c.first.set(:b=>5).save
     @c.all.should == [@c.load(:a=>1, :b=>5)]
     MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 5 WHERE (a = 1)", "SELECT * FROM a"]
-    @c.first.set(:b=>6).save(:b)
+    @c.first.set(:b=>6).save(:columns=>:b)
     @c.all.should == [@c.load(:a=>1, :b=>6)]
     MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET b = 6 WHERE (a = 1)", "SELECT * FROM a"]
   end
@@ -38,7 +38,7 @@ describe "Sequel::Plugins::UpdatePrimaryKey" do
     @c.first.update(:a=>2)
     @c.all.should == [@c.load(:a=>2, :b=>3)]
     MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 2 WHERE (a = 1)", "SELECT * FROM a"]
-    @c.first.set(:a=>3).save(:a)
+    @c.first.set(:a=>3).save(:columns=>:a)
     @c.all.should == [@c.load(:a=>3, :b=>3)]
     MODEL_DB.sqls.should == ["SELECT * FROM a LIMIT 1", "UPDATE a SET a = 3 WHERE (a = 2)", "SELECT * FROM a"]
   end

data/spec/extensions/validation_class_methods_spec.rb

@@ -11,7 +11,7 @@ describe Sequel::Model do
   before do
     @c = model_class.call Sequel::Model do
       def self.validates_coolness_of(attr)
-        validates_each(attr) {|o, a, v| o.errors[a] << 'is not cool' if v != :cool}
+        validates_each(attr) {|o, a, v| o.errors.add(a, 'is not cool') if v != :cool}
       end
     end
   end
@@ -41,7 +41,7 @@ describe Sequel::Model do
   end
 
   specify "should acccept validation definitions using validates_each" do
-    @c.validates_each(:xx, :yy) {|o, a, v| o.errors[a] << 'too low' if v < 50}
+    @c.validates_each(:xx, :yy) {|o, a, v| o.errors.add(a, 'too low') if v < 50}
     o = @c.new
     o.should_receive(:xx).once.and_return(40)
     o.should_receive(:yy).once.and_return(60)
@@ -105,8 +105,8 @@ describe Sequel::Model do
   end
   
   specify "should overwrite existing validation with the same tag and attribute" do
-    @c.validates_each(:xx, :xx, :tag=>:low) {|o, a, v| o.xxx; o.errors[a] << 'too low' if v < 50}
-    @c.validates_each(:yy, :yy) {|o, a, v| o.yyy; o.errors[a] << 'too low' if v < 50}
+    @c.validates_each(:xx, :xx, :tag=>:low) {|o, a, v| o.xxx; o.errors.add(a, 'too low') if v < 50}
+    @c.validates_each(:yy, :yy) {|o, a, v| o.yyy; o.errors.add(a, 'too low') if v < 50}
     @c.validates_presence_of(:zz, :zz)
     @c.validates_length_of(:aa, :aa, :tag=>:blah)
     o = @c.new
@@ -153,7 +153,7 @@ describe Sequel::Model do
     @c = model_class.call Sequel::Model do
       columns :score
       validates_each :score do |o, a, v|
-        o.errors[a] << 'too low' if v < 87
+        o.errors.add(a, 'too low') if v < 87
       end
     end
     
@@ -175,17 +175,17 @@ describe Sequel::Model do
     @o.score = 86
     @o.should_not be_valid
     @o.errors[:score].should == ['too low']
-    @o.errors[:blah].should be_empty
+    @o.errors.on(:blah).should be_nil
   end
 end
 
 describe "Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator" do
   before do
-    $testit = nil
+    @testit = testit = []
     
     @c = model_class.call Sequel::Model do
-      def self.validates_blah
-        $testit = 1324
+      (class << self; self end).send(:define_method, :validates_blah) do
+        testit << 1324
       end
     end
   end
@@ -194,7 +194,7 @@ describe "Sequel::Plugins::ValidationClassMethods::ClassMethods::Generator" do
     @c.validates do
       blah
     end
-    $testit.should == 1324
+    @testit.should == [1324]
   end
 end
 
@@ -641,7 +641,7 @@ describe ".validates with block" do
       columns :vvv
       validates do
         each :vvv do |o, a, v|
-          o.errors[a] << "is less than zero" if v.to_i < 0
+          o.errors.add(a, "is less than zero") if v.to_i < 0
         end
       end
     end
@@ -764,7 +764,7 @@ describe Sequel::Model, "Validations" do
     @person.should be_valid
   end
   
-  it "should validate that a column doesn't have a string value" do
+  qspecify "should validate that a column doesn't have a string value" do
     p = model_class.call Sequel::Model do
       columns :age, :price, :confirmed
       self.raise_on_typecast_failure = false
@@ -861,11 +861,11 @@ describe Sequel::Model, "Validations" do
     end
     User.dataset._fetch = proc do |sql|
       case sql
-      when /COUNT.*username = '0records'/
+      when /count.*username = '0records'/
         {:v => 0}
-      when /COUNT.*username = '2records'/
+      when /count.*username = '2records'/
         {:v => 2}
-      when /COUNT.*username = '1record'/
+      when /count.*username = '1record'/
         {:v => 1}
       when /username = '1record'/
         {:id => 3, :username => "1record", :password => "test"}
@@ -908,11 +908,11 @@ describe Sequel::Model, "Validations" do
     end
     User.dataset._fetch = proc do |sql|
       case sql
-      when /COUNT.*username = '0records'/
+      when /count.*username = '0records'/
         {:v => 0}
-      when /COUNT.*username = '2records'/
+      when /count.*username = '2records'/
         {:v => 2}
-      when /COUNT.*username = '1record'/
+      when /count.*username = '1record'/
         {:v => 1}
       when /username = '1record'/
         if sql =~ /password = 'anothertest'/
@@ -1022,7 +1022,7 @@ describe "Model#save" do
       columns :id, :x
 
       validates_each :x do |o, a, v|
-        o.errors[a] << 'blah' unless v == 7
+        o.errors.add(a, 'blah') unless v == 7
       end
     end
     @m = @c.load(:id => 4, :x=>6)

data/spec/extensions/validation_helpers_spec.rb

@@ -235,7 +235,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @m.should_not be_valid
   end
 
-  specify "should support validates_not_string" do
+  qspecify "should support validates_not_string" do
     @c.set_validations{validates_not_string(:value)}
     @m.value = 123
     @m.should be_valid
@@ -261,6 +261,11 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @m.meta_def(:db_schema){{:value=>{:type=>:integer}}}
     @m.should_not be_valid
     @m.errors.full_messages.should == ['value is not a valid integer']
+
+    @c.set_validations{validates_schema_types(:value, :message=>'is bad')}
+    @m.meta_def(:db_schema){{:value=>{:type=>:integer}}}
+    @m.should_not be_valid
+    @m.errors.full_messages.should == ['value is bad']
   end
 
   specify "should support validates_numeric" do
@@ -312,14 +317,12 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @m.errors.full_messages.should == ['value is not a valid integer']
     
     @c.set_validations{validates_type(Integer, :value)}
-    @m.value = nil
+    @m.value = 1
     @m.should be_valid
     @m.value = false
     @m.should_not be_valid
     
     @c.set_validations{validates_type([Integer, Float], :value)}
-    @m.value = nil
-    @m.should be_valid
     @m.value = 1
     @m.should be_valid
     @m.value = 1.0
@@ -329,6 +332,12 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @m.errors.full_messages.should == ['value is not a valid integer or float']
   end
 
+  qspecify "should have validates_type skip nil values by default" do
+    @c.set_validations{validates_type([Integer, Float], :value)}
+    @m.value = nil
+    @m.should be_valid
+  end
+
   specify "should support validates_not_null" do
     @c.set_validations{validates_not_null(:value)}
     @m.should_not be_valid
@@ -369,9 +378,9 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.set_validations{validates_unique(:username)}
     @c.dataset._fetch = proc do |sql|
       case sql
-      when /COUNT.*username = '0records'/
+      when /count.*username = '0records'/
         {:v => 0}
-      when /COUNT.*username = '1record'/
+      when /count.*username = '1record'/
         {:v => 1}
       end
     end
@@ -400,10 +409,10 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (id != 1)) LIMIT 1"
+    MODEL_DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (id != 1)) LIMIT 1"
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE (username = '0records') LIMIT 1"
+    MODEL_DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE (username = '0records') LIMIT 1"
   end
   
   it "should support validates_unique with multiple attributes" do
@@ -412,9 +421,9 @@ describe "Sequel::Plugins::ValidationHelpers" do
     @c.set_validations{validates_unique([:username, :password])}
     @c.dataset._fetch = proc do |sql|
       case sql
-      when /COUNT.*username = '0records'/
+      when /count.*username = '0records'/
         {:v => 0}
-      when /COUNT.*username = '1record'/
+      when /count.*username = '1record'/
         {:v => 1}
       end
     end
@@ -450,10 +459,10 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     @user = @c.load(:id=>1, :username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest') AND (id != 1)) LIMIT 1"
+    MODEL_DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest') AND (id != 1)) LIMIT 1"
     @user = @c.new(:username => "0records", :password => "anothertest")
     @user.should be_valid
-    MODEL_DB.sqls.last.should == "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"
+    MODEL_DB.sqls.last.should == "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"
   end
 
   it "should support validates_unique with a block" do
@@ -465,8 +474,8 @@ describe "Sequel::Plugins::ValidationHelpers" do
     MODEL_DB.reset
     @c.new(:username => "0records", :password => "anothertest").should be_valid
     @c.load(:id=>3, :username => "0records", :password => "anothertest").should be_valid
-    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND active) LIMIT 1",
-                    "SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND active AND (id != 3)) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '0records') AND active) LIMIT 1",
+                    "SELECT count(*) AS count FROM items WHERE ((username = '0records') AND active AND (id != 3)) LIMIT 1"]
   end
 
   it "should support validates_unique with a custom filter" do
@@ -478,8 +487,8 @@ describe "Sequel::Plugins::ValidationHelpers" do
     MODEL_DB.reset
     @c.new(:username => "0RECORDS", :password => "anothertest").should be_valid
     @c.load(:id=>3, :username => "0RECORDS", :password => "anothertest").should be_valid
-    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE (lower(username) = '0records') LIMIT 1",
-                    "SELECT COUNT(*) AS count FROM items WHERE ((lower(username) = '0records') AND (id != 3)) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE (lower(username) = '0records') LIMIT 1",
+                    "SELECT count(*) AS count FROM items WHERE ((lower(username) = '0records') AND (id != 3)) LIMIT 1"]
   end
 
   it "should support :only_if_modified option for validates_unique, and not check uniqueness for existing records if values haven't changed" do
@@ -490,7 +499,7 @@ describe "Sequel::Plugins::ValidationHelpers" do
     
     MODEL_DB.reset
     @c.new(:username => "0records", :password => "anothertest").should be_valid
-    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = 'anothertest')) LIMIT 1"]
     MODEL_DB.reset
     m = @c.load(:id=>3, :username => "0records", :password => "anothertest")
     m.should be_valid
@@ -498,23 +507,23 @@ describe "Sequel::Plugins::ValidationHelpers" do
 
     m.username = '1'
     m.should be_valid
-    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '1') AND (password = 'anothertest') AND (id != 3)) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '1') AND (password = 'anothertest') AND (id != 3)) LIMIT 1"]
 
     m = @c.load(:id=>3, :username => "0records", :password => "anothertest")
     MODEL_DB.reset
     m.password = '1'
     m.should be_valid
-    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '0records') AND (password = '1') AND (id != 3)) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '0records') AND (password = '1') AND (id != 3)) LIMIT 1"]
     MODEL_DB.reset
     m.username = '2'
     m.should be_valid
-    MODEL_DB.sqls.should == ["SELECT COUNT(*) AS count FROM items WHERE ((username = '2') AND (password = '1') AND (id != 3)) LIMIT 1"]
+    MODEL_DB.sqls.should == ["SELECT count(*) AS count FROM items WHERE ((username = '2') AND (password = '1') AND (id != 3)) LIMIT 1"]
   end
 
   it "should not attempt a database query if the underlying columns have validation errors" do
     @c.columns(:id, :username, :password)
     @c.set_dataset MODEL_DB[:items]
-    @c.set_validations{validates_not_string(:username); validates_unique([:username, :password])}
+    @c.set_validations{errors.add(:username, 'foo'); validates_unique([:username, :password])}
     @c.dataset._fetch = {:v=>0}
     
     MODEL_DB.reset

data/spec/extensions/xml_serializer_spec.rb

@@ -97,7 +97,7 @@ describe "Sequel::Plugins::XmlSerializer" do
     Album.from_xml(@album.to_xml(:include=>{:artist=>{:include=>{:albums=>{:only=>:name}}}}), :associations=>{:artist=>{:associations=>{:albums=>{:fields=>%w'name'}}}}).artist.albums.should == [Album.load(:name=>@album.name)]
   end
 
-  it "should automatically cascade parsing for all associations if :all_associations is used" do
+  qspecify "should automatically cascade parsing for all associations if :all_associations is used" do
     Artist.from_xml(@artist.to_xml(:include=>{:albums=>{:include=>:artist}}), :all_associations=>true).albums.map{|a| a.artist}.should == [@artist]
    end
   
@@ -181,16 +181,16 @@ describe "Sequel::Plugins::XmlSerializer" do
     proc{Album.dataset.naked.to_xml}.should raise_error(Sequel::Error)
   end
 
-  it "should have :associations option take precedence over :all_assocations" do
+  qspecify "should have :associations option take precedence over :all_assocations" do
     Artist.from_xml(@artist.to_xml(:include=>:albums), :associations=>[], :all_associations=>true, :fields=>[]).associations.should == {}
   end
 
-  it "should allow overriding of :all_columns options in associated objects" do
+  qspecify "should allow overriding of :all_columns options in associated objects" do
     Album.restrict_primary_key
     Artist.from_xml(@artist.to_xml(:include=>:albums), :associations=>{:albums=>{:fields=>[:id, :name, :artist_id], :missing=>:raise}}, :all_columns=>true).albums
   end
 
-  it "should allow setting columns that are restricted if :all_columns is used" do
+  qspecify "should allow setting columns that are restricted if :all_columns is used" do
     Artist.restrict_primary_key
     Artist.from_xml(@artist.to_xml, :all_columns=>true).should == @artist
   end
@@ -200,7 +200,7 @@ describe "Sequel::Plugins::XmlSerializer" do
     proc{Artist.array_from_xml("<?xml version=\"1.0\"?>\n")}.should raise_error(Sequel::Error)
   end
 
-  it "should raise an error if using :all_columns and non-column is in the XML" do
+  qspecify "should raise an error if using :all_columns and non-column is in the XML" do
     proc{Artist.from_xml("<?xml version=\"1.0\"?>\n<artist>\n  <foo>bar</foo>\n  <id>2</id>\n</artist>\n", :all_columns=>true)}.should raise_error(Sequel::Error)
   end
 

data/spec/integration/associations_test.rb

@@ -51,9 +51,6 @@ shared_examples_for "eager limit strategies" do
   end
   
   specify "should correctly handle limits and offsets when eager loading many_to_many associations" do
-    if @els == {:eager_limit_strategy=>:correlated_subquery} && Sequel.guarded?(:derby, :mssql)
-      pending("correlated subqueries on many_to_many associations not supported")
-    end
     Album.many_to_many :first_two_tags, {:clone=>:first_two_tags}.merge(@els) if @els
     Album.many_to_many :second_two_tags, {:clone=>:second_two_tags}.merge(@els) if @els
     Album.many_to_many :last_two_tags, {:clone=>:last_two_tags}.merge(@els) if @els
@@ -76,9 +73,6 @@ shared_examples_for "eager limit strategies" do
   end
   
   specify "should correctly handle limits and offsets when eager loading many_through_many associations" do
-    if @els == {:eager_limit_strategy=>:correlated_subquery} && Sequel.guarded?(:derby, :mssql)
-      pending("correlated subqueries on many_through_many associations not supported")
-    end
     Artist.many_through_many :first_two_tags, {:clone=>:first_two_tags}.merge(@els) if @els
     Artist.many_through_many :second_two_tags, {:clone=>:second_two_tags}.merge(@els) if @els
     Artist.many_through_many :last_two_tags, {:clone=>:last_two_tags}.merge(@els) if @els
@@ -573,7 +567,7 @@ describe "Sequel::Model Simple Associations" do
     end
     class ::Album < Sequel::Model(@db)
       plugin :dataset_associations
-      many_to_one :artist
+      many_to_one :artist, :reciprocal=>nil
       many_to_many :tags, :right_key=>:tag_id
       many_to_many :alias_tags, :clone=>:tags, :join_table=>:albums_tags___at
       many_to_many :first_two_tags, :clone=>:tags, :order=>:name, :limit=>2
@@ -603,13 +597,6 @@ describe "Sequel::Model Simple Associations" do
   
   it_should_behave_like "regular and composite key associations"
 
-  describe "with :eager_limit_strategy=>:correlated_subquery" do
-    before do
-      @els = {:eager_limit_strategy=>:correlated_subquery}
-    end
-    it_should_behave_like "eager limit strategies"
-  end unless Sequel.guarded?(:mysql, :db2, :oracle, :h2, :cubrid, :hsqldb)
-
   specify "should handle many_to_one associations with same name as :key" do
     Album.def_column_alias(:artist_id_id, :artist_id)
     Album.many_to_one :artist_id, :key_column =>:artist_id, :class=>Artist
@@ -632,7 +619,7 @@ describe "Sequel::Model Simple Associations" do
     Artist.set_dataset(:artists___ar)
     Album.set_dataset(:albums___a)
     Tag.set_dataset(:tags___t)
-    Artist.one_to_many :balbums, :class=>Album, :key=>:artist_id
+    Artist.one_to_many :balbums, :class=>Album, :key=>:artist_id, :reciprocal=>nil
     Album.many_to_many :btags, :class=>Tag, :join_table=>:albums_tags, :right_key=>:tag_id
     Album.many_to_one :bartist, :class=>Artist, :key=>:artist_id
     Tag.many_to_many :balbums, :class=>Album, :join_table=>:albums_tags, :right_key=>:album_id
@@ -650,13 +637,13 @@ describe "Sequel::Model Simple Associations" do
   
   specify "should have add method accept hashes and create new records" do
     @artist.remove_all_albums
-    Album.delete
+    Album.dataset.delete
     @album = @artist.add_album(:name=>'Al2')
     Album.first[:name].should == 'Al2'
     @artist.albums_dataset.first[:name].should == 'Al2'
     
     @album.remove_all_tags
-    Tag.delete
+    Tag.dataset.delete
     @album.add_tag(:name=>'T2')
     Tag.first[:name].should == 'T2'
     @album.tags_dataset.first[:name].should == 'T2'
@@ -766,7 +753,7 @@ describe "Sequel::Model Composite Key Associations" do
     [:albums_tags, :tags, :albums, :artists].each{|t| @db[t].delete}
     class ::Artist < Sequel::Model(@db)
       plugin :dataset_associations
-      set_primary_key :id1, :id2
+      set_primary_key [:id1, :id2]
       unrestrict_primary_key
       one_to_many :albums, :key=>[:artist_id1, :artist_id2], :order=>:name
       one_to_one :first_album, :clone=>:albums, :order=>:name
@@ -782,9 +769,9 @@ describe "Sequel::Model Composite Key Associations" do
     end
     class ::Album < Sequel::Model(@db)
       plugin :dataset_associations
-      set_primary_key :id1, :id2
+      set_primary_key [:id1, :id2]
       unrestrict_primary_key
-      many_to_one :artist, :key=>[:artist_id1, :artist_id2]
+      many_to_one :artist, :key=>[:artist_id1, :artist_id2], :reciprocal=>nil
       many_to_many :tags, :left_key=>[:album_id1, :album_id2], :right_key=>[:tag_id1, :tag_id2]
       many_to_many :alias_tags, :clone=>:tags, :join_table=>:albums_tags___at
       many_to_many :first_two_tags, :clone=>:tags, :order=>:name, :limit=>2
@@ -793,7 +780,7 @@ describe "Sequel::Model Composite Key Associations" do
     end
     class ::Tag < Sequel::Model(@db)
       plugin :dataset_associations
-      set_primary_key :id1, :id2
+      set_primary_key [:id1, :id2]
       unrestrict_primary_key
       many_to_many :albums, :right_key=>[:album_id1, :album_id2], :left_key=>[:tag_id1, :tag_id2]
     end
@@ -816,22 +803,15 @@ describe "Sequel::Model Composite Key Associations" do
 
   it_should_behave_like "regular and composite key associations"
 
-  describe "with :eager_limit_strategy=>:correlated_subquery" do
-    before do
-      @els = {:eager_limit_strategy=>:correlated_subquery}
-    end
-    it_should_behave_like "eager limit strategies"
-  end if INTEGRATION_DB.dataset.supports_multiple_column_in? && !Sequel.guarded?(:mysql, :db2, :oracle, :hsqldb)
-
   specify "should have add method accept hashes and create new records" do
     @artist.remove_all_albums
-    Album.delete
+    Album.dataset.delete
     @artist.add_album(:id1=>1, :id2=>2, :name=>'Al2')
     Album.first[:name].should == 'Al2'
     @artist.albums_dataset.first[:name].should == 'Al2'
     
     @album.remove_all_tags
-    Tag.delete
+    Tag.dataset.delete
     @album.add_tag(:id1=>1, :id2=>2, :name=>'T2')
     Tag.first[:name].should == 'T2'
     @album.tags_dataset.first[:name].should == 'T2'