sequel 3.21.0 → 3.36.0

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 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)
+    @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_inet_spec.rb

@@ -0,0 +1,44 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "pg_inet extension" do
+  ipv6_broken = (IPAddr.new('::1'); false) rescue true
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
+    @db.extend(Sequel::Postgres::InetDatabaseMethods)
+  end
+
+  it "should literalize IPAddr v4 instances to strings correctly" do
+    @db.literal(IPAddr.new('127.0.0.1')).should == "'127.0.0.1/32'"
+    @db.literal(IPAddr.new('127.0.0.0/8')).should == "'127.0.0.0/8'"
+  end
+
+  it "should literalize IPAddr v6 instances to strings correctly" do
+    @db.literal(IPAddr.new('2001:4f8:3:ba::/64')).should == "'2001:4f8:3:ba::/64'"
+    @db.literal(IPAddr.new('2001:4f8:3:ba:2e0:81ff:fe22:d1f1')).should == "'2001:4f8:3:ba:2e0:81ff:fe22:d1f1/128'"
+  end unless ipv6_broken
+
+  it "should not affect literalization of custom objects" do
+    o = Object.new
+    def o.sql_literal(ds) 'v' end
+    @db.literal(o).should == 'v'
+  end
+
+  it "should support using IPAddr as bound variables" do
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg(IPAddr.new('127.0.0.1'), nil).should == '127.0.0.1/32'
+  end
+
+  it "should parse inet/cidr type from the schema correctly" do
+    @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'inet'}, {:name=>'c', :db_type=>'cidr'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :ipaddr, :ipaddr]
+  end
+
+  it "should support typecasting for the ipaddr type" do
+    ip = IPAddr.new('127.0.0.1')
+    @db.typecast_value(:ipaddr, ip).should equal(ip)
+    @db.typecast_value(:ipaddr, ip.to_s).should == ip
+    proc{@db.typecast_value(:ipaddr, '')}.should raise_error(Sequel::InvalidValue)
+    proc{@db.typecast_value(:ipaddr, 1)}.should raise_error(Sequel::InvalidValue)
+  end
+end

data/spec/extensions/pg_json_spec.rb

