sequel 3.36.1 → 3.37.0

data/spec/extensions/nested_attributes_spec.rb

@@ -11,7 +11,7 @@ describe "NestedAttributes plugin" do
 
   def check_sql_array(*shoulds)
     sqls = @db.sqls
-    shoulds.length.should == sqls.length
+    sqls.length.should == shoulds.length
     shoulds.zip(sqls){|s, i| check_sqls(s, i)}
   end
 
@@ -59,9 +59,8 @@ describe "NestedAttributes plugin" do
     @db.sqls.should == []
     a.save
     check_sql_array(["INSERT INTO artists (name, id) VALUES ('Ar', 1)", "INSERT INTO artists (id, name) VALUES (1, 'Ar')"],
-      "INSERT INTO albums (name) VALUES ('Al')",
-      "UPDATE albums SET artist_id = NULL WHERE ((artist_id = 1) AND (id != 2))",
-      ["UPDATE albums SET artist_id = 1, name = 'Al' WHERE (id = 2)", "UPDATE albums SET name = 'Al', artist_id = 1 WHERE (id = 2)"])
+      "UPDATE albums SET artist_id = NULL WHERE (artist_id = 1)",
+      ["INSERT INTO albums (artist_id, name) VALUES (1, 'Al')", "INSERT INTO albums (name, artist_id) VALUES ('Al', 1)"])
   end
   
   it "should support creating new one_to_many objects" do
@@ -555,4 +554,22 @@ describe "NestedAttributes plugin" do
     proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
     proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
   end
