sequel 3.21.0 → 3.41.0

data/spec/extensions/arbitrary_servers_spec.rb

@@ -0,0 +1,110 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "arbtirary servers" do
+  before do
+    @db = Sequel.mock(:servers=>{})
+    @db.extension :arbitrary_servers
+  end
+
+  specify "should allow arbitrary server options using a hash" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      c.opts[:host].should == 'host1'
+      c.opts[:database].should == 'db1'
+    end
+  end
+
+  specify "should not cache connections to arbitrary servers" do
+    x = nil
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      x = c
+    end
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+      c2.should_not equal(x)
+    end
+  end
+
+  specify "should yield same connection correctly when nesting" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+        c2.should equal(c)
+      end
+    end
+  end
+
+  specify "should disconnect when connection is finished" do
+    x, x1 = nil, nil
+    @db.meta_def(:disconnect_connection){|c| x = c}
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      x1 = c
+      @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+        c2.should equal(c)
+      end
+      x.should equal(nil)
+    end
+    x.should equal(x1)
+  end
+
+  specify "should yield different connection correctly when nesting" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      c.opts[:host].should == 'host1'
+      @db.synchronize(:host=>'host2', :database=>'db1') do |c2|
+        c2.opts[:host].should == 'host2'
+        c2.should_not equal(c)
+      end
+    end
+  end
+
+  specify "should respect multithreaded access" do
+    @db.synchronize(:host=>'host1', :database=>'db1') do |c|
+      Thread.new do
+        @db.synchronize(:host=>'host1', :database=>'db1') do |c2|
+          c2.should_not equal(c)
+        end
+      end.join
+    end
+  end
+
+  specify "should work correctly with server_block plugin" do
+    @db.extend Sequel::ServerBlock
+    @db.with_server(:host=>'host1', :database=>'db1') do
+      @db.synchronize do |c|
+        c.opts[:host].should == 'host1'
+        c.opts[:database].should == 'db1'
+        @db.synchronize do |c2|
+          c2.should equal(c)
+        end
+      end
+    end
+  end
+
+
+  specify "should respect multithreaded access with server block plugin" do
+    @db.extend Sequel::ServerBlock
+    q, q1 = Queue.new, Queue.new
+    
+    t = nil
+    @db[:t].all
+    @db.with_server(:host=>'a') do
+      @db[:t].all
+      t = Thread.new do
+        @db[:t].all
+        @db.with_server(:host=>'c') do
+          @db[:t].all
+          @db.with_server(:host=>'d'){@db[:t].all}
+          q.push nil
+          q1.pop
+          @db[:t].all
+        end
+        @db[:t].all
+      end
+      q.pop
+      @db.with_server(:host=>'b'){@db[:t].all}
+      @db[:t].all
+    end
+    @db[:t].all
+    q1.push nil
+    t.join
+    @db.sqls.should == ['SELECT * FROM t', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t -- {:host=>"d"}',
+      'SELECT * FROM t -- {:host=>"b"}', 'SELECT * FROM t -- {:host=>"a"}', 'SELECT * FROM t', 'SELECT * FROM t -- {:host=>"c"}', 'SELECT * FROM t']
+  end
+end

data/spec/extensions/association_autoreloading_spec.rb

@@ -5,11 +5,7 @@ describe "AssociationAutoreloading plugin" do
     @c = Class.new(Sequel::Model)
     @c.plugin :association_autoreloading
     @Artist = Class.new(@c).set_dataset(:artists)
-    ds1 = @Artist.dataset
-    def ds1.fetch_rows(s)
-      (MODEL_DB.sqls ||= []) << s
-      yield({:id=>2, :name=>'Ar'})
-    end
+    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
     @Album = Class.new(@c).set_dataset(:albums)
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
@@ -22,18 +18,33 @@ describe "AssociationAutoreloading plugin" do
     album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-    MODEL_DB.reset
 
     album.artist_id = 1
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
   end
 
