sequel 4.44.0 → 4.45.0

data/spec/core_extensions_spec.rb

@@ -11,9 +11,13 @@ unless Object.const_defined?('Sequel') && Sequel.const_defined?('Model')
   Sequel::Deprecation.backtrace_filter = true
 end
 
+# SEQUEL5: Remove
+output = Sequel::Deprecation.output
+Sequel::Deprecation.output = nil
 Sequel.quote_identifiers = false
 Sequel.identifier_input_method = nil
 Sequel.identifier_output_method = nil
+Sequel::Deprecation.output = output
 
 Regexp.send(:include, Sequel::SQL::StringMethods)
 String.send(:include, Sequel::SQL::StringMethods)

data/spec/deprecation_helper.rb

@@ -0,0 +1,17 @@
+Sequel::Deprecation.backtrace_filter = lambda{|line, lineno| lineno < 4 || line =~ /_spec\.rb/}
+
+class Minitest::HooksSpec
+  def self.deprecated(*a, &block)
+    it(*a) do
+      deprecated{instance_exec(&block)}
+    end
+  end
+
+  def deprecated
+    output = Sequel::Deprecation.output
+    Sequel::Deprecation.output = nil
+    yield
+  ensure
+    Sequel::Deprecation.output = output
+  end
+end

data/spec/extensions/_deprecated_identifier_mangling_spec.rb

