sequel 4.49.0 → 5.0.0

data/spec/adapters/oracle_spec.rb

@@ -1,6 +1,6 @@
 SEQUEL_ADAPTER_TEST = :oracle
 
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+require_relative 'spec_helper'
 
 unless DB.opts[:autosequence]
   warn "Running oracle adapter specs without :autosequence Database option results in many errors, use the :autosequence Database option when testing"
@@ -310,12 +310,4 @@ describe "An Oracle database" do
 
     DB[:books].select(:title).group_by(:title).count.must_equal 2
   end
-
-  it "#for_update should use FOR UPDATE" do
-    DB[:books].for_update.sql.must_equal 'SELECT * FROM "BOOKS" FOR UPDATE'
-  end
-
-  it "#lock_style should accept symbols" do
-    DB[:books].lock_style(:update).sql.must_equal 'SELECT * FROM "BOOKS" FOR UPDATE'
-  end
 end

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
@@ -340,7 +327,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
 
@@ -407,7 +394,6 @@ describe "A PostgreSQL dataset" do
   end
   before do
     @d.delete
-    @db.sqls.clear
   end
   after do
     @db.drop_table?(:atest)
@@ -416,35 +402,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 +548,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 +564,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 +573,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
@@ -801,7 +738,7 @@ describe "A PostgreSQL dataset with a timestamp field" 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 +747,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)
@@ -837,13 +774,11 @@ describe "A PostgreSQL dataset with a timestamp field" do
       @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
+      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
@@ -952,7 +887,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 +919,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 +964,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 +1002,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 +1010,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 +1033,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 +1050,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 +1128,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 +1137,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 +1413,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
@@ -1663,7 +1557,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 +1580,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 +1666,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
@@ -2076,56 +1932,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 +1979,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 +2006,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 +2034,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 +2069,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 +2084,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 +2114,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 +2135,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 +2150,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 +2185,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 +2286,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 +2304,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 +2381,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 +2398,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 +2409,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 +2426,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 +2475,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 +2637,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 +2655,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 +2684,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 +2701,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 +2832,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 +2841,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 +2915,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 +2996,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 +3008,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 +3027,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 +3068,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 +3082,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 +3160,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 +3189,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 +3205,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 +3240,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 +3271,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 +3284,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 +3322,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 +3367,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 +3394,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 +3434,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 +3483,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 +3491,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 +3587,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