sequel 3.21.0 → 3.36.0

data/spec/extensions/null_dataset_spec.rb

@@ -0,0 +1,85 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "null_dataset extension" do
+  before do
+    @db = Sequel::mock(:fetch=>{:id=>1}, :autoid=>1, :numrows=>1, :columns=>[:id])
+    @ds = @db[:table].nullify
+    @i = 0
+    @pr = proc{|*a| @i += 1}
+  end
+  after do
+    @db.sqls.should == [] unless @skip_check
+  end
+
+  it "should make each be a noop" do
+    @ds.each(&@pr).should equal(@ds)
+    @i.should == 0
+  end
+
+  it "should make fetch_rows be a noop" do
+    @ds.fetch_rows("SELECT 1", &@pr).should == nil
+    @i.should == 0
+  end
+
+  it "should make insert be a noop" do
+    @ds.insert(1).should == nil
+  end
+
+  it "should make update be a noop" do
+    @ds.update(:a=>1).should == 0
+  end
+
+  it "should make delete be a noop" do
+    @ds.delete.should == 0
+  end
+
+  it "should make truncate be a noop" do
+    @ds.truncate.should == nil
+  end
+
+  it "should make execute_* be a noop" do
+    @ds.send(:execute_ddl,'FOO').should == nil
+    @ds.send(:execute_insert,'FOO').should == nil
+    @ds.send(:execute_dui,'FOO').should == nil
+    @ds.send(:execute,'FOO').should == nil
+  end
+
+  it "should have working columns" do
+    @skip_check = true
+    @ds.columns.should == [:id]
+    @db.sqls.should == ['SELECT * FROM table LIMIT 1']
+  end
+
+  it "should have count return 0" do
+    @ds.count.should == 0
+  end
+
+  it "should have empty return true" do
+    @ds.empty?.should == true
+  end
+
+  it "should make import a noop" do
+    @ds.import([:id], [[1], [2], [3]]).should == nil
+  end
+
+  it "should have nullify method returned modified receiver" do
+    @skip_check = true
+    ds = @db[:table]
+    ds.nullify.should_not equal(ds)
+    ds.each(&@pr)
+    @db.sqls.should == ['SELECT * FROM table']
+    @i.should == 1
+  end
+
+  it "should have null! method modify receiver" do
+    ds = @db[:table]
+    ds.nullify!.should equal(ds)
+    ds.each(&@pr)
+    @i.should == 0
+  end
+
+  it "should work with method chaining" do
+    @ds.where(:a=>1).select(:b).each(&@pr)
+    @i.should == 0
+  end
+end

data/spec/extensions/optimistic_locking_spec.rb

@@ -6,11 +6,8 @@ describe "optimistic_locking plugin" do
     end
     h = {1=>{:id=>1, :name=>'John', :lock_version=>2}}
     lv = @lv = "lock_version"