@@ -0,0 +1,314 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "identifier_mangling extension" do
+  after do
+    deprecated do
+      Sequel.quote_identifiers = false
+      Sequel.identifier_input_method = nil
+      Sequel.identifier_output_method = nil
+    end
+  end
+  
+  deprecated "should respect the :quote_identifiers option" do
+    db = Sequel::Database.new(:quote_identifiers=>false, :identifier_mangling=>true)
+    db.quote_identifiers?.must_equal false
+    db = Sequel::Database.new(:quote_identifiers=>true, :identifier_mangling=>true)
+    db.quote_identifiers?.must_equal true
+  end
+
+  deprecated "should respect the :quote_identifiers setting" do
+    db = Sequel::Database.new(:identifier_mangling=>true)
+    db.quote_identifiers?.must_equal false
+    db.quote_identifiers = true
+    db.quote_identifiers?.must_equal true
+  end
+
+  deprecated "should upcase on input and downcase on output by default" do
+    db = Sequel::Database.new(:identifier_mangling=>true)
+    db.send(:identifier_input_method_default).must_equal :upcase
+    db.send(:identifier_output_method_default).must_equal :downcase
+  end
+
+  deprecated "should respect the :identifier_input_method option" do
+    Sequel.identifier_input_method = nil
+    Sequel::Database.identifier_input_method.must_equal false
+    db = Sequel::Database.new(:identifier_input_method=>nil, :identifier_mangling=>true)
+    db.identifier_input_method.must_be_nil
+    db.identifier_input_method = :downcase
+    db.identifier_input_method.must_equal :downcase
+    db = Sequel::Database.new(:identifier_input_method=>:upcase, :identifier_mangling=>true)
+    db.identifier_input_method.must_equal :upcase
+    db.identifier_input_method = nil
+    db.identifier_input_method.must_be_nil
+    Sequel.identifier_input_method = :downcase
+    Sequel::Database.identifier_input_method.must_equal :downcase
+    db = Sequel::Database.new(:identifier_input_method=>nil, :identifier_mangling=>true)
+    db.identifier_input_method.must_be_nil
+    db.identifier_input_method = :upcase
+    db.identifier_input_method.must_equal :upcase
+    db = Sequel::Database.new(:identifier_input_method=>:upcase, :identifier_mangling=>true)
+    db.identifier_input_method.must_equal :upcase
+    db.identifier_input_method = nil
+    db.identifier_input_method.must_be_nil
+  end
+  
+  deprecated "should respect the :identifier_output_method option" do
+    Sequel.identifier_output_method = nil
+    Sequel::Database.identifier_output_method.must_equal false
+    db = Sequel::Database.new(:identifier_output_method=>nil, :identifier_mangling=>true)
+    db.identifier_output_method.must_be_nil
+    db.identifier_output_method = :downcase
+    db.identifier_output_method.must_equal :downcase
+    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
+    db.identifier_output_method.must_equal :upcase
+    db.identifier_output_method = nil
+    db.identifier_output_method.must_be_nil
+    Sequel.identifier_output_method = :downcase
+    Sequel::Database.identifier_output_method.must_equal :downcase
+    db = Sequel::Database.new(:identifier_output_method=>nil, :identifier_mangling=>true)
+    db.identifier_output_method.must_be_nil
+    db.identifier_output_method = :upcase
+    db.identifier_output_method.must_equal :upcase
+    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
+    db.identifier_output_method.must_equal :upcase
+    db.identifier_output_method = nil
+    db.identifier_output_method.must_be_nil
+  end
+
+  deprecated "should use the default Sequel.quote_identifiers value" do
+    Sequel.quote_identifiers = true
+    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+    Sequel.quote_identifiers = false
+    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
+    Sequel::Database.quote_identifiers = true
+    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+    Sequel::Database.quote_identifiers = false
+    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
+  end
+
+  deprecated "should use the default Sequel.identifier_input_method value" do
+    Sequel.identifier_input_method = :downcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
+    Sequel.identifier_input_method = :upcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :upcase
+    Sequel::Database.identifier_input_method = :downcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
+    Sequel::Database.identifier_input_method = :upcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_input_method.must_equal :upcase
+  end
+  
+  deprecated "should use the default Sequel.identifier_output_method value" do
+    Sequel.identifier_output_method = :downcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :downcase
+    Sequel.identifier_output_method = :upcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :upcase
+    Sequel::Database.identifier_output_method = :downcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :downcase
+    Sequel::Database.identifier_output_method = :upcase
+    Sequel::Database.new(:identifier_mangling=>true).identifier_output_method.must_equal :upcase
+  end
+
+  deprecated "should respect the quote_indentifiers_default method if Sequel.quote_identifiers = nil" do
+    Sequel.quote_identifiers = nil
+    Sequel::Database.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+    x = Class.new(Sequel::Database){def quote_identifiers_default; false end}
+    x.new(:identifier_mangling=>true).quote_identifiers?.must_equal false
+    y = Class.new(Sequel::Database){def quote_identifiers_default; true end}
+    y.new(:identifier_mangling=>true).quote_identifiers?.must_equal true
+  end
+  
+  deprecated "should respect the identifier_input_method_default method if Sequel.identifier_input_method is not called" do
+    class Sequel::Database
+      @identifier_input_method = nil
+    end
+    x = Class.new(Sequel::Database){def identifier_input_method_default; :downcase end}
+    x.new(:identifier_mangling=>true).identifier_input_method.must_equal :downcase
+    y = Class.new(Sequel::Database){def identifier_input_method_default; :camelize end}
+    y.new(:identifier_mangling=>true).identifier_input_method.must_equal :camelize
+  end
+  
+  deprecated "should respect the identifier_output_method_default method if Sequel.identifier_output_method is not called" do
+    class Sequel::Database
+      @identifier_output_method = nil
+    end
+    x = Class.new(Sequel::Database){def identifier_output_method_default; :upcase end}
+    x.new(:identifier_mangling=>true).identifier_output_method.must_equal :upcase
+    y = Class.new(Sequel::Database){def identifier_output_method_default; :underscore end}
+    y.new(:identifier_mangling=>true).identifier_output_method.must_equal :underscore
+  end
+end
+
+describe "Database#input_identifier_meth" do
+  deprecated "should be the input_identifer method of a default dataset for this database" do
+    db = Sequel::Database.new(:identifier_mangling=>true)
+    db.send(:input_identifier_meth).call(:a).must_equal 'a'
+    db.identifier_input_method = :upcase
+    db.send(:input_identifier_meth).call(:a).must_equal 'A'
+  end
+end
+
+describe "Database#output_identifier_meth" do
+  deprecated "should be the output_identifer method of a default dataset for this database" do
+    db = Sequel::Database.new(:identifier_mangling=>true)
+    db.send(:output_identifier_meth).call('A').must_equal :A
+    db.identifier_output_method = :downcase
+    db.send(:output_identifier_meth).call('A').must_equal :a
+  end
+end
+
+describe "Database#metadata_dataset" do
+  deprecated "should be a dataset with the default settings for identifier_mangling" do
+    ds = Sequel::Database.new(:identifier_mangling=>true).send(:metadata_dataset)
+    ds.literal(:a).must_equal 'A'
+    ds.send(:output_identifier, 'A').must_equal :a
+  end
+end
+
+describe "Dataset" do
+  before do
+    @dataset = Sequel.mock(:identifier_mangling=>true).dataset
+  end
+  
+  deprecated "should get quote_identifiers default from database" do
+    db = Sequel::Database.new(:quote_identifiers=>true, :identifier_mangling=>true)
+    db[:a].quote_identifiers?.must_equal true
+    db = Sequel::Database.new(:quote_identifiers=>false, :identifier_mangling=>true)
+    db[:a].quote_identifiers?.must_equal false
+  end
+
+  deprecated "should get identifier_input_method default from database" do
+    db = Sequel::Database.new(:identifier_input_method=>:upcase, :identifier_mangling=>true)
+    db[:a].identifier_input_method.must_equal :upcase
+    db = Sequel::Database.new(:identifier_input_method=>:downcase, :identifier_mangling=>true)
+    db[:a].identifier_input_method.must_equal :downcase
+  end
+
+  deprecated "should get identifier_output_method default from database" do
+    db = Sequel::Database.new(:identifier_output_method=>:upcase, :identifier_mangling=>true)
+    db[:a].identifier_output_method.must_equal :upcase
+    db = Sequel::Database.new(:identifier_output_method=>:downcase, :identifier_mangling=>true)
+    db[:a].identifier_output_method.must_equal :downcase
+  end
+  
+  # SEQUEL5: Remove
+  unless Sequel.mock(:identifier_mangling=>true).dataset.frozen?
+    deprecated "should have quote_identifiers= method which changes literalization of identifiers" do
+      @dataset.quote_identifiers = true
+      @dataset.literal(:a).must_equal '"a"'
+      @dataset.quote_identifiers = false
+      @dataset.literal(:a).must_equal 'a'
+    end
+    
+    deprecated "should have identifier_input_method= method which changes literalization of identifiers" do
+      @dataset.identifier_input_method = :upcase
+      @dataset.literal(:a).must_equal 'A'
+      @dataset.identifier_input_method = :downcase
+      @dataset.literal(:A).must_equal 'a'
+      @dataset.identifier_input_method = :reverse
+      @dataset.literal(:at_b).must_equal 'b_ta'
+    end
+    
+    deprecated "should have identifier_output_method= method which changes identifiers returned from the database" do
+      @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
+      @dataset.identifier_output_method = :upcase
+      @dataset.send(:output_identifier, "at_b_C").must_equal :AT_B_C
+      @dataset.identifier_output_method = :downcase
+      @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_c
+      @dataset.identifier_output_method = :reverse
+      @dataset.send(:output_identifier, "at_b_C").must_equal :C_b_ta
+    end
+  end
+  
+  deprecated "should have with_quote_identifiers method which returns cloned dataset with changed literalization of identifiers" do
+    @dataset.with_quote_identifiers(true).literal(:a).must_equal '"a"'
+    @dataset.with_quote_identifiers(false).literal(:a).must_equal 'a'
+    ds = @dataset.freeze.with_quote_identifiers(false)
+    ds.literal(:a).must_equal 'a'
+    ds.frozen?.must_equal true
+  end
+  
+  deprecated "should have with_identifier_input_method method which returns cloned dataset with changed literalization of identifiers" do
+    @dataset.with_identifier_input_method(:upcase).literal(:a).must_equal 'A'
+    @dataset.with_identifier_input_method(:downcase).literal(:A).must_equal 'a'
+    @dataset.with_identifier_input_method(:reverse).literal(:at_b).must_equal 'b_ta'
+    ds = @dataset.freeze.with_identifier_input_method(:reverse)
+    ds.frozen?.must_equal true
+    ds.literal(:at_b).must_equal 'b_ta'
+  end
+  
+  deprecated "should have with_identifier_output_method method which returns cloned dataset with changed identifiers returned from the database" do
+    @dataset.send(:output_identifier, "at_b_C").must_equal :at_b_C
+    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "at_b_C").must_equal :AT_B_C
+    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "at_b_C").must_equal :at_b_c
+    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "at_b_C").must_equal :C_b_ta
+    ds = @dataset.freeze.with_identifier_output_method(:reverse)
+    ds.send(:output_identifier, "at_b_C").must_equal :C_b_ta
+    ds.frozen?.must_equal true
+  end
+  
+  deprecated "should have output_identifier handle empty identifiers" do
+    @dataset.send(:output_identifier, "").must_equal :untitled
+    @dataset.with_identifier_output_method(:upcase).send(:output_identifier, "").must_equal :UNTITLED
+    @dataset.with_identifier_output_method(:downcase).send(:output_identifier, "").must_equal :untitled
+    @dataset.with_identifier_output_method(:reverse).send(:output_identifier, "").must_equal :deltitnu
+  end
+end
+
+describe "Frozen Datasets" do
+  before do
+    @ds = Sequel.mock(:identifier_mangling=>true)[:test].freeze
+  end
+
+  deprecated "should raise an error when calling mutation methods" do
+    proc{@ds.identifier_input_method = :a}.must_raise RuntimeError
+    proc{@ds.identifier_output_method = :a}.must_raise RuntimeError
+    proc{@ds.quote_identifiers = false}.must_raise RuntimeError
+  end
+end
+
+describe "identifier_mangling extension" do
+  deprecated "should be able to load dialects based on the database name" do
+    begin
+      qi = class Sequel::Database; @quote_identifiers; end
+      ii = class Sequel::Database; @identifier_input_method; end
+      io = class Sequel::Database; @identifier_output_method; end
+      Sequel.quote_identifiers = nil
+      class Sequel::Database; @identifier_input_method=nil; end
+      class Sequel::Database; @identifier_output_method=nil; end
+      Sequel.mock(:host=>'access').select(Date.new(2011, 12, 13)).sql.must_equal 'SELECT #2011-12-13#'
+      Sequel.mock(:host=>'db2').select(1).sql.must_equal 'SELECT 1 FROM "SYSIBM"."SYSDUMMY1"'
+      Sequel.mock(:host=>'mssql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM [A] WHERE (CONTAINS ([B], 'c'))"
+      Sequel.mock(:host=>'mysql')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM `a` WHERE (MATCH (`b`) AGAINST ('c'))"
+      Sequel.mock(:host=>'oracle')[:a].limit(1).sql.must_equal 'SELECT * FROM (SELECT * FROM "A") "T1" WHERE (ROWNUM <= 1)'
+      Sequel.mock(:host=>'postgres')[:a].full_text_search(:b, 'c').sql.must_equal "SELECT * FROM \"a\" WHERE (to_tsvector(CAST('simple' AS regconfig), (COALESCE(\"b\", ''))) @@ to_tsquery(CAST('simple' AS regconfig), 'c'))"
+      Sequel.mock(:host=>'sqlanywhere').from(:a).offset(1).sql.must_equal 'SELECT TOP 2147483647 START AT (1 + 1) * FROM "A"'
+      Sequel.mock(:host=>'sqlite')[:a___b].sql.must_equal "SELECT * FROM `a` AS 'b'"
+    ensure
+      Sequel.quote_identifiers = qi
+      Sequel::Database.send(:instance_variable_set, :@identifier_input_method, ii)
+      Sequel::Database.send(:instance_variable_set, :@identifier_output_method, io)
+    end
+  end
+end
+
+describe Sequel::Model, ".[] optimization" do
+  before do
+    @db = Sequel.mock(:identifier_mangling=>true, :quote_identifiers=>true)
+    def @db.schema(*) [[:id, {:primary_key=>true}]] end
+    def @db.supports_schema_parsing?() true end
+    @c = Class.new(Sequel::Model(@db))
+    @ds = @db.dataset.with_quote_identifiers(true)
+  end
+
+  deprecated "should have simple_pk and simple_table respect dataset's identifier input methods" do
+    ds = @db.from(:ab).with_identifier_input_method(:reverse)
+    @c.set_dataset ds
+    @c.simple_table.must_equal '"ba"'
+    @c.set_primary_key :cd
+    @c.simple_pk.must_equal '"dc"'
+
+    @c.set_dataset ds.from(:ef__gh)
+    @c.simple_table.must_equal '"fe"."hg"'
+  end
+end
+

data/spec/extensions/association_pks_spec.rb

@@ -57,8 +57,8 @@ describe "Sequel::Plugins::AssociationPks" do
     @Artist.plugin :association_pks
     @Album.plugin :association_pks
     @Vocalist.plugin :association_pks
-    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
-    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :delay_pks=>false
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id, :delay_pks=>false
     @db.sqls
   end
 
@@ -73,6 +73,13 @@ describe "Sequel::Plugins::AssociationPks" do
     @Album.load(:id=>3).tag_pks.must_equal []
   end
 
+  deprecated "should set associated pks correctly for a one_to_many association when :delay_pks is not set" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Artist.load(:id=>1).album_pks = [1, 2]
+    @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
+  end
+
   it "should set associated pks correctly for a one_to_many association" do
     @Artist.load(:id=>1).album_pks = [1, 2]
     @db.sqls.must_equal ["UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2))",
@@ -111,14 +118,14 @@ describe "Sequel::Plugins::AssociationPks" do
   end
 
   it "should set associated right-side cpks correctly for a one_to_many association" do
-    @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
+    @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id, :delay_pks=>false
     @Album.load(:id=>1).vocalist_pks = [["F1", "L1"], ["F2", "L2"]]
     @db.sqls.must_equal ["UPDATE vocalists SET album_id = 1 WHERE ((first, last) IN (('F1', 'L1'), ('F2', 'L2')))",
       "UPDATE vocalists SET album_id = NULL WHERE ((vocalists.album_id = 1) AND ((first, last) NOT IN (('F1', 'L1'), ('F2', 'L2'))))"]
   end
 
   it "should set associated right-side cpks correctly for a many_to_many association" do
-    @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last]
+    @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last], :delay_pks=>false
     @Album.load(:id=>2).vocalist_pks = [["F1", "L1"], ["F2", "L2"]]
     sqls = @db.sqls
     sqls[0].must_equal "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN (('F1', 'L1'), ('F2', 'L2'))))"