+  specify "should handle multiple many_to_one association with the same foreign key" do
+    @Album.many_to_one :artist2, :key=>:artist_id, :class=>@Artist
+    album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
+    album.artist
+    album.artist2
+    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1'] * 2
+
+    album.artist
+    album.artist2
+    MODEL_DB.sqls.should == []
+
+    album.artist_id = 1
+    album.artist
+    album.artist2
+    MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1'] * 2
+  end
+
   specify "should not reload when value has not changed" do
     album = @Album.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-    MODEL_DB.reset
 
     album.artist_id = 2
     album.artist
@@ -54,7 +65,6 @@ describe "AssociationAutoreloading plugin" do
     album.artist_id = 1
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
-    MODEL_DB.reset
 
     album.other_artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 1) LIMIT 1']
@@ -69,7 +79,6 @@ describe "AssociationAutoreloading plugin" do
     album.artist_id = 1
     album.composite_artist
     MODEL_DB.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 1) AND (artists.name = 'Al')) LIMIT 1"]
-    MODEL_DB.reset
 
     album.name = 'Al2'
     album.composite_artist
@@ -84,7 +93,6 @@ describe "AssociationAutoreloading plugin" do
     album = salbum.load(:id => 1, :name=>'Al', :artist_id=>2)
     album.artist
     MODEL_DB.sqls.should == ['SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1']
-    MODEL_DB.reset
 
     album.artist_id = 1
     album.artist

data/spec/extensions/association_dependencies_spec.rb

@@ -6,17 +6,9 @@ describe "AssociationDependencies plugin" do
     @c = Class.new(Sequel::Model)
     @c.plugin :association_dependencies
     @Artist = Class.new(@c).set_dataset(:artists)
-    ds1 = @Artist.dataset
-    def ds1.fetch_rows(s)
-      (MODEL_DB.sqls ||= []) << s
-      yield({:id=>2, :name=>'Ar'})
-    end
+    @Artist.dataset._fetch = {:id=>2, :name=>'Ar'}
     @Album = Class.new(@c).set_dataset(:albums)
-    ds1 = @Album.dataset
-    def ds1.fetch_rows(s)
-      (MODEL_DB.sqls ||= []) << s
-      yield({:id=>1, :name=>'Al', :artist_id=>2})
-    end
+    @Album.dataset._fetch = {:id=>1, :name=>'Al', :artist_id=>2}
     @Artist.columns :id, :name
     @Album.columns :id, :name, :artist_id
     @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
@@ -29,55 +21,55 @@ 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) LIMIT 1', '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
     @Album.add_association_dependencies :artist=>:delete
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (artists.id = 2)']
+    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)']
+    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)']
+    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
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE (id = 1)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['SELECT * FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM albums WHERE id = 1', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow deleting associated one_to_many objects" do
     @Artist.add_association_dependencies :albums=>:delete
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (albums.artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    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)']
+    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
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['UPDATE albums SET artist_id = NULL WHERE (artist_id = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should allow nullifying associated many_to_many associations" do
     @Artist.add_association_dependencies :other_artists=>:nullify
     @Artist.load(:id=>2, :name=>'Ar').destroy
-    MODEL_DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE (id = 2)']
+    MODEL_DB.sqls.should == ['DELETE FROM aoa WHERE (l = 2)', 'DELETE FROM artists WHERE id = 2']
   end
 
   specify "should raise an error if attempting to nullify a many_to_one association" do
@@ -105,23 +97,21 @@ describe "AssociationDependencies plugin" do
   specify "should allow specifying association dependencies in the plugin call" do
     @Album.plugin :association_dependencies, :artist=>:destroy
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    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) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
-    MODEL_DB.reset
+    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']
 
     @Album.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)']
-    MODEL_DB.reset
+    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE id = 1']
 
     @Album.add_association_dependencies :artist=>:destroy
     c2 = Class.new(@Album)
     c2.load(:id=>1, :name=>'Al', :artist_id=>2).destroy
