sequel 3.33.0 → 3.34.0

data/spec/extensions/pg_auto_parameterize_spec.rb

@@ -0,0 +1,64 @@
+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.extend Sequel::Postgres::AutoParameterize::DatabaseMethods
+    @db.synchronize{|c| def c.escape_bytea(v) v*2 end}
+  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]']
+
+    @db.server_version = 80000
+    @db[:table].insert(:a=>1).should == 1
+    @db.sqls.should == ['INSERT INTO table (a) VALUES ($1::int4) -- 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
+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

data/spec/extensions/pg_hstore_spec.rb

@@ -0,0 +1,195 @@
+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
+  end
+
+  it "should parse hstore strings correctly" do
+    @c.parse('').to_hash.should == {}
+    @c.parse('"a"=>"b"').to_hash.should == {'a'=>'b'}
+    @c.parse('"a"=>"b", "c"=>NULL').to_hash.should == {'a'=>'b', 'c'=>nil}
+    @c.parse('"a"=>"b", "c"=>"NULL"').to_hash.should == {'a'=>'b', 'c'=>'NULL'}
+    @c.parse('"a"=>"b", "c"=>"\\\\ \\"\'=>"').to_hash.should == {'a'=>'b', 'c'=>'\ "\'=>'}
+  end
+
+  it "should cache parse results" do
+    r = @c::Parser.new('')
+    o = r.parse
+    o.should == {}
+    r.parse.should equal(o)
+  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))
+  end
+
+  it "should have Hash#hstore method for creating HStore instances" do
+    {}.hstore.should be_a_kind_of(@c)
+  end
+
+  it "should HStore#to_hash method for getting underlying hash" do
+    {}.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"}
+  end
+
+  it "should convert keys and values to strings on assignment" do
+    v = {}.hstore
+    v[1] = 2
+    v.to_hash.should == {"1"=>"2"}
+    v.store(:'1', 3)
+    v.to_hash.should == {"1"=>"3"}
+  end
+
+  it "should not convert nil values to strings on creation" do
+    {:foo=>nil}.hstore.to_hash.should == {"foo"=>nil}
+  end
+
+  it "should not convert nil values to strings on assignment" do
+    v = {}.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'
+
+    {'foo'=>'bar'}.hstore.fetch(:foo).should == 'bar'
+    {'foo'=>'bar'}.hstore.fetch(:foo2, 2).should == 2
+    k = nil
+    {'foo2'=>'bar'}.hstore.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
+
+    {'foo'=>'bar', '1'=>'2'}.hstore.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
+    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
+  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
+  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'
+  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
+    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'
+    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
+    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]
+    end
+  end
+
+  it "should have delete convert key to string" do
+    v = {'foo'=>'bar'}.hstore
+    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.replace(:bar=>1)
+    v.should be_a_kind_of(@c)
+    v.should == {'bar'=>'1'}
+    v.to_hash[:bar].should == '1'
+  end
+
+  it "should handle #merge with hashes that do not use strings" do
+    v = {'foo'=>'bar'}.hstore.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.merge!(:bar=>1)
+    v.should be_a_kind_of(@c)
+    v.should == {'foo'=>'bar', 'bar'=>'1'}
+
+    v = {'foo'=>'bar'}.hstore
+    v.update(:bar=>1)
+    v.should be_a_kind_of(@c)
+    v.should == {'foo'=>'bar', 'bar'=>'1'}
+  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"'
+    @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))
+  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 of the various array types" 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)
+    @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
+    proc{@db.typecast_value(:hstore, [])}.should raise_error(Sequel::InvalidValue)
+  end
+end

data/spec/extensions/pg_statement_cache_spec.rb