@@ -142,7 +149,7 @@ describe "Sequel::Plugins::AssociationPks" do
   end
 
   it "should set associated pks correctly for left-side cpks for a one_to_many association" do
-    @Vocalist.one_to_many :instruments, :class=>@Instrument, :key=>[:first, :last]
+    @Vocalist.one_to_many :instruments, :class=>@Instrument, :key=>[:first, :last], :delay_pks=>false
     @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks = [1, 2]
     sqls = @db.sqls
     sqls[0].must_match(/UPDATE instruments SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(id IN \(1, 2\)\)/)
@@ -151,7 +158,7 @@ describe "Sequel::Plugins::AssociationPks" do
   end
 
   it "should set associated pks correctly for left-side cpks for a many_to_many association" do
-    @Vocalist.many_to_many :instruments, :class=>@Instrument, :join_table=>:vocalists_instruments, :left_key=>[:first, :last]
+    @Vocalist.many_to_many :instruments, :class=>@Instrument, :join_table=>:vocalists_instruments, :left_key=>[:first, :last], :delay_pks=>false
     @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks = [1, 2]
     sqls = @db.sqls
     sqls[0].must_equal "DELETE FROM vocalists_instruments WHERE ((first = 'F2') AND (last = 'L2') AND (instrument_id NOT IN (1, 2)))"