-    MODEL_DB.sqls.should == ['DELETE FROM albums WHERE (id = 1)', 'SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1', 'DELETE FROM artists WHERE (id = 2)']
+    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

data/spec/extensions/association_pks_spec.rb

@@ -2,42 +2,62 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Plugins::AssociationPks" do
   before do
-    @db = MODEL_DB.clone
-    mod = Module.new do
-      def fetch_rows(sql)
-        case sql
-        when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
-          yield({:id=>1})
-          yield({:id=>2})
-          yield({:id=>3})
-        when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
-          yield({:tag_id=>1}) if $1 == '1'
-          yield({:tag_id=>2}) if $1 != '3'
-          yield({:tag_id=>3}) if $1 == '2'
-        end
+    @db = Sequel.mock(:fetch=>proc do |sql|
+      case sql
+      when "SELECT id FROM albums WHERE (albums.artist_id = 1)"
+        [{:id=>1}, {:id=>2}, {:id=>3}]
+      when /SELECT tag_id FROM albums_tags WHERE \(album_id = (\d)\)/
+        a = []
+        a << {:tag_id=>1} if $1 == '1'
+        a << {:tag_id=>2} if $1 != '3'
+        a << {:tag_id=>3} if $1 == '2'
+        a
+      when "SELECT first, last FROM vocalists WHERE (vocalists.album_id = 1)"
+        [{:first=>"F1", :last=>"L1"}, {:first=>"F2", :last=>"L2"}]
+      when /SELECT first, last FROM albums_vocalists WHERE \(album_id = (\d)\)/
+        a = []
+        a << {:first=>"F1", :last=>"L1"} if $1 == '1'
+        a << {:first=>"F2", :last=>"L2"} if $1 != '3'
+        a << {:first=>"F3", :last=>"L3"} if $1 == '2'
+        a
+      when "SELECT id FROM instruments WHERE ((instruments.first = 'F1') AND (instruments.last = 'L1'))"
+        [{:id=>1}, {:id=>2}]
+      when /SELECT instrument_id FROM vocalists_instruments WHERE \(\((?:first|last) = '?[FL1](\d)/
+        a = []
+        a << {:instrument_id=>1} if $1 == "1"
+        a << {:instrument_id=>2} if $1 != "3"
+        a << {:instrument_id=>3} if $1 == "2"
+        a
+      when "SELECT year, week FROM hits WHERE ((hits.first = 'F1') AND (hits.last = 'L1'))"
+        [{:year=>1997, :week=>1}, {:year=>1997, :week=>2}]
+      when /SELECT year, week FROM vocalists_hits WHERE \(\((?:first|last) = '?[FL1](\d)/
+        a = []
+        a << {:year=>1997, :week=>1} if $1 == "1"
+        a << {:year=>1997, :week=>2} if $1 != "3"
+        a << {:year=>1997, :week=>3} if $1 == "2"
+        a
       end
-    end
-    @db.meta_def(:dataset) do |*opts|
-      ds = super(*opts)
-      ds.extend mod
-      ds
-    end
-    def @db.transaction(opts)
-      execute('BEGIN')
-      yield
-      execute('COMMIT')
-    end
+    end)
     @Artist = Class.new(Sequel::Model(@db[:artists]))
     @Artist.columns :id
-    @Album= Class.new(Sequel::Model(@db[:albums]))
+    @Album = Class.new(Sequel::Model(@db[:albums]))
     @Album.columns :id, :artist_id
     @Tag = Class.new(Sequel::Model(@db[:tags]))
     @Tag.columns :id
+    @Vocalist = Class.new(Sequel::Model(@db[:vocalists]))
+    @Vocalist.columns :first, :last, :album_id
+    @Vocalist.set_primary_key [:first, :last]
+    @Instrument = Class.new(Sequel::Model(@db[:instruments]))
+    @Instrument.columns :id, :first, :last
+    @Hit = Class.new(Sequel::Model(@db[:hits]))
+    @Hit.columns :year, :week, :first, :last
+    @Hit.set_primary_key [:year, :week]
     @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
-    @db.reset
+    @db.sqls
   end
 
   specify "should return correct associated pks for one_to_many associations" do
@@ -57,10 +77,117 @@ describe "Sequel::Plugins::AssociationPks" do
       "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (id NOT IN (1, 2)))"]
   end
 
+  specify "should use associated class's primary key for a one_to_many association" do
+    @Album.set_primary_key :foo
+    @Artist.load(:id=>1).album_pks = [1, 2]
+    @db.sqls.should == ["UPDATE albums SET artist_id = 1 WHERE (foo IN (1, 2))",
+      "UPDATE albums SET artist_id = NULL WHERE ((albums.artist_id = 1) AND (foo NOT IN (1, 2)))"]
+  end
+
   specify "should set associated pks correctly for a many_to_many association" do
     @Album.load(:id=>2).tag_pks = [1, 3]
-    @db.sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    @db.sqls[1].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls.length.should == 3
+  end
+
+  specify "should return correct right-side associated cpks for one_to_many associations" do
+    @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
+    @Album.load(:id=>1).vocalist_pks.should == [["F1", "L1"], ["F2", "L2"]]
+    @Album.load(:id=>2).vocalist_pks.should == []
+  end
+
+  specify "should return correct right-side associated cpks for many_to_many associations" do
+    @Album.many_to_many :vocalists, :class=>@Vocalist, :join_table=>:albums_vocalists, :left_key=>:album_id, :right_key=>[:first, :last]
+    @Album.load(:id=>1).vocalist_pks.should == [["F1", "L1"], ["F2", "L2"]]
+    @Album.load(:id=>2).vocalist_pks.should == [["F2", "L2"], ["F3", "L3"]]
+    @Album.load(:id=>3).vocalist_pks.should == []
+  end
+
+  specify "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.load(:id=>1).vocalist_pks = [["F1", "L1"], ["F2", "L2"]]
+    @db.sqls.should == ["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
+
+  specify "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.load(:id=>2).vocalist_pks = [["F1", "L1"], ["F2", "L2"]]
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN (('F1', 'L1'), ('F2', 'L2'))))"
+    sqls[1].should == 'SELECT first, last FROM albums_vocalists WHERE (album_id = 2)'
+    match = sqls[2].match(/INSERT INTO albums_vocalists \((.*)\) VALUES \((.*)\)/)
+    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"'F1'", "last"=>"'L1'", "album_id"=>"2"}
+    sqls.length.should == 3
+  end
+
+  specify "should return correct associated pks for left-side cpks for one_to_many associations" do
+    @Vocalist.one_to_many :instruments, :class=>@Instrument, :key=>[:first, :last]
+    @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks.should == [1, 2]
+    @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks.should == []
+  end
+
+  specify "should return correct associated pks for left-side cpks for many_to_many associations" do
+    @Vocalist.many_to_many :instruments, :class=>@Instrument, :join_table=>:vocalists_instruments, :left_key=>[:first, :last]
+    @Vocalist.load(:first=>'F1', :last=>'L1').instrument_pks.should == [1, 2]
+    @Vocalist.load(:first=>'F2', :last=>'L2').instrument_pks.should == [2, 3]
+    @Vocalist.load(:first=>'F3', :last=>'L3').instrument_pks.should == []
+  end
+
+  specify "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.load(:first=>'F1', :last=>'L1').instrument_pks = [1, 2]
+    sqls = @db.sqls
+    sqls[0].should =~ /UPDATE instruments SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(id IN \(1, 2\)\)/
+    sqls[1].should =~ /UPDATE instruments SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(instruments.first = 'F1'\) AND \(instruments.last = 'L1'\) AND \(id NOT IN \(1, 2\)\)\)/
+    sqls.length.should == 2
+  end
+
+  specify "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.load(:first=>'F2', :last=>'L2').instrument_pks = [1, 2]
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM vocalists_instruments WHERE ((first = 'F2') AND (last = 'L2') AND (instrument_id NOT IN (1, 2)))"
+    sqls[1].should == "SELECT instrument_id FROM vocalists_instruments WHERE ((first = 'F2') AND (last = 'L2'))"
+    match = sqls[2].match(/INSERT INTO vocalists_instruments \((.*)\) VALUES \((.*)\)/)
+    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"'F2'", "last"=>"'L2'", "instrument_id"=>"1"}
+    sqls.length.should == 3
+  end
+
+  specify "should return correct right-side associated cpks for left-side cpks for one_to_many associations" do
+    @Vocalist.one_to_many :hits, :class=>@Hit, :key=>[:first, :last]
+    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.should == [[1997, 1], [1997, 2]]
+    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.should == []
+  end
+
+  specify "should return correct right-side associated cpks for left-side cpks for many_to_many associations" do
+    @Vocalist.many_to_many :hits, :class=>@Hit, :join_table=>:vocalists_hits, :left_key=>[:first, :last], :right_key=>[:year, :week]
+    @Vocalist.load(:first=>'F1', :last=>'L1').hit_pks.should == [[1997, 1], [1997, 2]]
+    @Vocalist.load(:first=>'F2', :last=>'L2').hit_pks.should == [[1997, 2], [1997, 3]]
+    @Vocalist.load(:first=>'F3', :last=>'L3').hit_pks.should == []
+  end
+
+  specify "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.load(:first=>'F1', :last=>'L1').hit_pks = [[1997, 1], [1997, 2]]
+    sqls = @db.sqls
+    sqls[0].should =~ /UPDATE hits SET (first = 'F1', last = 'L1'|last = 'L1', first = 'F1') WHERE \(\(year, week\) IN \(\(1997, 1\), \(1997, 2\)\)\)/
+    sqls[1].should =~ /UPDATE hits SET (first = NULL, last = NULL|last = NULL, first = NULL) WHERE \(\(hits.first = 'F1'\) AND \(hits.last = 'L1'\) AND \(\(year, week\) NOT IN \(\(1997, 1\), \(1997, 2\)\)\)\)/
+    sqls.length.should == 2
+  end
+
+  specify "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.load(:first=>'F2', :last=>'L2').hit_pks = [[1997, 1], [1997, 2]]
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
+    sqls[1].should == "SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"
+    match = sqls[2].match(/INSERT INTO vocalists_hits \((.*)\) VALUES \((.*)\)/)
+    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"'F2'", "last"=>"'L2'", "year"=>"1997", "week"=>"1"}
+    sqls.length.should == 3
   end
 
   specify "should use transactions if the object is configured to use transactions" do
