sequel 4.49.0 → 5.3.0

data/spec/adapters/postgres_spec.rb

@@ -1,31 +1,21 @@
 SEQUEL_ADAPTER_TEST = :postgres
 
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative 'spec_helper'
 
 uses_pg = Sequel::Postgres::USES_PG if DB.adapter_scheme == :postgres
 uses_pg_or_jdbc = uses_pg || DB.adapter_scheme == :jdbc
-# SEQUEL5: Remove native handling
 
-def DB.sqls
-  (@sqls ||= [])
-end
-logger = Object.new
-def logger.method_missing(m, msg)
-  DB.sqls << msg
-end
-DB.loggers << logger
-
-DB.extension :pg_array, :pg_hstore, :pg_range, :pg_row, :pg_inet, :pg_json, :pg_enum
+DB.extension :pg_array, :pg_range, :pg_row, :pg_inet, :pg_json, :pg_enum
 begin
   DB.extension :pg_interval
 rescue LoadError
 end
+DB.extension :pg_hstore if DB.type_supported?('hstore')
 
 describe "PostgreSQL", '#create_table' do
   before do
     @db = DB
     @db.test_connection
-    DB.sqls.clear
   end
   after do
     @db.drop_table?(:tmp_dolls, :unlogged_dolls)
@@ -33,9 +23,9 @@ describe "PostgreSQL", '#create_table' do
 
   it "should create a temporary table" do
     @db.create_table(:tmp_dolls, :temp => true){text :name}
-    check_sqls do
-      @db.sqls.must_equal ['CREATE TEMPORARY TABLE "tmp_dolls" ("name" text)']
-    end
+    @db.table_exists?(:tmp_dolls).must_equal true
+    @db.disconnect
+    @db.table_exists?(:tmp_dolls).must_equal false
   end
 
   it "temporary table should support :on_commit option" do
@@ -80,9 +70,6 @@ describe "PostgreSQL", '#create_table' do
 
   it "should create an unlogged table" do
     @db.create_table(:unlogged_dolls, :unlogged => true){text :name}
-    check_sqls do
-      @db.sqls.must_equal ['CREATE UNLOGGED TABLE "unlogged_dolls" ("name" text)']
-    end
   end
 
   it "should create a table inheriting from another table" do
@@ -238,14 +225,6 @@ describe "PostgreSQL", 'INSERT ON CONFLICT' do
     @ds.insert_conflict(:constraint=>:ic_test_a_uidx, :update=>{:b=>6}, :update_where=>{Sequel[:ic_test][:b]=>4}).insert(1, 3, 4).must_be_nil
     @ds.all.must_equal [{:a=>1, :b=>5, :c=>5, :c_is_unique=>false}]
   end
