sequel 3.33.0 → 3.34.0

data/lib/sequel/version.rb

@@ -3,7 +3,7 @@ module Sequel
   MAJOR = 3
   # The minor version of Sequel.  Bumped for every non-patch level
   # release, generally around once a month.
-  MINOR = 33
+  MINOR = 34
   # The tiny version of Sequel.  Usually 0, only bumped for bugfix
   # releases that fix regressions from previous versions.
   TINY  = 0

data/spec/adapters/firebird_spec.rb

@@ -247,7 +247,7 @@ end
 describe "A Firebird database" do
   before do
     @db = FIREBIRD_DB
-    @db.drop_table(:posts) rescue nil
+    @db.drop_table?(:posts)
     @db.sqls.clear
   end
 

data/spec/adapters/mssql_spec.rb

@@ -67,10 +67,10 @@ end
 describe "MSSQL full_text_search" do
   before do
     @db = MSSQL_DB
-    @db.drop_table(:posts) rescue nil
+    @db.drop_table?(:posts)
   end
   after do
-    @db.drop_table(:posts) rescue nil
+    @db.drop_table?(:posts)
   end
   
   specify "should support fulltext indexes and full_text_search" do
@@ -109,8 +109,7 @@ describe "MSSQL Dataset#output" do
     @ds = @db[:items]
   end
   after do
-    @db.drop_table(:items)
-    @db.drop_table(:out)
+    @db.drop_table?(:items, :out)
   end
 
   specify "should format OUTPUT clauses without INTO for DELETE statements" do
@@ -256,7 +255,7 @@ describe "MSSQL::Dataset#import" do
     @ds = @db[:test]
   end
   after do
-    @db.drop_table(:test) rescue nil
+    @db.drop_table?(:test)
   end
   
   specify "#import should work correctly with an arbitrary output value" do
@@ -291,7 +290,7 @@ describe "Offset support" do
     @ds.import [:id, :parent_id], [[1,nil],[2,nil],[3,1],[4,1],[5,3],[6,5]]
   end
   after do
-    @db.drop_table(:i)
+    @db.drop_table?(:i)
   end
   
   specify "should return correct rows" do
@@ -314,8 +313,7 @@ describe "Common Table Expressions" do
     @ds.import [:id, :parent_id], [[1,nil],[2,nil],[3,1],[4,1],[5,3],[6,5]]
   end
   after do
-    @db.drop_table(:i1)
-    @db.drop_table(:i2)
+    @db.drop_table?(:i1, :i2)
   end
 
   specify "using #with should be able to update" do
@@ -385,7 +383,7 @@ describe "MSSSQL::Dataset#insert" do
     @ds = @db[:test5]
   end
   after do
-    @db.drop_table(:test5) rescue nil
+    @db.drop_table?(:test5)
   end
 
   specify "should have insert_select return nil if disable_insert_output is used" do
@@ -424,8 +422,7 @@ describe "MSSSQL::Dataset#into" do
     @db[:t].insert(:id => 1, :value => "test")
     @db << @db[:t].into(:new).select_sql
     @db[:new].all.should == [{:id => 1, :value => "test"}]
-    @db.drop_table(:t)
-    @db.drop_table(:new)
+    @db.drop_table?(:t, :new)
   end
 end
 
@@ -434,7 +431,7 @@ describe "A MSSQL database" do
     @db = MSSQL_DB
   end
   after do
-    @db.drop_table(:a)
+    @db.drop_table?(:a)
   end
   
   specify "should handle many existing types for set_column_allow_null" do
@@ -461,7 +458,7 @@ describe "MSSQL::Database#rename_table" do
     MSSQL_DB.create_table! :'foo bar' do
       text :name
     end
-    MSSQL_DB.drop_table :baz rescue nil
+    MSSQL_DB.drop_table? :baz
     proc { MSSQL_DB.rename_table 'foo bar', 'baz' }.should_not raise_error
   end
   
@@ -501,7 +498,7 @@ describe "MSSQL::Database#mssql_unicode_strings = false" do
     MSSQL_DB.mssql_unicode_strings = false
   end
   after do
-    MSSQL_DB.drop_table(:items)
+    MSSQL_DB.drop_table?(:items)
     MSSQL_DB.mssql_unicode_strings = true
   end
 
@@ -535,7 +532,7 @@ describe "A MSSQL database adds index with include" do
   end
 
   after :all do
-    @db.drop_table @table_name
+    @db.drop_table? @table_name
   end
 
   cspecify "should be able add index with include" do

data/spec/adapters/mysql_spec.rb

@@ -26,9 +26,7 @@ def logger.method_missing(m, msg)
   MYSQL_DB.sqls << msg
 end
 MYSQL_DB.loggers = [logger]
-MYSQL_DB.drop_table(:items) rescue nil
-MYSQL_DB.drop_table(:dolls) rescue nil
-MYSQL_DB.drop_table(:booltest) rescue nil
+MYSQL_DB.drop_table?(:items, :dolls, :booltest)
 
 SQL_BEGIN = 'BEGIN'
 SQL_ROLLBACK = 'ROLLBACK'
@@ -40,7 +38,7 @@ describe "MySQL", '#create_table' do
     MYSQL_DB.sqls.clear
   end
   after do
-    @db.drop_table(:dolls) rescue nil
+    @db.drop_table?(:dolls)
   end
 
   specify "should allow to specify options for MySQL" do
@@ -83,7 +81,7 @@ describe "MySQL", '#create_table' do
     @db.schema(:dolls).map{|k, v| v[:auto_increment]}.should == [nil, nil, true]
   end
 
-  specify "should support collate with various other column options" do
+  cspecify "should support collate with various other column options", :swift do
     @db.create_table!(:dolls){ String :name, :size=>128, :collate=>:utf8_bin, :default=>'foo', :null=>false, :unique=>true}
     @db[:dolls].insert
     @db[:dolls].select_map(:name).should == ["foo"]
@@ -113,7 +111,7 @@ if MYSQL_DB.adapter_scheme == :mysql
     end
     after do
       @db.convert_tinyint_to_bool = true
-      @db.drop_table(:booltest)
+      @db.drop_table?(:booltest)
     end
 
     specify "should consider tinyint(1) datatypes as boolean if set, but not larger tinyints" do
@@ -161,7 +159,7 @@ describe "A MySQL dataset" do
     MYSQL_DB.sqls.clear
   end
   after do
-    MYSQL_DB.drop_table(:items)
+    MYSQL_DB.drop_table?(:items)
   end
 
   specify "should quote columns and tables using back-ticks if quoting identifiers" do
