sequel 3.39.0 → 3.40.0

data/lib/sequel/plugins/json_serializer.rb

@@ -61,6 +61,25 @@ module Sequel
     #
     #   Album.to_json(:array=>[Album[1], Album[2]])
     #
+    # Note that active_support/json makes incompatible changes to the to_json API,
+    # and breaks some aspects of the json_serializer plugin.  You can undo the damage
+    # done by active_support/json by doing:
+    #
+    #   class Array
+    #     def to_json(options = {})
+    #       JSON.generate(self)
+    #     end
+    #   end
+    #
+    #   class Hash
+    #     def to_json(options = {})
+    #       JSON.generate(self)
+    #     end
+    #   end
+    #
+    # Note that this will probably cause active_support/json to no longer work
+    # correctly in some cases.
+    #
     # Usage:
     #
     #   # Add JSON output capability to all model subclass instances (called before loading subclasses)

data/lib/sequel/sql.rb

@@ -1030,6 +1030,17 @@ module Sequel
         !@no_expression
       end
 
+      # Merge the CASE expression into the conditions, useful for databases that
+      # don't support CASE expressions.
+      def with_merged_expression
+        if expression?
+          e = expression
+          CaseExpression.new(conditions.map{|c, r| [::Sequel::SQL::BooleanExpression.new(:'=', e, c), r]}, default)
+        else
+          self
+        end
+      end
+
       to_s_method :case_expression_sql
     end
 

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 39
+  MINOR = 40
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/postgres_spec.rb

@@ -1320,6 +1320,26 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
       end.should == 'foo'
       called.should be_true
 
+      # Check weird identifier names
+      called = false
+      @db.listen('FOO bar', :after_listen=>proc{@db.notify('FOO bar')}) do |ev, pid, payload|
+        ev.should == 'FOO bar'
+        pid.should == notify_pid
+        ['', nil].should include(payload)
+        called = true
+      end.should == 'FOO bar'
+      called.should be_true
+
+      # Check identifier symbols
+      called = false
+      @db.listen(:foo, :after_listen=>proc{@db.notify(:foo)}) do |ev, pid, payload|
+        ev.should == 'foo'
+        pid.should == notify_pid
+        ['', nil].should include(payload)
+        called = true
+      end.should == 'foo'
+      called.should be_true
+
       called = false
       @db.listen('foo', :after_listen=>proc{@db.notify('foo', :payload=>'bar')}) do |ev, pid, payload|
         ev.should == 'foo'
@@ -1592,6 +1612,11 @@ describe 'PostgreSQL array handling' do
     @ds.filter(:i=>:$i).call(:first, :i=>[1,2]).should == {:i=>[1,2]}
     @ds.filter(:i=>:$i).call(:first, :i=>[1,3]).should == nil
 
+    # NULL values
+    @ds.delete
+    @ds.call(:insert, {:i=>[nil,nil]}, {:i=>:$i})
+    @ds.first.should == {:i=>[nil, nil]}
+
     @db.create_table!(:items) do
       column :i, 'text[]'
     end
@@ -1751,6 +1776,10 @@ describe 'PostgreSQL hstore handling' do
     @ds.filter(:i=>:$i).call(:first, :i=>Sequel.hstore(@h)).should == {:i=>@h}
     @ds.filter(:i=>:$i).call(:first, :i=>Sequel.hstore({})).should == nil
 
+    @ds.delete
+    @ds.call(:insert, {:i=>Sequel.hstore('a'=>nil)}, {:i=>:$i})
+    @ds.get(:i).should == Sequel.hstore('a'=>nil)
+
     @ds.delete
     @ds.call(:insert, {:i=>@h}, {:i=>:$i})
     @ds.get(:i).should == @h
@@ -2014,6 +2043,10 @@ describe 'PostgreSQL json type' do
     @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json(@a)).should == {:i=>@a}
     @ds.filter(Sequel.cast(:i, String)=>:$i).call(:first, :i=>Sequel.pg_json([])).should == nil
 
+    @ds.delete
+    @ds.call(:insert, {:i=>Sequel.pg_json('a'=>nil)}, {:i=>:$i})
+    @ds.get(:i).should == Sequel.pg_json('a'=>nil)
+
     @db.create_table!(:items){column :i, 'json[]'}
     j = Sequel.pg_array([Sequel.pg_json('a'=>1), Sequel.pg_json(['b', 2])], :text)
     @ds.call(:insert, {:i=>j}, {:i=>:$i})
@@ -2499,6 +2532,10 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds.get(:address).should == {:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}
     @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345']))[:id].should == 1
     @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])).should == nil