-
-  it "Dataset#insert_conflict should respect expressions in the target argument" do
-    @ds.insert_conflict(:target=>:a).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"a\") DO NOTHING"
-    @ds.insert_conflict(:target=>:c, :conflict_where=>{:c_is_unique=>true}).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"c\") WHERE (\"c_is_unique\" IS TRUE) DO NOTHING"
-    @ds.insert_conflict(:target=>[:b, :c]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", \"c\") DO NOTHING"
-    @ds.insert_conflict(:target=>[:b, Sequel.function(:round, :c)]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", round(\"c\")) DO NOTHING"
-    @ds.insert_conflict(:target=>[:b, Sequel.virtual_row{|o| o.round(:c)}]).insert_sql(1, 2, 3).must_equal "INSERT INTO \"ic_test\" VALUES (1, 2, 3) ON CONFLICT (\"b\", round(\"c\")) DO NOTHING"
-  end
 end if DB.server_version >= 90500
 
 describe "A PostgreSQL database" do
@@ -340,7 +319,7 @@ describe "A PostgreSQL database" do
     @db.get(Sequel.cast('10 20', :int2vector)).wont_equal 10
   end
 
-  cspecify "should not typecast the money type incorrectly", [:do] do
+  it "should not typecast the money type incorrectly" do
     @db.get(Sequel.cast('10.01', :money)).wont_equal 0
   end
 
@@ -368,13 +347,6 @@ describe "A PostgreSQL database" do
     Sequel.connect(DB.opts.merge(:notice_receiver=>proc{|r| a = r.result_error_message})){|db| db.do("BEGIN\nRAISE WARNING 'foo';\nEND;")}
     a.must_equal "WARNING:  foo\n"
   end if uses_pg && DB.server_version >= 90000
-
-  # These only test the SQL created, because a true test using file_fdw or postgres_fdw
-  # requires superuser permissions, and you should not be running the tests as a superuser.
-  it "should support creating and dropping foreign tables" do
-    DB.send(:create_table_sql, :t, DB.create_table_generator{Integer :a}, :foreign=>:f, :options=>{:o=>1}).must_equal 'CREATE FOREIGN TABLE "t" ("a" integer) SERVER "f" OPTIONS (o \'1\')'
-    DB.send(:drop_table_sql, :t, :foreign=>true).must_equal 'DROP FOREIGN TABLE "t"'
-  end
 end
 
 describe "A PostgreSQL database with domain types" do
@@ -407,7 +379,6 @@ describe "A PostgreSQL dataset" do
   end
   before do
     @d.delete
-    @db.sqls.clear
   end
   after do
     @db.drop_table?(:atest)
@@ -416,35 +387,6 @@ describe "A PostgreSQL dataset" do
     @db.drop_table?(:test)
   end
 
-  it "should quote columns and tables using double quotes if quoting identifiers" do
-    check_sqls do
-      @d.select(:name).sql.must_equal 'SELECT "name" FROM "test"'
-      @d.select(Sequel.lit('COUNT(*)')).sql.must_equal 'SELECT COUNT(*) FROM "test"'
-      @d.select(Sequel.function(:max, :value)).sql.must_equal 'SELECT max("value") FROM "test"'
-      @d.select(Sequel.function(:NOW)).sql.must_equal 'SELECT NOW() FROM "test"'
-      @d.select(Sequel.function(:max, Sequel[:items][:value])).sql.must_equal 'SELECT max("items"."value") FROM "test"'
-      @d.order(Sequel.desc(:name)).sql.must_equal 'SELECT * FROM "test" ORDER BY "name" DESC'
-      @d.select(Sequel.lit('test.name AS item_name')).sql.must_equal 'SELECT test.name AS item_name FROM "test"'
-      @d.select(Sequel.lit('"name"')).sql.must_equal 'SELECT "name" FROM "test"'
-      @d.select(Sequel.lit('max(test."name") AS "max_name"')).sql.must_equal 'SELECT max(test."name") AS "max_name" FROM "test"'
-      @d.insert_sql(:x => :y).must_match(/\AINSERT INTO "test" \("x"\) VALUES \("y"\)( RETURNING NULL)?\z/)
-
-      @d.select(Sequel.function(:test, :abc, 'hello')).sql.must_equal "SELECT test(\"abc\", 'hello') FROM \"test\""
-      @d.select(Sequel.function(:test, Sequel[:abc][:def], 'hello')).sql.must_equal "SELECT test(\"abc\".\"def\", 'hello') FROM \"test\""
-      @d.select(Sequel.function(:test, Sequel[:abc][:def], 'hello').as(:x2)).sql.must_equal "SELECT test(\"abc\".\"def\", 'hello') AS \"x2\" FROM \"test\""
-      @d.insert_sql(:value => 333).must_match(/\AINSERT INTO "test" \("value"\) VALUES \(333\)( RETURNING NULL)?\z/)
-    end
-  end
-
-  it "should quote fields correctly when reversing the order if quoting identifiers" do
-    check_sqls do
-      @d.reverse_order(:name).sql.must_equal 'SELECT * FROM "test" ORDER BY "name" DESC'
-      @d.reverse_order(Sequel.desc(:name)).sql.must_equal 'SELECT * FROM "test" ORDER BY "name" ASC'
-      @d.reverse_order(:name, Sequel.desc(:test)).sql.must_equal 'SELECT * FROM "test" ORDER BY "name" DESC, "test" ASC'
-      @d.reverse_order(Sequel.desc(:name), :test).sql.must_equal 'SELECT * FROM "test" ORDER BY "name" ASC, "test" DESC'
-    end
-  end
-
   it "should support regexps" do
     @d.insert(:name => 'abc', :value => 1)
     @d.insert(:name => 'bcd', :value => 2)
@@ -591,27 +533,13 @@ describe "A PostgreSQL dataset" do
     @db.transaction(:synchronous=>true){}
     @db.transaction(:synchronous=>:off){}
     @db.transaction(:synchronous=>false){}
-    @db.sqls.grep(/synchronous/).must_equal ["SET LOCAL synchronous_commit = on", "SET LOCAL synchronous_commit = on", "SET LOCAL synchronous_commit = off", "SET LOCAL synchronous_commit = off"]
 
-    @db.sqls.clear
     @db.transaction(:synchronous=>nil){}
-    check_sqls do
-      @db.sqls.must_equal ['BEGIN', 'COMMIT']
-    end
-
     if @db.server_version >= 90100
-      @db.sqls.clear
       @db.transaction(:synchronous=>:local){}
-      check_sqls do
-        @db.sqls.grep(/synchronous/).must_equal ["SET LOCAL synchronous_commit = local"]
-      end
 
       if @db.server_version >= 90200
-        @db.sqls.clear
         @db.transaction(:synchronous=>:remote_write){}
-        check_sqls do
-          @db.sqls.grep(/synchronous/).must_equal ["SET LOCAL synchronous_commit = remote_write"]
-        end
       end
     end
   end
@@ -621,7 +549,6 @@ describe "A PostgreSQL dataset" do
     @db.transaction(:read_only=>false){}
     @db.transaction(:isolation=>:serializable, :read_only=>true){}
     @db.transaction(:isolation=>:serializable, :read_only=>false){}
-    @db.sqls.grep(/READ/).must_equal ["SET TRANSACTION READ ONLY", "SET TRANSACTION READ WRITE", "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY", "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE"]
   end
 
   it "should have #transaction support deferrable transactions" do
@@ -631,43 +558,38 @@ describe "A PostgreSQL dataset" do
     @db.transaction(:deferrable=>false, :read_only=>false){}
     @db.transaction(:isolation=>:serializable, :deferrable=>true, :read_only=>true){}
     @db.transaction(:isolation=>:serializable, :deferrable=>false, :read_only=>false){}
-    @db.sqls.grep(/DEF/).must_equal ["SET TRANSACTION DEFERRABLE", "SET TRANSACTION NOT DEFERRABLE", "SET TRANSACTION READ ONLY DEFERRABLE", "SET TRANSACTION READ WRITE NOT DEFERRABLE",  "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ ONLY DEFERRABLE", "SET TRANSACTION ISOLATION LEVEL SERIALIZABLE READ WRITE NOT DEFERRABLE"]
   end if DB.server_version >= 90100
 
   it "should support creating indexes concurrently" do
     @db.add_index :test, [:name, :value], :concurrently=>true
-    check_sqls do
-      @db.sqls.must_equal ['CREATE INDEX CONCURRENTLY "test_name_value_index" ON "test" ("name", "value")']
-    end
   end
 
   it "should support dropping indexes only if they already exist" do
+    proc{@db.drop_index :test, [:name, :value], :name=>'tnv1'}.must_raise Sequel::DatabaseError
+    @db.drop_index :test, [:name, :value], :if_exists=>true, :name=>'tnv1'
     @db.add_index :test, [:name, :value], :name=>'tnv1'
-    @db.sqls.clear
     @db.drop_index :test, [:name, :value], :if_exists=>true, :name=>'tnv1'
-    check_sqls do
-      @db.sqls.must_equal ['DROP INDEX IF EXISTS "tnv1"']
-    end
   end
 
   it "should support CASCADE when dropping indexes" do
-    @db.add_index :test, [:name, :value], :name=>'tnv2'
-    @db.sqls.clear
+    @db.add_index :test, [:name, :value], :name=>'tnv2', :unique=>true
+    @db.create_table(:atest){text :name; integer :value; foreign_key [:name, :value], :test, :key=>[:name, :value]}
+    @db.foreign_key_list(:atest).length.must_equal 1
     @db.drop_index :test, [:name, :value], :cascade=>true, :name=>'tnv2'
-    check_sqls do
-      @db.sqls.must_equal ['DROP INDEX "tnv2" CASCADE']
-    end
+    @db.foreign_key_list(:atest).length.must_equal 0
   end
 
   it "should support dropping indexes concurrently" do
     @db.add_index :test, [:name, :value], :name=>'tnv2'
-    @db.sqls.clear
     @db.drop_index :test, [:name, :value], :concurrently=>true, :name=>'tnv2'
-    check_sqls do
-      @db.sqls.must_equal ['DROP INDEX CONCURRENTLY "tnv2"']
-    end
   end if DB.server_version >= 90200
 
+  it "should support creating indexes only if they do not exist" do
+    @db.add_index :test, [:name, :value], :name=>'tnv3'
+    proc{@db.add_index :test, [:name, :value], :name=>'tnv3'}.must_raise Sequel::DatabaseError
+    @db.add_index :test, [:name, :value], :if_not_exists=>true, :name=>'tnv3'
+  end if DB.server_version >= 90500
+
   it "#lock should lock table if inside a transaction" do
     @db.transaction{@d.lock('EXCLUSIVE'); @d.insert(:name=>'a')}
   end
@@ -790,18 +712,19 @@ describe "A PostgreSQL dataset with a timestamp field" do
       DateTime :time
     end
     @d = @db[:test3]
+    @db.extension :pg_extended_date_support
   end
   before do
     @d.delete
   end
   after do
-    @db.convert_infinite_timestamps = false if @db.adapter_scheme == :postgres
+    @db.convert_infinite_timestamps = false
   end
   after(:all) do
     @db.drop_table?(:test3)
   end
 
-  cspecify "should store milliseconds in time fields for Time objects", [:do], [:swift] do
+  it "should store milliseconds in time fields for Time objects" do
     t = Time.now
     @d.insert(:time=>t)
     t2 = @d.get(:time)
@@ -810,7 +733,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
     (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).must_equal t.usec
   end
 
-  cspecify "should store milliseconds in time fields for DateTime objects", [:do], [:swift] do
+  it "should store milliseconds in time fields for DateTime objects" do
     t = DateTime.now
     @d.insert(:time=>t)
     t2 = @d.get(:time)
@@ -819,76 +742,130 @@ describe "A PostgreSQL dataset with a timestamp field" do
     (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).must_equal t.strftime('%N').to_i/1000
   end
 
-  if DB.adapter_scheme == :postgres
-    it "should handle infinite timestamps if convert_infinite_timestamps is set" do
-      @d.insert(:time=>Sequel.cast('infinity', DateTime))
-      @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:time).must_be_nil
-      @db.convert_infinite_timestamps = :string
-      @db[:test3].get(:time).must_equal 'infinity'
-      @db.convert_infinite_timestamps = :float
-      @db[:test3].get(:time).must_equal 1.0/0.0
-      @db.convert_infinite_timestamps = 'nil'
-      @db[:test3].get(:time).must_be_nil
-      @db.convert_infinite_timestamps = 'string'
-      @db[:test3].get(:time).must_equal 'infinity'
-      @db.convert_infinite_timestamps = 'float'
-      @db[:test3].get(:time).must_equal 1.0/0.0
-      @db.convert_infinite_timestamps = 't'
-      @db[:test3].get(:time).must_equal 1.0/0.0
-      @db.convert_infinite_timestamps = 'f'
-      if RUBY_VERSION >= '1.9'
-        proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
-        @db.convert_infinite_timestamps = nil
-        proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
-        @db.convert_infinite_timestamps = false
-        proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
-      end
-
-      @d.update(:time=>Sequel.cast('-infinity', DateTime))
-      @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:time).must_be_nil
-      @db.convert_infinite_timestamps = :string
-      @db[:test3].get(:time).must_equal '-infinity'
-      @db.convert_infinite_timestamps = :float
-      @db[:test3].get(:time).must_equal(-1.0/0.0)
-    end
-
-    it "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.must_equal 'infinity'
-      c.new(:time=>'-infinity').time.must_equal '-infinity'
-      c.new(:time=>1.0/0.0).time.must_equal 1.0/0.0
-      c.new(:time=>-1.0/0.0).time.must_equal(-1.0/0.0)
-    end
-
-    it "should handle infinite dates if convert_infinite_timestamps is set" do
-      @d.insert(:date=>Sequel.cast('infinity', Date))
-      @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:date).must_be_nil
-      @db.convert_infinite_timestamps = :string
-      @db[:test3].get(:date).must_equal 'infinity'
-      @db.convert_infinite_timestamps = :float
-      @db[:test3].get(:date).must_equal 1.0/0.0
-
-      @d.update(:date=>Sequel.cast('-infinity', :timestamp))
-      @db.convert_infinite_timestamps = :nil
-      @db[:test3].get(:date).must_be_nil
-      @db.convert_infinite_timestamps = :string
-      @db[:test3].get(:date).must_equal '-infinity'
-      @db.convert_infinite_timestamps = :float
-      @db[:test3].get(:date).must_equal(-1.0/0.0)
-    end
-
-    it "should handle conversions from infinite strings/floats in models" do
-      c = Class.new(Sequel::Model(:test3))
-      @db.convert_infinite_timestamps = :float
-      c.new(:date=>'infinity').date.must_equal 'infinity'
-      c.new(:date=>'-infinity').date.must_equal '-infinity'
-      c.new(:date=>1.0/0.0).date.must_equal 1.0/0.0
-      c.new(:date=>-1.0/0.0).date.must_equal(-1.0/0.0)
-    end
+  it "should handle BC times and dates" do
+    d = Date.new(-1234, 2, 3)
+    @db.get(Sequel.cast(d, Date)).must_equal d
+    begin
+      Sequel.default_timezone = :utc
+      t = Time.at(-100000000000).utc + 0.5
+      @db.get(Sequel.cast(t, Time)).must_equal t
+      @db.get(Sequel.cast(t, :timestamptz)).must_equal t
+      Sequel.datetime_class = DateTime
+      dt = DateTime.new(-1234, 2, 3, 10, 20, Rational(30, 20))
+      @db.get(Sequel.cast(dt, DateTime)).must_equal dt
+      @db.get(Sequel.cast(dt, :timestamptz)).must_equal dt
+    ensure
+      Sequel.datetime_class = Time
+      Sequel.default_timezone = nil
+    end
+  end
+
+  it "should handle infinite timestamps if convert_infinite_timestamps is set" do
+    @d.insert(:time=>Sequel.cast('infinity', DateTime))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(:time).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(:time).must_equal 'infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(:time).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 'nil'
+    @db[:test3].get(:time).must_be_nil
+    @db.convert_infinite_timestamps = 'string'
+    @db[:test3].get(:time).must_equal 'infinity'
+    @db.convert_infinite_timestamps = 'date'
+    @db[:test3].get(:time).must_equal Date::Infinity.new
+    @db.convert_infinite_timestamps = 'float'
+    @db[:test3].get(:time).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 't'
+    @db[:test3].get(:time).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = true
+    @db[:test3].get(:time).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 'f'
+    proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
+    @db.convert_infinite_timestamps = nil
+    proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
+    @db.convert_infinite_timestamps = false
+    proc{@db[:test3].get(:time)}.must_raise ArgumentError, Sequel::InvalidValue
+
+    @d.update(:time=>Sequel.cast('-infinity', DateTime))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(:time).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(:time).must_equal '-infinity'
+    @db.convert_infinite_timestamps = :date
+    @db[:test3].get(:time).must_equal -Date::Infinity.new
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(:time).must_equal(-1.0/0.0)
+  end
+
+  it "should handle infinite dates if convert_infinite_timestamps is set" do
+    @d.insert(:time=>Sequel.cast('infinity', DateTime))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(Sequel.cast(:time, Date)).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 'infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 'nil'
+    @db[:test3].get(Sequel.cast(:time, Date)).must_be_nil
+    @db.convert_infinite_timestamps = 'string'
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 'infinity'
+    @db.convert_infinite_timestamps = 'float'
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 't'
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = true
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal 1.0/0.0
+    @db.convert_infinite_timestamps = 'f'
+    proc{@db[:test3].get(Sequel.cast(:time, Date))}.must_raise ArgumentError, Sequel::InvalidValue
+    @db.convert_infinite_timestamps = nil
+    proc{@db[:test3].get(Sequel.cast(:time, Date))}.must_raise ArgumentError, Sequel::InvalidValue
+    @db.convert_infinite_timestamps = false
+    proc{@db[:test3].get(Sequel.cast(:time, Date))}.must_raise ArgumentError, Sequel::InvalidValue
+
+    @d.update(:time=>Sequel.cast('-infinity', DateTime))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(Sequel.cast(:time, Date)).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal '-infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(Sequel.cast(:time, Date)).must_equal(-1.0/0.0)
+  end
+
+  it "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.must_equal 'infinity'
+    c.new(:time=>'-infinity').time.must_equal '-infinity'
+    c.new(:time=>1.0/0.0).time.must_equal 1.0/0.0
+    c.new(:time=>-1.0/0.0).time.must_equal(-1.0/0.0)
+  end
+
+  it "should handle infinite dates if convert_infinite_timestamps is set" do
+    @d.insert(:date=>Sequel.cast('infinity', Date))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(:date).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(:date).must_equal 'infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(:date).must_equal 1.0/0.0
+
+    @d.update(:date=>Sequel.cast('-infinity', :timestamp))
+    @db.convert_infinite_timestamps = :nil
+    @db[:test3].get(:date).must_be_nil
+    @db.convert_infinite_timestamps = :string
+    @db[:test3].get(:date).must_equal '-infinity'
+    @db.convert_infinite_timestamps = :float
+    @db[:test3].get(:date).must_equal(-1.0/0.0)
+  end
+
+  it "should handle conversions from infinite strings/floats in models" do
+    c = Class.new(Sequel::Model(:test3))
+    @db.convert_infinite_timestamps = :float
+    c.new(:date=>'infinity').date.must_equal 'infinity'
+    c.new(:date=>'-infinity').date.must_equal '-infinity'
+    c.new(:date=>1.0/0.0).date.must_equal 1.0/0.0
+    c.new(:date=>-1.0/0.0).date.must_equal(-1.0/0.0)
   end
 
   it "explain and analyze should not raise errors" do