@@ -0,0 +1,101 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+begin
+  Sequel.extension :pg_json
+rescue LoadError => e
+  skip_warn "can't load pg_json extension (#{e.class}: #{e})"
+else
+describe "pg_json extension" do
+  before(:all) do
+    m = Sequel::Postgres
+    @m = m::JSONDatabaseMethods
+    @hc = m::JSONHash
+    @ac = m::JSONArray
+
+    # Create subclass in correct namespace for easily overriding methods
+    j = m::JSON = JSON.dup
+    j.instance_eval do
+      Parser = JSON::Parser
+      alias old_parse parse
+      def parse(s)
+        return 1 if s == '1'
+        old_parse(s) 
+      end
+    end
+  end
+  before do
+    @db = Sequel.connect('mock://postgres', :quote_identifiers=>false)
+    @db.extend(Module.new{def bound_variable_arg(arg, conn) arg end})
+  end
+
+  it "should parse json strings correctly" do
+    @m.parse_json('[]').should be_a_kind_of(@ac)
+    @m.parse_json('[]').to_a.should == []
+    @m.parse_json('[1]').to_a.should == [1]
+    @m.parse_json('[1, 2]').to_a.should == [1, 2]
+    @m.parse_json('[1, [2], {"a": "b"}]').to_a.should == [1, [2], {'a'=>'b'}]
+    @m.parse_json('{}').should be_a_kind_of(@hc)
+    @m.parse_json('{}').to_hash.should == {}
+    @m.parse_json('{"a": "b"}').to_hash.should == {'a'=>'b'}
+    @m.parse_json('{"a": "b", "c": [1, 2, 3]}').to_hash.should == {'a'=>'b', 'c'=>[1, 2, 3]}
+    @m.parse_json('{"a": "b", "c": {"d": "e"}}').to_hash.should == {'a'=>'b', 'c'=>{'d'=>'e'}}
+  end
+
+  it "should raise an error when attempting to parse invalid json" do
+    proc{@m.parse_json('')}.should raise_error(Sequel::InvalidValue)
+    proc{@m.parse_json('1')}.should raise_error(Sequel::InvalidValue)
+  end
+
+  it "should literalize HStores to strings correctly" do
+    @db.literal([].pg_json).should == "'[]'::json"
+    @db.literal([1, [2], {'a'=>'b'}].pg_json).should == "'[1,[2],{\"a\":\"b\"}]'::json"
+    @db.literal({}.pg_json).should == "'{}'::json"
+    @db.literal({'a'=>'b'}.pg_json).should == "'{\"a\":\"b\"}'::json"
+  end
+
+  it "should have Hash#pg_json method for creating JSONHash instances" do
+    {}.pg_json.should be_a_kind_of(@hc)
+  end
+
+  it "should have Array#pg_json method for creating JSONArray instances" do
+    [].pg_json.should be_a_kind_of(@ac)
+  end
+
+  it "should have JSONHash#to_hash method for getting underlying hash" do
+    {}.pg_json.to_hash.should be_a_kind_of(Hash)
+  end
+
+  it "should have JSONArray#to_a method for getting underlying array" do
+    [].pg_json.to_a.should be_a_kind_of(Array)
+  end
+
+  it "should support using JSONHash and JSONArray as bound variables" do
+    @db.extend @m
+    @db.bound_variable_arg(1, nil).should == 1
+    @db.bound_variable_arg([1].pg_json, nil).should == '[1]'
+    @db.bound_variable_arg({'a'=>'b'}.pg_json, nil).should == '{"a":"b"}'
+  end
+
+  it "should parse json type from the schema correctly" do
+    @db.extend @m
+    @db.fetch = [{:name=>'id', :db_type=>'integer'}, {:name=>'i', :db_type=>'json'}]
+    @db.schema(:items).map{|e| e[1][:type]}.should == [:integer, :json]
+  end
+
+  it "should support typecasting for the json type" do
+    @db.extend @m
+    h = {1=>2}.pg_json
+    a = [1].pg_json
+    @db.typecast_value(:json, h).should equal(h)
+    @db.typecast_value(:json, h.to_hash).should == h
+    @db.typecast_value(:json, h.to_hash).should be_a_kind_of(@hc)
+    @db.typecast_value(:json, a).should equal(a)
+    @db.typecast_value(:json, a.to_a).should == a
+    @db.typecast_value(:json, a.to_a).should be_a_kind_of(@ac)
+    @db.typecast_value(:json, '[]').should == [].pg_json
+    @db.typecast_value(:json, '{"a": "b"}').should == {"a"=>"b"}.pg_json
+    proc{@db.typecast_value(:json, '')}.should raise_error(Sequel::InvalidValue)
+    proc{@db.typecast_value(:json, 1)}.should raise_error(Sequel::InvalidValue)
+  end
+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

data/spec/extensions/prepared_statements_associations_spec.rb