-    @c.dataset.quote_identifiers = false
-    @c.dataset.meta_def(:h){h}
-    @c.dataset.meta_def(:lv){lv}
-    @c.dataset.meta_def(:update) do |opts|
-      case update_sql(opts)
+    @c.instance_dataset.numrows = @c.dataset.numrows = proc do |sql|
+      case sql
       when /UPDATE people SET (name|#{lv}) = ('Jim'|'Bob'|\d+), (?:name|#{lv}) = ('Jim'|'Bob'|\d+) WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
         name, nlv = $1 == 'name' ? [$2, $3] : [$3, $2]
         m = h[$4.to_i]
@@ -28,20 +25,6 @@ describe "optimistic_locking plugin" do
         else
           0
         end
-      else
-        puts update_sql(opts)
-      end
-    end
-    @c.dataset.instance_eval do
-      def fetch_rows(sql)
-        m = h[1].dup
-        v = m.delete(:lock_version)
-        m[lv.to_sym] = v
-        yield(m)
-      end
-    end
-    @c.dataset.meta_def(:delete) do
-      case delete_sql
       when /DELETE FROM people WHERE \(\(id = (\d+)\) AND \(#{lv} = (\d+)\)\)/
         m = h[$1.to_i]
         if m && m[lv.to_sym] == $2.to_i
@@ -51,9 +34,15 @@ describe "optimistic_locking plugin" do
           0
         end
       else
-        puts delete_sql
+        puts sql
       end
     end
+    @c.instance_dataset._fetch = @c.dataset._fetch = proc do |sql|
+      m = h[1].dup
+      v = m.delete(:lock_version)
+      m[lv.to_sym] = v
+      m
+    end
     @c.columns :id, :name, :lock_version
     @c.plugin :optimistic_locking
   end
@@ -106,6 +95,20 @@ describe "optimistic_locking plugin" do
     proc{p2.update(:name=>'Bob')}.should raise_error(Sequel::Plugins::OptimisticLocking::Error)
   end
 
+  specify "should work correctly if attempting to refresh and save again after a failed save" do
+    p1 = @c[1]
+    p2 = @c[1]
+    p1.update(:name=>'Jim')
+    begin
+      p2.update(:name=>'Bob')
+    rescue Sequel::Plugins::OptimisticLocking::Error
+      p2.refresh
+      @c.db.sqls
+      proc{p2.update(:name=>'Bob')}.should_not raise_error
+    end
+    @c.db.sqls.first.should =~ /UPDATE people SET (name = 'Bob', lock_version = 4|lock_version = 4, name = 'Bob') WHERE \(\(id = 1\) AND \(lock_version = 3\)\)/
+  end
+
   specify "should increment the lock column when #modified! even if no columns are changed" do
     p1 = @c[1]
     p1.modified!
@@ -115,7 +118,7 @@ describe "optimistic_locking plugin" do
   end
 
   specify "should not increment the lock column when the update fails" do
-    @c.dataset.meta_def(:update) { raise Exception }
+    @c.instance_dataset.meta_def(:update) { raise Exception }
     p1 = @c[1]
     p1.modified!
     lv = p1.lock_version

data/spec/extensions/pg_array_ops_spec.rb

@@ -0,0 +1,105 @@
+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
+  end
+
+  it "should support the standard mathematical operators" do
+    @db.literal(@a < @a).should == "(a < a)"
+    @db.literal(@a <= @a).should == "(a <= a)"
+    @db.literal(@a > @a).should == "(a > a)"
+    @db.literal(@a >= @a).should == "(a >= a)"
+  end
+
+  it "#[] should support subscript access" do
+    @db.literal(@a[1]).should == "a[1]"
+    @db.literal(@a[1][2]).should == "a[1][2]"
+  end
+
+  it "#any should use the ANY method" do
+    @db.literal(1=>@a.any).should == "(1 = ANY(a))"
+  end
+
+  it "#all should use the ALL method" do
+    @db.literal(1=>@a.all).should == "(1 = ALL(a))"
+  end
+
+  it "#contains should use the @> operator" do
+    @db.literal(@a.contains(:b)).should == "(a @> b)"
+  end
+
+  it "#contained_by should use the <@ operator" do
+    @db.literal(@a.contained_by(:b)).should == "(a <@ b)"
+  end
+
+  it "#overlaps should use the && operator" do
+    @db.literal(@a.overlaps(:b)).should == "(a && b)"
+  end
+
+  it "#push/concat should use the || operator in append mode" do
+    @db.literal(@a.push(:b)).should == "(a || b)"
+    @db.literal(@a.concat(:b)).should == "(a || b)"
+  end
+
+  it "#unshift should use the || operator in prepend mode" do
+    @db.literal(@a.unshift(:b)).should == "(b || a)"
+  end
+
+  it "#dims should use the array_dims function" do
+    @db.literal(@a.dims).should == "array_dims(a)"
+  end
+
+  it "#length should use the array_length function" do
+    @db.literal(@a.length).should == "array_length(a, 1)"
+    @db.literal(@a.length(2)).should == "array_length(a, 2)"
+  end
+
+  it "#length should use the array_lower function" do
+    @db.literal(@a.lower).should == "array_lower(a, 1)"
+    @db.literal(@a.lower(2)).should == "array_lower(a, 2)"
+  end
+
+  it "#to_string/join should use the array_to_string function" do
+    @db.literal(@a.to_string).should == "array_to_string(a, '', NULL)"
+    @db.literal(@a.join).should == "array_to_string(a, '', NULL)"
+    @db.literal(@a.join(':')).should == "array_to_string(a, ':', NULL)"
+    @db.literal(@a.join(':', '*')).should == "array_to_string(a, ':', '*')"
+  end
+
+  it "#unnest should use the unnest function" do
+    @db.literal(@a.unnest).should == "unnest(a)"
+  end
+
+  it "#pg_array should return self" do
+    @a.pg_array.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)"
+  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)"
+  end
+
+  it "should be able to turn symbols into array ops using pg_array" do
+    @db.literal(:a.pg_array.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)"
+  end if pg_array_loaded
+end

data/spec/extensions/pg_array_spec.rb

@@ -0,0 +1,196 @@
+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})
+    @m = Sequel::Postgres
+  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']
+  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']]]
+  end
+
+  it "should parse text arrays with embedded deliminaters" do
+    @m::PGStringArray.parse('{{"{},","\\",\\,\\\\\\"\\""}}').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]
+  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]]]
+  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]
+  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]]]
+  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]]]
+  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')]
+  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')]]]
+  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')]]
+  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')]]]
+  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]]
+    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]
+  end
+
+  it "should literalize arrays without types correctly" do
+    @db.literal(@m::PGArray.new([])).should == 'ARRAY[]'
+    @db.literal(@m::PGArray.new([1])).should == 'ARRAY[1]'
+    @db.literal(@m::PGArray.new([nil])).should == 'ARRAY[NULL]'
+    @db.literal(@m::PGArray.new([nil, 1])).should == 'ARRAY[NULL,1]'
+    @db.literal(@m::PGArray.new([1.0, 2.5])).should == 'ARRAY[1.0,2.5]'
+    @db.literal(@m::PGArray.new([BigDecimal.new('1'), BigDecimal.new('2.000000000000000000005')])).should == 'ARRAY[1.0,2.000000000000000000005]'
+    @db.literal(@m::PGArray.new([nil, "NULL"])).should == "ARRAY[NULL,'NULL']"
+    @db.literal(@m::PGArray.new([nil, "{},[]'\""])).should == "ARRAY[NULL,'{},[]''\"']"
+  end
+
+  it "should literalize multidimensional arrays correctly" do
+    @db.literal(@m::PGArray.new([[]])).should == 'ARRAY[[]]'
+    @db.literal(@m::PGArray.new([[1, 2]])).should == 'ARRAY[[1,2]]'
+    @db.literal(@m::PGArray.new([[3], [5]])).should == 'ARRAY[[3],[5]]'
+    @db.literal(@m::PGArray.new([[[1.0]], [[2.5]]])).should == 'ARRAY[[[1.0]],[[2.5]]]'
+    @db.literal(@m::PGArray.new([[[["NULL"]]]])).should == "ARRAY[[[['NULL']]]]"
+    @db.literal(@m::PGArray.new([["a", "b"], ["{},[]'\"", nil]])).should == "ARRAY[['a','b'],['{},[]''\"',NULL]]"
+  end
+
+  it "should literalize with types correctly" do
+    @db.literal(@m::PGArray.new([1], :int4)).should == 'ARRAY[1]::int4[]'
+    @db.literal(@m::PGArray.new([nil], :text)).should == 'ARRAY[NULL]::text[]'
+    @db.literal(@m::PGArray.new([nil, 1], :int8)).should == 'ARRAY[NULL,1]::int8[]'
+    @db.literal(@m::PGArray.new([1.0, 2.5], :real)).should == 'ARRAY[1.0,2.5]::real[]'
+    @db.literal(@m::PGArray.new([BigDecimal.new('1'), BigDecimal.new('2.000000000000000000005')], :decimal)).should == 'ARRAY[1.0,2.000000000000000000005]::decimal[]'
+    @db.literal(@m::PGArray.new([nil, "NULL"], :varchar)).should == "ARRAY[NULL,'NULL']::varchar[]"
+    @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[]'
+    @db.literal([[[1], [2]], [[3], [4]]].pg_array(:real)).should == 'ARRAY[[[1],[2]],[[3],[4]]]::real[]'
+  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(["\\ \"", '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"))
+    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
+end

data/spec/extensions/pg_auto_parameterize_spec.rb

@@ -0,0 +1,65 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_auto_parameterize extension" do
+  before 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
+  end
+
+  it "should automatically parameterize queries strings, blobs, numerics, dates, and times" do
+    pr = proc do |ds, sql, *args|
+      arg = args[0]
+      parg = args[1] || arg
+      s = ds.filter(:a=>arg).sql
+      s.should == sql
+      s.args.should == (parg == :nil ? nil : [parg])
+    end
+    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::int4)', 1)
+    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::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))
+    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))
+    pr.call(@db[:table], 'SELECT * FROM table WHERE (a = $1::timestamp)', Time.utc(2012, 1, 2, 3, 4, 5))
+  end
+
+  it "should extract parameters from query string when executing" do
+    @db.fetch = {:a=>1}
+    @db.numrows = 1
+    @db.autoid = 1
+
+    @db[:table].filter(:a=>1).all.should == [{:a=>1}]
+    @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[:table].filter(:a=>1).delete.should == 1
+    @db.sqls.should == ['DELETE FROM table WHERE (a = $1::int4) -- args: [1]']
+
+    @db[:table].insert(:a=>1).should == 1
+    @db.sqls.should == ['INSERT INTO table (a) VALUES ($1::int4) RETURNING id -- args: [1]']
+  end
+
+  it "should not automatically paramiterize if no_auto_parameterize is used" do
+    @db[:table].no_auto_parameterize.filter(:a=>1).sql.should == 'SELECT * FROM table WHERE (a = 1)'
+  end
+
+  it "should not automatically parameterize prepared statements" do
+    @db[:table].filter(:a=>1, :b=>:$b).prepare(:select).sql.should =~ /SELECT \* FROM table WHERE \(\((a = 1|b = \$b)\) AND \((a = 1|b = \$b)\)\)/
+  end
+
+  it "should show args with string when inspecting SQL " do
+    @db[:table].filter(:a=>1).sql.inspect.should == '"SELECT * FROM table WHERE (a = $1::int4); [1]"'
+  end
+
+  it "should not auto parameterize when using cursors" do
+    @db[:table].filter(:a=>1).use_cursor.opts[:no_auto_parameterize].should be_true
+  end
+end