+
+  it "should accept a proc for the :fields option that accepts the associated object and returns an array of fields" do
+    @Tag.columns :id, :name, :number
+    @Album.nested_attributes :tags, :destroy=>true, :remove=>true, :fields=>proc{|object| object.is_a?(@Tag) ? [:name] : []}
+
+    al = @Album.load(:id=>10, :name=>'Al')
+    t = @Tag.load(:id=>30, :name=>'T', :number=>10)
+    al.associations[:tags] = [t]
+    al.set(:tags_attributes=>[{:id=>30, :name=>'T2'}, {:name=>'T3'}])
+    @db.sqls.should == []
+    al.save
+    check_sql_array("UPDATE albums SET name = 'Al' WHERE (id = 10)",
+      "UPDATE tags SET name = 'T2' WHERE (id = 30)",
+      "INSERT INTO tags (name) VALUES ('T3')",
+      ["INSERT INTO at (album_id, tag_id) VALUES (10, 1)", "INSERT INTO at (tag_id, album_id) VALUES (1, 10)"])
+    proc{al.set(:tags_attributes=>[{:id=>30, :name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
+    proc{al.set(:tags_attributes=>[{:name=>'T2', :number=>3}])}.should raise_error(Sequel::Error)
+  end
 end

data/spec/extensions/pg_array_ops_spec.rb

@@ -1,16 +1,6 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "Sequel::Postgres::ArrayOp" do
-  # Attempt to load pg_array first to test PGArray -> ArrayOp code
-  pg_array_loaded = begin
-    Sequel.extension :pg_array
-    true
-  rescue LoadError
-    false
-  end
-
-  Sequel.extension :pg_array_ops
-
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
     @a = :a.pg_array
@@ -101,5 +91,5 @@ describe "Sequel::Postgres::ArrayOp" do
 
   it "should allow transforming PGArray instances into ArrayOp instances" do
     @db.literal([1,2].pg_array.op.push(3)).should == "(ARRAY[1,2] || 3)"
-  end if pg_array_loaded
+  end
 end

data/spec/extensions/pg_array_spec.rb

@@ -1,108 +1,119 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
-begin
-  Sequel.extension :pg_array
-rescue LoadError => e
-  skip_warn "can't load pg_array extension (#{e.class}: #{e})"
-else
 describe "pg_array extension" do
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
+    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end; def get_conversion_procs(conn) {} end})
+    @db.extend_datasets(Module.new{def supports_timestamp_timezones?; false; end; def supports_timestamp_usecs?; false; end})
+    @db.extension(:pg_array)
     @m = Sequel::Postgres
+    @convertor = @m::PG_TYPES
   end
 
   it "should parse single dimensional text arrays" do
-    @m::PGStringArray.parse("{a}").to_a.first.should be_a_kind_of(String)
-    @m::PGStringArray.parse("{}").to_a.should == []
-    @m::PGStringArray.parse("{a}").to_a.should == ['a']
-    @m::PGStringArray.parse('{"a b"}').to_a.should == ['a b']
-    @m::PGStringArray.parse('{a,b}').to_a.should == ['a', 'b']
+    c = @convertor[1009]
+    c.call("{a}").to_a.first.should be_a_kind_of(String)
+    c.call("{}").to_a.should == []
+    c.call("{a}").to_a.should == ['a']
+    c.call('{"a b"}').to_a.should == ['a b']
+    c.call('{a,b}').to_a.should == ['a', 'b']
   end
 
   it "should parse multi-dimensional text arrays" do
-    @m::PGStringArray.parse("{{}}").to_a.should == [[]]
-    @m::PGStringArray.parse("{{a},{b}}").to_a.should == [['a'], ['b']]
-    @m::PGStringArray.parse('{{"a b"},{c}}').to_a.should == [['a b'], ['c']]
-    @m::PGStringArray.parse('{{{a},{b}},{{c},{d}}}').to_a.should == [[['a'], ['b']], [['c'], ['d']]]
-    @m::PGStringArray.parse('{{{a,e},{b,f}},{{c,g},{d,h}}}').to_a.should == [[['a', 'e'], ['b', 'f']], [['c', 'g'], ['d', 'h']]]
+    c = @convertor[1009]
+    c.call("{{}}").to_a.should == [[]]
+    c.call("{{a},{b}}").to_a.should == [['a'], ['b']]
+    c.call('{{"a b"},{c}}').to_a.should == [['a b'], ['c']]
+    c.call('{{{a},{b}},{{c},{d}}}').to_a.should == [[['a'], ['b']], [['c'], ['d']]]
+    c.call('{{{a,e},{b,f}},{{c,g},{d,h}}}').to_a.should == [[['a', 'e'], ['b', 'f']], [['c', 'g'], ['d', 'h']]]
   end
 
   it "should parse text arrays with embedded deliminaters" do
-    @m::PGStringArray.parse('{{"{},","\\",\\,\\\\\\"\\""}}').to_a.should == [['{},', '",,\\""']]
+    c = @convertor[1009]
+    c.call('{{"{},","\\",\\,\\\\\\"\\""}}').to_a.should == [['{},', '",,\\""']]
   end
 
   it "should parse single dimensional integer arrays" do
-    @m::PGIntegerArray.parse("{1}").to_a.first.should be_a_kind_of(Integer)
-    @m::PGIntegerArray.parse("{}").to_a.should == []
-    @m::PGIntegerArray.parse("{1}").to_a.should == [1]
-    @m::PGIntegerArray.parse('{2,3}').to_a.should == [2, 3]
-    @m::PGIntegerArray.parse('{3,4,5}').to_a.should == [3, 4, 5]
+    c = @convertor[1007]
+    c.call("{1}").to_a.first.should be_a_kind_of(Integer)
+    c.call("{}").to_a.should == []
+    c.call("{1}").to_a.should == [1]
+    c.call('{2,3}').to_a.should == [2, 3]
+    c.call('{3,4,5}').to_a.should == [3, 4, 5]
   end
 
   it "should parse multiple dimensional integer arrays" do
-    @m::PGIntegerArray.parse("{{}}").to_a.should == [[]]
-    @m::PGIntegerArray.parse("{{1}}").to_a.should == [[1]]
-    @m::PGIntegerArray.parse('{{2},{3}}').to_a.should == [[2], [3]]
-    @m::PGIntegerArray.parse('{{{1,2},{3,4}},{{5,6},{7,8}}}').to_a.should == [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
+    c = @convertor[1007]
+    c.call("{{}}").to_a.should == [[]]
+    c.call("{{1}}").to_a.should == [[1]]
+    c.call('{{2},{3}}').to_a.should == [[2], [3]]
+    c.call('{{{1,2},{3,4}},{{5,6},{7,8}}}').to_a.should == [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
   end
 
   it "should parse single dimensional float arrays" do
-    @m::PGFloatArray.parse("{}").to_a.should == []
-    @m::PGFloatArray.parse("{1.5}").to_a.should == [1.5]
-    @m::PGFloatArray.parse('{2.5,3.5}').to_a.should == [2.5, 3.5]
-    @m::PGFloatArray.parse('{3.5,4.5,5.5}').to_a.should == [3.5, 4.5, 5.5]
+    c = @convertor[1022]
+    c.call("{}").to_a.should == []
+    c.call("{1.5}").to_a.should == [1.5]
+    c.call('{2.5,3.5}').to_a.should == [2.5, 3.5]
+    c.call('{3.5,4.5,5.5}').to_a.should == [3.5, 4.5, 5.5]
   end
 
   it "should parse multiple dimensional float arrays" do
-    @m::PGFloatArray.parse("{{}}").to_a.should == [[]]
-    @m::PGFloatArray.parse("{{1.5}}").to_a.should == [[1.5]]
-    @m::PGFloatArray.parse('{{2.5},{3.5}}').to_a.should == [[2.5], [3.5]]
-    @m::PGFloatArray.parse('{{{1.5,2.5},{3.5,4.5}},{{5.5,6.5},{7.5,8.5}}}').to_a.should == [[[1.5, 2.5], [3.5, 4.5]], [[5.5, 6.5], [7.5, 8.5]]]
+    c = @convertor[1022]
+    c.call("{{}}").to_a.should == [[]]
+    c.call("{{1.5}}").to_a.should == [[1.5]]
+    c.call('{{2.5},{3.5}}').to_a.should == [[2.5], [3.5]]
+    c.call('{{{1.5,2.5},{3.5,4.5}},{{5.5,6.5},{7.5,8.5}}}').to_a.should == [[[1.5, 2.5], [3.5, 4.5]], [[5.5, 6.5], [7.5, 8.5]]]
   end
 
   it "should parse integers in float arrays as floats" do
-    @m::PGFloatArray.parse("{1}").to_a.first.should be_a_kind_of(Float)
-    @m::PGFloatArray.parse("{1}").to_a.should == [1.0]
-    @m::PGFloatArray.parse('{{{1,2},{3,4}},{{5,6},{7,8}}}').to_a.should == [[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]]
+    c = @convertor[1022]
+    c.call("{1}").to_a.first.should be_a_kind_of(Float)
+    c.call("{1}").to_a.should == [1.0]
+    c.call('{{{1,2},{3,4}},{{5,6},{7,8}}}').to_a.should == [[[1.0, 2.0], [3.0, 4.0]], [[5.0, 6.0], [7.0, 8.0]]]
   end
 
   it "should parse single dimensional decimal arrays" do
-    @m::PGDecimalArray.parse("{}").to_a.should == []
-    @m::PGDecimalArray.parse("{1.5}").to_a.should == [BigDecimal.new('1.5')]
-    @m::PGDecimalArray.parse('{2.5,3.5}').to_a.should == [BigDecimal.new('2.5'), BigDecimal.new('3.5')]
-    @m::PGDecimalArray.parse('{3.5,4.5,5.5}').to_a.should == [BigDecimal.new('3.5'), BigDecimal.new('4.5'), BigDecimal.new('5.5')]
+    c = @convertor[1231]
+    c.call("{}").to_a.should == []
+    c.call("{1.5}").to_a.should == [BigDecimal.new('1.5')]
+    c.call('{2.5,3.5}').to_a.should == [BigDecimal.new('2.5'), BigDecimal.new('3.5')]
+    c.call('{3.5,4.5,5.5}').to_a.should == [BigDecimal.new('3.5'), BigDecimal.new('4.5'), BigDecimal.new('5.5')]
   end
 
   it "should parse multiple dimensional decimal arrays" do
-    @m::PGDecimalArray.parse("{{}}").to_a.should == [[]]
-    @m::PGDecimalArray.parse("{{1.5}}").to_a.should == [[BigDecimal.new('1.5')]]
-    @m::PGDecimalArray.parse('{{2.5},{3.5}}').to_a.should == [[BigDecimal.new('2.5')], [BigDecimal.new('3.5')]]
-    @m::PGDecimalArray.parse('{{{1.5,2.5},{3.5,4.5}},{{5.5,6.5},{7.5,8.5}}}').to_a.should == [[[BigDecimal.new('1.5'), BigDecimal.new('2.5')], [BigDecimal.new('3.5'), BigDecimal.new('4.5')]], [[BigDecimal.new('5.5'), BigDecimal.new('6.5')], [BigDecimal.new('7.5'), BigDecimal.new('8.5')]]]
+    c = @convertor[1231]
+    c.call("{{}}").to_a.should == [[]]
+    c.call("{{1.5}}").to_a.should == [[BigDecimal.new('1.5')]]
+    c.call('{{2.5},{3.5}}').to_a.should == [[BigDecimal.new('2.5')], [BigDecimal.new('3.5')]]
+    c.call('{{{1.5,2.5},{3.5,4.5}},{{5.5,6.5},{7.5,8.5}}}').to_a.should == [[[BigDecimal.new('1.5'), BigDecimal.new('2.5')], [BigDecimal.new('3.5'), BigDecimal.new('4.5')]], [[BigDecimal.new('5.5'), BigDecimal.new('6.5')], [BigDecimal.new('7.5'), BigDecimal.new('8.5')]]]
   end
 
   it "should parse decimal values with arbitrary precision" do
-    @m::PGDecimalArray.parse("{1.000000000000000000005}").to_a.should == [BigDecimal.new('1.000000000000000000005')]
-    @m::PGDecimalArray.parse("{{1.000000000000000000005,2.000000000000000000005},{3.000000000000000000005,4.000000000000000000005}}").to_a.should == [[BigDecimal.new('1.000000000000000000005'), BigDecimal.new('2.000000000000000000005')], [BigDecimal.new('3.000000000000000000005'), BigDecimal.new('4.000000000000000000005')]]
+    c = @convertor[1231]
+    c.call("{1.000000000000000000005}").to_a.should == [BigDecimal.new('1.000000000000000000005')]
+    c.call("{{1.000000000000000000005,2.000000000000000000005},{3.000000000000000000005,4.000000000000000000005}}").to_a.should == [[BigDecimal.new('1.000000000000000000005'), BigDecimal.new('2.000000000000000000005')], [BigDecimal.new('3.000000000000000000005'), BigDecimal.new('4.000000000000000000005')]]
   end
 
   it "should parse integers in decimal arrays as BigDecimals" do
-    @m::PGDecimalArray.parse("{1}").to_a.first.should be_a_kind_of(BigDecimal)
-    @m::PGDecimalArray.parse("{1}").to_a.should == [BigDecimal.new('1')]
-    @m::PGDecimalArray.parse('{{{1,2},{3,4}},{{5,6},{7,8}}}').to_a.should == [[[BigDecimal.new('1'), BigDecimal.new('2')], [BigDecimal.new('3'), BigDecimal.new('4')]], [[BigDecimal.new('5'), BigDecimal.new('6')], [BigDecimal.new('7'), BigDecimal.new('8')]]]
+    c = @convertor[1231]
+    c.call("{1}").to_a.first.should be_a_kind_of(BigDecimal)
+    c.call("{1}").to_a.should == [BigDecimal.new('1')]
+    c.call('{{{1,2},{3,4}},{{5,6},{7,8}}}').to_a.should == [[[BigDecimal.new('1'), BigDecimal.new('2')], [BigDecimal.new('3'), BigDecimal.new('4')]], [[BigDecimal.new('5'), BigDecimal.new('6')], [BigDecimal.new('7'), BigDecimal.new('8')]]]
   end
 
   it "should parse arrays with NULL values" do
-    [@m::PGStringArray, @m::PGIntegerArray, @m::PGFloatArray, @m::PGDecimalArray].each do |c|
-      c.parse("{NULL}").should == [nil]
-      c.parse("{NULL,NULL}").should == [nil,nil]
-      c.parse("{{NULL,NULL},{NULL,NULL}}").should == [[nil,nil],[nil,nil]]
+    @convertor.values_at(1007, 1009, 1022, 1231).each do |c|
+      c.call("{NULL}").should == [nil]
+      c.call("{NULL,NULL}").should == [nil,nil]
+      c.call("{{NULL,NULL},{NULL,NULL}}").should == [[nil,nil],[nil,nil]]
     end
   end
 
   it 'should parse arrays with "NULL" values' do
-    @m::PGStringArray.parse('{NULL,"NULL",NULL}').to_a.should == [nil, "NULL", nil]
-    @m::PGStringArray.parse('{NULLA,"NULL",NULL}').to_a.should == ["NULLA", "NULL", nil]
+    c = @convertor[1009]
+    c.call('{NULL,"NULL",NULL}').to_a.should == [nil, "NULL", nil]
+    c.call('{NULLA,"NULL",NULL}').to_a.should == ["NULLA", "NULL", nil]
   end
 
   it "should literalize arrays without types correctly" do
@@ -135,24 +146,6 @@ describe "pg_array extension" do
     @db.literal(@m::PGArray.new([nil, "{},[]'\""], :"varchar(255)")).should == "ARRAY[NULL,'{},[]''\"']::varchar(255)[]"
   end
 
-  it "should have reasonable default types" do
-    @db.literal(@m::PGArray.new([])).should == 'ARRAY[]'
-    @db.literal(@m::PGIntegerArray.new([])).should == 'ARRAY[]::int4[]'
-    @db.literal(@m::PGFloatArray.new([])).should == 'ARRAY[]::double precision[]'
-    @db.literal(@m::PGStringArray.new([])).should == 'ARRAY[]::text[]'
-    @db.literal(@m::PGDecimalArray.new([])).should == 'ARRAY[]::decimal[]'
-  end
-
-  it "should use varchar type for char arrays without length" do
-    @db.literal(@m::PGStringArray.new([], :char)).should == 'ARRAY[]::varchar[]'
-    @db.literal(@m::PGStringArray.new([], 'char')).should == 'ARRAY[]::varchar[]'
-  end
-
-  it "should use given type for char arrays with length" do
-    @db.literal(@m::PGStringArray.new([], :'char(2)')).should == 'ARRAY[]::char(2)[]'
-    @db.literal(@m::PGStringArray.new([], 'char(1)')).should == 'ARRAY[]::char(1)[]'
-  end
-
   it "should have Array#pg_array method for easy PGArray creation" do
     @db.literal([1].pg_array).should == 'ARRAY[1]'
     @db.literal([1, 2].pg_array(:int4)).should == 'ARRAY[1,2]::int4[]'
@@ -160,37 +153,135 @@ describe "pg_array extension" do
   end
 
   it "should support using arrays as bound variables" do
-    @db.extend Sequel::Postgres::PGArray::DatabaseMethods
     @db.bound_variable_arg(1, nil).should == 1
     @db.bound_variable_arg([1,2].pg_array, nil).should == '{1,2}'
     @db.bound_variable_arg([1,2], nil).should == '{1,2}'
     @db.bound_variable_arg([[1,2]], nil).should == '{{1,2}}'
     @db.bound_variable_arg([1.0,2.0], nil).should == '{1.0,2.0}'
+    @db.bound_variable_arg([Sequel.lit('a'), Sequel.blob("a\0'\"")], nil).should == '{a,"a\\\\000\\\\047\\""}'
     @db.bound_variable_arg(["\\ \"", 'NULL', nil], nil).should == '{"\\\\ \\"","NULL",NULL}'
   end
 
   it "should parse array types from the schema correctly" do
-    @db.extend Sequel::Postgres::PGArray::DatabaseMethods
     @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'integer[]'}, {:name=>'f', :db_type=>'real[]'}, {:name=>'d', :db_type=>'numeric[]'}, {:name=>'t', :db_type=>'text[]'}]
     @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :integer_array, :float_array, :decimal_array, :string_array]
   end
 
   it "should support typecasting of the various array types" do
-    @db.extend Sequel::Postgres::PGArray::DatabaseMethods
-    a = [1, 2]
-    o = a.pg_array
-    %w[integer float decimal string].each do |x|
-      @db.typecast_value(:"#{x}_array", o).should equal(o)
-      @db.typecast_value(:"#{x}_array", a).should == a
-      @db.typecast_value(:"#{x}_array", a).should be_a_kind_of(eval("Sequel::Postgres::PG#{x.capitalize}Array"))
-      @db.typecast_value(:"#{x}_array", '{}').should == []
-      @db.typecast_value(:"#{x}_array", '{}').should be_a_kind_of(eval("Sequel::Postgres::PG#{x.capitalize}Array"))
+    {
+      :integer=>{:class=>Integer, :convert=>['1', '1', 1, '1']},
+      :float=>{:db_type=>'double precision',  :class=>Float, :convert=>['1.1', '1.1', 1.1, '1.1']},
+      :decimal=>{:db_type=>'numeric', :class=>BigDecimal, :convert=>['1.00000000000000000000000001', '1.00000000000000000000000001', BigDecimal.new('1.00000000000000000000000001'), '1.00000000000000000000000001']},
+      :string=>{:db_type=>'text', :class=>String, :convert=>['1', 1, '1', "'1'"]},
+      :bigint=>{:class=>Integer, :convert=>['1', '1', 1, '1']},
+      :boolean=>{:class=>TrueClass, :convert=>['t', 't', true, 'true']},
+      :blob=>{:db_type=>'bytea', :class=>Sequel::SQL::Blob, :convert=>['1', '1', '1', "'1'"]},
+      :date=>{:class=>Date, :convert=>['2011-10-12', '2011-10-12', Date.new(2011, 10, 12), "'2011-10-12'"]},
+      :time=>{:db_type=>'time without time zone', :class=>Sequel::SQLTime, :convert=>['01:02:03', '01:02:03', Sequel::SQLTime.create(1, 2, 3), "'01:02:03'"]},
+      :datetime=>{:db_type=>'timestamp without time zone', :class=>Time, :convert=>['2011-10-12 01:02:03', '2011-10-12 01:02:03', Time.local(2011, 10, 12, 1, 2, 3), "'2011-10-12 01:02:03'"]},
+      :time_timezone=>{:db_type=>'time with time zone', :class=>Sequel::SQLTime, :convert=>['01:02:03', '01:02:03', Sequel::SQLTime.create(1, 2, 3), "'01:02:03'"]},
+      :datetime_timezone=>{:db_type=>'timestamp with time zone', :class=>Time, :convert=>['2011-10-12 01:02:03', '2011-10-12 01:02:03', Time.local(2011, 10, 12, 1, 2, 3), "'2011-10-12 01:02:03'"]},
+    }.each do |type, h|
+      meth = :"#{type}_array"
+      db_type = h[:db_type]||type
+      klass = h[:class]
+      text_in, array_in, value, output = h[:convert]
+
+      ["{#{text_in}}", [array_in]].each do |input|
+        v = @db.typecast_value(meth, input)
+        v.should == [value]
+        v.first.should be_a_kind_of(klass)
+        v.array_type.should_not be_nil
+        @db.typecast_value(meth, [value].pg_array).should == v
+        @db.typecast_value(meth, v).should equal(v)
+      end
+
+      ["{{#{text_in}}}", [[array_in]]].each do |input|
+        v = @db.typecast_value(meth, input)
+        v.should == [[value]]
+        v.first.first.should be_a_kind_of(klass)
+        v.array_type.should_not be_nil
+        @db.typecast_value(meth, [[value]].pg_array).should == v
+        @db.typecast_value(meth, v).should equal(v)
+      end
+
+      @db.literal(@db.typecast_value(meth, [array_in])).should == "ARRAY[#{output}]::#{db_type}[]"
+      @db.typecast_value(meth, '{}').should == []
+      @db.literal(@db.typecast_value(meth, '{}')).should == "ARRAY[]::#{db_type}[]"
     end
-    @db.typecast_value(:integer_array, '{1}').should == [1]
-    @db.typecast_value(:float_array, '{1}').should == [1.0]
-    @db.typecast_value(:decimal_array, '{1}').should == [BigDecimal.new('1')]
-    @db.typecast_value(:string_array, '{1}').should == ['1']
     proc{@db.typecast_value(:integer_array, {})}.should raise_error(Sequel::InvalidValue)
   end
-end
+
+  it "should support registering custom array types" do
+    Sequel::Postgres::PGArray.register('foo')
+    @db.typecast_value(:foo_array, []).should be_a_kind_of(Sequel::Postgres::PGArray)
+    @db.fetch = [{:name=>'id', :db_type=>'foo[]'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:foo_array]
+  end
+
+  it "should support registering custom types with :type_symbol option" do
+    Sequel::Postgres::PGArray.register('foo', :type_symbol=>:bar)
+    @db.typecast_value(:bar_array, []).should be_a_kind_of(Sequel::Postgres::PGArray)
+    @db.fetch = [{:name=>'id', :db_type=>'foo[]'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:bar_array]
+  end
+
+  it "should support using a block as a custom conversion proc given as block" do
+    Sequel::Postgres::PGArray.register('foo'){|s| (s*2).to_i}
+    @db.typecast_value(:foo_array, '{1}').should == [11]
+  end
+
+  it "should support using a block as a custom conversion proc given as :converter option" do
+    Sequel::Postgres::PGArray.register('foo', :converter=>proc{|s| (s*2).to_i})
+    @db.typecast_value(:foo_array, '{1}').should == [11]
+  end
+
+  it "should support using an existing scaler conversion proc via the :scalar_oid option" do
+    Sequel::Postgres::PGArray.register('foo', :scalar_oid=>16)
+    @db.typecast_value(:foo_array, '{"t"}').should == [true]
+  end
+
+  it "should raise an error if using :scalar_oid option with unexisting scalar conversion proc" do
+    proc{Sequel::Postgres::PGArray.register('foo', :scalar_oid=>0)}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if using :converter option and a block argument" do
+    proc{Sequel::Postgres::PGArray.register('foo', :converter=>proc{}){}}.should raise_error(Sequel::Error)
+  end
+
+  it "should raise an error if using :scalar_oid option and a block argument" do
+    proc{Sequel::Postgres::PGArray.register('foo', :scalar_oid=>16){}}.should raise_error(Sequel::Error)
+  end
+
+  it "should support registering custom types with :oid option" do
+    Sequel::Postgres::PGArray.register('foo', :oid=>1)
+    Sequel::Postgres::PG_TYPES[1].call('{1}').should be_a_kind_of(Sequel::Postgres::PGArray)
+  end
+
+  it "should support registering custom types with :parser=>:json option" do
+    Sequel::Postgres::PGArray.register('foo', :oid=>2, :parser=>:json)
+    Sequel::Postgres::PG_TYPES[2].should be_a_kind_of(Sequel::Postgres::PGArray::JSONCreator)
+  end
+
+  it "should support registering convertors with :parser=>:json option" do
+    Sequel::Postgres::PGArray.register('foo', :oid=>4, :parser=>:json){|s| s * 2}
+    Sequel::Postgres::PG_TYPES[4].call('{{1, 2}, {3, 4}}').should == [[2, 4], [6, 8]]
+  end
+
+  it "should support registering custom types with :array_type option" do
+    Sequel::Postgres::PGArray.register('foo', :oid=>3, :array_type=>:blah)
+    @db.literal(Sequel::Postgres::PG_TYPES[3].call('{}')).should == 'ARRAY[]::blah[]'
+  end
+
+  it "should use and not override existing database typecast method if :typecast_method option is given" do
+    Sequel::Postgres::PGArray.register('foo', :typecast_method=>:float)
+    @db.fetch = [{:name=>'id', :db_type=>'foo[]'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:float_array]
+  end
+
+  it "should set appropriate timestamp conversion procs when getting conversion procs" do
+    procs = @db.send(:get_conversion_procs, nil)
+    procs[1185].call('{"2011-10-20 11:12:13"}').should == [Time.local(2011, 10, 20, 11, 12, 13)]
+    procs[1115].call('{"2011-10-20 11:12:13"}').should == [Time.local(2011, 10, 20, 11, 12, 13)]
+  end
 end

data/spec/extensions/pg_auto_parameterize_spec.rb

@@ -5,7 +5,7 @@ describe "pg_auto_parameterize extension" do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
     @db.synchronize{|c| def c.escape_bytea(v) v*2 end}
     @db.extend_datasets{def use_cursor(*) clone end}
-    @db.extend Sequel::Postgres::AutoParameterize::DatabaseMethods
+    @db.extension :pg_auto_parameterize
   end
 
   it "should automatically parameterize queries strings, blobs, numerics, dates, and times" do
@@ -20,7 +20,7 @@ describe "pg_auto_parameterize extension" do
     pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::int8)', 18446744073709551616)
     pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::double precision)', 1.1)
     pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::numeric)', BigDecimal.new('1.01'))
-    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::text)', "a")
+    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1)', "a")
     pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::bytea)', "a\0b".to_sequel_blob)
     pr.call(@db[:table], 'SELECT * FROM table WHERE (a = 1)', '1'.lit, :nil)
     pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::time)', Sequel::SQLTime.create(1, 2, 3, 500000))