@@ -71,15 +198,82 @@ describe "Sequel::Plugins::AssociationPks" do
       "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)))",
       "COMMIT"]
-    @db.reset
 
     album = @Album.load(:id=>2)
     album.use_transactions = true
     album.tag_pks = [1, 3]
-    @db.sqls[0].should == "BEGIN"
-    @db.sqls[1].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
-    @db.sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
-    @db.sqls[3].should == "COMMIT"
+    sqls = @db.sqls
+    sqls[0].should == "BEGIN"
+    sqls[1].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[2].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls[4].should == "COMMIT"
+    sqls.length.should == 5
+  end
+
+  specify "should automatically convert keys to numbers if the primary key is an integer for one_to_many associations" do
+    @Album.db_schema[:id][:type] = :integer
+    @Artist.load(:id=>1).album_pks = %w'1 2'
+    @db.sqls.should == ["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
+
+  specify "should not automatically convert keys if the primary key is not an integer for one_to_many associations" do
+    @Album.db_schema[:id][:type] = :string
+    @Artist.load(:id=>1).album_pks = %w'1 2'
+    @db.sqls.should == ["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
+
+  specify "should automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
+    @Tag.db_schema[:id][:type] = :integer
+    @Album.load(:id=>2).tag_pks = %w'1 3'
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN (1, 3)))"
+    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, 1|1, 2)\)/
+    sqls.length.should == 3
   end
 
