sequel 3.37.0 → 3.38.0

data/spec/extensions/many_through_many_spec.rb

@@ -244,7 +244,7 @@ describe Sequel::Model, "many_through_many" do
   end
   
   it "should support an array for the select option" do
-    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[:tags.*, :albums__name]
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], [:albums, :id, :id], [:albums_tags, :album_id, :tag_id]], :select=>[Sequel::SQL::ColumnAll.new(:tags), :albums__name]
     n = @c1.load(:id => 1234)
     n.tags_dataset.sql.should == 'SELECT tags.*, albums.name FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON (albums.id = albums_tags.album_id) INNER JOIN albums_artists ON ((albums_artists.album_id = albums.id) AND (albums_artists.artist_id = 1234))'
     n.tags.should == [@c2.load(:id=>1)]
@@ -914,12 +914,12 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
   end
 
   it "should respect the association's :graph_block option" do 
-    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :graph_block=>proc{|ja,lja,js| {:active.qualify(ja)=>true}}
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :graph_block=>proc{|ja,lja,js| {Sequel.qualify(ja, :active)=>true}}
     @c1.eager_graph(:tags).sql.should == 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON ((tags.id = albums_tags.tag_id) AND (tags.active IS TRUE))'
   end
 
   it "should respect the association's :block option on through" do 
-    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id, :block=>proc{|ja,lja,js| {:active.qualify(ja)=>true}}}, [:albums_tags, :album_id, :tag_id]]
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id, :block=>proc{|ja,lja,js| {Sequel.qualify(ja, :active)=>true}}}, [:albums_tags, :album_id, :tag_id]]
     @c1.eager_graph(:tags).sql.should == 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON ((albums.id = albums_artists.album_id) AND (albums.active IS TRUE)) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id)'
   end
 
@@ -943,7 +943,7 @@ describe "Sequel::Plugins::ManyThroughMany eager loading methods" do
   end
 
   it "should only qualify unqualified symbols, identifiers, or ordered versions in association's :order" do
-    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[:blah__id.identifier, :blah__id.identifier.desc, :blah__id.desc, :blah__id, :album_id, :album_id.desc, 1, 'RANDOM()'.lit, :a.qualify(:b)]
+    @c1.many_through_many :tags, [[:albums_artists, :artist_id, :album_id], {:table=>:albums, :left=>:id, :right=>:id}, [:albums_tags, :album_id, :tag_id]], :order=>[Sequel.identifier(:blah__id), Sequel.identifier(:blah__id).desc, Sequel.desc(:blah__id), :blah__id, :album_id, Sequel.desc(:album_id), 1, Sequel.lit('RANDOM()'), Sequel.qualify(:b, :a)]
     @c1.order(:artists__blah2, :artists__blah3).eager_graph(:tags).sql.should == 'SELECT artists.id, tags.id AS tags_id FROM artists LEFT OUTER JOIN albums_artists ON (albums_artists.artist_id = artists.id) LEFT OUTER JOIN albums ON (albums.id = albums_artists.album_id) LEFT OUTER JOIN albums_tags ON (albums_tags.album_id = albums.id) LEFT OUTER JOIN tags ON (tags.id = albums_tags.tag_id) ORDER BY artists.blah2, artists.blah3, tags.blah__id, tags.blah__id DESC, blah.id DESC, blah.id, tags.album_id, tags.album_id DESC, 1, RANDOM(), b.a'
   end
 

data/spec/extensions/pg_array_ops_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "Sequel::Postgres::ArrayOp" do
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @a = :a.pg_array
+    @a = Sequel.pg_array_op(:a)
   end
 
   it "should support the standard mathematical operators" do
@@ -76,20 +76,28 @@ describe "Sequel::Postgres::ArrayOp" do
     @a.pg_array.should equal(@a)
   end
 