@@ -241,6 +239,12 @@ describe "A MySQL dataset" do
     @d.filter(:name => /^bc/).count.should == 1
   end
 
+  specify "should have explain output" do
+    @d.explain.should be_a_kind_of(String)
+    @d.explain(:extended=>true).should be_a_kind_of(String)
+    @d.explain.should_not == @d.explain(:extended=>true)
+  end
+
   specify "should correctly literalize strings with comment backslashes in them" do
     @d.delete
     proc {@d << {:name => ':\\'}}.should_not raise_error
@@ -285,7 +289,7 @@ describe "Dataset#distinct" do
     @ds = @db[:a]
   end
   after do
-    @db.drop_table(:a)
+    @db.drop_table?(:a)
   end
 
   it "#distinct with arguments should return results distinct on those arguments" do
@@ -450,12 +454,12 @@ describe "A MySQL database with table options" do
     Sequel::MySQL.default_collate = 'utf8_general_ci'
 
     @db = MYSQL_DB
-    @db.drop_table(:items) rescue nil
+    @db.drop_table?(:items)
 
     MYSQL_DB.sqls.clear
   end
   after do
-    @db.drop_table(:items) rescue nil
+    @db.drop_table?(:items)
 
     Sequel::MySQL.default_engine = nil
     Sequel::MySQL.default_charset = nil
@@ -481,12 +485,11 @@ end
 describe "A MySQL database" do
   before do
     @db = MYSQL_DB
-    @db.drop_table(:items) rescue nil
+    @db.drop_table?(:items)
     MYSQL_DB.sqls.clear
   end
   after do
-    @db.drop_table(:items) rescue nil
-    @db.drop_table(:users) rescue nil
+    @db.drop_table?(:items, :users)
   end
 
   specify "should support defaults for boolean columns" do
@@ -601,8 +604,7 @@ end
 
 describe "MySQL foreign key support" do
   after do
-    MYSQL_DB.drop_table(:testfk) rescue nil
-    MYSQL_DB.drop_table(:testpk) rescue nil
+    MYSQL_DB.drop_table?(:testfk, :testpk)
   end
 
   specify "should create table without :key" do
@@ -674,11 +676,11 @@ end
 describe "A MySQL database" do
   before do
     @db = MYSQL_DB
-    @db.drop_table(:posts) rescue nil
+    @db.drop_table?(:posts)
     @db.sqls.clear
   end
   after do
-    @db.drop_table(:posts) rescue nil
+    @db.drop_table?(:posts)
   end
 
   specify "should support fulltext indexes and full_text_search" do
@@ -750,7 +752,7 @@ describe "MySQL::Dataset#insert and related methods" do
     MYSQL_DB.sqls.clear
   end
   after do
-    MYSQL_DB.drop_table(:items)
+    MYSQL_DB.drop_table?(:items)
   end
 
   specify "#insert should insert record with default values when no arguments given" do
@@ -786,6 +788,62 @@ describe "MySQL::Dataset#insert and related methods" do
     @d.all.should == [{:name => 'abc', :value => 6}, {:name => 'def', :value => 2}]
   end
 
+  specify "#multi_replace should insert multiple records in a single statement" do
+    @d.multi_replace([{:name => 'abc'}, {:name => 'def'}])
+
+    MYSQL_DB.sqls.should == [
+      SQL_BEGIN,
+      "REPLACE INTO `items` (`name`) VALUES ('abc'), ('def')",
+      SQL_COMMIT
+    ]
+
+    @d.all.should == [
+      {:name => 'abc', :value => nil}, {:name => 'def', :value => nil}
+    ]
+  end
+
+  specify "#multi_replace should split the list of records into batches if :commit_every option is given" do
+    @d.multi_replace([{:value => 1}, {:value => 2}, {:value => 3}, {:value => 4}],
+      :commit_every => 2)
+
+    MYSQL_DB.sqls.should == [
+      SQL_BEGIN,
+      "REPLACE INTO `items` (`value`) VALUES (1), (2)",
+      SQL_COMMIT,
+      SQL_BEGIN,
+      "REPLACE INTO `items` (`value`) VALUES (3), (4)",
+      SQL_COMMIT
+    ]
+
+    @d.all.should == [
+      {:name => nil, :value => 1}, 
+      {:name => nil, :value => 2},
+      {:name => nil, :value => 3}, 
+      {:name => nil, :value => 4}
+    ]
+  end
+
+  specify "#multi_replace should split the list of records into batches if :slice option is given" do
+    @d.multi_replace([{:value => 1}, {:value => 2}, {:value => 3}, {:value => 4}],
+      :slice => 2)
+
+    MYSQL_DB.sqls.should == [
+      SQL_BEGIN,
+      "REPLACE INTO `items` (`value`) VALUES (1), (2)",
+      SQL_COMMIT,
+      SQL_BEGIN,
+      "REPLACE INTO `items` (`value`) VALUES (3), (4)",
+      SQL_COMMIT
+    ]
+
+    @d.all.should == [
+      {:name => nil, :value => 1}, 
+      {:name => nil, :value => 2},
+      {:name => nil, :value => 3}, 
+      {:name => nil, :value => 4}
+    ]
+  end
+
   specify "#multi_insert should insert multiple records in a single statement" do
     @d.multi_insert([{:name => 'abc'}, {:name => 'def'}])
 
@@ -916,7 +974,7 @@ describe "MySQL::Dataset#update and related methods" do
     @d = MYSQL_DB[:items]
   end
   after do
-    MYSQL_DB.drop_table(:items)
+    MYSQL_DB.drop_table?(:items)
   end
 
   specify "#update_ignore should not raise error where normal update would fail" do
@@ -937,7 +995,7 @@ describe "MySQL::Dataset#replace" do
     MYSQL_DB.sqls.clear
   end
   after do
-    MYSQL_DB.drop_table(:items)
+    MYSQL_DB.drop_table?(:items)
   end
 
   specify "should use default values if they exist" do
@@ -1005,7 +1063,7 @@ describe "MySQL::Dataset#calc_found_rows" do
     MYSQL_DB.create_table!(:items){Integer :a}
   end
   after do
-    MYSQL_DB.drop_table(:items)
+    MYSQL_DB.drop_table?(:items)
   end
 
   specify "should add the SQL_CALC_FOUND_ROWS keyword when selecting" do
@@ -1035,7 +1093,7 @@ if MYSQL_DB.adapter_scheme == :mysql or MYSQL_DB.adapter_scheme == :jdbc or MYSQ
       MYSQL_DB.sqls.clear
     end
     after do