+
+    @ds.delete
+    @ds.call(:insert, {:address=>Sequel.pg_row([nil, nil, nil])}, {:address=>:$address, :id=>1})
+    @ds.get(:address).should == {:street=>nil, :city=>nil, :zip=>nil}
   end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'use arrays of row types in bound variables' do
@@ -2507,6 +2544,11 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds.get(:company).should == {:id=>1, :employees=>[{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}]}
     @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])]))[:id].should == 1
     @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])])])).should == nil
+
+
+    @ds.delete
+    @ds.call(:insert, {:employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row([nil, nil, nil])])])}, {:employees=>:$employees, :id=>1})
+    @ds.get(:employees).should == [{:address=>{:city=>nil, :zip=>nil, :street=>nil}, :id=>1}]
   end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'operations/functions with pg_row_ops' do

data/spec/core/database_spec.rb

@@ -617,6 +617,18 @@ shared_examples_for "Database#transaction" do
                        'BEGIN', 'SET TRANSACTION ISOLATION LEVEL SERIALIZABLE', 'DROP TABLE serializable', 'COMMIT']
   end
   
+  specify "should support :disconnect=>:retry option for automatically retrying on disconnect" do
+    a = []
+    @db.transaction(:disconnect=>:retry){a << 1; raise Sequel::DatabaseDisconnectError if a.length < 2}
+    @db.sqls.should == ['BEGIN', 'ROLLBACK', 'BEGIN', 'COMMIT']
+    a.should == [1, 1]
+  end
+  
+  specify "should raise an error if attempting to use :disconnect=>:retry inside another transaction" do
+    proc{@db.transaction{@db.transaction(:disconnect=>:retry){}}}.should raise_error(Sequel::Error)
+    @db.sqls.should == ['BEGIN', 'ROLLBACK']
+  end
+  
   specify "should handle returning inside of the block by committing" do
     def @db.ret_commit
       transaction do
@@ -2067,12 +2079,16 @@ describe "Database#column_schema_to_ruby_default" do
     db = Sequel::Database.new
     p = lambda{|d,t| db.send(:column_schema_to_ruby_default, d, t)}
     p[nil, :integer].should be_nil
+    p[1, :integer].should == 1
     p['1', :integer].should == 1
     p['-1', :integer].should == -1
+    p[1.0, :float].should == 1.0
     p['1.0', :float].should == 1.0
     p['-1.0', :float].should == -1.0
     p['1.0', :decimal].should == BigDecimal.new('1.0')
     p['-1.0', :decimal].should == BigDecimal.new('-1.0')
+    p[true, :boolean].should == true
+    p[false, :boolean].should == false
     p['1', :boolean].should == true
     p['0', :boolean].should == false
     p['true', :boolean].should == true
@@ -2085,6 +2101,7 @@ describe "Database#column_schema_to_ruby_default" do
     p["''", :string].should == ''
     p["'\\a''b'", :string].should == "\\a'b"
     p["'NULL'", :string].should == "NULL"
+    p[Date.today, :date].should == Date.today
     p["'2009-10-29'", :date].should == Date.new(2009,10,29)
     p["CURRENT_TIMESTAMP", :date].should == Sequel::CURRENT_DATE
     p["CURRENT_DATE", :date].should == Sequel::CURRENT_DATE

data/spec/core/dataset_spec.rb

@@ -3020,6 +3020,11 @@ describe "Dataset#insert_sql" do
     @ds.insert_sql('c' => 'd').should == "INSERT INTO items (c) VALUES ('d')"
   end
 
+  specify "should quote string keys" do
+    @ds.quote_identifiers = true
+    @ds.insert_sql('c' => 'd').should == "INSERT INTO \"items\" (\"c\") VALUES ('d')"
+  end
+
   specify "should accept array subscript references" do
     @ds.insert_sql((Sequel.subscript(:day, 1)) => 'd').should == "INSERT INTO items (day[1]) VALUES ('d')"
   end
@@ -3666,6 +3671,12 @@ describe "Sequel::Dataset #with and #with_recursive" do
     @ds.with_recursive(:t, @db[:x], @db[:t], :args=>[:b, :c]).sql.should == 'WITH t(b, c) AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM t'
   end
   