@@ -175,7 +182,7 @@ describe "Sequel::Plugins::AssociationPks" do
   end
 
   it "should set associated right-side cpks correctly for left-side cpks for a one_to_many association" do
-    @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last], :order=>:week
+    @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last], :order=>:week, :delay_pks=>false
     @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks = [[1997, 1], [1997, 2]]
     sqls = @db.sqls
     sqls[0].must_match(/UPDATE hits SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(\(year, week\) IN \(\(1997, 1\), \(1997, 2\)\)\)/)
@@ -184,7 +191,7 @@ describe "Sequel::Plugins::AssociationPks" do
   end
 
   it "should set associated right-side cpks correctly for left-side cpks for a many_to_many association" do
-    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
+    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week], :delay_pks=>false
     @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks = [[1997, 1], [1997, 2]]
     sqls = @db.sqls
     sqls[0].must_equal "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
@@ -253,7 +260,7 @@ describe "Sequel::Plugins::AssociationPks" do
   it "should automatically convert keys to numbers for appropriate integer primary key for composite key associations" do
     @Hit.db_schema[:year][:type] = :integer
     @Hit.db_schema[:week][:type] = :integer
-    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
+    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week], :delay_pks=>false
     @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks = [['1997', '1'], ['1997', '2']]
     sqls = @db.sqls
     sqls[0].must_equal "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