-      MYSQL_DB.drop_table(:items)
+      MYSQL_DB.drop_table?(:items)
       MYSQL_DB.execute('DROP PROCEDURE test_sproc')
     end
 
@@ -1126,7 +1184,7 @@ if MYSQL_DB.adapter_scheme == :mysql
       MYSQL_DB[:b].insert(25)
     end
     after do
-      MYSQL_DB.drop_table(:a, :b)
+      MYSQL_DB.drop_table?(:a, :b)
     end
 
     specify "should combine all results by default" do

data/spec/adapters/postgres_spec.rb

@@ -6,6 +6,14 @@ unless defined?(POSTGRES_DB)
 end
 INTEGRATION_DB = POSTGRES_DB unless defined?(INTEGRATION_DB)
 
+# Automatic parameterization changes the SQL used, so don't check
+# for expected SQL if it is being used.
+if defined?(Sequel::Postgres::AutoParameterize)
+  check_sqls = false
+else
+  check_sqls = true
+end
+
 def POSTGRES_DB.sqls
   (@sqls ||= [])
 end
@@ -13,7 +21,7 @@ logger = Object.new
 def logger.method_missing(m, msg)
   POSTGRES_DB.sqls << msg
 end
-POSTGRES_DB.loggers = [logger]
+POSTGRES_DB.loggers << logger
 
 #POSTGRES_DB.instance_variable_set(:@server_version, 80100)
 POSTGRES_DB.create_table! :test do
@@ -61,7 +69,6 @@ describe "A PostgreSQL dataset" do
   end
 
   specify "should quote columns and tables using double quotes if quoting identifiers" do
-    @d.quote_identifiers = true
     @d.select(:name).sql.should == \
       'SELECT "name" FROM "test"'
 
@@ -89,27 +96,28 @@ describe "A PostgreSQL dataset" do
     @d.select('max(test."name") AS "max_name"'.lit).sql.should == \
       'SELECT max(test."name") AS "max_name" FROM "test"'
 
-    @d.select(:test.sql_function(:abc, 'hello')).sql.should == \
-      "SELECT test(\"abc\", 'hello') FROM \"test\""
+    @d.insert_sql(:x => :y).should =~ \
+      /\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/
 
-    @d.select(:test.sql_function(:abc__def, 'hello')).sql.should == \
-      "SELECT test(\"abc\".\"def\", 'hello') FROM \"test\""
+    if check_sqls
+      @d.select(:test.sql_function(:abc, 'hello')).sql.should == \
+        "SELECT test(\"abc\", 'hello') FROM \"test\""
 
-    @d.select(:test.sql_function(:abc__def, 'hello').as(:x2)).sql.should == \
-      "SELECT test(\"abc\".\"def\", 'hello') AS \"x2\" FROM \"test\""
+      @d.select(:test.sql_function(:abc__def, 'hello')).sql.should == \
+        "SELECT test(\"abc\".\"def\", 'hello') FROM \"test\""
 
-    @d.insert_sql(:value => 333).should =~ \
-      /\AINSERT INTO "test" \("value"\) VALUES \(333\)( RETURNING NULL)?\z/
+      @d.select(:test.sql_function(:abc__def, 'hello').as(:x2)).sql.should == \
+        "SELECT test(\"abc\".\"def\", 'hello') AS \"x2\" FROM \"test\""
 
-    @d.insert_sql(:x => :y).should =~ \
-      /\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/
+      @d.insert_sql(:value => 333).should =~ \
+        /\AINSERT INTO "test" \("value"\) VALUES \(333\)( RETURNING NULL)?\z/
 
-    @d.disable_insert_returning.insert_sql(:value => 333).should =~ \
-      /\AINSERT INTO "test" \("value"\) VALUES \(333\)\z/
+      @d.disable_insert_returning.insert_sql(:value => 333).should =~ \
+        /\AINSERT INTO "test" \("value"\) VALUES \(333\)\z/
+    end
   end
 
   specify "should quote fields correctly when reversing the order if quoting identifiers" do
-    @d.quote_identifiers = true
     @d.reverse_order(:name).sql.should == \
       'SELECT * FROM "test" ORDER BY "name" DESC'
 
@@ -167,7 +175,7 @@ describe "Dataset#distinct" do
     @ds = @db[:a]
   end
   after do
-    @db.drop_table(:a)
+    @db.drop_table?(:a)
   end
 
   it "#distinct with arguments should return results distinct on those arguments" do
@@ -191,7 +199,7 @@ if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
       @ds = POSTGRES_DB[:items]
     end
     after do
-      POSTGRES_DB.drop_table(:items)
+      POSTGRES_DB.drop_table?(:items)
       POSTGRES_DB.disconnect
     end
 
@@ -240,27 +248,60 @@ end
 
 describe "A PostgreSQL dataset with a timestamp field" do
   before do
-    @d = POSTGRES_DB[:test3]
+    @db = POSTGRES_DB
+    @d = @db[:test3]
     @d.delete
   end
+  after do
+    @db.convert_infinite_timestamps = false if @db.adapter_scheme == :postgres
+  end
 
-  cspecify "should store milliseconds in time fields for Time objects", :do do
+  cspecify "should store milliseconds in time fields for Time objects", :do, :swift do
     t = Time.now
     @d << {:value=>1, :time=>t}
-    t2 = @d[:value =>'1'][:time]
+    t2 = @d[:value =>1][:time]
     @d.literal(t2).should == @d.literal(t)
     t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
     t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000 == t.usec
   end
 
-  cspecify "should store milliseconds in time fields for DateTime objects", :do do
+  cspecify "should store milliseconds in time fields for DateTime objects", :do, :swift do
     t = DateTime.now
     @d << {:value=>1, :time=>t}
-    t2 = @d[:value =>'1'][:time]
+    t2 = @d[:value =>1][:time]
     @d.literal(t2).should == @d.literal(t)
     t2.strftime('%Y-%m-%d %H:%M:%S').should == t.strftime('%Y-%m-%d %H:%M:%S')
     t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000 == t.strftime('%N').to_i/1000
   end