+  specify "#with and #with_recursive should quote the columns in the :args option" do
+    @ds.quote_identifiers = true
+    @ds.with(:t, @db[:x], :args=>[:b]).sql.should == 'WITH "t"("b") AS (SELECT * FROM x) SELECT * FROM "t"'
+    @ds.with_recursive(:t, @db[:x], @db[:t], :args=>[:b, :c]).sql.should == 'WITH "t"("b", "c") AS (SELECT * FROM x UNION ALL SELECT * FROM t) SELECT * FROM "t"'
+  end
+  
   specify "#with_recursive should take an :union_all=>false option" do
     @ds.with_recursive(:t, @db[:x], @db[:t], :union_all=>false).sql.should == 'WITH t AS (SELECT * FROM x UNION SELECT * FROM t) SELECT * FROM t'
   end

data/spec/core/expression_filters_spec.rb

@@ -942,6 +942,19 @@ describe Sequel::SQL::Subscript do
   end
 end
 
+describe Sequel::SQL::CaseExpression, "#with_merged_expression" do
+  specify "should return self if it has no expression" do
+    c = Sequel.case({1=>0}, 3)
+    c.with_merged_expression.should equal(c)
+  end
+
+  specify "should merge expression into conditions if it has an expression" do
+    db = Sequel::Database.new
+    c = Sequel.case({1=>0}, 3, 4)
+    db.literal(c.with_merged_expression).should == db.literal(Sequel.case({{4=>1}=>0}, 3))
+  end
+end
+
 describe "Sequel.recursive_map" do
   specify "should recursively convert an array using a callable" do
     Sequel.recursive_map(['1'], proc{|s| s.to_i}).should == [1]

data/spec/extensions/association_pks_spec.rb

@@ -12,16 +12,49 @@ describe "Sequel::Plugins::AssociationPks" do
         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)
     @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.sqls
@@ -60,6 +93,103 @@ describe "Sequel::Plugins::AssociationPks" do
     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
     artist = @Artist.load(:id=>1)
     artist.use_transactions = true
@@ -88,14 +218,14 @@ 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 not automatically convert keys if the primary key is not an integer for many_to_many associations" do
+  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 one_to_many associations" do
+  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
@@ -116,4 +246,34 @@ describe "Sequel::Plugins::AssociationPks" do
     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/pg_hstore_spec.rb

@@ -191,4 +191,10 @@ describe "pg_hstore extension" do
     @db.typecast_value(:hstore, {'a'=>'b'}).should == Sequel.hstore("a"=>"b")
     proc{@db.typecast_value(:hstore, [])}.should raise_error(Sequel::InvalidValue)
   end
+
+  it "should be serializable" do 
+    v = Sequel.hstore('foo'=>'bar')
+    dump = Marshal.dump(v) 
+    Marshal.load(dump).should == v    
+  end 
 end

data/spec/extensions/pg_row_spec.rb

@@ -158,6 +158,13 @@ describe "pg_row extension" do
     @db.bound_variable_arg([@m::HashRow.subclass(nil, [:a, :b]).call(:a=>"1", :b=>"abc\\'\",")], nil).should == '{"(\\"1\\",\\"abc\\\\\\\\\'\\\\\\",\\")"}'
   end
 
+  it "should handle nils in bound variables" do
+    @db.bound_variable_arg(@m::ArrayRow.call([nil, nil]), nil).should == '(,)'
+    @db.bound_variable_arg(@m::HashRow.subclass(nil, [:a, :b]).call(:a=>nil, :b=>nil), nil).should == '(,)'
+    @db.bound_variable_arg([@m::ArrayRow.call([nil, nil])], nil).should == '{"(,)"}'
+    @db.bound_variable_arg([@m::HashRow.subclass(nil, [:a, :b]).call(:a=>nil, :b=>nil)], nil).should == '{"(,)"}'
+  end
+  
   it "should allow registering row type parsers by introspecting system tables" do
     @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
     @db.conversion_procs[5] = p5 = proc{|s| s * 2}
@@ -247,6 +254,16 @@ describe "pg_row extension" do
     @db.conversion_procs[1].call('(1,b)').should == [{:bar=>1, :baz=>'bb'}]
   end
 
+  it "should handle nil values when converting columns" do
+    @db.conversion_procs[5] = p5 = proc{|s| s * 2}
+    @db.fetch = [[{:oid=>1, :typrelid=>2, :typarray=>3}], [{:attname=>'bar', :atttypid=>4}]]
+    called = false
+    @db.conversion_procs[4] = proc{|s| called = true; s}
+    @db.register_row_type(:foo)
+    @db.conversion_procs[1].call('()').should == {:bar=>nil}
+    called.should be_false
+  end
+
   it "should registering array type for row type if type has an array oid" do
     @db.conversion_procs[4] = p4 = proc{|s| s.to_i}
     @db.conversion_procs[5] = p5 = proc{|s| s * 2}