@@ -952,7 +929,6 @@ describe "A PostgreSQL database" do
   before do
     @db = DB
     @db.drop_table?(:posts)
-    @db.sqls.clear
   end
   after do
     @db.drop_table?(:posts)
@@ -985,12 +961,7 @@ describe "A PostgreSQL database" do
 
   it "should support opclass specification" do
     @db.create_table(:posts){text :title; text :body; integer :user_id; index(:user_id, :opclass => :int4_ops, :type => :btree)}
-    check_sqls do
-      @db.sqls.must_equal [
-      'CREATE TABLE "posts" ("title" text, "body" text, "user_id" integer)',
-      'CREATE INDEX "posts_user_id_index" ON "posts" USING btree ("user_id" int4_ops)'
-      ]
-    end
+    proc{@db.create_table(:posts){text :title; text :body; integer :user_id; index(:user_id, :opclass => :bogus_opclass, :type => :btree)}}.must_raise Sequel::DatabaseError
   end
 
   it "should support fulltext indexes and searching" do
@@ -1035,52 +1006,25 @@ describe "A PostgreSQL database" do
 
   it "should support spatial indexes" do
     @db.create_table(:posts){box :geom; spatial_index [:geom]}
-    check_sqls do
-      @db.sqls.must_equal [
-        'CREATE TABLE "posts" ("geom" box)',
-        'CREATE INDEX "posts_geom_index" ON "posts" USING gist ("geom")'
-      ]
-    end
   end
 
   it "should support indexes with index type" do
     @db.create_table(:posts){point :p; index :p, :type => 'gist'}
-    check_sqls do
-      @db.sqls.must_equal [
-        'CREATE TABLE "posts" ("p" point)',
-        'CREATE INDEX "posts_p_index" ON "posts" USING gist ("p")'
-      ]
-    end
   end
 
   it "should support unique indexes with index type" do
-    @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'btree', :unique => true}
-    check_sqls do
-      @db.sqls.must_equal [
-        'CREATE TABLE "posts" ("title" varchar(5))',
-        'CREATE UNIQUE INDEX "posts_title_index" ON "posts" USING btree ("title")'
-      ]
-    end
+    @db.create_table(:posts){varchar :title, :size => 5; index :title, :type => 'btree', :unique => true, :name=>:post_index_foo}
+    @db.indexes(:posts).length.must_equal 1
+    @db.indexes(:posts)[:post_index_foo][:unique].must_equal true
   end
 
   it "should support partial indexes" do
     @db.create_table(:posts){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
-    check_sqls do
-      @db.sqls.must_equal [
-        'CREATE TABLE "posts" ("title" varchar(5))',
-        'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
-      ]
-    end
   end
 
-  it "should support identifiers for table names in indicies" do
-    @db.create_table(Sequel::SQL::Identifier.new(:posts)){varchar :title, :size => 5; index :title, :where => {:title => '5'}}
-    check_sqls do
-      @db.sqls.must_equal [
-        'CREATE TABLE "posts" ("title" varchar(5))',
-        'CREATE INDEX "posts_title_index" ON "posts" ("title") WHERE ("title" = \'5\')'
-      ]
-    end
+  it "should support identifiers for table names when creating indexes" do
+    @db.create_table(Sequel::SQL::Identifier.new(:posts)){varchar :title, :size => 5; index :title}
+    @db.indexes(:posts).length.must_equal 1
   end
 
   it "should support renaming tables" do
@@ -1100,7 +1044,6 @@ describe "Postgres::Dataset#import" do
   before do
     @db = DB
     @db.create_table!(:test){primary_key :x; Integer :y}
-    @db.sqls.clear
     @ds = @db[:test]
   end
   after do
@@ -1109,9 +1052,6 @@ describe "Postgres::Dataset#import" do
 
   it "#import should a single insert statement" do
     @ds.import([:x, :y], [[1, 2], [3, 4]])
-    check_sqls do
-      @db.sqls.must_equal ['BEGIN', 'INSERT INTO "test" ("x", "y") VALUES (1, 2), (3, 4)', 'COMMIT']
-    end
     @ds.all.must_equal [{:x=>1, :y=>2}, {:x=>3, :y=>4}]
   end
 
@@ -1135,7 +1075,6 @@ describe "Postgres::Dataset#insert" do
   before do
     @db = DB
     @db.create_table!(:test5){primary_key :xid; Integer :value}
-    @db.sqls.clear
     @ds = @db[:test5]
   end
   after do
@@ -1153,11 +1092,8 @@ describe "Postgres::Dataset#insert" do
     @ds.all.must_equal [{:xid=>1, :value=>10}]
   end
 
-  it "should use INSERT RETURNING" do
+  it "should have insert return primary key value" do
     @ds.insert(:value=>10).must_equal 1
-    check_sqls do
-      @db.sqls.last.must_equal 'INSERT INTO "test5" ("value") VALUES (10) RETURNING "xid"'
-    end
   end
 
   it "should have insert_select insert the record and return the inserted record" do
@@ -1234,7 +1170,7 @@ describe "Postgres::Database schema qualified tables" do
     @db.create_table(Sequel[:schema_test][:domains]){integer :i}
     sch = @db.schema(Sequel[:schema_test][:domains])
     cs = sch.map{|x| x.first}
-    cs.must_include(:i)
+    cs.first.must_equal :i
     cs.wont_include(:data_type)
   end
 
@@ -1243,7 +1179,7 @@ describe "Postgres::Database schema qualified tables" do
     @db.create_table(Sequel[:schema_test][:domains]){integer :i}
     sch = @db.schema(:domains, :schema=>:schema_test)
     cs = sch.map{|x| x.first}
-    cs.must_include(:i)
+    cs.first.must_equal :i
     cs.wont_include(:d)
     @db.drop_table(:domains)
   end
@@ -1519,19 +1455,19 @@ if DB.server_version >= 80300
     it "should search by indexed column" do
       record =  {:title => "oopsla conference", :body => "test"}
       @ds.insert(record)
-      @ds.full_text_search(:title, "oopsla").all.must_include(record)
+      @ds.full_text_search(:title, "oopsla").all.must_equal [record]
     end
 
     it "should join multiple coumns with spaces to search by last words in row" do
       record = {:title => "multiple words", :body => "are easy to search"}
       @ds.insert(record)
-      @ds.full_text_search([:title, :body], "words").all.must_include(record)
+      @ds.full_text_search([:title, :body], "words").all.must_equal [record]
     end
 
     it "should return rows with a NULL in one column if a match in another column" do
       record = {:title => "multiple words", :body =>nil}
       @ds.insert(record)
-      @ds.full_text_search([:title, :body], "words").all.must_include(record)
+      @ds.full_text_search([:title, :body], "words").all.must_equal [record]
     end
   end
 end
@@ -1580,47 +1516,34 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
 
   it "#create_function and #drop_function should create and drop functions" do
     proc{@d['SELECT tf()'].all}.must_raise(Sequel::DatabaseError)
-    args = ['tf', 'SELECT 1', {:returns=>:integer}]
-    @d.send(:create_function_sql, *args).must_match(/\A\s*CREATE FUNCTION tf\(\)\s+RETURNS integer\s+LANGUAGE SQL\s+AS 'SELECT 1'\s*\z/)
-    @d.create_function(*args)
+    @d.create_function('tf', 'SELECT 1', :returns=>:integer)
     @d['SELECT tf()'].all.must_equal [{:tf=>1}]
-    @d.send(:drop_function_sql, 'tf').must_equal 'DROP FUNCTION tf()'
     @d.drop_function('tf')
     proc{@d['SELECT tf()'].all}.must_raise(Sequel::DatabaseError)
   end
 
   it "#create_function and #drop_function should support options" do
     args = ['tf', 'SELECT $1 + $2', {:args=>[[:integer, :a], :integer], :replace=>true, :returns=>:integer, :language=>'SQL', :behavior=>:immutable, :strict=>true, :security_definer=>true, :cost=>2, :set=>{:search_path => 'public'}}]
-    @d.send(:create_function_sql,*args).must_match(/\A\s*CREATE OR REPLACE FUNCTION tf\(a integer, integer\)\s+RETURNS integer\s+LANGUAGE SQL\s+IMMUTABLE\s+STRICT\s+SECURITY DEFINER\s+COST 2\s+SET search_path = public\s+AS 'SELECT \$1 \+ \$2'\s*\z/)
     @d.create_function(*args)
     # Make sure replace works
     @d.create_function(*args)
     @d['SELECT tf(1, 2)'].all.must_equal [{:tf=>3}]
     args = ['tf', {:if_exists=>true, :cascade=>true, :args=>[[:integer, :a], :integer]}]
-    @d.send(:drop_function_sql,*args).must_equal 'DROP FUNCTION IF EXISTS tf(a integer, integer) CASCADE'
     @d.drop_function(*args)
     # Make sure if exists works
     @d.drop_function(*args)
   end
 
   it "#create_language and #drop_language should create and drop languages" do
-    @d.send(:create_language_sql, :plpgsql).must_equal 'CREATE LANGUAGE plpgsql'
     @d.create_language(:plpgsql, :replace=>true) if @d.server_version < 90000
     proc{@d.create_language(:plpgsql)}.must_raise(Sequel::DatabaseError)
-    @d.send(:drop_language_sql, :plpgsql).must_equal 'DROP LANGUAGE plpgsql'
     @d.drop_language(:plpgsql) if @d.server_version < 90000
     proc{@d.drop_language(:plpgsql)}.must_raise(Sequel::DatabaseError) if @d.server_version < 90000
-    @d.send(:create_language_sql, :plpgsql, :replace=>true, :trusted=>true, :handler=>:a, :validator=>:b).must_equal(@d.server_version >= 90000 ? 'CREATE OR REPLACE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b' : 'CREATE TRUSTED LANGUAGE plpgsql HANDLER a VALIDATOR b')
-    @d.send(:drop_language_sql, :plpgsql, :if_exists=>true, :cascade=>true).must_equal 'DROP LANGUAGE IF EXISTS plpgsql CASCADE'
     # Make sure if exists works
     @d.drop_language(:plpgsql, :if_exists=>true, :cascade=>true) if @d.server_version < 90000
   end
 
   it "#create_schema and #drop_schema should create and drop schemas" do
-    @d.send(:create_schema_sql, :sequel).must_equal 'CREATE SCHEMA "sequel"'
-    @d.send(:create_schema_sql, :sequel, :if_not_exists=>true, :owner=>:foo).must_equal 'CREATE SCHEMA IF NOT EXISTS "sequel" AUTHORIZATION "foo"'
-    @d.send(:drop_schema_sql, :sequel).must_equal 'DROP SCHEMA "sequel"'
-    @d.send(:drop_schema_sql, :sequel, :if_exists=>true, :cascade=>true).must_equal 'DROP SCHEMA IF EXISTS "sequel" CASCADE'
     @d.create_schema(:sequel)
     @d.create_schema(:sequel, :if_not_exists=>true) if @d.server_version >= 90300
     @d.create_table(Sequel[:sequel][:test]){Integer :a}
@@ -1630,7 +1553,6 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
   it "#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).must_equal '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)
@@ -1639,15 +1561,11 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
     @d[:test].filter(:name=>'a').all.must_equal [{:name=>'a', :value=>1}]
     @d[:test].filter(:name=>'a').update(:value=>3)
     @d[:test].filter(:name=>'a').all.must_equal [{:name=>'a', :value=>3}]
-    @d.send(:drop_trigger_sql, :test, :identity).must_equal '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']).must_equal 'CREATE TRIGGER identity AFTER INSERT ON "test" EXECUTE PROCEDURE tf(1, \'a\')'
-    @d.send(:drop_trigger_sql, :test, :identity, :if_exists=>true, :cascade=>true).must_equal 'DROP TRIGGER IF EXISTS identity ON "test" CASCADE'
     # Make sure if exists works
     @d.drop_trigger(:test, :identity, :if_exists=>true, :cascade=>true)
 
     if @d.supports_trigger_conditions?