+
+  if POSTGRES_DB.adapter_scheme == :postgres
+    specify "should handle infinite timestamps if convert_infinite_timestamps is set" do
+      @d << {:time=>'infinity'.cast(:timestamp)}
+      @db.convert_infinite_timestamps = :nil
+      @db[:test3].get(:time).should == nil
+      @db.convert_infinite_timestamps = :string
+      @db[:test3].get(:time).should == 'infinity'
+      @db.convert_infinite_timestamps = :float
+      @db[:test3].get(:time).should == 1.0/0.0
+
+      @d.update(:time=>'-infinity'.cast(:timestamp))
+      @db.convert_infinite_timestamps = :nil
+      @db[:test3].get(:time).should == nil
+      @db.convert_infinite_timestamps = :string
+      @db[:test3].get(:time).should == '-infinity'
+      @db.convert_infinite_timestamps = :float
+      @db[:test3].get(:time).should == -1.0/0.0
+    end
+
+    specify "should handle conversions from infinite strings/floats in models" do
+      c = Class.new(Sequel::Model(:test3))
+      @db.convert_infinite_timestamps = :float
+      c.new(:time=>'infinity').time.should == 'infinity'
+      c.new(:time=>'-infinity').time.should == '-infinity'
+      c.new(:time=>1.0/0.0).time.should == 1.0/0.0
+      c.new(:time=>-1.0/0.0).time.should == -1.0/0.0
+    end
+  end
 end
 
 describe "PostgreSQL's EXPLAIN and ANALYZE" do
@@ -317,11 +358,11 @@ end
 describe "A PostgreSQL database" do
   before do
     @db = POSTGRES_DB
-    @db.drop_table(:posts) rescue nil
+    @db.drop_table?(:posts)
     @db.sqls.clear
   end
   after do
-    @db.drop_table(:posts) rescue nil
+    @db.drop_table?(:posts)
   end
 
   specify "should support resetting the primary key sequence" do
@@ -364,9 +405,9 @@ describe "A PostgreSQL database" do
     @db.create_table(:posts){text :title; text :body; full_text_index [:title, :body]; full_text_index :title, :language => 'french'}
     @db.sqls.should == [
       %{CREATE TABLE "posts" ("title" text, "body" text)},
-      %{CREATE INDEX "posts_title_body_index" ON "posts" USING gin (to_tsvector('simple', (COALESCE("title", '') || ' ' || COALESCE("body", ''))))},
-      %{CREATE INDEX "posts_title_index" ON "posts" USING gin (to_tsvector('french', (COALESCE("title", ''))))}
-    ]
+      %{CREATE INDEX "posts_title_body_index" ON "posts" USING gin (to_tsvector('simple'::regconfig, (COALESCE("title", '') || ' ' || COALESCE("body", ''))))},
+      %{CREATE INDEX "posts_title_index" ON "posts" USING gin (to_tsvector('french'::regconfig, (COALESCE("title", ''))))}
+    ] if check_sqls
 
     @db[:posts].insert(:title=>'ruby rails', :body=>'yowsa')
     @db[:posts].insert(:title=>'sequel', :body=>'ruby')
@@ -377,9 +418,9 @@ describe "A PostgreSQL database" do
     @db[:posts].full_text_search([:title, :body], ['yowsa', 'rails']).all.should == [:title=>'ruby rails', :body=>'yowsa']
     @db[:posts].full_text_search(:title, 'scooby', :language => 'french').all.should == [{:title=>'ruby scooby', :body=>'x'}]
     @db.sqls.should == [
-      %{SELECT * FROM "posts" WHERE (to_tsvector('simple', (COALESCE("title", ''))) @@ to_tsquery('simple', 'rails'))},
-      %{SELECT * FROM "posts" WHERE (to_tsvector('simple', (COALESCE("title", '') || ' ' || COALESCE("body", ''))) @@ to_tsquery('simple', 'yowsa | rails'))},
-      %{SELECT * FROM "posts" WHERE (to_tsvector('french', (COALESCE("title", ''))) @@ to_tsquery('french', 'scooby'))}]
+      %{SELECT * FROM "posts" WHERE (to_tsvector('simple'::regconfig, (COALESCE("title", ''))) @@ to_tsquery('simple'::regconfig, 'rails'))},
+      %{SELECT * FROM "posts" WHERE (to_tsvector('simple'::regconfig, (COALESCE("title", '') || ' ' || COALESCE("body", ''))) @@ to_tsquery('simple'::regconfig, 'yowsa | rails'))},
+      %{SELECT * FROM "posts" WHERE (to_tsvector('french'::regconfig, (COALESCE("title", ''))) @@ to_tsquery('french'::regconfig, 'scooby'))}] if check_sqls
 
     @db[:posts].full_text_search(:title, :$n).call(:select, :n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
     @db[:posts].full_text_search(:title, :$n).prepare(:select, :fts_select).call(:n=>'rails').should == [{:title=>'ruby rails', :body=>'yowsa'}]
@@ -439,13 +480,13 @@ describe "Postgres::Dataset#import" do
     @ds = @db[:test]
   end
   after do
-    @db.drop_table(:test) rescue nil
+    @db.drop_table?(:test)
   end
 
   specify "#import should return separate insert statements if server_version < 80200" do
     @ds.meta_def(:server_version){80199}
     @ds.import([:x, :y], [[1, 2], [3, 4]])
-    @db.sqls.should == ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2)', 'INSERT INTO "test" ("x", "y") VALUES (3, 4)', 'COMMIT']
+    @db.sqls.should == ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2)', 'INSERT INTO "test" ("x", "y") VALUES (3, 4)', 'COMMIT'] if check_sqls
     @ds.all.should == [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
 
@@ -495,7 +536,7 @@ describe "Postgres::Dataset#insert" do
     @ds = @db[:test5]
   end
   after do
-    @db.drop_table(:test5) rescue nil
+    @db.drop_table?(:test5)
   end
 
   specify "should work with static SQL" do
@@ -516,7 +557,7 @@ describe "Postgres::Dataset#insert" do
       "SELECT currval('\"public\".test5_xid_seq')",
       'INSERT INTO "test5" ("value") VALUES (13)',
       "SELECT currval('\"public\".test5_xid_seq')"
-    ]
+    ] if check_sqls
     @ds.all.should == [{:xid=>1, :value=>10}, {:xid=>2, :value=>20}, {:xid=>3, :value=>13}]
   end
 
@@ -540,7 +581,7 @@ describe "Postgres::Dataset#insert" do
   specify "should use INSERT RETURNING if server_version >= 80200" do
     @ds.meta_def(:server_version){80201}
     @ds.insert(:value=>10).should == 1
-    @db.sqls.last.should == 'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"'
+    @db.sqls.last.should == 'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"' if check_sqls
   end
 
   specify "should have insert_select return nil if server_version < 80200" do
@@ -582,7 +623,6 @@ describe "Postgres::Database schema qualified tables" do
     POSTGRES_DB.instance_variable_set(:@primary_key_sequences, {})
   end
   after do
-    POSTGRES_DB.quote_identifiers = false
     POSTGRES_DB << "DROP SCHEMA schema_test CASCADE"
     POSTGRES_DB.default_schema = nil
   end