@@ -38,7 +38,7 @@ describe "pg_auto_parameterize extension" do
     @db.sqls.should == ['SELECT * FROM table WHERE (a = $1::int4) -- args: [1]']
 
     @db[:table].filter(:a=>1).update(:b=>'a').should == 1
-    @db.sqls.should == ['UPDATE table SET b = $1::text WHERE (a = $2::int4) -- args: ["a", 1]']
+    @db.sqls.should == ['UPDATE table SET b = $1 WHERE (a = $2::int4) -- args: ["a", 1]']
 
     @db[:table].filter(:a=>1).delete.should == 1
     @db.sqls.should == ['DELETE FROM table WHERE (a = $1::int4) -- args: [1]']

data/spec/extensions/pg_hstore_spec.rb

@@ -6,6 +6,7 @@ describe "pg_hstore extension" do
     @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
     @m = Sequel::Postgres
     @c = @m::HStore
+    @db.extension :pg_hstore
   end
 
   it "should parse hstore strings correctly" do
@@ -164,7 +165,6 @@ describe "pg_hstore extension" do
   end
 
   it "should support using hstores as bound variables" do
-    @db.extend @c::DatabaseMethods
     @db.bound_variable_arg(1, nil).should == 1
     @db.bound_variable_arg({'1'=>'2'}, nil).should == '"1"=>"2"'
     @db.bound_variable_arg({'1'=>'2'}.hstore, nil).should == '"1"=>"2"'
@@ -175,13 +175,11 @@ describe "pg_hstore extension" do
   end
 
   it "should parse hstore type from the schema correctly" do
-    @db.extend @c::DatabaseMethods
     @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'hstore'}]
     @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :hstore]
   end
 
   it "should support typecasting for the hstore type" do
-    @db.extend @c::DatabaseMethods
     h = {1=>2}.hstore
     @db.typecast_value(:hstore, h).should equal(h)
     @db.typecast_value(:hstore, '').should be_a_kind_of(@c)