-      @d.send(:create_trigger_sql, :test, :identity, :tf, :each_row=>true, :when=> {Sequel[:new][:name] => 'b'}).must_equal %q{CREATE TRIGGER identity BEFORE INSERT OR UPDATE OR DELETE ON "test" FOR EACH ROW WHEN ("new"."name" = 'b') EXECUTE PROCEDURE tf()}
       @d.create_trigger(:test, :identity, :tf, :each_row=>true, :events => :update, :when=> {Sequel[:new][:name] => 'b'})
       @d[:test].filter(:name=>'a').update(:value=>nil)
       @d[:test].filter(:name=>'a').all.must_equal [{:name=>'a', :value=>nil}]
@@ -1663,7 +1581,6 @@ if DB.adapter_scheme == :postgres
     before(:all) do
       @db = DB
       @db.create_table!(:test_cursor){Integer :x}
-      @db.sqls.clear
       @ds = @db[:test_cursor]
       @db.transaction{1001.times{|i| @ds.insert(i)}}
     end
@@ -1687,23 +1604,19 @@ if DB.adapter_scheme == :postgres
     end
 
     it "should respect the :rows_per_fetch option" do
-      @db.sqls.clear
+      i = 0
+      @ds = @ds.with_extend{define_method(:execute){|*a, &block| i+=1; super(*a, &block);}}
       @ds.use_cursor.all
-      check_sqls do
-        @db.sqls.length.must_equal 6
-        @db.sqls.clear
-      end
+      i.must_equal 2
+
+      i = 0
       @ds.use_cursor(:rows_per_fetch=>100).all
-      check_sqls do
-        @db.sqls.length.must_equal 15
-      end
+      i.must_equal 11
     end
 
     it "should respect the :hold=>true option for creating the cursor WITH HOLD and not using a transaction" do
       @ds.use_cursor.each{@db.in_transaction?.must_equal true}
-      check_sqls{@db.sqls.any?{|s| s =~ /WITH HOLD/}.must_equal false}
       @ds.use_cursor(:hold=>true).each{@db.in_transaction?.must_equal false}
-      check_sqls{@db.sqls.any?{|s| s =~ /WITH HOLD/}.must_equal true}
     end
 
     it "should support updating individual rows based on a cursor" do
@@ -1777,39 +1690,6 @@ if DB.adapter_scheme == :postgres
       @db[:foo].get(:bar).must_equal 'foo'.reverse
     end
   end
-
-  describe "Postgres::PG_NAMED_TYPES" do
-    before(:all) do
-      deprecated do
-        @db = DB
-        @cp = @db.conversion_procs.dup
-        @db.conversion_procs.delete(1013)
-        Sequel::Postgres::PG_NAMED_TYPES[:oidvector] = lambda{|v| v.reverse}
-        @db.reset_conversion_procs
-        @db.register_array_type('oidvector')
-      end
-    end
-    after(:all) do
-      deprecated do
-        Sequel::Postgres::PG_NAMED_TYPES.delete(:oidvector)
-        @db.conversion_procs.replace(@cp)
-        @db.drop_table?(:foo)
-        @db.drop_enum(:foo_enum) rescue nil
-      end
-    end
-
-    deprecated "should look up conversion procs by name" do
-      @db.create_table!(:foo){oidvector :bar}
-      @db[:foo].insert(Sequel.cast('21', :oidvector))
-      @db[:foo].get(:bar).must_equal '12'
-    end
-
-    deprecated "should handle array types of named types" do
-      @db.create_table!(:foo){column :bar, 'oidvector[]'}
-      @db[:foo].insert(Sequel.pg_array(['21'], :oidvector))
-      @db[:foo].get(:bar).must_equal ['12']
-    end
-  end
 end
 
 if uses_pg_or_jdbc && DB.server_version >= 90000
@@ -1892,6 +1772,31 @@ if uses_pg_or_jdbc && DB.server_version >= 90000
     end
   end
 
+  describe "Postgres::Database#copy_into using UTF-8 encoding" do
+    before(:all) do
+      @db = DB
+      @db.create_table!(:test_copy){String :t}
+      @ds = @db[:test_copy].order(:t)
+    end
+    before do
+      @db[:test_copy].delete
+    end
+    after(:all) do
+      @db.drop_table?(:test_copy)
+    end
+
+    it "should work with UTF-8 characters using the :data option" do
+      @db.copy_into(:test_copy, :data=>(["\u00E4\n"]*2))
+      @ds.select_map([:t]).map{|a| a.map{|s| s.force_encoding('UTF-8')}}.must_equal([["\u00E4"]] * 2)
+    end
+
+    it "should work with UTF-8 characters using a block" do
+      buf = (["\u00E4\n"]*2)
+      @db.copy_into(:test_copy){buf.shift}
+      @ds.select_map([:t]).map{|a| a.map{|s| s.force_encoding('UTF-8')}}.must_equal([["\u00E4"]] * 2)
+    end
+  end
+
   describe "Postgres::Database#copy_table" do
     before(:all) do
       @db = DB