@@ -638,7 +678,7 @@ describe "Postgres::Database schema qualified tables" do
       POSTGRES_DB.schema(:public__domains).map{|x| x.first}.should == [:d]
       POSTGRES_DB.schema(:schema_test__domains).map{|x| x.first}.should == [:i]
     ensure
-      POSTGRES_DB.drop_table(:public__domains)
+      POSTGRES_DB.drop_table?(:public__domains)
     end
   end
 
@@ -658,7 +698,6 @@ describe "Postgres::Database schema qualified tables" do
   end
 
   specify "should be able to get serial sequences for tables that have spaces in the name in a given schema" do
-    POSTGRES_DB.quote_identifiers = true
     POSTGRES_DB.create_table(:"schema_test__schema test"){primary_key :i}
     POSTGRES_DB.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."schema test_i_seq"'
   end
@@ -670,7 +709,6 @@ describe "Postgres::Database schema qualified tables" do
   end
 
   specify "should be able to get custom sequences for tables that have spaces in the name in a given schema" do
-    POSTGRES_DB.quote_identifiers = true
     POSTGRES_DB << "CREATE SEQUENCE schema_test.\"ks eq\""
     POSTGRES_DB.create_table(:"schema_test__schema test"){integer :j; primary_key :k, :type=>:integer, :default=>"nextval('schema_test.\"ks eq\"'::regclass)".lit}
     POSTGRES_DB.primary_key_sequence(:"schema_test__schema test").should == '"schema_test"."ks eq"'
@@ -691,7 +729,6 @@ describe "Postgres::Database schema qualified tables and eager graphing" do
     @db = POSTGRES_DB
     @db.run "DROP SCHEMA s CASCADE" rescue nil
     @db.run "CREATE SCHEMA s"
-    @db.quote_identifiers = true
 
     @db.create_table(:s__bands){primary_key :id; String :name}
     @db.create_table(:s__albums){primary_key :id; String :name; foreign_key :band_id, :s__bands}
@@ -733,7 +770,6 @@ describe "Postgres::Database schema qualified tables and eager graphing" do
     @m4 = @Member.create(:name=>"JC", :band=>@b2)
   end
   after(:all) do
-    @db.quote_identifiers = false
     @db.run "DROP SCHEMA s CASCADE"
   end
 
@@ -916,7 +952,7 @@ if POSTGRES_DB.dataset.supports_window_functions?
       @ds.insert(:id=>6, :group_id=>2, :amount=>100000)
     end
     after do
-      @db.drop_table(:i1)
+      @db.drop_table?(:i1)
     end
 
     specify "should give correct results for window functions" do
@@ -941,7 +977,7 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
     @d.drop_function('tf', :if_exists=>true, :cascade=>true, :args=>%w'integer integer')
     @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
     @d.drop_schema(:sequel, :if_exists=>true, :cascade=>true)
-    @d.drop_table(:test) rescue nil
+    @d.drop_table?(:test)
   end
 
   specify "#create_function and #drop_function should create and drop functions" do
@@ -983,9 +1019,9 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
   end
 
   specify "#create_schema and #drop_schema should create and drop schemas" do
-    @d.send(:create_schema_sql, :sequel).should == 'CREATE SCHEMA sequel'
-    @d.send(:drop_schema_sql, :sequel).should == 'DROP SCHEMA sequel'
-    @d.send(:drop_schema_sql, :sequel, :if_exists=>true, :cascade=>true).should == 'DROP SCHEMA IF EXISTS sequel CASCADE'
+    @d.send(:create_schema_sql, :sequel).should == 'CREATE SCHEMA "sequel"'
+    @d.send(:drop_schema_sql, :sequel).should == 'DROP SCHEMA "sequel"'
+    @d.send(:drop_schema_sql, :sequel, :if_exists=>true, :cascade=>true).should == 'DROP SCHEMA IF EXISTS "sequel" CASCADE'
     @d.create_schema(:sequel)
     @d.create_table(:sequel__test){Integer :a}
     if @d.server_version >= 80200
@@ -998,7 +1034,7 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
   specify "#create_trigger and #drop_trigger should create and drop triggers" do
     @d.create_language(:plpgsql) if @d.server_version < 90000
     @d.create_function(:tf, 'BEGIN IF NEW.value IS NULL THEN RAISE EXCEPTION \'Blah\'; END IF; RETURN NEW; END;', :language=>:plpgsql, :returns=>:trigger)
-    @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON test FOR EACH ROW EXECUTE PROCEDURE tf()'
+    @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true).should == 'CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON "test" FOR EACH ROW EXECUTE PROCEDURE tf()'
     @d.create_table(:test){String :name; Integer :value}
     @d.create_trigger(:test, :identity, :tf, :each_row=>true)
     @d[:test].insert(:name=>'a', :value=>1)
@@ -1007,10 +1043,10 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
     @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>1}]
     @d[:test].filter(:name=>'a').update(:value=>3)
     @d[:test].filter(:name=>'a').all.should == [{:name=>'a', :value=>3}]
-    @d.send(:drop_trigger_sql, :test, :identity).should == 'DROP TRIGGER identity ON test'
+    @d.send(:drop_trigger_sql, :test, :identity).should == 'DROP TRIGGER identity ON "test"'
     @d.drop_trigger(:test, :identity)
-    @d.send(:create_trigger_sql, :test, :identity, :tf, :after=>true, :events=>:insert, :args=>[1, 'a']).should == 'CREATE TRIGGER identity AFTER INSERT ON test EXECUTE PROCEDURE tf(1, \'a\')'
-    @d.send(:drop_trigger_sql, :test, :identity, :if_exists=>true, :cascade=>true).should == 'DROP TRIGGER IF EXISTS identity ON test CASCADE'
+    @d.send(:create_trigger_sql, :test, :identity, :tf, :after=>true, :events=>:insert, :args=>[1, 'a']).should == 'CREATE TRIGGER identity AFTER INSERT ON "test" EXECUTE PROCEDURE tf(1, \'a\')'
+    @d.send(:drop_trigger_sql, :test, :identity, :if_exists=>true, :cascade=>true).should == 'DROP TRIGGER IF EXISTS identity ON "test" CASCADE'
     # Make sure if exists works
     @d.drop_trigger(:test, :identity, :if_exists=>true, :cascade=>true)
   end
@@ -1026,7 +1062,7 @@ if POSTGRES_DB.adapter_scheme == :postgres
       @db.transaction{1001.times{|i| @ds.insert(i)}}
     end
     after(:all) do
-      @db.drop_table(:test_cursor) rescue nil
+      @db.drop_table?(:test_cursor)
     end
 
     specify "should return the same results as the non-cursor use" do