+  it "Sequel.pg_array_op should return arg for ArrayOp" do
+    Sequel.pg_array_op(@a).should equal(@a)
+  end
+
   it "should be able to turn expressions into array ops using pg_array" do
-    @db.literal(:a.qualify(:b).pg_array.push(3)).should == "(b.a || 3)"
-    @db.literal(:a.sql_function(:b).pg_array.push(3)).should == "(a(b) || 3)"
+    @db.literal(Sequel.qualify(:b, :a).pg_array.push(3)).should == "(b.a || 3)"
+    @db.literal(Sequel.function(:a, :b).pg_array.push(3)).should == "(a(b) || 3)"
   end
 
   it "should be able to turn literal strings into array ops using pg_array" do
-    @db.literal('a'.lit.pg_array.unnest).should == "unnest(a)"
+    @db.literal(Sequel.lit('a').pg_array.unnest).should == "unnest(a)"
+  end
+
+  it "should be able to turn symbols into array ops using Sequel.pg_array_op" do
+    @db.literal(Sequel.pg_array_op(:a).unnest).should == "unnest(a)"
   end
 
-  it "should be able to turn symbols into array ops using pg_array" do
-    @db.literal(:a.pg_array.unnest).should == "unnest(a)"
+  it "should be able to turn symbols into array ops using Sequel.pg_array" do
+    @db.literal(Sequel.pg_array(:a).unnest).should == "unnest(a)"
   end
 
   it "should allow transforming PGArray instances into ArrayOp instances" do
-    @db.literal([1,2].pg_array.op.push(3)).should == "(ARRAY[1,2] || 3)"
+    @db.literal(Sequel.pg_array([1,2]).op.push(3)).should == "(ARRAY[1,2] || 3)"
   end
 end

data/spec/extensions/pg_array_spec.rb

@@ -1,17 +1,23 @@
 require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 
 describe "pg_array extension" do
+  before(:all) do
+    @pg_types = Sequel::Postgres::PG_TYPES.dup
+  end
+  after(:all) do
+    Sequel::Postgres::PG_TYPES.replace(@pg_types)
+  end
+
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @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
+    @converter = @m::PG_TYPES
   end
 
   it "should parse single dimensional text arrays" do