@@ -1972,7 +1877,6 @@ if uses_pg_or_jdbc && DB.server_version >= 90000
       e.wrapped_exception.must_be_kind_of ArgumentError
       e.message.must_include "foo"
     end
-
   end
 end
 
@@ -2076,56 +1980,35 @@ describe 'PostgreSQL special float handling' do
   before do
     @db = DB
     @db.create_table!(:test5){Float :value}
-    @db.sqls.clear
     @ds = @db[:test5]
   end
   after do
     @db.drop_table?(:test5)
   end
 
-  check_sqls do
-    it 'should quote NaN' do
-      nan = 0.0/0.0
-      @ds.insert_sql(:value => nan).must_equal %q{INSERT INTO "test5" ("value") VALUES ('NaN')}
-    end
-
-    it 'should quote +Infinity' do
-      inf = 1.0/0.0
-      @ds.insert_sql(:value => inf).must_equal %q{INSERT INTO "test5" ("value") VALUES ('Infinity')}
-    end
-
-    it 'should quote -Infinity' do
-      inf = -1.0/0.0
-      @ds.insert_sql(:value => inf).must_equal %q{INSERT INTO "test5" ("value") VALUES ('-Infinity')}
-    end
+  it 'inserts NaN' do
+    nan = 0.0/0.0
+    @ds.insert(:value=>nan)
+    @ds.all[0][:value].nan?.must_equal true
   end
 
-  if DB.adapter_scheme == :postgres
-    it 'inserts NaN' do
-      nan = 0.0/0.0
-      @ds.insert(:value=>nan)
-      @ds.all[0][:value].nan?.must_equal true
-    end
-
-    it 'inserts +Infinity' do
-      inf = 1.0/0.0
-      @ds.insert(:value=>inf)
-      @ds.all[0][:value].infinite?.must_be :>,  0
-    end
+  it 'inserts +Infinity' do
+    inf = 1.0/0.0
+    @ds.insert(:value=>inf)
+    @ds.all[0][:value].infinite?.must_be :>,  0
+  end
 
-    it 'inserts -Infinity' do
-      inf = -1.0/0.0
-      @ds.insert(:value=>inf)
-      @ds.all[0][:value].infinite?.must_be :<,  0
-    end
+  it 'inserts -Infinity' do
+    inf = -1.0/0.0
+    @ds.insert(:value=>inf)
+    @ds.all[0][:value].infinite?.must_be :<,  0
   end
-end
+end if DB.adapter_scheme == :postgres
 
 describe 'PostgreSQL array handling' do
   before(:all) do
     @db = DB
     @ds = @db[:items]
-    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
     @tp = lambda{@db.schema(:items).map{|a| a.last[:type]}}
   end
   after do
@@ -2144,27 +2027,23 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array([1], :int2), Sequel.pg_array([nil, 2], :int4), Sequel.pg_array([3, nil], :int8), Sequel.pg_array([4, nil, 4.5], :real), Sequel.pg_array([5, nil, 5.5], "double precision"))
     @ds.count.must_equal 1
     rs = @ds.all