@@ -1055,23 +1091,17 @@ if POSTGRES_DB.adapter_scheme == :postgres
     before do
       @db = POSTGRES_DB
       Sequel::Postgres::PG_NAMED_TYPES[:interval] = lambda{|v| v.reverse}
-      @db.instance_eval do
-        disconnect
-        @conversion_procs = nil
-      end
+      @db.reset_conversion_procs
     end
     after do
       Sequel::Postgres::PG_NAMED_TYPES.delete(:interval)
-      @db.instance_eval do
-        disconnect
-        @conversion_procs = nil
-      end
-      @db.drop_table(:foo)
+      @db.reset_conversion_procs
+      @db.drop_table?(:foo)
     end
 
     specify "should look up conversion procs by name" do
       @db.create_table!(:foo){interval :bar}
-      @db[:foo].insert('21 days')
+      @db[:foo].insert('21 days'.cast(:interval))
       @db[:foo].get(:bar).should == 'syad 12'
     end
   end
@@ -1087,7 +1117,7 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
       ds.insert(3, 4)
     end
     after(:all) do
-      @db.drop_table(:test_copy) rescue nil
+      @db.drop_table?(:test_copy)
     end
 
     specify "without a block or options should return a text version of the table as a single string" do
@@ -1111,7 +1141,7 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
     end
 
     specify "should accept dataset as first argument" do
-      @db.copy_table(@db[:test_copy].cross_join(:test_copy___tc).order(1, 2, 3, 4)).should == "1\t2\t1\t2\n1\t2\t3\t4\n3\t4\t1\t2\n3\t4\t3\t4\n"
+      @db.copy_table(@db[:test_copy].cross_join(:test_copy___tc).order(:test_copy__x, :test_copy__y, :tc__x, :tc__y)).should == "1\t2\t1\t2\n1\t2\t3\t4\n3\t4\t1\t2\n3\t4\t3\t4\n"
     end
 
     specify "with a block and no options should yield each row as a string in text format" do
@@ -1207,11 +1237,11 @@ if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRE
       i = 0
       @db.listen('foo2', :timeout=>0.001, :loop=>proc{i+=1; throw :stop if i > 3}){|ev, pid, payload| called = true}.should == nil
       i.should == 4
-    end
+    end unless RUBY_VERSION == '1.9.2' && RUBY_PLATFORM =~ /mingw/ # Ruby freezes on this spec on this platform/version
   end
 end
 
-describe 'POSTGRES special float handling' do
+describe 'PostgreSQL special float handling' do
   before do
     @db = POSTGRES_DB
     @db.create_table!(:test5){Float :value}
@@ -1219,22 +1249,24 @@ describe 'POSTGRES special float handling' do
     @ds = @db[:test5]
   end
   after do
-    @db.drop_table(:test5) rescue nil
+    @db.drop_table?(:test5)
   end
 
-  specify 'should quote NaN' do
-    nan = 0.0/0.0
-    @ds.insert_sql(:value => nan).should == %q{INSERT INTO test5 (value) VALUES ('NaN')}
-  end
+  if check_sqls
+    specify 'should quote NaN' do
+      nan = 0.0/0.0
+      @ds.insert_sql(:value => nan).should == %q{INSERT INTO "test5" ("value") VALUES ('NaN')}
+    end
 
-  specify 'should quote +Infinity' do
-    inf = 1.0/0.0
-    @ds.insert_sql(:value => inf).should == %q{INSERT INTO test5 (value) VALUES ('Infinity')}
-  end
+    specify 'should quote +Infinity' do
+      inf = 1.0/0.0
+      @ds.insert_sql(:value => inf).should == %q{INSERT INTO "test5" ("value") VALUES ('Infinity')}
+    end
 
-  specify 'should quote -Infinity' do
-    inf = -1.0/0.0
-    @ds.insert_sql(:value => inf).should == %q{INSERT INTO test5 (value) VALUES ('-Infinity')}
+    specify 'should quote -Infinity' do
+      inf = -1.0/0.0
+      @ds.insert_sql(:value => inf).should == %q{INSERT INTO "test5" ("value") VALUES ('-Infinity')}
+    end
   end
 
   if POSTGRES_DB.adapter_scheme == :postgres
@@ -1257,3 +1289,338 @@ describe 'POSTGRES special float handling' do
     end
   end
 end