@@ -264,12 +271,12 @@ describe "Sequel::Plugins::AssociationPks" do
 
     @Vocalist.db_schema[:first][:type] = :integer
     @Vocalist.db_schema[:last][:type] = :integer
-    @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
+    @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id, :delay_pks=>false
     @Album.load(:id=>1).vocalist_pks = [["11", "11"], ["12", "12"]]
     @db.sqls.must_equal ["UPDATE vocalists SET album_id = 1 WHERE ((first, last) IN ((11, 11), (12, 12)))",
       "UPDATE vocalists SET album_id = NULL WHERE ((vocalists.album_id = 1) AND ((first, last) NOT IN ((11, 11), (12, 12))))"]
 
-    @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last]
+    @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last], :delay_pks=>false
     @Album.load(:id=>2).vocalist_pks = [["11", "11"], ["12", "12"]]
     sqls = @db.sqls
     sqls[0].must_equal "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN ((11, 11), (12, 12))))"
@@ -281,7 +288,7 @@ describe "Sequel::Plugins::AssociationPks" do
     sqls.length.must_equal 6
   end
 
-  it "should handle delaying setting of association pks until after saving for new objects, if :delay plugin option is used" do
+  deprecated "should handle delaying setting of association pks until after saving for new objects, if :delay_pks=>true association option is used" do
     @Artist.one_to_many :albums, :clone=>:albums, :delay_pks=>true
     @Album.many_to_many :tags, :clone=>:tags, :delay_pks=>true
     @Album.db_schema[:id][:type] = :integer