+  specify "should not automatically convert keys to numbers if the primary key is an integer for many_to_many associations" do
+    @Tag.db_schema[:id][:type] = :string
+    @Album.load(:id=>2).tag_pks = %w'1 3'
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_tags WHERE ((album_id = 2) AND (tag_id NOT IN ('1', '3')))"
+    sqls[1].should == 'SELECT tag_id FROM albums_tags WHERE (album_id = 2)'
+    sqls[2].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '1'|'1', 2)\)/
+    sqls[3].should =~ /INSERT INTO albums_tags \((album_id, tag_id|tag_id, album_id)\) VALUES \((2, '3'|'3', 2)\)/
+    sqls.length.should == 4
+  end
+
+  specify "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.load(:first=>'F2', :last=>'L2').hit_pks = [['1997', '1'], ['1997', '2']]
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2') AND ((year, week) NOT IN ((1997, 1), (1997, 2))))"
+    sqls[1].should == "SELECT year, week FROM vocalists_hits WHERE ((first = 'F2') AND (last = 'L2'))"
+    match = sqls[2].match(/INSERT INTO vocalists_hits \((.*)\) VALUES \((.*)\)/)
+    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"'F2'", "last"=>"'L2'", "year"=>"1997", "week"=>"1"}
+    sqls.length.should == 3
+
+    @Vocalist.db_schema[:first][:type] = :integer
+    @Vocalist.db_schema[:last][:type] = :integer
+    @Album.one_to_many :vocalists, :class=>@Vocalist, :key=>:album_id
+    @Album.load(:id=>1).vocalist_pks = [["11", "11"], ["12", "12"]]
+    @db.sqls.should == ["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.load(:id=>2).vocalist_pks = [["11", "11"], ["12", "12"]]
+    sqls = @db.sqls
+    sqls[0].should == "DELETE FROM albums_vocalists WHERE ((album_id = 2) AND ((first, last) NOT IN ((11, 11), (12, 12))))"
+    sqls[1].should == 'SELECT first, last FROM albums_vocalists WHERE (album_id = 2)'
+    match = sqls[2].match(/INSERT INTO albums_vocalists \((.*)\) VALUES \((.*)\)/)
+    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"11", "last"=>"11", "album_id"=>"2"}
+    match = sqls[3].match(/INSERT INTO albums_vocalists \((.*)\) VALUES \((.*)\)/)
+    Hash[match[1].split(', ').zip(match[2].split(', '))].should == {"first"=>"12", "last"=>"12", "album_id"=>"2"}
+    sqls.length.should == 4
+  end
 end

data/spec/extensions/association_proxies_spec.rb

@@ -31,13 +31,13 @@ describe "Sequel::Plugins::AssociationProxies" do
   
   it "should reload the cached association if sent an array method and the reload flag was given" do
     @t.select{|x| false}.should == []
-    Item.db.sqls.length == 1
+    Item.db.sqls.length.should == 1
     @t.select{|x| false}.should == []
-    Item.db.sqls.length == 1
+    Item.db.sqls.length.should == 0
     @i.tags(true).select{|x| false}.should == []
-    Item.db.sqls.length == 2
+    Item.db.sqls.length.should == 1
     @t.filter(:a=>1).sql.should == "SELECT tags.* FROM tags INNER JOIN items_tags ON ((items_tags.tag_id = tags.id) AND (items_tags.item_id = 1)) WHERE (a = 1)"
-    Item.db.sqls.length == 2
+    Item.db.sqls.length.should == 0
   end
   
   it "should not return a proxy object for associations that do not return an array" do