-    if @native
-      rs.must_equal [{: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.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs.must_equal [{: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.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
 
     @ds.delete
     @ds.insert(Sequel.pg_array([[1], [2]], :int2), Sequel.pg_array([[nil, 2], [3, 4]], :int4), Sequel.pg_array([[3, nil], [nil, nil]], :int8), Sequel.pg_array([[4, nil], [nil, 4.5]], :real), Sequel.pg_array([[5, nil], [nil, 5.5]], "double precision"))
 
     rs = @ds.all
-    if @native
-      rs.must_equal [{: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.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs.must_equal [{: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.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'insert and retrieve decimal arrays' do
@@ -2175,26 +2054,22 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array([BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')], :numeric))
     @ds.count.must_equal 1
     rs = @ds.all
-    if @native
-      rs.must_equal [{:n=>[BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')]}]
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs.must_equal [{:n=>[BigDecimal.new('1.000000000000000000001'), nil, BigDecimal.new('1')]}]
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
 
     @ds.delete
     @ds.insert(Sequel.pg_array([[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]], :numeric))
     rs = @ds.all
-    if @native
-      rs.must_equal [{:n=>[[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]]}]
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs.must_equal [{:n=>[[BigDecimal.new('1.0000000000000000000000000000001'), nil], [nil, BigDecimal.new('1')]]}]
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'insert and retrieve string arrays' do
@@ -2207,26 +2082,22 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array(['a', nil, 'NULL', 'b"\'c'], 'char(4)'), Sequel.pg_array(['a', nil, 'NULL', 'b"\'c', '', ''], :varchar), Sequel.pg_array(['a', nil, 'NULL', 'b"\'c'], :text))
     @ds.count.must_equal 1
     rs = @ds.all
-    if @native
-      rs.must_equal [{:c=>['a   ', nil, 'NULL', 'b"\'c'], :vc=>['a', nil, 'NULL', 'b"\'c', '', ''], :t=>['a', nil, 'NULL', 'b"\'c']}]
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs.must_equal [{:c=>['a   ', nil, 'NULL', 'b"\'c'], :vc=>['a', nil, 'NULL', 'b"\'c', '', ''], :t=>['a', nil, 'NULL', 'b"\'c']}]
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
 
     @ds.delete
     @ds.insert(Sequel.pg_array([[['a'], [nil]], [['NULL'], ['b"\'c']]], 'char(4)'), Sequel.pg_array([[['a[],\\[\\]\\,\\""NULL",'], ['']], [['NULL'], ['b"\'c']]], :varchar), Sequel.pg_array([[['a'], [nil]], [['NULL'], ['b"\'c']]], :text))
     rs = @ds.all
-    if @native
-      rs.must_equal [{:c=>[[['a   '], [nil]], [['NULL'], ['b"\'c']]], :vc=>[[['a[],\\[\\]\\,\\""NULL",'], ['']], [['NULL'], ['b"\'c']]], :t=>[[['a'], [nil]], [['NULL'], ['b"\'c']]]}]
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs.must_equal [{:c=>[[['a   '], [nil]], [['NULL'], ['b"\'c']]], :vc=>[[['a[],\\[\\]\\,\\""NULL",'], ['']], [['NULL'], ['b"\'c']]], :t=>[[['a'], [nil]], [['NULL'], ['b"\'c']]]}]
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'insert and retrieve arrays of other types' do
@@ -2246,14 +2117,12 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array([true, false], :bool), Sequel.pg_array([d, nil], :date), Sequel.pg_array([t, nil], :time), Sequel.pg_array([ts, nil], :timestamp), Sequel.pg_array([ts, nil], :timestamptz))
     @ds.count.must_equal 1
     rs = @ds.all
-    if @native
-      rs.must_equal [{:b=>[true, false], :d=>[d, nil], :t=>[t, nil], :ts=>[ts, nil], :tstz=>[ts, nil]}]
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs.must_equal [{:b=>[true, false], :d=>[d, nil], :t=>[t, nil], :ts=>[ts, nil], :tstz=>[ts, nil]}]
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
 
     @db.create_table!(:items) do
       column :ba, 'bytea[]'
@@ -2263,15 +2132,13 @@ describe 'PostgreSQL array handling' do
     @tp.call.must_equal [:blob_array, :time_timezone_array, :oid_array]
     @ds.insert(Sequel.pg_array([Sequel.blob("a\0"), nil], :bytea), Sequel.pg_array([t, nil], :timetz), Sequel.pg_array([1, 2, 3], :oid))
     @ds.count.must_equal 1
-    if @native
-      rs = @ds.all
-      rs.must_equal [{:ba=>[Sequel.blob("a\0"), nil], :tz=>[t, nil], :o=>[1, 2, 3]}]
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs = @ds.all
+    rs.must_equal [{:ba=>[Sequel.blob("a\0"), nil], :tz=>[t, nil], :o=>[1, 2, 3]}]
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
 
     @db.create_table!(:items) do
       column :x, 'xml[]'
@@ -2295,21 +2162,19 @@ describe 'PostgreSQL array handling' do
                Sequel.pg_array(['N'], :name),
                Sequel.pg_array(['1 2'], :oidvector))
     @ds.count.must_equal 1
-    if @native
-      rs = @ds.all
-      r = rs.first
-      m = r.delete(:m)
-      m.class.must_equal(Sequel::Postgres::PGArray)
-      m.to_a.must_be_kind_of(Array)
-      m.first.must_be_kind_of(String)
-      r.must_be(:==, :x=>['<a></a>'], :b=>['1'], :vb=>['10'], :u=>['c0f24910-39e7-11e4-916c-0800200c9a66'], :xi=>['12'], :c=>['12'], :n=>['N'], :o=>['1 2'])
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      r[:m] = m
-      @ds.delete
-      @ds.insert(r)
-      @ds.all.must_equal rs
-    end
+    rs = @ds.all
+    r = rs.first
+    m = r.delete(:m)
+    m.class.must_equal(Sequel::Postgres::PGArray)
+    m.to_a.must_be_kind_of(Array)
+    m.first.must_be_kind_of(String)
+    r.must_be(:==, :x=>['<a></a>'], :b=>['1'], :vb=>['10'], :u=>['c0f24910-39e7-11e4-916c-0800200c9a66'], :xi=>['12'], :c=>['12'], :n=>['N'], :o=>['1 2'])
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    r[:m] = m
+    @ds.delete
+    @ds.insert(r)
+    @ds.all.must_equal rs
   end
 
   it 'insert and retrieve empty arrays' do
@@ -2318,15 +2183,13 @@ describe 'PostgreSQL array handling' do
     end
     @ds.insert(:n=>Sequel.pg_array([], :integer))
     @ds.count.must_equal 1
-    if @native
-      rs = @ds.all
-      rs.must_equal [{:n=>[]}]
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs = @ds.all
+    rs.must_equal [{:n=>[]}]
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'convert ruby array :default values' do
@@ -2335,15 +2198,13 @@ describe 'PostgreSQL array handling' do
     end
     @ds.insert
     @ds.count.must_equal 1
-    if @native
-      rs = @ds.all
-      rs.must_equal [{:n=>[]}]
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs = @ds.all
+    rs.must_equal [{:n=>[]}]
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'insert and retrieve custom array types' do
@@ -2372,14 +2233,12 @@ describe 'PostgreSQL array handling' do
     @ds.insert(Sequel.pg_array([int2v], :int2vector))
     @ds.count.must_equal 1
     rs = @ds.all
-    if @native
-      rs.must_equal [{:b=>[int2v]}]
-      rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
-      rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs.must_equal [{:b=>[int2v]}]
+    rs.first.values.each{|v| v.class.must_equal(Sequel::Postgres::PGArray)}
+    rs.first.values.each{|v| v.to_a.must_be_kind_of(Array)}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'retrieve arrays with explicit bounds' do
@@ -2475,7 +2334,6 @@ describe 'PostgreSQL array handling' do
       column :t, 'text[]'
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :pg_typecast_on_load, :i, :f, :d, :t unless @native
     h = {: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 = c.create(h)
     o.i.must_equal [1, 2, nil]
@@ -2494,7 +2352,6 @@ describe 'PostgreSQL array handling' do
       column :t, 'varchar[]'
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :pg_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.must_equal [1, 2, nil]
     o.f.must_equal [[1, 2.5], [3, 4.5]]
@@ -2572,11 +2429,9 @@ describe 'PostgreSQL array handling' do
       @ds.from{Sequel.pg_array([1,2,3]).op.unnest([4,5,6], [7,8]).as(:t1, [:a, :b, :c])}.select_order_map([:a, :b, :c]).must_equal [[1, 4, 7], [2, 5, 8], [3, 6, nil]]
     end
 
-    if @native
-      @ds.get(Sequel.pg_array(:i).push(4)).must_equal [1, 2, 3, 4]
-      @ds.get(Sequel.pg_array(:i).unshift(4)).must_equal [4, 1, 2, 3]
-      @ds.get(Sequel.pg_array(:i).concat(:i2)).must_equal [1, 2, 3, 2, 1]
-    end
+    @ds.get(Sequel.pg_array(:i).push(4)).must_equal [1, 2, 3, 4]
+    @ds.get(Sequel.pg_array(:i).unshift(4)).must_equal [4, 1, 2, 3]
+    @ds.get(Sequel.pg_array(:i).concat(:i2)).must_equal [1, 2, 3, 2, 1]
 
     if @db.type_supported?(:hstore)
       Sequel.extension :pg_hstore_ops
@@ -2591,7 +2446,6 @@ describe 'PostgreSQL hstore handling' do
     @db = DB
     @ds = @db[:items]
     @h = {'a'=>'b', 'c'=>nil, 'd'=>'NULL', 'e'=>'\\\\" \\\' ,=>'}
-    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after do
     @db.drop_table?(:items)
@@ -2603,17 +2457,15 @@ describe 'PostgreSQL hstore handling' do
     end
     @ds.insert(Sequel.hstore(@h))
     @ds.count.must_equal 1
-    if @native
-      rs = @ds.all
-      v = rs.first[:h]
-      v.must_equal @h
-      v.class.must_equal(Sequel::Postgres::HStore)
-      v.to_hash.must_be_kind_of(Hash)
-      v.to_hash.must_equal @h
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs = @ds.all
+    v = rs.first[:h]
+    v.must_equal @h
+    v.class.must_equal(Sequel::Postgres::HStore)
+    v.to_hash.must_be_kind_of(Hash)
+    v.to_hash.must_equal @h
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'insert and retrieve hstore[] values' do
@@ -2622,16 +2474,14 @@ describe 'PostgreSQL hstore handling' do
     end
     @ds.insert(Sequel.pg_array([Sequel.hstore(@h)], :hstore))
     @ds.count.must_equal 1
-    if @native
-      rs = @ds.all
-      v = rs.first[:h].first
-      v.class.must_equal(Sequel::Postgres::HStore)
-      v.to_hash.must_be_kind_of(Hash)
-      v.to_hash.must_equal @h
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs = @ds.all
+    v = rs.first[:h].first
+    v.class.must_equal(Sequel::Postgres::HStore)
+    v.to_hash.must_be_kind_of(Hash)
+    v.to_hash.must_equal @h
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'use hstore in bound variables' do
@@ -2673,7 +2523,6 @@ describe 'PostgreSQL hstore handling' do
     end
     Sequel.extension :pg_hstore_ops
     c.plugin :many_through_many
-    c.plugin :pg_typecast_on_load, :h unless @native
 
     h = {'item_id'=>"2", 'left_item_id'=>"1"}
     o2 = c.create(:id=>2)
@@ -2836,7 +2685,6 @@ describe 'PostgreSQL json type' do
     @ds = @db[:items]
     @a = [1, 2, {'a'=>'b'}, 3.0]
     @h = {'a'=>'b', '1'=>[3, 4, 5]}
-    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after do
     @db.drop_table?(:items)
@@ -2855,32 +2703,28 @@ describe 'PostgreSQL json type' do
       @db.create_table!(:items){column :j, json_type}
       @ds.insert(pg_json.call(@h))
       @ds.count.must_equal 1
-      if @native
-        rs = @ds.all
-        v = rs.first[:j]
-        v.class.must_equal(hash_class)
-        v.to_hash.must_be_kind_of(Hash)
-        v.must_equal @h
-        v.to_hash.must_equal @h
-        @ds.delete
-        @ds.insert(rs.first)
-        @ds.all.must_equal rs
-      end
+      rs = @ds.all
+      v = rs.first[:j]
+      v.class.must_equal(hash_class)
+      v.to_hash.must_be_kind_of(Hash)
+      v.must_equal @h
+      v.to_hash.must_equal @h
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.must_equal rs
 
       @ds.delete
       @ds.insert(pg_json.call(@a))
       @ds.count.must_equal 1
-      if @native
-        rs = @ds.all
-        v = rs.first[:j]
-        v.class.must_equal(array_class)
-        v.to_a.must_be_kind_of(Array)
-        v.must_equal @a
-        v.to_a.must_equal @a
-        @ds.delete
-        @ds.insert(rs.first)
-        @ds.all.must_equal rs
-      end
+      rs = @ds.all
+      v = rs.first[:j]
+      v.class.must_equal(array_class)
+      v.to_a.must_be_kind_of(Array)
+      v.must_equal @a
+      v.to_a.must_equal @a
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.must_equal rs
     end
 
     it 'insert and retrieve json[] values' do
@@ -2888,17 +2732,15 @@ describe 'PostgreSQL json type' do
       j = Sequel.pg_array([pg_json.call('a'=>1), pg_json.call(['b', 2])])
       @ds.insert(j)
       @ds.count.must_equal 1
-      if @native
-        rs = @ds.all
-        v = rs.first[:j]
-        v.class.must_equal(Sequel::Postgres::PGArray)
-        v.to_a.must_be_kind_of(Array)
-        v.must_equal j
-        v.to_a.must_equal j
-        @ds.delete
-        @ds.insert(rs.first)
-        @ds.all.must_equal rs
-      end
+      rs = @ds.all
+      v = rs.first[:j]
+      v.class.must_equal(Sequel::Postgres::PGArray)
+      v.to_a.must_be_kind_of(Array)
+      v.must_equal j
+      v.to_a.must_equal j
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.must_equal rs
     end
 
     it 'with models' do
@@ -2907,7 +2749,6 @@ describe 'PostgreSQL json type' do
         column :h, json_type
       end
       c = Class.new(Sequel::Model(@db[:items]))
-      c.plugin :pg_typecast_on_load, :h unless @native
       c.create(:h=>pg_json.call(@h)).h.must_equal @h
       c.create(:h=>pg_json.call(@a)).h.must_equal @a
     end
@@ -3039,7 +2880,6 @@ describe 'PostgreSQL inet/cidr types' do
       @ipv6 = IPAddr.new(@v6)
       @ipv6nm = IPAddr.new(@v6nm)
     end
-    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after do
     @db.drop_table?(:items)
@@ -3049,51 +2889,45 @@ describe 'PostgreSQL inet/cidr types' do
     @db.create_table!(:items){inet :i; cidr :c}
     @ds.insert(@ipv4, @ipv4nm)
     @ds.count.must_equal 1
-    if @native
+    rs = @ds.all
+    rs.first[:i].must_equal @ipv4
+    rs.first[:c].must_equal @ipv4nm
+    rs.first[:i].must_be_kind_of(IPAddr)
+    rs.first[:c].must_be_kind_of(IPAddr)
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
+
+    unless ipv6_broken
+      @ds.delete
+      @ds.insert(@ipv6, @ipv6nm)
+      @ds.count.must_equal 1
       rs = @ds.all
-      rs.first[:i].must_equal @ipv4
-      rs.first[:c].must_equal @ipv4nm
+      rs.first[:j]
+      rs.first[:i].must_equal @ipv6
+      rs.first[:c].must_equal @ipv6nm
       rs.first[:i].must_be_kind_of(IPAddr)
       rs.first[:c].must_be_kind_of(IPAddr)
       @ds.delete
       @ds.insert(rs.first)
       @ds.all.must_equal rs
     end
-
-    unless ipv6_broken
-      @ds.delete
-      @ds.insert(@ipv6, @ipv6nm)
-      @ds.count.must_equal 1
-      if @native
-        rs = @ds.all
-        rs.first[:j]
-        rs.first[:i].must_equal @ipv6
-        rs.first[:c].must_equal @ipv6nm
-        rs.first[:i].must_be_kind_of(IPAddr)
-        rs.first[:c].must_be_kind_of(IPAddr)
-        @ds.delete
-        @ds.insert(rs.first)
-        @ds.all.must_equal rs
-      end
-    end
   end
 
   it 'insert and retrieve inet/cidr/macaddr array values' do
     @db.create_table!(:items){column :i, 'inet[]'; column :c, 'cidr[]'; column :m, 'macaddr[]'}
     @ds.insert(Sequel.pg_array([@ipv4], 'inet'), Sequel.pg_array([@ipv4nm], 'cidr'), Sequel.pg_array(['12:34:56:78:90:ab'], 'macaddr'))
     @ds.count.must_equal 1
-    if @native
-      rs = @ds.all
-      rs.first.values.all?{|c| c.is_a?(Sequel::Postgres::PGArray)}.must_equal true
-      rs.first[:i].first.must_equal @ipv4
-      rs.first[:c].first.must_equal @ipv4nm
-      rs.first[:m].first.must_equal '12:34:56:78:90:ab'
-      rs.first[:i].first.must_be_kind_of(IPAddr)
-      rs.first[:c].first.must_be_kind_of(IPAddr)
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs = @ds.all
+    rs.first.values.all?{|c| c.is_a?(Sequel::Postgres::PGArray)}.must_equal true
+    rs.first[:i].first.must_equal @ipv4
+    rs.first[:c].first.must_equal @ipv4nm
+    rs.first[:m].first.must_equal '12:34:56:78:90:ab'
+    rs.first[:i].first.must_be_kind_of(IPAddr)
+    rs.first[:c].first.must_be_kind_of(IPAddr)
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'use ipaddr in bound variables' do
@@ -3129,7 +2963,6 @@ describe 'PostgreSQL inet/cidr types' do
       cidr :c
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :pg_typecast_on_load, :i, :c unless @native
     c.create(:i=>@v4, :c=>@v4nm).values.values_at(:i, :c).must_equal [@ipv4, @ipv4nm]
     unless ipv6_broken
       c.create(:i=>@ipv6, :c=>@ipv6nm).values.values_at(:i, :c).must_equal [@ipv6, @ipv6nm]
@@ -3211,7 +3044,6 @@ describe 'PostgreSQL range types' do
     @r.each{|k, v| @ra[k] = Sequel.pg_array([v], @map[k])}
     @r.each{|k, v| @pgr[k] = Sequel.pg_range(v)}
     @r.each{|k, v| @pgra[k] = Sequel.pg_array([Sequel.pg_range(v)], @map[k])}
-    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after do
     @db.drop_table?(:items)
@@ -3224,19 +3056,17 @@ describe 'PostgreSQL range types' do
       input.each{|k, v| h[k] = Sequel.cast(v, @map[k])}
       @ds.insert(h)
       @ds.count.must_equal 1
-      if @native
-        rs = @ds.all
-        rs.first.each do |k, v|
-          v.class.must_equal(Sequel::Postgres::PGRange)
-          v.to_range.must_be_kind_of(Range)
-          v.must_be :==, @r[k]
-          v.to_range.must_equal @r[k]
-        end
-        @ds.delete
-        @ds.insert(rs.first)
-        @ds.all.must_equal rs
+      rs = @ds.all
+      rs.first.each do |k, v|
+        v.class.must_equal(Sequel::Postgres::PGRange)
+        v.to_range.must_be_kind_of(Range)
+        v.must_be :==, @r[k]
+        v.to_range.must_equal @r[k]
       end
       @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.must_equal rs
+      @ds.delete
     end
   end
 
@@ -3245,21 +3075,19 @@ describe 'PostgreSQL range types' do
     [@ra, @pgra].each do |input|
       @ds.insert(input)
       @ds.count.must_equal 1
-      if @native
-        rs = @ds.all
-        rs.first.each do |k, v|
-          v.class.must_equal(Sequel::Postgres::PGArray)
-          v.to_a.must_be_kind_of(Array)
-          v.first.class.must_equal(Sequel::Postgres::PGRange)
-          v.first.to_range.must_be_kind_of(Range)
-          v.must_be :==, @ra[k].to_a
-          v.first.must_be :==, @r[k]
-        end
-        @ds.delete
-        @ds.insert(rs.first)
-        @ds.all.must_equal rs
+      rs = @ds.all
+      rs.first.each do |k, v|
+        v.class.must_equal(Sequel::Postgres::PGArray)
+        v.to_a.must_be_kind_of(Array)
+        v.first.class.must_equal(Sequel::Postgres::PGRange)
+        v.first.to_range.must_be_kind_of(Range)
+        v.must_be :==, @ra[k].to_a
+        v.first.must_be :==, @r[k]
       end
       @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.must_equal rs
+      @ds.delete
     end
   end
 
@@ -3288,14 +3116,12 @@ describe 'PostgreSQL range types' do
   it 'with models' do
     @db.create_table!(:items){primary_key :id; int4range :i4; int8range :i8; numrange :n; daterange :d; tsrange :t; tstzrange :tz}
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :pg_typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
     v = c.create(@r).values
     v.delete(:id)
     v.must_be :==, @r
 
     @db.create_table!(:items){primary_key :id; column :i4, 'int4range[]'; column :i8, 'int8range[]'; column :n, 'numrange[]'; column :d, 'daterange[]'; column :t, 'tsrange[]'; column :tz, 'tstzrange[]'}
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :pg_typecast_on_load, :i4, :i8, :n, :d, :t, :tz unless @native
     v = c.create(@ra).values
     v.delete(:id)
     v.each{|k,v1| v1.must_be :==, @ra[k].to_a}
@@ -3304,10 +3130,8 @@ describe 'PostgreSQL range types' do
   it 'works with current_datetime_timestamp extension' do
     ds = @db.dataset.extension(:current_datetime_timestamp)
     tsr = ds.get(Sequel.pg_range(ds.current_datetime..ds.current_datetime, :tstzrange))
-    if @native
-      tsr.begin.must_be_kind_of Time
-      tsr.end.must_be_kind_of Time
-    end
+    tsr.begin.must_be_kind_of Time
+    tsr.end.must_be_kind_of Time
   end
 
   it 'operations/functions with pg_range_ops' do
@@ -3384,10 +3208,6 @@ describe 'PostgreSQL interval types' do
   before(:all) do
     @db = DB
     @ds = @db[:items]
-    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
-  end
-  after(:all) do
-    Sequel::Postgres::PG__TYPES.delete(1186) # SEQUEL5: Remove
   end
   after do
     @db.drop_table?(:items)
@@ -3417,16 +3237,14 @@ describe 'PostgreSQL interval types' do
     ].each do |instr, outstr, value, parts|
       @ds.insert(instr)
       @ds.count.must_equal 1
-      if @native
-        @ds.get(Sequel.cast(:i, String)).must_equal outstr
-        rs = @ds.all
-        rs.first[:i].is_a?(ActiveSupport::Duration).must_equal true
-        rs.first[:i].must_equal ActiveSupport::Duration.new(value, parts)
-        rs.first[:i].parts.sort_by{|k,v| k.to_s}.reject{|k,v| v == 0}.must_equal parts.sort_by{|k,v| k.to_s}
-        @ds.delete
-        @ds.insert(rs.first)
-        @ds.all.must_equal rs
-      end
+      @ds.get(Sequel.cast(:i, String)).must_equal outstr
+      rs = @ds.all
+      rs.first[:i].is_a?(ActiveSupport::Duration).must_equal true
+      rs.first[:i].must_equal ActiveSupport::Duration.new(value, parts)
+      rs.first[:i].parts.sort_by{|k,v| k.to_s}.reject{|k,v| v == 0}.must_equal parts.sort_by{|k,v| k.to_s}
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.must_equal rs
       @ds.delete
     end
   end
@@ -3435,16 +3253,14 @@ describe 'PostgreSQL interval types' do
     @db.create_table!(:items){column :i, 'interval[]'}
     @ds.insert(Sequel.pg_array(['1 year 2 months 3 weeks 4 days 5 hours 6 minutes 7 seconds'], 'interval'))
     @ds.count.must_equal 1
-    if @native
-      rs = @ds.all
-      rs.first[:i].is_a?(Sequel::Postgres::PGArray).must_equal true
-      rs.first[:i].first.is_a?(ActiveSupport::Duration).must_equal true
-      rs.first[:i].first.must_equal ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
-      rs.first[:i].first.parts.sort_by{|k,v| k.to_s}.must_equal [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]].sort_by{|k,v| k.to_s}
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
-    end
+    rs = @ds.all
+    rs.first[:i].is_a?(Sequel::Postgres::PGArray).must_equal true
+    rs.first[:i].first.is_a?(ActiveSupport::Duration).must_equal true
+    rs.first[:i].first.must_equal ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
+    rs.first[:i].first.parts.sort_by{|k,v| k.to_s}.must_equal [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]].sort_by{|k,v| k.to_s}
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
   end
 
   it 'use intervals in bound variables' do
@@ -3472,7 +3288,6 @@ describe 'PostgreSQL interval types' do
       interval :i
     end
     c = Class.new(Sequel::Model(@db[:items]))
-    c.plugin :pg_typecast_on_load, :i, :c unless @native
     v = c.create(:i=>'1 year 2 mons 25 days 05:06:07').i
     v.is_a?(ActiveSupport::Duration).must_equal true
     v.must_equal ActiveSupport::Duration.new(31557600 + 2*86400*30 + 3*86400*7 + 4*86400 + 5*3600 + 6*60 + 7, [[:years, 1], [:months, 2], [:days, 25], [:seconds, 18367]])
@@ -3504,8 +3319,6 @@ describe 'PostgreSQL row-valued/composite types' do
     @db.register_row_type(Sequel.qualify(:public, :person))
     @db.register_row_type(Sequel[:public][:company])
     @new_oids = @db.conversion_procs.keys - oids
-
-    @native = DB.adapter_scheme == :postgres || DB.adapter_scheme == :jdbc
   end
   after(:all) do
     @new_oids.each{|oid| @db.conversion_procs.delete(oid)}
@@ -3519,22 +3332,20 @@ describe 'PostgreSQL row-valued/composite types' do
   it 'insert and retrieve row types' do
     @ds.insert(:id=>1, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345']))
     @ds.count.must_equal 1
-    if @native
-      # Single row valued type
-      rs = @ds.all
-      v = rs.first[:address]
-      v.class.superclass.must_equal(Sequel::Postgres::PGRow::HashRow)
-      v.to_hash.must_be_kind_of(Hash)
-      v.to_hash.must_equal(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345')
-      @ds.delete
-      @ds.insert(rs.first)
-      @ds.all.must_equal rs
+    # Single row valued type
+    rs = @ds.all
+    v = rs.first[:address]
+    v.class.superclass.must_equal(Sequel::Postgres::PGRow::HashRow)
+    v.to_hash.must_be_kind_of(Hash)
+    v.to_hash.must_equal(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345')
+    @ds.delete
+    @ds.insert(rs.first)
+    @ds.all.must_equal rs
 
-      # Nested row value type
-      p = @ds.get(:person)
-      p[:id].must_equal 1
-      p[:address].must_equal v
-    end
+    # Nested row value type
+    p = @ds.get(:person)
+    p[:id].must_equal 1
+    p[:address].must_equal v
   end
 
   it 'insert and retrieve row types containing domains' do
@@ -3559,19 +3370,17 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds = @db[:company]
     @ds.insert(:id=>1, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])]))
     @ds.count.must_equal 1
-    if @native
-      v = @ds.get(:company)
-      v.class.superclass.must_equal(Sequel::Postgres::PGRow::HashRow)
-      v.to_hash.must_be_kind_of(Hash)
-      v[:id].must_equal 1
-      employees = v[:employees]
-      employees.class.must_equal(Sequel::Postgres::PGArray)
-      employees.to_a.must_be_kind_of(Array)
-      employees.must_equal [{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}]
-      @ds.delete
-      @ds.insert(v[:id], v[:employees])
-      @ds.get(:company).must_equal v
-    end
+    v = @ds.get(:company)
+    v.class.superclass.must_equal(Sequel::Postgres::PGRow::HashRow)
+    v.to_hash.must_be_kind_of(Hash)
+    v[:id].must_equal 1
+    employees = v[:employees]
+    employees.class.must_equal(Sequel::Postgres::PGArray)
+    employees.to_a.must_be_kind_of(Array)
+    employees.must_equal [{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}]
+    @ds.delete
+    @ds.insert(v[:id], v[:employees])
+    @ds.get(:company).must_equal v
   end
 
   it 'use row types in bound variables' do
@@ -3606,11 +3415,9 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds = @db[:company]
     @ds.insert(:id=>1, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345'])])]))
     @ds.get(Sequel.pg_row(:company)[:id]).must_equal 1
-    if @native
-      @ds.get(Sequel.pg_row(:company)[:employees]).must_equal [{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}]
-      @ds.get(Sequel.pg_row(:company)[:employees][1]).must_equal(:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'})
-      @ds.get(Sequel.pg_row(:company)[:employees][1][:address]).must_equal(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345')
-    end
+    @ds.get(Sequel.pg_row(:company)[:employees]).must_equal [{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}]
+    @ds.get(Sequel.pg_row(:company)[:employees][1]).must_equal(:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'})
+    @ds.get(Sequel.pg_row(:company)[:employees][1][:address]).must_equal(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345')
     @ds.get(Sequel.pg_row(:company)[:employees][1][:id]).must_equal 1
     @ds.get(Sequel.pg_row(:company)[:employees][1][:address][:street]).must_equal '123 Sesame St'
     @ds.get(Sequel.pg_row(:company)[:employees][1][:address][:city]).must_equal 'Somewhere'
@@ -3635,22 +3442,18 @@ describe 'PostgreSQL row-valued/composite types' do
       @db[:b].select(Sequel.pg_row(:b)[:a]).first.must_equal(:a=>2)
       @db[:b].select(Sequel.pg_row(:b).splat[:a]).first.must_equal(:a=>1)
 
-      if @native
-        @db[:b].select(:b).first.must_equal(:b=>{:a=>2})
-        @db[:b].select(Sequel.pg_row(:b).splat).first.must_equal(:a=>1, :b=>{:a=>2})
-        @db[:b].select(Sequel.pg_row(:b).splat(:b)).first.must_equal(:b=>{:a=>1, :b=>{:a=>2}})
-      end
+      @db[:b].select(:b).first.must_equal(:b=>{:a=>2})
+      @db[:b].select(Sequel.pg_row(:b).splat).first.must_equal(:a=>1, :b=>{:a=>2})
+      @db[:b].select(Sequel.pg_row(:b).splat(:b)).first.must_equal(:b=>{:a=>1, :b=>{:a=>2}})
     end
 
     it "* should expand the table type into separate columns" do
       ds = @db[:b].select(Sequel.pg_row(:b).splat(:b)).from_self(:alias=>:t)
-      if @native
-        ds.first.must_equal(:b=>{:a=>1, :b=>{:a=>2}})
-        ds.select(Sequel.pg_row(:b).*).first.must_equal(:a=>1, :b=>{:a=>2})
-        ds.select(Sequel.pg_row(:b)[:b]).first.must_equal(:b=>{:a=>2})
-        ds.select(Sequel.pg_row(Sequel[:t][:b]).*).first.must_equal(:a=>1, :b=>{:a=>2})
-        ds.select(Sequel.pg_row(Sequel[:t][:b])[:b]).first.must_equal(:b=>{:a=>2})
-      end
+      ds.first.must_equal(:b=>{:a=>1, :b=>{:a=>2}})
+      ds.select(Sequel.pg_row(:b).*).first.must_equal(:a=>1, :b=>{:a=>2})
+      ds.select(Sequel.pg_row(:b)[:b]).first.must_equal(:b=>{:a=>2})
+      ds.select(Sequel.pg_row(Sequel[:t][:b]).*).first.must_equal(:a=>1, :b=>{:a=>2})
+      ds.select(Sequel.pg_row(Sequel[:t][:b])[:b]).first.must_equal(:b=>{:a=>2})
       ds.select(Sequel.pg_row(:b)[:a]).first.must_equal(:a=>1)
       ds.select(Sequel.pg_row(Sequel[:t][:b])[:a]).first.must_equal(:a=>1)
     end
@@ -3679,41 +3482,37 @@ describe 'PostgreSQL row-valued/composite types' do
     it 'insert and retrieve row types as model objects' do
       @ds.insert(:id=>1, :address=>@a)
       @ds.count.must_equal 1
-      if @native
-        # Single row valued type
-        rs = @ds.all
-        v = rs.first[:address]
-        v.must_be_kind_of(Address)
-        v.must_equal @a
-        @ds.delete
-        @ds.insert(rs.first)
-        @ds.all.must_equal rs
-
-        # Nested row value type
-        p = @ds.get(:person)
-        p.must_be_kind_of(Person)
-        p.id.must_equal 1
-        p.address.must_be_kind_of(Address)
-        p.address.must_equal @a
-      end
+      # Single row valued type
+      rs = @ds.all
+      v = rs.first[:address]
+      v.must_be_kind_of(Address)
+      v.must_equal @a
+      @ds.delete
+      @ds.insert(rs.first)
+      @ds.all.must_equal rs
+
+      # Nested row value type
+      p = @ds.get(:person)
+      p.must_be_kind_of(Person)
+      p.id.must_equal 1
+      p.address.must_be_kind_of(Address)
+      p.address.must_equal @a
     end
 
     it 'insert and retrieve arrays of row types as model objects' do
       @ds = @db[:company]
       @ds.insert(:id=>1, :employees=>@es)
       @ds.count.must_equal 1
-      if @native
-        v = @ds.get(:company)
-        v.must_be_kind_of(Company)
-        v.id.must_equal 1
-        employees = v[:employees]
-        employees.class.must_equal(Sequel::Postgres::PGArray)
-        employees.to_a.must_be_kind_of(Array)
-        employees.must_equal @es
-        @ds.delete
-        @ds.insert(v.id, v.employees)
-        @ds.get(:company).must_equal v
-      end
+      v = @ds.get(:company)
+      v.must_be_kind_of(Company)
+      v.id.must_equal 1
+      employees = v[:employees]
+      employees.class.must_equal(Sequel::Postgres::PGArray)
+      employees.to_a.must_be_kind_of(Array)
+      employees.must_equal @es
+      @ds.delete
+      @ds.insert(v.id, v.employees)
+      @ds.get(:company).must_equal v
     end
 
     it 'use model objects in bound variables' do
@@ -3732,7 +3531,6 @@ describe 'PostgreSQL row-valued/composite types' do
     end if uses_pg_or_jdbc
 
     it 'model typecasting' do
-      Person.plugin :pg_typecast_on_load, :address unless @native
       a = Address.new(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345')
       o = Person.create(:id=>1, :address=>['123 Sesame St', 'Somewhere', '12345'])
       o.address.must_equal a
@@ -3741,7 +3539,6 @@ describe 'PostgreSQL row-valued/composite types' do
       o = Person.create(:id=>1, :address=>a)
       o.address.must_equal a
 
-      Company.plugin :pg_typecast_on_load, :employees unless @native
       e = Person.new(:id=>1, :address=>a)
       o = Company.create(:id=>1, :employees=>[{:id=>1, :address=>{:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12345'}}])
       o.employees.must_equal [e]
@@ -3838,8 +3635,6 @@ end
 
 describe "PostgreSQL stored procedures for datasets" do
   before do
-    require 'sequel/adapters/utils/stored_procedures'
-
     @db = DB
     @db.create_table!(:items) do
       primary_key :id