data/spec/extensions/pg_hstore_ops_spec.rb

@@ -0,0 +1,136 @@
+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
+  end
+
+  it "#- should use the - operator" do
+    @ds.literal(@h - 'a').should == "(h - 'a')"
+  end
+
+  it "#- should return an HStoreOp" do
+    @ds.literal((@h - 'a')['a']).should == "((h - 'a') -> 'a')"
+  end
+
+  it "#[] should use the -> operator" do
+    @ds.literal(@h['a']).should == "(h -> 'a')"
+  end
+
+  it "#[] should return a string expression" do
+    @ds.literal(@h['a'] + 'b').should == "((h -> 'a') || 'b')"
+  end
+
+  it "#concat and #merge should use the || operator" do
+    @ds.literal(@h.concat(:h1)).should == "(h || h1)"
+    @ds.literal(@h.merge(:h1)).should == "(h || h1)"
+  end
+
+  it "#concat should return an HStoreOp" do
+    @ds.literal(@h.concat(:h1)['a']).should == "((h || h1) -> 'a')"
+  end
+
+  it "#contain_all should use the ?& operator" do
+    @ds.literal(@h.contain_all(:h1)).should == "(h ?& h1)"
+  end
+
+  it "#contain_any should use the ?| operator" do
+    @ds.literal(@h.contain_any(:h1)).should == "(h ?| h1)"
+  end
+
+  it "#contains should use the @> operator" do
+    @ds.literal(@h.contains(:h1)).should == "(h @> h1)"
+  end
+
+  it "#contained_by should use the <@ operator" do
+    @ds.literal(@h.contained_by(:h1)).should == "(h <@ h1)"
+  end
+
+  it "#defined should use the defined function" do
+    @ds.literal(@h.defined('a')).should == "defined(h, 'a')"
+  end
+
+  it "#delete should use the delete function" do
+    @ds.literal(@h.delete('a')).should == "delete(h, 'a')"
+  end
+
+  it "#delete should return an HStoreOp" do
+    @ds.literal(@h.delete('a')['a']).should == "(delete(h, 'a') -> 'a')"
+  end
+
+  it "#each should use the each function" do
+    @ds.literal(@h.each).should == "each(h)"
+  end
+
+  it "#has_key? and aliases should use the ? operator" do
+    @ds.literal(@h.has_key?('a')).should == "(h ? 'a')"
+    @ds.literal(@h.key?('a')).should == "(h ? 'a')"
+    @ds.literal(@h.member?('a')).should == "(h ? 'a')"
+    @ds.literal(@h.include?('a')).should == "(h ? 'a')"
+    @ds.literal(@h.exist?('a')).should == "(h ? 'a')"
+  end
+
+  it "#hstore should return the receiver" do
+    @h.hstore.should equal(@h)
+  end
+
+  it "#keys and #akeys should use the akeys function" do
+    @ds.literal(@h.keys).should == "akeys(h)"
+    @ds.literal(@h.akeys).should == "akeys(h)"
+  end
+
+  it "#populate should use the populate_record function" do
+    @ds.literal(@h.populate(:a)).should == "populate_record(a, h)"
+  end
+
+  it "#record_set should use the #= operator" do
+    @ds.literal(@h.record_set(:a)).should == "(a #= h)"
+  end
+
+  it "#skeys should use the skeys function" do
+    @ds.literal(@h.skeys).should == "skeys(h)"
+  end
+
+  it "#slice should should use the slice function" do
+    @ds.literal(@h.slice(:a)).should == "slice(h, a)"
+  end
+
+  it "#slice should return an HStoreOp" do
+    @ds.literal(@h.slice(:a)['a']).should == "(slice(h, a) -> 'a')"
+  end
+
+  it "#svals should use the svals function" do
+    @ds.literal(@h.svals).should == "svals(h)"
+  end
+
+  it "#to_array should use the hstore_to_array function" do
+    @ds.literal(@h.to_array).should == "hstore_to_array(h)"
+  end
+
+  it "#to_matrix should use the hstore_to_matrix function" do
+    @ds.literal(@h.to_matrix).should == "hstore_to_matrix(h)"
+  end
+
+  it "#values and #avals should use the avals function" do
+    @ds.literal(@h.values).should == "avals(h)"
+    @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')"
+  end
+
+  it "should be able to turn literal strings into hstore ops using hstore" do
+    @ds.literal('a'.lit.hstore['a']).should == "(a -> 'a')"
+  end
+
+  it "should be able to turn symbols into hstore ops using hstore" do
+    @ds.literal(: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')"
+  end
+end