@@ -316,13 +323,54 @@ describe "Sequel::Plugins::AssociationPks" do
       "COMMIT",
       "SELECT * FROM albums WHERE (id = 2) LIMIT 1"
     ]
+
+    al = @Album.load(:id=>1)
+    al.tag_pks = [2,3]
+    @db.sqls.must_equal [
+      "DELETE FROM albums_tags WHERE ((album_id = 1) AND (tag_id NOT IN (2, 3)))",
+      "SELECT tag_id FROM albums_tags WHERE (album_id = 1)",
+      "BEGIN",
+      "INSERT INTO albums_tags (album_id, tag_id) VALUES (1, 3)",
+      "COMMIT"
+    ]
+    al.tag_pks.must_equal [1, 2]
   end
 
-  it "should handle delaying setting of association pks until after saving for existing objects, if :delay=>:all plugin option is used" do
+  it "should handle delaying setting of association pks until after saving for existing objects, if :delay_pks=>:always association option is used" do
     @Artist.one_to_many :albums, :clone=>:albums, :delay_pks=>:always
     @Album.many_to_many :tags, :clone=>:tags, :delay_pks=>:always
     @Album.db_schema[:id][:type] = :integer
 
+    ar = @Artist.new
+    ar.album_pks.must_equal []
+    ar.album_pks = ["1","2","3"]
+    ar.album_pks.must_equal [1,2,3]
+    @db.sqls.must_equal []
+
+    ar.save
+    @db.sqls.must_equal [
+      "INSERT INTO artists DEFAULT VALUES",
+      "UPDATE albums SET artist_id = 1 WHERE (id IN (1, 2, 3))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2, 3)))",
+      "SELECT * FROM artists WHERE (id = 1) LIMIT 1",
+    ]
+
+    al = @Album.new
+    al.tag_pks.must_equal []
+    al.tag_pks = [1,2]
+    al.tag_pks.must_equal [1, 2]
+    @db.sqls.must_equal []
+
+    al.save
+    @db.sqls.must_equal [
+      "INSERT INTO albums DEFAULT VALUES",
+      "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 2)))",
+      "SELECT tag_id FROM albums_tags WHERE (album_id = 2)",
+      "BEGIN",
+      "INSERT INTO albums_tags (album_id, tag_id) VALUES (2, 1)",
+      "COMMIT",
+      "SELECT * FROM albums WHERE (id = 2) LIMIT 1"
+    ]
     ar = @Artist.load(:id=>1)
     ar.album_pks.must_equal [1,2,3]
     @db.sqls