+
+describe 'PostgreSQL array handling' do
+  before(:all) do
+    Sequel.extension :pg_array
+    @db = POSTGRES_DB
+    @db.extend Sequel::Postgres::PGArray::DatabaseMethods
+    @ds = @db[:items]
+    @native = POSTGRES_DB.adapter_scheme == :postgres
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+
+  specify 'insert and retrieve integer and float arrays of various sizes' do
+    @db.create_table!(:items) do
+      column :i2, 'int2[]'
+      column :i4, 'int4[]'
+      column :i8, 'int8[]'
+      column :r, 'real[]'
+      column :dp, 'double precision[]'
+    end
+    @ds.insert([1].pg_array(:int2), [nil, 2].pg_array(:int4), [3, nil].pg_array(:int8), [4, nil, 4.5].pg_array(:real), [5, nil, 5.5].pg_array("double precision"))
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      rs.should == [{:i2=>[1], :i4=>[nil, 2], :i8=>[3, nil], :r=>[4.0, nil, 4.5], :dp=>[5.0, nil, 5.5]}]
+      rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
+      rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+
+      @ds.delete
+      @ds.insert([[1], [2]].pg_array(:int2), [[nil, 2], [3, 4]].pg_array(:int4), [[3, nil], [nil, nil]].pg_array(:int8), [[4, nil], [nil, 4.5]].pg_array(:real), [[5, nil], [nil, 5.5]].pg_array("double precision"))
+      rs = @ds.all
+      rs.should == [{:i2=>[[1], [2]], :i4=>[[nil, 2], [3, 4]], :i8=>[[3, nil], [nil, nil]], :r=>[[4, nil], [nil, 4.5]], :dp=>[[5, nil], [nil, 5.5]]}]
+      rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
+      rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
+  specify 'insert and retrieve decimal arrays' do
+    @db.create_table!(:items) do
+      column :n, 'numeric[]'
+    end
+    @ds.insert([BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')].pg_array(:numeric))
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      rs.should == [{:n=>[BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')]}]
+      rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
+      rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+
+      @ds.delete
+      @ds.insert([[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]].pg_array(:numeric))
+      rs = @ds.all
+      rs.should == [{:n=>[[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]]}]
+      rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
+      rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
+  specify 'insert and retrieve string arrays' do
+    @db.create_table!(:items) do
+      column :c, 'char(4)[]'
+      column :vc, 'varchar[]'
+      column :t, 'text[]'
+    end
+    @ds.insert(['a', nil, 'NULL', 'b"\'c'].pg_array('char(4)'), ['a', nil, 'NULL', 'b"\'c'].pg_array(:varchar), ['a', nil, 'NULL', 'b"\'c'].pg_array(:text))
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      rs.should == [{:c=>['a   ', nil, 'NULL', 'b"\'c'], :vc=>['a', nil, 'NULL', 'b"\'c'], :t=>['a', nil, 'NULL', 'b"\'c']}]
+      rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
+      rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+
+      @ds.delete
+      @ds.insert([[['a'], [nil]], [['NULL'], ['b"\'c']]].pg_array('char(4)'), [[['a'], ['']], [['NULL'], ['b"\'c']]].pg_array(:varchar), [[['a'], [nil]], [['NULL'], ['b"\'c']]].pg_array(:text))
+      rs = @ds.all
+      rs.should == [{:c=>[[['a   '], [nil]], [['NULL'], ['b"\'c']]], :vc=>[[['a'], ['']], [['NULL'], ['b"\'c']]], :t=>[[['a'], [nil]], [['NULL'], ['b"\'c']]]}]
+      rs.first.values.each{|v| v.should_not be_a_kind_of(Array)}
+      rs.first.values.each{|v| v.to_a.should be_a_kind_of(Array)}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
+  specify 'use arrays in bound variables' do
+    @db.create_table!(:items) do
+      column :i, 'int4[]'
+    end
+    @ds.call(:insert, {:i=>[1,2]}, {:i=>:$i})
+    @ds.get(:i).should == [1, 2]
+    @ds.filter(:i=>:$i).call(:first, :i=>[1,2]).should == {:i=>[1,2]}
+    @ds.filter(:i=>:$i).call(:first, :i=>[1,3]).should == nil
+
+    @db.create_table!(:items) do
+      column :i, 'text[]'
+    end
+    a = ["\"\\\\\"{}\n\t\r \v\b123afP", 'NULL', nil, '']
+    @ds.call(:insert, {:i=>:$i}, :i=>a.pg_array)
+    @ds.get(:i).should == a
+    @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
+    @ds.filter(:i=>:$i).call(:first, :i=>['', nil, nil, 'a']).should == nil
+  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+  specify 'with models' do
+    @db.create_table!(:items) do
+      primary_key :id
+      column :i, 'integer[]'
+      column :f, 'double precision[]'
+      column :d, 'numeric[]'
+      column :t, 'text[]'
+    end
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :typecast_on_load, :i, :f, :d, :t unless @native
+    o = c.create(:i=>[1,2, nil], :f=>[[1, 2.5], [3, 4.5]], :d=>[1, BigDecimal.new('1.000000000000000000001')], :t=>[%w'a b c', ['NULL', nil, '1']])
+    o.i.should == [1, 2, nil]
+    o.f.should == [[1, 2.5], [3, 4.5]]
+    o.d.should == [BigDecimal.new('1'), BigDecimal.new('1.000000000000000000001')]
+    o.t.should == [%w'a b c', ['NULL', nil, '1']]
+  end
+
+  specify 'operations/functions with pg_array_ops' do
+    Sequel.extension :pg_array_ops
+    @db.create_table!(:items){column :i, 'integer[]'; column :i2, 'integer[]'; column :i3, 'integer[]'; column :i4, 'integer[]'; column :i5, 'integer[]'}
+    @ds.insert([1, 2, 3].pg_array, [2, 1].pg_array, [4, 4].pg_array, [[5, 5], [4, 3]].pg_array, [1, nil, 5].pg_array)
+
+    @ds.get(:i.pg_array > :i3).should be_false
+    @ds.get(:i3.pg_array > :i).should be_true
+
+    @ds.get(:i.pg_array >= :i3).should be_false
+    @ds.get(:i.pg_array >= :i).should be_true
+
+    @ds.get(:i3.pg_array < :i).should be_false
+    @ds.get(:i.pg_array < :i3).should be_true
+
+    @ds.get(:i3.pg_array <= :i).should be_false
+    @ds.get(:i.pg_array <= :i).should be_true
+
+    @ds.get({5=>:i.pg_array.any}.sql_expr).should be_false
+    @ds.get({1=>:i.pg_array.any}.sql_expr).should be_true
+
+    @ds.get({1=>:i3.pg_array.all}.sql_expr).should be_false
+    @ds.get({4=>:i3.pg_array.all}.sql_expr).should be_true
+
+    @ds.get(:i2.pg_array[1]).should == 2
+    @ds.get(:i2.pg_array[2]).should == 1
+
+    @ds.get(:i4.pg_array[2][1]).should == 4
+    @ds.get(:i4.pg_array[2][2]).should == 3
+
+    @ds.get(:i.pg_array.contains(:i2)).should be_true
+    @ds.get(:i.pg_array.contains(:i3)).should be_false
+
+    @ds.get(:i2.pg_array.contained_by(:i)).should be_true
+    @ds.get(:i.pg_array.contained_by(:i2)).should be_false
+
+    @ds.get(:i.pg_array.overlaps(:i2)).should be_true
+    @ds.get(:i2.pg_array.overlaps(:i3)).should be_false
+
+    @ds.get(:i.pg_array.dims).should == '[1:3]'
+    @ds.get(:i.pg_array.length).should == 3
+    @ds.get(:i.pg_array.lower).should == 1
+
+    if @db.server_version >= 90000
+      @ds.get(:i5.pg_array.join).should == '15'
+      @ds.get(:i5.pg_array.join(':')).should == '1:5'
+      @ds.get(:i5.pg_array.join(':', '*')).should == '1:*:5'
+    end
+    @ds.select(:i.pg_array.unnest).from_self.count.should == 3 if @db.server_version >= 80400
+
+    if @native
+      @ds.get(:i.pg_array.push(4)).should == [1, 2, 3, 4]
+      @ds.get(:i.pg_array.unshift(4)).should == [4, 1, 2, 3]
+      @ds.get(:i.pg_array.concat(:i2)).should == [1, 2, 3, 2, 1]
+    end
+  end
+end
+
+describe 'PostgreSQL hstore handling' do
+  before(:all) do
+    Sequel.extension :pg_hstore
+    @db = POSTGRES_DB
+    @db.extend Sequel::Postgres::HStore::DatabaseMethods
+    @ds = @db[:items]
+    @h = {'a'=>'b', 'c'=>nil, 'd'=>'NULL', 'e'=>'\\\\" \\\' ,=>'}
+    @native = POSTGRES_DB.adapter_scheme == :postgres
+  end
+  after do
+    @db.drop_table?(:items)
+  end
+
+  specify 'insert and retrieve hstore values' do
+    @db.create_table!(:items) do
+      column :h, :hstore
+    end
+    @ds.insert(@h.hstore)
+    @ds.count.should == 1
+    if @native
+      rs = @ds.all
+      v = rs.first[:h]
+      v.should_not be_a_kind_of(Hash)
+      v.to_hash.should be_a_kind_of(Hash)
+      v.to_hash.should == @h
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.should == rs
+    end
+  end
+
+  specify 'use hstore in bound variables' do
+    @db.create_table!(:items) do
+      column :i, :hstore
+    end
+    @ds.call(:insert, {:i=>@h.hstore}, {:i=>:$i})
+    @ds.get(:i).should == @h
+    @ds.filter(:i=>:$i).call(:first, :i=>@h.hstore).should == {:i=>@h}
+    @ds.filter(:i=>:$i).call(:first, :i=>{}.hstore).should == nil
+
+    @ds.delete
+    @ds.call(:insert, {:i=>@h}, {:i=>:$i})
+    @ds.get(:i).should == @h
+    @ds.filter(:i=>:$i).call(:first, :i=>@h).should == {:i=>@h}
+    @ds.filter(:i=>:$i).call(:first, :i=>{}).should == nil
+  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+
+  specify 'with models' do
+    @db.create_table!(:items) do
+      primary_key :id
+      column :h, :hstore
+    end
+    c = Class.new(Sequel::Model(@db[:items]))
+    c.plugin :typecast_on_load, :h unless @native
+    c.create(:h=>@h.hstore).h.should == @h
+  end
+
+  specify 'operations/functions with pg_hstore_ops' do
+    Sequel.extension :pg_hstore_ops
+    Sequel.extension :pg_array
+    Sequel.extension :pg_array_ops
+    @db.create_table!(:items){hstore :h1; hstore :h2; hstore :h3; String :t}
+    @ds.insert({'a'=>'b', 'c'=>nil}.hstore, {'a'=>'b'}.hstore, {'d'=>'e'}.hstore)
+    h1 = :h1.hstore
+    h2 = :h2.hstore
+    h3 = :h3.hstore
+    
+    @ds.get(h1['a']).should == 'b'
+    @ds.get(h1['d']).should == nil
+
+    @ds.get(h2.concat(h3).keys.pg_array.length).should == 2
+    @ds.get(h1.concat(h3).keys.pg_array.length).should == 3
+    @ds.get(h2.merge(h3).keys.pg_array.length).should == 2
+    @ds.get(h1.merge(h3).keys.pg_array.length).should == 3
+
+    unless @db.adapter_scheme == :do
+      # Broken DataObjects thinks operators with ? represent placeholders
+      @ds.get(h1.contain_all(%w'a c'.pg_array)).should == true
+      @ds.get(h1.contain_all(%w'a d'.pg_array)).should == false
+
+      @ds.get(h1.contain_any(%w'a d'.pg_array)).should == true
+      @ds.get(h1.contain_any(%w'e d'.pg_array)).should == false
+    end
+
+    @ds.get(h1.contains(h2)).should == true
+    @ds.get(h1.contains(h3)).should == false
+
+    @ds.get(h2.contained_by(h1)).should == true
+    @ds.get(h2.contained_by(h3)).should == false
+
+    @ds.get(h1.defined('a')).should == true
+    @ds.get(h1.defined('c')).should == false
+    @ds.get(h1.defined('d')).should == false
+
+    @ds.get(h1.delete('a')['c']).should == nil
+    @ds.get(h1.delete(%w'a d'.pg_array)['c']).should == nil
+    @ds.get(h1.delete(h2)['c']).should == nil
+
+    @ds.from({'a'=>'b', 'c'=>nil}.hstore.op.each).order(:key).all.should == [{:key=>'a', :value=>'b'}, {:key=>'c', :value=>nil}]
+
+    unless @db.adapter_scheme == :do
+      @ds.get(h1.has_key?('c')).should == true
+      @ds.get(h1.include?('c')).should == true
+      @ds.get(h1.key?('c')).should == true
+      @ds.get(h1.member?('c')).should == true
+      @ds.get(h1.exist?('c')).should == true
+      @ds.get(h1.has_key?('d')).should == false
+      @ds.get(h1.include?('d')).should == false
+      @ds.get(h1.key?('d')).should == false
+      @ds.get(h1.member?('d')).should == false
+      @ds.get(h1.exist?('d')).should == false
+    end
+
+    @ds.get(h1.hstore.hstore.hstore.keys.pg_array.length).should == 2
+    @ds.get(h1.keys.pg_array.length).should == 2
+    @ds.get(h2.keys.pg_array.length).should == 1
+    @ds.get(h1.akeys.pg_array.length).should == 2
+    @ds.get(h2.akeys.pg_array.length).should == 1
+
+    @ds.from({'t'=>'s'}.hstore.op.populate(Sequel::SQL::Cast.new(nil, :items))).select_map(:t).should == ['s']
+    @ds.from(:items___i).select({'t'=>'s'}.hstore.op.record_set(:i).as(:r)).from_self(:alias=>:s).select('(r).*'.lit).from_self.select_map(:t).should == ['s']
+
+    @ds.from({'t'=>'s', 'a'=>'b'}.hstore.op.skeys.as(:s)).select_order_map(:s).should == %w'a t'
+
+    @ds.get(h1.slice(%w'a c'.pg_array).keys.pg_array.length).should == 2
+    @ds.get(h1.slice(%w'd c'.pg_array).keys.pg_array.length).should == 1
+    @ds.get(h1.slice(%w'd e'.pg_array).keys.pg_array.length).should == nil
+
+    @ds.from({'t'=>'s', 'a'=>'b'}.hstore.op.svals.as(:s)).select_order_map(:s).should == %w'b s'
+
+    @ds.get(h1.to_array.pg_array.length).should == 4
+    @ds.get(h2.to_array.pg_array.length).should == 2
+
+    @ds.get(h1.to_matrix.pg_array.length).should == 2
+    @ds.get(h2.to_matrix.pg_array.length).should == 1
+
+    @ds.get(h1.values.pg_array.length).should == 2
+    @ds.get(h2.values.pg_array.length).should == 1
+    @ds.get(h1.avals.pg_array.length).should == 2
+    @ds.get(h2.avals.pg_array.length).should == 1
+  end
+end if POSTGRES_DB.type_supported?(:hstore)