@@ -0,0 +1,209 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+Sequel::Postgres::StatementCache::PGError = Sequel::Error
+
+describe "pg_statement_cache and pg_auto_parameterize extensions" do
+  before do
+    @dbp = proc do |opts|
+      @db = Sequel.connect 'mock://postgres', :quote_identifiers=>false, :statement_cache_opts=>{:max_size=>4}.merge(opts),
+        :after_connect=>(proc do |c|
+          c.extend(Module.new do
+            def execute_query(sql, args)
+              raise Sequel::Postgres::StatementCache::PGError if @db.exec_raise
+              @db.execute(sql, :arguments=>args, :no_eq=>true)
+            end
+            def prepare(name, sql)
+              raise Sequel::Postgres::StatementCache::PGError if sql =~ /prepare_raise/
+              @ps ||= {}
+              @ps[name] = sql
+              @db._sqls << "PREPARE #{name} AS #{sql}"
+            end
+            def exec_prepared(name, args=nil)
+              @db._sqls << "EXECUTE #{name} (#{@ps[name]})#{" -- args: #{args.inspect}" if args}"
+            end
+          end)
+        end)
+      @db.extend Sequel::Postgres::AutoParameterize::DatabaseMethods
+      @db.extend Sequel::Postgres::StatementCache::DatabaseMethods
+      @db.extend(Module.new do
+        attr_accessor :exec_raise
+        def _execute(c, sql, opts={})
+          opts[:no_eq] ? super : c.send(:execute_query, sql, opts[:arguments])
+        end
+        def _sqls
+          @sqls
+        end
+        def statement_cache
+          synchronize{|c| c.statement_cache}
+        end
+      end)
+      @db
+    end
+    @db = @dbp.call({})
+  end
+
+  it "should automatically prepare statements executed multiple times" do
+    @db[:table].filter(:b=>2).all
+    3.times{|i| @db[:table].filter(:a=>i).all}
+    @db.sqls.should == ["SELECT * FROM table WHERE (b = $1::int4) -- args: [2]",
+      "SELECT * FROM table WHERE (a = $1::int4) -- args: [0]",
+      "PREPARE sequel_pgap_2 AS SELECT * FROM table WHERE (a = $1::int4)",
+      "EXECUTE sequel_pgap_2 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [1]",
+      "EXECUTE sequel_pgap_2 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [2]"]
+  end
+
+  it "should work correctly for queries without parameters" do
+    @db[:table].filter(:b).all
+    3.times{|i| @db[:table].filter(:a).all}
+    @db.sqls.should == ["SELECT * FROM table WHERE b",
+      "SELECT * FROM table WHERE a",
+      "PREPARE sequel_pgap_2 AS SELECT * FROM table WHERE a",
+      "EXECUTE sequel_pgap_2 (SELECT * FROM table WHERE a)",
+      "EXECUTE sequel_pgap_2 (SELECT * FROM table WHERE a)"]
+  end
+
+  it "should correctly return the size of the cache" do
+    sc = @db.statement_cache
+    sc.size.should == 0
+    @db[:table].filter(:b=>2).all
+    sc.size.should == 1
+    3.times{|i| @db[:table].filter(:a=>i).all}
+    sc.size.should == 2
+  end
+
+  it "should correctly clear the cache" do
+    sc = @db.statement_cache
+    sc.size.should == 0
+    @db[:table].filter(:b=>2).all
+    sc.size.should == 1
+    3.times{|i| @db[:table].filter(:a=>i).all}
+    sc.size.should == 2
+    sc.clear
+    sc.size.should == 0
+    3.times{|i| @db[:table].filter(:a=>i).all}
+    sc.size.should == 1
+  end
+
+  it "should correctly yield each entry in the cache" do
+    @db[:table].filter(:b=>2).all
+    3.times{|i| @db[:table].filter(:a=>i).all}
+    a = []
+    @db.statement_cache.each{|k, v| a << [k, v]}
+    a.sort!
+    a[0][0].should == "SELECT * FROM table WHERE (a = $1::int4)"
+    a[1][0].should == "SELECT * FROM table WHERE (b = $1::int4)"
+    s1 = a[1][1]
+    s1.cache_id.should == 1
+    s1.num_executes.should == 1
+    s1 = a[0][1]
+    s1.cache_id.should == 2
+    s1.num_executes.should == 3
+  end
+
+  it "should automatically cleanup the cache when it goes beyond its maximum size" do
+    sc = @db.statement_cache
+    4.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
+    sc.size.should == 4
+    @db[:table].filter(:b=>1).all
+    sc.size.should == 2
+  end
+
+  it "should clear statement caches when altering tables" do
+    @db[:table].filter(:b=>2).all
+    sc = @db.statement_cache
+    @db.alter_table(:foo){drop_column :bar}
+    sc.size.should == 0
+  end
+
+  it "should clear statement caches when dropping tables" do
+    @db[:table].filter(:b=>2).all
+    sc = @db.statement_cache
+    @db.drop_table(:foo)
+    sc.size.should == 0
+  end
+
+  it "should deallocate prepared statements when clearing the cache" do
+    3.times{|i| @db[:table].filter(:a=>i).all}
+    @db.sqls
+    @db.statement_cache.clear
+    @db.sqls.should == ["DEALLOCATE sequel_pgap_1"]
+  end
+
+  it "should deallocate prepared statements when cleaning up the cache" do
+    @db = @dbp.call(:sorter=>proc{|t, s| -s.num_executes})
+    4.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
+    @db[:table].filter(:a0=>1).all
+    @db.sqls
+    @db[:table].filter(:b=>1).all
+    @db.sqls.should == ["DEALLOCATE sequel_pgap_1", "SELECT * FROM table WHERE (b = $1::int4) -- args: [1]"]
+  end
+
+  it "should not deallocate nonprepared statements when clearing the cache" do
+    4.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
+    @db.sqls
+    @db.statement_cache.clear
+    @db.sqls.should == []
+  end
+
+  it "should not deallocate nonprepared statements when cleaning up the cache" do
+    @db = @dbp.call(:sorter=>proc{|t, s| -s.num_executes})
+    4.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
+    @db.sqls
+    @db[:table].filter(:b=>1).all
+    @db.sqls.should == ["SELECT * FROM table WHERE (b = $1::int4) -- args: [1]"]
+  end
+
+  it "should have a configurable max_size and min_size" do
+    @db = @dbp.call(:max_size=>10, :min_size=>2)
+    10.times{|i| @db[:table].filter(:"a#{i}"=>1).all}
+    sc = @db.statement_cache
+    sc.size.should == 10
+    @db[:table].filter(:b=>1).all
+    sc.size.should == 2
+  end
+
+  it "should have a configurable prepare_after" do
+    @db = @dbp.call(:prepare_after=>3)
+    4.times{|i| @db[:table].filter(:a=>i).all}
+    @db.sqls.should == ["SELECT * FROM table WHERE (a = $1::int4) -- args: [0]",
+      "SELECT * FROM table WHERE (a = $1::int4) -- args: [1]",
+      "PREPARE sequel_pgap_1 AS SELECT * FROM table WHERE (a = $1::int4)",
+      "EXECUTE sequel_pgap_1 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [2]",
+      "EXECUTE sequel_pgap_1 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [3]"]
+  end
+
+  it "should have a configurable sorter" do
+    @db = @dbp.call(:sorter=>proc{|t, s| s.num_executes})
+    4.times{|i| (i+1).times{@db[:table].filter(:"a#{i}"=>1).all}}
+    @db[:table].filter(:b=>1).all
+    sc = @db.statement_cache
+    a = []
+    sc.each{|k, v| a << [k, v]}
+    a.sort!
+    a[0][0].should == "SELECT * FROM table WHERE (a3 = $1::int4)"
+    a[1][0].should == "SELECT * FROM table WHERE (b = $1::int4)"
+    s1 = a[1][1]
+    s1.num_executes.should == 1
+    s1 = a[0][1]
+    s1.cache_id.should == 4
+    s1.num_executes.should == 4
+  end
+
+  it "should ignore errors when preparing queries" do
+    3.times{|i| @db[:table].filter(:prepare_raise=>1).all}
+    @db.sqls.should == ["SELECT * FROM table WHERE (prepare_raise = $1::int4) -- args: [1]",
+      "SELECT * FROM table WHERE (prepare_raise = $1::int4) -- args: [1]",
+      "SELECT * FROM table WHERE (prepare_raise = $1::int4) -- args: [1]"]
+  end
+
+  it "should ignore errors when deallocating queries" do
+    3.times{|i| @db[:table].filter(:a=>1).all}
+    @db.exec_raise = true
+    @db.statement_cache.clear
+    @db.sqls.should == ["SELECT * FROM table WHERE (a = $1::int4) -- args: [1]",
+      "PREPARE sequel_pgap_1 AS SELECT * FROM table WHERE (a = $1::int4)",
+      "EXECUTE sequel_pgap_1 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [1]",
+      "EXECUTE sequel_pgap_1 (SELECT * FROM table WHERE (a = $1::int4)) -- args: [1]"]
+  end
+
+end