-    c = @convertor[1009]
+    c = @converter[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']
@@ -20,7 +26,7 @@ describe "pg_array extension" do
   end
 
   it "should parse multi-dimensional text arrays" do
-    c = @convertor[1009]
+    c = @converter[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']]
@@ -29,12 +35,12 @@ describe "pg_array extension" do
   end
 
   it "should parse text arrays with embedded deliminaters" do
-    c = @convertor[1009]
+    c = @converter[1009]
     c.call('{{"{},","\\",\\,\\\\\\"\\""}}').to_a.should == [['{},', '",,\\""']]
   end
 
   it "should parse single dimensional integer arrays" do
-    c = @convertor[1007]
+    c = @converter[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]
@@ -43,7 +49,7 @@ describe "pg_array extension" do
   end
 
   it "should parse multiple dimensional integer arrays" do
-    c = @convertor[1007]
+    c = @converter[1007]
     c.call("{{}}").to_a.should == [[]]
     c.call("{{1}}").to_a.should == [[1]]
     c.call('{{2},{3}}').to_a.should == [[2], [3]]
@@ -51,7 +57,7 @@ describe "pg_array extension" do
   end
 
   it "should parse single dimensional float arrays" do
-    c = @convertor[1022]
+    c = @converter[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]
@@ -59,7 +65,7 @@ describe "pg_array extension" do
   end
 
   it "should parse multiple dimensional float arrays" do
-    c = @convertor[1022]
+    c = @converter[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]]
@@ -67,14 +73,14 @@ describe "pg_array extension" do
   end
 
   it "should parse integers in float arrays as floats" do
-    c = @convertor[1022]
+    c = @converter[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
-    c = @convertor[1231]
+    c = @converter[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')]
@@ -82,7 +88,7 @@ describe "pg_array extension" do
   end
 
   it "should parse multiple dimensional decimal arrays" do
-    c = @convertor[1231]
+    c = @converter[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')]]
@@ -90,20 +96,20 @@ describe "pg_array extension" do
   end
 
   it "should parse decimal values with arbitrary precision" do
-    c = @convertor[1231]
+    c = @converter[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
-    c = @convertor[1231]
+    c = @converter[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
-    @convertor.values_at(1007, 1009, 1022, 1231).each do |c|
+    @converter.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]]
@@ -111,7 +117,7 @@ describe "pg_array extension" do
   end
 
   it 'should parse arrays with "NULL" values' do
-    c = @convertor[1009]
+    c = @converter[1009]
     c.call('{NULL,"NULL",NULL}').to_a.should == [nil, "NULL", nil]
     c.call('{NULLA,"NULL",NULL}').to_a.should == ["NULLA", "NULL", nil]
   end
@@ -146,15 +152,29 @@ describe "pg_array extension" do
     @db.literal(@m::PGArray.new([nil, "{},[]'\""], :"varchar(255)")).should == "ARRAY[NULL,'{},[]''\"']::varchar(255)[]"
   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[]'
-    @db.literal([[[1], [2]], [[3], [4]]].pg_array(:real)).should == 'ARRAY[[[1],[2]],[[3],[4]]]::real[]'
+  it "should have Sequel.pg_array method for easy PGArray creation" do
+    @db.literal(Sequel.pg_array([1])).should == 'ARRAY[1]'
+    @db.literal(Sequel.pg_array([1, 2], :int4)).should == 'ARRAY[1,2]::int4[]'
+    @db.literal(Sequel.pg_array([[[1], [2]], [[3], [4]]], :real)).should == 'ARRAY[[[1],[2]],[[3],[4]]]::real[]'
+  end
+
+  it "should have Sequel.pg_array return existing PGArrays as-is" do
+    a = Sequel.pg_array([1])
+    Sequel.pg_array(a).should equal(a)
+  end
+
+  it "should have Sequel.pg_array create a new PGArrays if type of existing does not match" do
+    a = Sequel.pg_array([1], :int4)
+    b = Sequel.pg_array(a, :int8)
+    a.should == b
+    a.should_not equal(b)
+    a.array_type.should == :int4
+    b.array_type.should == :int8
   end
 
   it "should support using arrays as bound variables" do
     @db.bound_variable_arg(1, nil).should == 1
-    @db.bound_variable_arg([1,2].pg_array, nil).should == '{1,2}'
+    @db.bound_variable_arg(Sequel.pg_array([1,2]), 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}'
@@ -169,45 +189,44 @@ describe "pg_array extension" do
 
   it "should support typecasting of the various array types" do
     {
-      :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'"]},
+      :integer=>{:class=>Integer, :convert=>['1', 1, '1']},
+      :float=>{:db_type=>'double precision',  :class=>Float, :convert=>['1.1', 1.1, '1.1']},
+      :decimal=>{:db_type=>'numeric', :class=>BigDecimal, :convert=>['1.00000000000000000000000001', BigDecimal.new('1.00000000000000000000000001'), '1.00000000000000000000000001']},
+      :string=>{:db_type=>'text', :class=>String, :convert=>[1, '1', "'1'"]},
+      :bigint=>{:class=>Integer, :convert=>['1', 1, '1']},
+      :boolean=>{:class=>TrueClass, :convert=>['t', true, 'true']},
+      :blob=>{:db_type=>'bytea', :class=>Sequel::SQL::Blob, :convert=>['1', '1', "'1'"]},
+      :date=>{:class=>Date, :convert=>['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', 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', 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', 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', 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]
+      array_in, value, output = h[:convert]
 
-      ["{#{text_in}}", [array_in]].each do |input|
+      [[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, Sequel.pg_array([value])).should == v
         @db.typecast_value(meth, v).should equal(v)
       end
 
-      ["{{#{text_in}}}", [[array_in]]].each do |input|
+      [[[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, Sequel.pg_array([[value]])).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}[]"
+      @db.literal(@db.typecast_value(meth, [])).should == "ARRAY[]::#{db_type}[]"
     end
     proc{@db.typecast_value(:integer_array, {})}.should raise_error(Sequel::InvalidValue)
   end
@@ -227,18 +246,32 @@ describe "pg_array extension" do
   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]
+    Sequel::Postgres::PGArray.register('foo', :oid=>1234){|s| (s*2).to_i}
+    @converter[1234].call('{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]
+    Sequel::Postgres::PGArray.register('foo', :oid=>1234, :converter=>proc{|s| (s*2).to_i})
+    @converter[1234].call('{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]
+    Sequel::Postgres::PGArray.register('foo', :oid=>1234, :scalar_oid=>16)
+    @converter[1234].call('{t}').should == [true]
+  end
+
+  it "should support using a given conversion procs hash via the :type_procs option" do
+    h = {16=>proc{|s| "!#{s}"}}
+    Sequel::Postgres::PGArray.register('foo', :oid=>1234, :scalar_oid=>16, :type_procs=>h)
+    h[1234].call('{t}').should == ["!t"]
+  end
+
+  it "should support adding methods to the given module via the :typecast_methods_module option" do
+    m = Module.new
+    Sequel::Postgres::PGArray.register('foo15', :scalar_typecast=>:boolean, :typecast_methods_module=>m)
+    @db.typecast_value(:foo15_array, ['t']).should == ['t']
+    @db.extend(m)
+    @db.typecast_value(:foo15_array, ['t']).should == [true]
   end
 
   it "should raise an error if using :scalar_oid option with unexisting scalar conversion proc" do
@@ -263,7 +296,7 @@ describe "pg_array extension" do
     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
+  it "should support registering converters 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
@@ -280,7 +313,7 @@ describe "pg_array extension" do
   end
 
   it "should set appropriate timestamp conversion procs when getting conversion procs" do
-    procs = @db.send(:get_conversion_procs, nil)
+    procs = @db.conversion_procs
     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

data/spec/extensions/pg_auto_parameterize_spec.rb

@@ -21,8 +21,8 @@ describe "pg_auto_parameterize extension" do
     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)', "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::bytea)', Sequel.blob("a\0b"))
+    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = 1)', Sequel.lit('1'), :nil)
     pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::time)', Sequel::SQLTime.create(1, 2, 3, 500000))
     pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::date)', Date.today)
     pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::timestamp)', DateTime.new(2012, 1, 2, 3, 4, 5))

data/spec/extensions/pg_hstore_ops_spec.rb

@@ -3,7 +3,7 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "Sequel::Postgres::HStoreOp" do
   before do
     @ds = Sequel.connect('mock://postgres', :quote_identifiers=>false).dataset
-    @h = :h.hstore
+    @h = Sequel.hstore_op(:h)
   end
 
   it "#- should use the - operator" do
@@ -117,20 +117,24 @@ describe "Sequel::Postgres::HStoreOp" do
     @ds.literal(@h.avals).should == "avals(h)"
   end
 
-  it "should be able to turn expressions into hstore ops using hstore" do
-    @ds.literal(:a.qualify(:b).hstore['a']).should == "(b.a -> 'a')"
-    @ds.literal(:a.sql_function(:b).hstore['a']).should == "(a(b) -> 'a')"
+  it "should have Sequel.hstore_op return HStoreOp instances as-is" do
+    Sequel.hstore_op(@h).should equal(@h)
   end
 
-  it "should be able to turn literal strings into hstore ops using hstore" do
-    @ds.literal('a'.lit.hstore['a']).should == "(a -> 'a')"
+  it "should have Sequel.hstore return HStoreOp instances" do
+    Sequel.hstore(:h).should == @h
+  end
+
+  it "should be able to turn expressions into hstore ops using hstore" do
+    @ds.literal(Sequel.qualify(:b, :a).hstore['a']).should == "(b.a -> 'a')"
+    @ds.literal(Sequel.function(:a, :b).hstore['a']).should == "(a(b) -> 'a')"
   end
 
-  it "should be able to turn symbols into hstore ops using hstore" do
-    @ds.literal(:a.hstore['a']).should == "(a -> 'a')"
+  it "should be able to turn literal strings into hstore ops using hstore" do
+    @ds.literal(Sequel.lit('a').hstore['a']).should == "(a -> 'a')"
   end
 
   it "should allow transforming HStore instances into HStoreOp instances" do
-    @ds.literal({'a'=>'b'}.hstore.op['a']).should == "('\"a\"=>\"b\"'::hstore -> 'a')"
+    @ds.literal(Sequel.hstore('a'=>'b').op['a']).should == "('\"a\"=>\"b\"'::hstore -> 'a')"
   end
 end

data/spec/extensions/pg_hstore_spec.rb

@@ -3,7 +3,6 @@ require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
 describe "pg_hstore extension" do
   before do
     @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
-    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
     @m = Sequel::Postgres
     @c = @m::HStore
     @db.extension :pg_hstore
@@ -25,28 +24,33 @@ describe "pg_hstore extension" do
   end
 
   it "should literalize HStores to strings correctly" do
-    @db.literal({}.hstore).should == '\'\'::hstore'
-    @db.literal({"a"=>"b"}.hstore).should == '\'"a"=>"b"\'::hstore'
-    @db.literal({"c"=>nil}.hstore).should == '\'"c"=>NULL\'::hstore'
-    @db.literal({"c"=>'NULL'}.hstore).should == '\'"c"=>"NULL"\'::hstore'
-    @db.literal({'c'=>'\ "\'=>'}.hstore).should == '\'"c"=>"\\\\ \\"\'\'=>"\'::hstore'
-    ['\'"a"=>"b","c"=>"d"\'::hstore', '\'"c"=>"d","a"=>"b"\'::hstore'].should include(@db.literal({"a"=>"b","c"=>"d"}.hstore))
+    @db.literal(Sequel.hstore({})).should == '\'\'::hstore'
+    @db.literal(Sequel.hstore("a"=>"b")).should == '\'"a"=>"b"\'::hstore'
+    @db.literal(Sequel.hstore("c"=>nil)).should == '\'"c"=>NULL\'::hstore'
+    @db.literal(Sequel.hstore("c"=>'NULL')).should == '\'"c"=>"NULL"\'::hstore'
+    @db.literal(Sequel.hstore('c'=>'\ "\'=>')).should == '\'"c"=>"\\\\ \\"\'\'=>"\'::hstore'
+    ['\'"a"=>"b","c"=>"d"\'::hstore', '\'"c"=>"d","a"=>"b"\'::hstore'].should include(@db.literal(Sequel.hstore("a"=>"b","c"=>"d")))
   end
 
-  it "should have Hash#hstore method for creating HStore instances" do
-    {}.hstore.should be_a_kind_of(@c)
+  it "should have Sequel.hstore method for creating HStore instances" do
+    Sequel.hstore({}).should be_a_kind_of(@c)
+  end
+
+  it "should have Sequel.hstore return HStores as-is" do
+    a = Sequel.hstore({})
+    Sequel.hstore(a).should equal(a)
   end
 
   it "should HStore#to_hash method for getting underlying hash" do
-    {}.hstore.to_hash.should be_a_kind_of(Hash)
+    Sequel.hstore({}).to_hash.should be_a_kind_of(Hash)
   end
 
   it "should convert keys and values to strings on creation" do
-    {1=>2}.hstore.to_hash.should == {"1"=>"2"}
+    Sequel.hstore(1=>2).to_hash.should == {"1"=>"2"}
   end
 
   it "should convert keys and values to strings on assignment" do
-    v = {}.hstore
+    v = Sequel.hstore({})
     v[1] = 2
     v.to_hash.should == {"1"=>"2"}
     v.store(:'1', 3)
@@ -54,92 +58,92 @@ describe "pg_hstore extension" do
   end
 
   it "should not convert nil values to strings on creation" do
-    {:foo=>nil}.hstore.to_hash.should == {"foo"=>nil}
+    Sequel.hstore(:foo=>nil).to_hash.should == {"foo"=>nil}
   end
 
   it "should not convert nil values to strings on assignment" do
-    v = {}.hstore
+    v = Sequel.hstore({})
     v[:foo] = nil
     v.to_hash.should == {"foo"=>nil}
   end
 
   it "should convert lookups by key to string" do
-    {'foo'=>'bar'}.hstore[:foo].should == 'bar'
-    {'1'=>'bar'}.hstore[1].should == 'bar'
+    Sequel.hstore('foo'=>'bar')[:foo].should == 'bar'
+    Sequel.hstore('1'=>'bar')[1].should == 'bar'
 
-    {'foo'=>'bar'}.hstore.fetch(:foo).should == 'bar'
-    {'foo'=>'bar'}.hstore.fetch(:foo2, 2).should == 2
+    Sequel.hstore('foo'=>'bar').fetch(:foo).should == 'bar'
+    Sequel.hstore('foo'=>'bar').fetch(:foo2, 2).should == 2
     k = nil
-    {'foo2'=>'bar'}.hstore.fetch(:foo){|key| k = key }.should == 'foo'
+    Sequel.hstore('foo2'=>'bar').fetch(:foo){|key| k = key }.should == 'foo'
     k.should == 'foo'
     
-    {'foo'=>'bar'}.hstore.has_key?(:foo).should be_true
-    {'foo'=>'bar'}.hstore.has_key?(:bar).should be_false
-    {'foo'=>'bar'}.hstore.key?(:foo).should be_true
-    {'foo'=>'bar'}.hstore.key?(:bar).should be_false
-    {'foo'=>'bar'}.hstore.member?(:foo).should be_true
-    {'foo'=>'bar'}.hstore.member?(:bar).should be_false
-    {'foo'=>'bar'}.hstore.include?(:foo).should be_true
-    {'foo'=>'bar'}.hstore.include?(:bar).should be_false
+    Sequel.hstore('foo'=>'bar').has_key?(:foo).should be_true
+    Sequel.hstore('foo'=>'bar').has_key?(:bar).should be_false
+    Sequel.hstore('foo'=>'bar').key?(:foo).should be_true
+    Sequel.hstore('foo'=>'bar').key?(:bar).should be_false
+    Sequel.hstore('foo'=>'bar').member?(:foo).should be_true
+    Sequel.hstore('foo'=>'bar').member?(:bar).should be_false
+    Sequel.hstore('foo'=>'bar').include?(:foo).should be_true
+    Sequel.hstore('foo'=>'bar').include?(:bar).should be_false
 
-    {'foo'=>'bar', '1'=>'2'}.hstore.values_at(:foo3, :foo, :foo2, 1).should == [nil, 'bar', nil, '2']
+    Sequel.hstore('foo'=>'bar', '1'=>'2').values_at(:foo3, :foo, :foo2, 1).should == [nil, 'bar', nil, '2']
 
     if RUBY_VERSION >= '1.9.0'
-      {'foo'=>'bar'}.hstore.assoc(:foo).should == ['foo', 'bar']
-      {'foo'=>'bar'}.hstore.assoc(:foo2).should == nil
+      Sequel.hstore('foo'=>'bar').assoc(:foo).should == ['foo', 'bar']
+      Sequel.hstore('foo'=>'bar').assoc(:foo2).should == nil
     end
   end
 
   it "should convert has_value?/value? lookups to string" do
-    {'foo'=>'bar'}.hstore.has_value?(:bar).should be_true
-    {'foo'=>'bar'}.hstore.has_value?(:foo).should be_false
-    {'foo'=>'bar'}.hstore.value?(:bar).should be_true
-    {'foo'=>'bar'}.hstore.value?(:foo).should be_false
+    Sequel.hstore('foo'=>'bar').has_value?(:bar).should be_true
+    Sequel.hstore('foo'=>'bar').has_value?(:foo).should be_false
+    Sequel.hstore('foo'=>'bar').value?(:bar).should be_true
+    Sequel.hstore('foo'=>'bar').value?(:foo).should be_false
   end
 
   it "should handle nil values in has_value?/value? lookups" do
-    {'foo'=>''}.hstore.has_value?('').should be_true
-    {'foo'=>''}.hstore.has_value?(nil).should be_false
-    {'foo'=>nil}.hstore.has_value?(nil).should be_true
+    Sequel.hstore('foo'=>'').has_value?('').should be_true
+    Sequel.hstore('foo'=>'').has_value?(nil).should be_false
+    Sequel.hstore('foo'=>nil).has_value?(nil).should be_true
   end
 
   it "should have underlying hash convert lookups by key to string" do
-    {'foo'=>'bar'}.hstore.to_hash[:foo].should == 'bar'
-    {'1'=>'bar'}.hstore.to_hash[1].should == 'bar'
+    Sequel.hstore('foo'=>'bar').to_hash[:foo].should == 'bar'
+    Sequel.hstore('1'=>'bar').to_hash[1].should == 'bar'
   end
 
   if RUBY_VERSION >= '1.9.0'
     it "should convert key lookups to string" do
-      {'foo'=>'bar'}.hstore.key(:bar).should == 'foo'
-      {'foo'=>'bar'}.hstore.key(:bar2).should be_nil
+      Sequel.hstore('foo'=>'bar').key(:bar).should == 'foo'
+      Sequel.hstore('foo'=>'bar').key(:bar2).should be_nil
     end
 
     it "should handle nil values in key lookups" do
-      {'foo'=>''}.hstore.key('').should == 'foo'
-      {'foo'=>''}.hstore.key(nil).should == nil
-      {'foo'=>nil}.hstore.key(nil).should == 'foo'
+      Sequel.hstore('foo'=>'').key('').should == 'foo'
+      Sequel.hstore('foo'=>'').key(nil).should == nil
+      Sequel.hstore('foo'=>nil).key(nil).should == 'foo'
     end
 
     it "should convert rassoc lookups to string" do
-      {'foo'=>'bar'}.hstore.rassoc(:bar).should == ['foo', 'bar']
-      {'foo'=>'bar'}.hstore.rassoc(:bar2).should be_nil
+      Sequel.hstore('foo'=>'bar').rassoc(:bar).should == ['foo', 'bar']
+      Sequel.hstore('foo'=>'bar').rassoc(:bar2).should be_nil
     end
 
     it "should handle nil values in rassoc lookups" do
-      {'foo'=>''}.hstore.rassoc('').should == ['foo', '']
-      {'foo'=>''}.hstore.rassoc(nil).should == nil
-      {'foo'=>nil}.hstore.rassoc(nil).should == ['foo', nil]
+      Sequel.hstore('foo'=>'').rassoc('').should == ['foo', '']
+      Sequel.hstore('foo'=>'').rassoc(nil).should == nil
+      Sequel.hstore('foo'=>nil).rassoc(nil).should == ['foo', nil]
     end
   end
 
   it "should have delete convert key to string" do
-    v = {'foo'=>'bar'}.hstore
+    v = Sequel.hstore('foo'=>'bar')
     v.delete(:foo).should == 'bar'
     v.to_hash.should == {}
   end
 
   it "should handle #replace with hashes that do not use strings" do
-    v = {'foo'=>'bar'}.hstore
+    v = Sequel.hstore('foo'=>'bar')
     v.replace(:bar=>1)
     v.should be_a_kind_of(@c)
     v.should == {'bar'=>'1'}
@@ -147,18 +151,18 @@ describe "pg_hstore extension" do
   end
 
   it "should handle #merge with hashes that do not use strings" do
-    v = {'foo'=>'bar'}.hstore.merge(:bar=>1)
+    v = Sequel.hstore('foo'=>'bar').merge(:bar=>1)
     v.should be_a_kind_of(@c)
     v.should == {'foo'=>'bar', 'bar'=>'1'}
   end
 
   it "should handle #merge/#update with hashes that do not use strings" do
-    v = {'foo'=>'bar'}.hstore
+    v = Sequel.hstore('foo'=>'bar')
     v.merge!(:bar=>1)
     v.should be_a_kind_of(@c)
     v.should == {'foo'=>'bar', 'bar'=>'1'}
 
-    v = {'foo'=>'bar'}.hstore
+    v = Sequel.hstore('foo'=>'bar')
     v.update(:bar=>1)
     v.should be_a_kind_of(@c)
     v.should == {'foo'=>'bar', 'bar'=>'1'}
@@ -167,11 +171,11 @@ describe "pg_hstore extension" do
   it "should support using hstores as bound variables" do
     @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"'
-    @db.bound_variable_arg({'1'=>nil}.hstore, nil).should == '"1"=>NULL'
-    @db.bound_variable_arg({'1'=>"NULL"}.hstore, nil).should == '"1"=>"NULL"'
-    @db.bound_variable_arg({'1'=>"'\\ \"=>"}.hstore, nil).should == '"1"=>"\'\\\\ \\"=>"'
-    ['"a"=>"b","c"=>"d"', '"c"=>"d","a"=>"b"'].should include(@db.bound_variable_arg({"a"=>"b","c"=>"d"}.hstore, nil))
+    @db.bound_variable_arg(Sequel.hstore('1'=>'2'), nil).should == '"1"=>"2"'
+    @db.bound_variable_arg(Sequel.hstore('1'=>nil), nil).should == '"1"=>NULL'
+    @db.bound_variable_arg(Sequel.hstore('1'=>"NULL"), nil).should == '"1"=>"NULL"'
+    @db.bound_variable_arg(Sequel.hstore('1'=>"'\\ \"=>"), nil).should == '"1"=>"\'\\\\ \\"=>"'
+    ['"a"=>"b","c"=>"d"', '"c"=>"d","a"=>"b"'].should include(@db.bound_variable_arg(Sequel.hstore("a"=>"b","c"=>"d"), nil))
   end
 
   it "should parse hstore type from the schema correctly" do
@@ -180,14 +184,11 @@ describe "pg_hstore extension" do
   end
 
   it "should support typecasting for the hstore type" do
-    h = {1=>2}.hstore
+    h = Sequel.hstore(1=>2)
     @db.typecast_value(:hstore, h).should equal(h)
-    @db.typecast_value(:hstore, '').should be_a_kind_of(@c)
-    @db.typecast_value(:hstore, '').should == {}.hstore
-    @db.typecast_value(:hstore, '"a"=>"b"').should == {"a"=>"b"}.hstore
     @db.typecast_value(:hstore, {}).should be_a_kind_of(@c)
-    @db.typecast_value(:hstore, {}).should == {}.hstore
-    @db.typecast_value(:hstore, {'a'=>'b'}).should == {"a"=>"b"}.hstore
+    @db.typecast_value(:hstore, {}).should == Sequel.hstore({})
+    @db.typecast_value(:hstore, {'a'=>'b'}).should == Sequel.hstore("a"=>"b")
     proc{@db.typecast_value(:hstore, [])}.should raise_error(Sequel::InvalidValue)
   end
 end