@@ -0,0 +1,111 @@
+require File.join(File.dirname(File.expand_path(__FILE__)), "spec_helper")
+
+describe "Sequel::Plugins::AssociationPks" do
+  before do
+    @db = Sequel.mock
+    @db.extend_datasets do
+      def select_sql
+        sql = super
+        sql << ' -- prepared' if is_a?(Sequel::Dataset::PreparedStatementMethods)
+        sql
+      end
+    end
+    @Artist = Class.new(Sequel::Model(@db[:artists]))
+    @Artist.columns :id, :id2
+    @Album= Class.new(Sequel::Model(@db[:albums]))
+    @Album.columns :id, :artist_id, :id2, :artist_id2
+    @Tag = Class.new(Sequel::Model(@db[:tags]))
+    @Tag.columns :id, :id2
+    @Artist.plugin :prepared_statements_associations
+    @Album.plugin :prepared_statements_associations
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    @Album.many_to_one :artist, :class=>@Artist
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>:album_id
+    @Artist.plugin :many_through_many
+    @Artist.many_through_many :tags, [[:albums, :artist_id, :id], [:albums_tags, :album_id, :tag_id]], :class=>@Tag
+    @db.sqls
+  end
+
+  specify "should run correct SQL for associations" do
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1) -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2).artist
+    @db.sqls.should == ["SELECT * FROM artists WHERE (artists.id = 2) LIMIT 1 -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2).tags
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.album_id = 1)) -- prepared"]
+
+    @Artist.load(:id=>1).tags
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON (albums_tags.tag_id = tags.id) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.artist_id = 1)) -- prepared"]
+  end
+
+  specify "should run correct SQL for composite key associations" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
+    @Album.many_to_one :artist, :class=>@Artist, :key=>[:artist_id, :artist_id2], :primary_key=>[:id, :id2]
+    @Album.many_to_many :tags, :class=>@Tag, :join_table=>:albums_tags, :left_key=>[:album_id, :album_id2], :right_key=>[:tag_id, :tag_id2], :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
+    @Artist.many_through_many :tags, [[:albums, [:artist_id, :artist_id2], [:id, :id2]], [:albums_tags, [:album_id, :album_id2], [:tag_id, :tag_id2]]], :class=>@Tag, :right_primary_key=>[:id, :id2], :left_primary_key=>[:id, :id2]
+
+    @Artist.load(:id=>1, :id2=>2).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2, :artist_id2=>3).artist
+    @db.sqls.should == ["SELECT * FROM artists WHERE ((artists.id = 2) AND (artists.id2 = 3)) LIMIT 1 -- prepared"]
+
+    @Album.load(:id=>1, :artist_id=>2, :id2=>3).tags
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2) AND (albums_tags.album_id = 1) AND (albums_tags.album_id2 = 3)) -- prepared"]
+
+    @Artist.load(:id=>1, :id2=>2).tags
+    @db.sqls.should == ["SELECT tags.* FROM tags INNER JOIN albums_tags ON ((albums_tags.tag_id = tags.id) AND (albums_tags.tag_id2 = tags.id2)) INNER JOIN albums ON ((albums.id = albums_tags.album_id) AND (albums.id2 = albums_tags.album_id2) AND (albums.artist_id = 1) AND (albums.artist_id2 = 2)) -- prepared"]
+  end
+
+  specify "should not run query if no objects can be associated" do
+    @Artist.new.albums.should == []
+    @Album.new.artist.should == nil
+    @db.sqls.should == []
+  end
+
+  specify "should run a regular query if there is a callback" do
+    @Artist.load(:id=>1).albums(proc{|ds| ds})
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :prepared_statement=>false option is used for the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :prepared_statement=>false
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if unrecognized association is used" do
+    a = @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id
+    a[:type] = :foo
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if a block is used when defining the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id do |ds| ds end
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (albums.artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :conditions option is used when defining the association" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+  end
+
+  specify "should run a regular query if :dataset option is used when defining the association" do
+    album = @Album
+    @Artist.one_to_many :albums, :class=>@Album, :dataset=>proc{album.filter(:artist_id=>id)} 
+    @Artist.load(:id=>1).albums
+    @db.sqls.should == ["SELECT * FROM albums WHERE (artist_id = 1)"]
+  end
+
+  specify "should run a regular query if :cloning an association that doesn't used prepared statements" do
+    @Artist.one_to_many :albums, :class=>@Album, :key=>:artist_id, :conditions=>{:a=>1} 
+    @Artist.one_to_many :oalbums, :clone=>:albums
+    @Artist.load(:id=>1).oalbums
+    @db.sqls.should == ["SELECT * FROM albums WHERE ((albums.artist_id = 1) AND (a = 1))"]
+  end
+end