sequel 3.48.0 → 4.0.0

data/spec/adapters/oracle_spec.rb

@@ -1,69 +1,66 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+SEQUEL_ADAPTER_TEST = :oracle
 
-unless defined?(ORACLE_DB)
-  ORACLE_DB = Sequel.connect('oracle://hr:hr@localhost/XE')
-end
-INTEGRATION_DB = ORACLE_DB unless defined?(INTEGRATION_DB)
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
 describe "An Oracle database" do
   before(:all) do
-    ORACLE_DB.create_table!(:items) do
+    DB.create_table!(:items) do
       String :name, :size => 50
       Integer :value
       Date :date_created
       index :value
     end
 
-    ORACLE_DB.create_table!(:books) do
+    DB.create_table!(:books) do
       Integer :id
       String :title, :size => 50
       Integer :category_id
     end
 
-    ORACLE_DB.create_table!(:categories) do
+    DB.create_table!(:categories) do
       Integer :id
       String :cat_name, :size => 50
     end
-    @d = ORACLE_DB[:items]
+    @d = DB[:items]
   end
   after do
     @d.delete
   end
   after(:all) do
-    ORACLE_DB.drop_table?(:items, :books, :categories)
+    DB.drop_table?(:items, :books, :categories)
   end
 
   specify "should provide disconnect functionality" do
-    ORACLE_DB.execute("select user from dual")
-    ORACLE_DB.pool.size.should == 1
-    ORACLE_DB.disconnect
-    ORACLE_DB.pool.size.should == 0
+    DB.execute("select user from dual")
+    DB.pool.size.should == 1
+    DB.disconnect
+    DB.pool.size.should == 0
   end
 
   specify "should have working view_exists?" do
     begin
-      ORACLE_DB.view_exists?(:cats).should be_false
-      ORACLE_DB.create_view(:cats, ORACLE_DB[:categories])
-      ORACLE_DB.view_exists?(:cats).should be_true
-      om = ORACLE_DB.identifier_output_method
-      im = ORACLE_DB.identifier_input_method
-      ORACLE_DB.identifier_output_method = :reverse
-      ORACLE_DB.identifier_input_method = :reverse
-      ORACLE_DB.view_exists?(:STAC).should be_true
-      ORACLE_DB.view_exists?(:cats).should be_false
+      DB.view_exists?(:cats).should be_false
+      DB.create_view(:cats, DB[:categories])
+      DB.view_exists?(:cats).should be_true
+      om = DB.identifier_output_method
+      im = DB.identifier_input_method
+      DB.identifier_output_method = :reverse
+      DB.identifier_input_method = :reverse
+      DB.view_exists?(:STAC).should be_true
+      DB.view_exists?(:cats).should be_false
     ensure
-      ORACLE_DB.identifier_output_method = om
-      ORACLE_DB.identifier_input_method = im
-      ORACLE_DB.drop_view(:cats)
+      DB.identifier_output_method = om
+      DB.identifier_input_method = im
+      DB.drop_view(:cats)
     end
   end
 
   specify "should be able to get current sequence value with SQL" do
     begin
-      ORACLE_DB.create_table!(:foo){primary_key :id}
-      ORACLE_DB.fetch('SELECT seq_foo_id.nextval FROM DUAL').single_value.should == 1
+      DB.create_table!(:foo){primary_key :id}
+      DB.fetch('SELECT seq_foo_id.nextval FROM DUAL').single_value.should == 1
     ensure
-      ORACLE_DB.drop_table(:foo)
+      DB.drop_table(:foo)
     end
   end
   
@@ -78,19 +75,19 @@ describe "An Oracle database" do
       [:date_created, [:datetime, false, true, nil]]]
      
     {:books => books_schema, :categories => categories_schema, :items => items_schema}.each_pair do |table, expected_schema|
-      schema = ORACLE_DB.schema(table)
+      schema = DB.schema(table)
       schema.should_not be_nil
       schema.map{|c, s| [c, s.values_at(:type, :primary_key, :allow_null, :ruby_default)]}.should == expected_schema
     end
   end
   
   specify "should create a temporary table" do
-    ORACLE_DB.create_table! :test_tmp, :temp => true do
+    DB.create_table! :test_tmp, :temp => true do
       varchar2 :name, :size => 50
       primary_key :id, :integer, :null => false
       index :name, :unique => true
     end
-    ORACLE_DB.drop_table?(:test_tmp)
+    DB.drop_table?(:test_tmp)
   end
 
   specify "should return the correct record count" do
@@ -225,7 +222,7 @@ describe "An Oracle database" do
   end
   
   specify "should support transactions" do
-    ORACLE_DB.transaction do
+    DB.transaction do
       @d << {:name => 'abc', :value => 1}
     end
 
@@ -233,14 +230,14 @@ describe "An Oracle database" do
   end
 
   specify "should return correct result" do
-    @d1 = ORACLE_DB[:books]
+    @d1 = DB[:books]
     @d1.delete
     @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
     @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
     @d1 << {:id => 3, :title => 'ccc', :category_id => 101}
     @d1 << {:id => 4, :title => 'ddd', :category_id => 102}
     
-    @d2 = ORACLE_DB[:categories]
+    @d2 = DB[:categories]
     @d2.delete
     @d2 << {:id => 100, :cat_name => 'ruby'}
     @d2 << {:id => 101, :cat_name => 'rails'}
@@ -270,7 +267,7 @@ describe "An Oracle database" do
   end  
 
   specify "should allow columns to be renamed" do
-    @d1 = ORACLE_DB[:books]
+    @d1 = DB[:books]
     @d1.delete
     @d1 << {:id => 1, :title => 'aaa', :category_id => 100}
     @d1 << {:id => 2, :title => 'bbb', :category_id => 100}
@@ -284,14 +281,14 @@ describe "An Oracle database" do
   end
 
   specify "nested queries should work" do
-    ORACLE_DB[:books].select(:title).group_by(:title).count.should == 2
+    DB[:books].select(:title).group_by(:title).count.should == 2
   end
 
   specify "#for_update should use FOR UPDATE" do
-    ORACLE_DB[:books].for_update.sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
+    DB[:books].for_update.sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
   end
 
   specify "#lock_style should accept symbols" do
-    ORACLE_DB[:books].lock_style(:update).sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
+    DB[:books].lock_style(:update).sql.should == 'SELECT * FROM "BOOKS" FOR UPDATE'
   end
 end

data/spec/adapters/postgres_spec.rb

@@ -1,26 +1,20 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
+SEQUEL_ADAPTER_TEST = :postgres
 
-unless defined?(POSTGRES_DB)
-  POSTGRES_URL = 'postgres://postgres:postgres@localhost:5432/reality_spec' unless defined? POSTGRES_URL
-  POSTGRES_DB = Sequel.connect(ENV['SEQUEL_PG_SPEC_DB']||POSTGRES_URL)
-end
-INTEGRATION_DB = POSTGRES_DB unless defined?(INTEGRATION_DB)
+require File.join(File.dirname(File.expand_path(__FILE__)), 'spec_helper.rb')
 
-def POSTGRES_DB.sqls
+def DB.sqls
   (@sqls ||= [])
 end
 logger = Object.new
 def logger.method_missing(m, msg)
-  POSTGRES_DB.sqls << msg
+  DB.sqls << msg
 end
-POSTGRES_DB.loggers << logger
-
-#POSTGRES_DB.instance_variable_set(:@server_version, 80200)
+DB.loggers << logger
 
 describe "PostgreSQL", '#create_table' do
   before do
-    @db = POSTGRES_DB
-    POSTGRES_DB.sqls.clear
+    @db = DB
+    DB.sqls.clear
   end
   after do
     @db.drop_table?(:tmp_dolls)
@@ -48,31 +42,52 @@ describe "PostgreSQL", '#create_table' do
   end
 end
 
-describe "PostgreSQL temporary views" do
+describe "PostgreSQL views" do
   before do
-    @db = POSTGRES_DB
-    @db.drop_view(:items_view) rescue nil
+    @db = DB
+    @db.drop_view(:items_view, :cascade=>true, :if_exists=>true)
     @db.create_table!(:items){Integer :number}
     @db[:items].insert(10)
     @db[:items].insert(20)
   end
   after do
+    @opts ||={}
+    @db.drop_view(:items_view, @opts.merge(:if_exists=>true, :cascade=>true)) rescue nil
     @db.drop_table?(:items)
   end
 
-  specify "should be supported" do
+  specify "should support temporary views" do
     @db.create_view(:items_view, @db[:items].where(:number=>10), :temp=>true)
     @db[:items_view].map(:number).should == [10]
     @db.create_or_replace_view(:items_view, @db[:items].where(:number=>20),  :temp=>true)
     @db[:items_view].map(:number).should == [20]
-    @db.disconnect
-    lambda{@db[:items_view].map(:number)}.should raise_error(Sequel::DatabaseError)
   end
-end unless POSTGRES_DB.adapter_scheme == :do # Causes freezing later
+
+  specify "should support recursive views" do
+    @db.create_view(:items_view, @db[:items].where(:number=>10).union(@db[:items, :items_view].where(Sequel.-(:number, 5)=>:n).select(:number), :all=>true, :from_self=>false), :recursive=>[:n])
+    @db[:items_view].select_order_map(:n).should == [10]
+    @db[:items].insert(15)
+    @db[:items_view].select_order_map(:n).should == [10, 15, 20]
+  end if DB.server_version >= 90300
+
+  specify "should support materialized views" do
+    @opts = {:materialized=>true}
+    @db.create_view(:items_view, @db[:items].where{number >= 10}, @opts)
+    @db[:items_view].select_order_map(:number).should == [10, 20]
+    @db[:items].insert(15)
+    @db[:items_view].select_order_map(:number).should == [10, 20]
+    @db.refresh_view(:items_view)
+    @db[:items_view].select_order_map(:number).should == [10, 15, 20]
+  end if DB.server_version >= 90300
+
+  specify "should support :if_exists=>true for not raising an error if the view does not exist" do
+    proc{@db.drop_view(:items_view, :if_exists=>true)}.should_not raise_error
+  end
+end 
     
 describe "A PostgreSQL database" do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db.create_table!(:public__testfk){primary_key :id; foreign_key :i, :public__testfk}
   end
   after(:all) do
@@ -118,7 +133,7 @@ end
 
 describe "A PostgreSQL database with domain types" do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db << "DROP DOMAIN IF EXISTS positive_number CASCADE"
     @db << "CREATE DOMAIN positive_number AS numeric(10,2) CHECK (VALUE > 0)"
     @db.create_table!(:testfk){positive_number :id, :primary_key=>true}
@@ -137,7 +152,7 @@ end
 
 describe "A PostgreSQL dataset" do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @d = @db[:test]
     @db.create_table! :test do
       text :name
@@ -216,7 +231,7 @@ describe "A PostgreSQL dataset" do
     @db[:atest].insert(2)
     proc{@db[:atest].insert(2)}.should raise_error(Sequel::Postgres::ExclusionConstraintViolation)
     @db.alter_table(:atest){drop_constraint 'atest_ex'}
-  end if POSTGRES_DB.server_version >= 90000
+  end if DB.server_version >= 90000
 
   specify "should support Database#do for executing anonymous code blocks" do
     @db.drop_table?(:btest)
@@ -225,7 +240,7 @@ describe "A PostgreSQL dataset" do
 
     @db.do "BEGIN EXECUTE 'DROP TABLE btest; CREATE TABLE atest (a INTEGER)'; EXECUTE 'INSERT INTO atest VALUES (1)'; END", :language=>:plpgsql
     @db[:atest].select_map(:a).should == [1]
-  end if POSTGRES_DB.server_version >= 90000
+  end if DB.server_version >= 90000
 
   specify "should support adding foreign key constarints that are not yet valid, and validating them later" do
     @db.create_table!(:atest){primary_key :id; Integer :fk}
@@ -238,7 +253,7 @@ describe "A PostgreSQL dataset" do
     @db[:atest].where(:id=>1).update(:fk=>2)
     @db.alter_table(:atest){validate_constraint :atest_fk}
     proc{@db.alter_table(:atest){validate_constraint :atest_fk}}.should_not raise_error
-  end if POSTGRES_DB.server_version >= 90200
+  end if DB.server_version >= 90200
 
   specify "should support :using when altering a column's type" do
     @db.create_table!(:atest){Integer :t}
@@ -305,7 +320,7 @@ describe "A PostgreSQL dataset" do
     @db.transaction(:isolation=>:serializable, :deferrable=>true, :read_only=>true){}
     @db.transaction(:isolation=>:serializable, :deferrable=>false, :read_only=>false){}
     @db.sqls.grep(/DEF/).should == ["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 POSTGRES_DB.server_version >= 90100
+  end if DB.server_version >= 90100
 
   specify "should support creating indexes concurrently" do
     @db.add_index :test, [:name, :value], :concurrently=>true
@@ -339,7 +354,7 @@ describe "A PostgreSQL dataset" do
     check_sqls do
       @db.sqls.should == ['DROP INDEX CONCURRENTLY "tnv2"']
     end
-  end if POSTGRES_DB.server_version >= 90200
+  end if DB.server_version >= 90200
 
   specify "#lock should lock table if inside a transaction" do
     @db.transaction{@d.lock('EXCLUSIVE'); @d.insert(:name=>'a')}
@@ -376,7 +391,7 @@ end
 
 describe "Dataset#distinct" do
   before do
-    @db = POSTGRES_DB
+    @db = DB
     @db.create_table!(:a) do
       Integer :a
       Integer :b
@@ -397,29 +412,29 @@ describe "Dataset#distinct" do
   end
 end
 
-if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
+if DB.pool.respond_to?(:max_size) and DB.pool.max_size > 1
   describe "Dataset#for_update support" do
     before do
-      @db = POSTGRES_DB.create_table!(:items) do
+      @db = DB.create_table!(:items) do
         primary_key :id
         Integer :number
         String :name
       end
-      @ds = POSTGRES_DB[:items]
+      @ds = DB[:items]
     end
     after do
-      POSTGRES_DB.drop_table?(:items)
-      POSTGRES_DB.disconnect
+      DB.drop_table?(:items)
+      DB.disconnect
     end
 
     specify "should handle FOR UPDATE" do
       @ds.insert(:number=>20)
       c, t = nil, nil
       q = Queue.new
-      POSTGRES_DB.transaction do
+      DB.transaction do
         @ds.for_update.first(:id=>1)
         t = Thread.new do
-          POSTGRES_DB.transaction do
+          DB.transaction do
             q.push nil
             @ds.filter(:id=>1).update(:name=>'Jim')
             c = @ds.first(:id=>1)
@@ -438,10 +453,10 @@ if POSTGRES_DB.pool.respond_to?(:max_size) and POSTGRES_DB.pool.max_size > 1
       @ds.insert(:number=>20)
       c, t = nil
       q = Queue.new
-      POSTGRES_DB.transaction do
+      DB.transaction do
         @ds.for_share.first(:id=>1)
         t = Thread.new do
-          POSTGRES_DB.transaction do
+          DB.transaction do
             c = @ds.for_share.filter(:id=>1).first
             q.push nil
           end
@@ -457,7 +472,7 @@ end
 
 describe "A PostgreSQL dataset with a timestamp field" do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db.create_table! :test3 do
       Date :date
       DateTime :time
@@ -492,7 +507,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
     (t2.is_a?(Time) ? t2.usec : t2.strftime('%N').to_i/1000).should == t.strftime('%N').to_i/1000
   end
 
-  if POSTGRES_DB.adapter_scheme == :postgres
+  if DB.adapter_scheme == :postgres
     specify "should handle infinite timestamps if convert_infinite_timestamps is set" do
       @d << {:time=>Sequel.cast('infinity', DateTime)}
       @db.convert_infinite_timestamps = :nil
@@ -566,7 +581,7 @@ describe "A PostgreSQL dataset with a timestamp field" do
   end
 
   specify "explain and analyze should not raise errors" do
-    @d = POSTGRES_DB[:test3]
+    @d = DB[:test3]
     proc{@d.explain}.should_not raise_error
     proc{@d.analyze}.should_not raise_error
   end
@@ -579,7 +594,7 @@ end
 
 describe "A PostgreSQL database" do
   before do
-    @db = POSTGRES_DB
+    @db = DB
     @db.create_table! :test2 do
       text :name
       integer :value
@@ -624,7 +639,7 @@ end
 
 describe "A PostgreSQL database" do
   before do
-    @db = POSTGRES_DB
+    @db = DB
     @db.drop_table?(:posts)
     @db.sqls.clear
   end
@@ -671,12 +686,12 @@ describe "A PostgreSQL database" do
   end
 
   specify "should support fulltext indexes and searching" do
-    @db.create_table(:posts){text :title; text :body; full_text_index [:title, :body]; full_text_index :title, :language => 'french'}
+    @db.create_table(:posts){text :title; text :body; full_text_index [:title, :body]; full_text_index :title, :language => 'french', :index_type=>:gist}
     check_sqls do
       @db.sqls.should == [
         %{CREATE TABLE "posts" ("title" text, "body" text)},
         %{CREATE INDEX "posts_title_body_index" ON "posts" USING gin (to_tsvector('simple'::regconfig, (COALESCE("title", '') || ' ' || COALESCE("body", ''))))},
-        %{CREATE INDEX "posts_title_index" ON "posts" USING gin (to_tsvector('french'::regconfig, (COALESCE("title", ''))))}
+        %{CREATE INDEX "posts_title_index" ON "posts" USING gist (to_tsvector('french'::regconfig, (COALESCE("title", ''))))}
       ]
     end
 
@@ -757,7 +772,7 @@ end
 
 describe "Postgres::Dataset#import" do
   before do
-    @db = POSTGRES_DB
+    @db = DB
     @db.create_table!(:test){primary_key :x; Integer :y}
     @db.sqls.clear
     @ds = @db[:test]
@@ -793,7 +808,7 @@ end
 
 describe "Postgres::Dataset#insert" do
   before do
-    @db = POSTGRES_DB
+    @db = DB
     @db.create_table!(:test5){primary_key :xid; Integer :value}
     @db.sqls.clear
     @ds = @db[:test5]
@@ -844,14 +859,13 @@ end
 
 describe "Postgres::Database schema qualified tables" do
   before do
-    @db = POSTGRES_DB
+    @db = DB
     @db << "CREATE SCHEMA schema_test"
     @db.instance_variable_set(:@primary_keys, {})
     @db.instance_variable_set(:@primary_key_sequences, {})
   end
   after do
     @db << "DROP SCHEMA schema_test CASCADE"
-    @db.default_schema = nil
   end
 
   specify "should be able to create, drop, select and insert into tables in a given schema" do
@@ -869,7 +883,7 @@ describe "Postgres::Database schema qualified tables" do
 
   specify "#tables should not include tables in a default non-public schema" do
     @db.create_table(:schema_test__schema_test){integer :i}
-    @db.tables.should include(:schema_test)
+    @db.tables(:schema=>:schema_test).should include(:schema_test)
     @db.tables.should_not include(:pg_am)
     @db.tables.should_not include(:domain_udt_usage)
   end
@@ -965,7 +979,7 @@ end
 
 describe "Postgres::Database schema qualified tables and eager graphing" do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db.run "DROP SCHEMA s CASCADE" rescue nil
     @db.run "CREATE SCHEMA s"
 
@@ -1141,21 +1155,21 @@ describe "Postgres::Database schema qualified tables and eager graphing" do
 
 end
 
-if POSTGRES_DB.server_version >= 80300
+if DB.server_version >= 80300
   describe "PostgreSQL tsearch2" do
     before(:all) do
-      POSTGRES_DB.create_table! :test6 do
+      DB.create_table! :test6 do
         text :title
         text :body
         full_text_index [:title, :body]
       end
-      @ds = POSTGRES_DB[:test6]
+      @ds = DB[:test6]
     end
     after do
-      POSTGRES_DB[:test6].delete
+      DB[:test6].delete
     end
     after(:all) do
-      POSTGRES_DB.drop_table?(:test6)
+      DB.drop_table?(:test6)
     end
 
     specify "should search by indexed column" do
@@ -1178,10 +1192,10 @@ if POSTGRES_DB.server_version >= 80300
   end
 end
 
-if POSTGRES_DB.dataset.supports_window_functions?
+if DB.dataset.supports_window_functions?
   describe "Postgres::Dataset named windows" do
     before do
-      @db = POSTGRES_DB
+      @db = DB
       @db.create_table!(:i1){Integer :id; Integer :group_id; Integer :amount}
       @ds = @db[:i1].order(:id)
       @ds.insert(:id=>1, :group_id=>1, :amount=>1)
@@ -1210,7 +1224,7 @@ end
 
 describe "Postgres::Database functions, languages, schemas, and triggers" do
   before do
-    @d = POSTGRES_DB
+    @d = DB
   end
   after do
     @d.drop_function('tf', :if_exists=>true, :cascade=>true)
@@ -1260,9 +1274,11 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
 
   specify "#create_schema and #drop_schema should create and drop schemas" do
     @d.send(:create_schema_sql, :sequel).should == 'CREATE SCHEMA "sequel"'
+    @d.send(:create_schema_sql, :sequel, :if_not_exists=>true, :owner=>:foo).should == 'CREATE SCHEMA IF NOT EXISTS "sequel" AUTHORIZATION "foo"'
     @d.send(:drop_schema_sql, :sequel).should == 'DROP SCHEMA "sequel"'
     @d.send(:drop_schema_sql, :sequel, :if_exists=>true, :cascade=>true).should == 'DROP SCHEMA IF EXISTS "sequel" CASCADE'
     @d.create_schema(:sequel)
+    @d.create_schema(:sequel, :if_not_exists=>true) if @d.server_version >= 90300
     @d.create_table(:sequel__test){Integer :a}
     @d.drop_schema(:sequel, :if_exists=>true, :cascade=>true)
   end
@@ -1288,10 +1304,10 @@ describe "Postgres::Database functions, languages, schemas, and triggers" do
   end
 end
 
-if POSTGRES_DB.adapter_scheme == :postgres
+if DB.adapter_scheme == :postgres
   describe "Postgres::Dataset #use_cursor" do
     before(:all) do
-      @db = POSTGRES_DB
+      @db = DB
       @db.create_table!(:test_cursor){Integer :x}
       @db.sqls.clear
       @ds = @db[:test_cursor]
@@ -1329,7 +1345,7 @@ if POSTGRES_DB.adapter_scheme == :postgres
 
   describe "Postgres::PG_NAMED_TYPES" do
     before do
-      @db = POSTGRES_DB
+      @db = DB
       Sequel::Postgres::PG_NAMED_TYPES[:interval] = lambda{|v| v.reverse}
       @db.extension :pg_array
       @db.reset_conversion_procs
@@ -1354,10 +1370,10 @@ if POSTGRES_DB.adapter_scheme == :postgres
   end
 end
 
-if ((POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || POSTGRES_DB.adapter_scheme == :jdbc) && POSTGRES_DB.server_version >= 90000
+if ((DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || DB.adapter_scheme == :jdbc) && DB.server_version >= 90000
   describe "Postgres::Database#copy_into" do
     before(:all) do
-      @db = POSTGRES_DB
+      @db = DB
       @db.create_table!(:test_copy){Integer :x; Integer :y}
       @ds = @db[:test_copy].order(:x, :y)
     end
@@ -1436,7 +1452,7 @@ if ((POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || POST
 
   describe "Postgres::Database#copy_table" do
     before(:all) do
-      @db = POSTGRES_DB
+      @db = DB
       @db.create_table!(:test_copy){Integer :x; Integer :y}
       ds = @db[:test_copy]
       ds.insert(1, 2)
@@ -1506,10 +1522,10 @@ if ((POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG) || POST
   end
 end
 
-if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && POSTGRES_DB.server_version >= 90000
+if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG && DB.server_version >= 90000
   describe "Postgres::Database LISTEN/NOTIFY" do
     before(:all) do
-      @db = POSTGRES_DB
+      @db = DB
     end
 
     specify "should support listen and notify" do
@@ -1591,7 +1607,7 @@ end
 
 describe 'PostgreSQL special float handling' do
   before do
-    @db = POSTGRES_DB
+    @db = DB
     @db.create_table!(:test5){Float :value}
     @db.sqls.clear
     @ds = @db[:test5]
@@ -1617,7 +1633,7 @@ describe 'PostgreSQL special float handling' do
     end
   end
 
-  if POSTGRES_DB.adapter_scheme == :postgres
+  if DB.adapter_scheme == :postgres
     specify 'inserts NaN' do
       nan = 0.0/0.0
       @ds.insert(:value=>nan)
@@ -1640,11 +1656,11 @@ end
 
 describe 'PostgreSQL array handling' do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db.extension :pg_array
     @ds = @db[:items]
-    @native = POSTGRES_DB.adapter_scheme == :postgres
-    @jdbc = POSTGRES_DB.adapter_scheme == :jdbc
+    @native = DB.adapter_scheme == :postgres
+    @jdbc = DB.adapter_scheme == :jdbc
     @tp = lambda{@db.schema(:items).map{|a| a.last[:type]}}
   end
   after do
@@ -1841,7 +1857,7 @@ describe 'PostgreSQL array handling' do
       @ds.insert(rs.first)
       @ds.all.should == rs
     end
-  end unless POSTGRES_DB.adapter_scheme == :jdbc
+  end unless DB.adapter_scheme == :jdbc
 
   specify 'use arrays in bound variables' do
     @db.create_table!(:items) do
@@ -1901,7 +1917,7 @@ describe 'PostgreSQL array handling' do
     @ds.get(:i).should == a
     @ds.filter(:i=>:$i).call(:first, :i=>a).should == {:i=>a}
     @ds.filter(:i=>:$i).call(:first, :i=>Sequel.pg_array([Sequel.blob("b\0")], 'bytea')).should == nil
-  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
     @db.create_table!(:items) do
@@ -1943,6 +1959,10 @@ describe 'PostgreSQL array handling' do
     @ds.get(Sequel.expr(1=>Sequel.pg_array(:i3).all)).should be_false
     @ds.get(Sequel.expr(4=>Sequel.pg_array(:i3).all)).should be_true
 
+    @ds.get(Sequel.expr(1=>Sequel.pg_array(:i)[1..1].any)).should be_true
+    @ds.get(Sequel.expr(2=>Sequel.pg_array(:i)[1..1].any)).should be_false
+
+    @ds.get(Sequel.pg_array(:i2)[1]).should == 2
     @ds.get(Sequel.pg_array(:i2)[1]).should == 2
     @ds.get(Sequel.pg_array(:i2)[2]).should == 1
 
@@ -1962,28 +1982,41 @@ describe 'PostgreSQL array handling' do
     @ds.get(Sequel.pg_array(:i).length).should == 3
     @ds.get(Sequel.pg_array(:i).lower).should == 1
 
+    if @db.server_version >= 80400
+      @ds.select(Sequel.pg_array(:i).unnest).from_self.count.should == 3
+    end
     if @db.server_version >= 90000
       @ds.get(Sequel.pg_array(:i5).join).should == '15'
       @ds.get(Sequel.pg_array(:i5).join(':')).should == '1:5'
       @ds.get(Sequel.pg_array(:i5).join(':', '*')).should == '1:*:5'
     end
-    @ds.select(Sequel.pg_array(:i).unnest).from_self.count.should == 3 if @db.server_version >= 80400
+    if @db.server_version >= 90300
+      @ds.get(Sequel.pg_array(:i5).remove(1).length).should == 2
+      @ds.get(Sequel.pg_array(:i5).replace(1, 4).contains([1])).should be_false
+      @ds.get(Sequel.pg_array(:i5).replace(1, 4).contains([4])).should be_true
+    end
 
     if @native
       @ds.get(Sequel.pg_array(:i).push(4)).should == [1, 2, 3, 4]
       @ds.get(Sequel.pg_array(:i).unshift(4)).should == [4, 1, 2, 3]
       @ds.get(Sequel.pg_array(:i).concat(:i2)).should == [1, 2, 3, 2, 1]
     end
+
+    if @db.type_supported?(:hstore)
+      Sequel.extension :pg_hstore, :pg_hstore_ops
+      @db.get(Sequel.pg_array(['a', 'b']).op.hstore['a']).should == 'b'
+      @db.get(Sequel.pg_array(['a', 'b']).op.hstore(['c', 'd'])['a']).should == 'c'
+    end
   end
 end
 
 describe 'PostgreSQL hstore handling' do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db.extension :pg_array, :pg_hstore
     @ds = @db[:items]
     @h = {'a'=>'b', 'c'=>nil, 'd'=>'NULL', 'e'=>'\\\\" \\\' ,=>'}
-    @native = POSTGRES_DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres
   end
   after do
     @db.drop_table?(:items)
@@ -2043,7 +2076,7 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(:i).should == @h
     @ds.filter(:i=>:$i).call(:first, :i=>@h).should == {:i=>@h}
     @ds.filter(:i=>:$i).call(:first, :i=>{}).should == nil
-  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models and associations' do
     @db.create_table!(:items) do
@@ -2224,16 +2257,16 @@ describe 'PostgreSQL hstore handling' do
     @ds.get(h1.avals.length).should == 2
     @ds.get(h2.avals.length).should == 1
   end
-end if POSTGRES_DB.type_supported?(:hstore)
+end if DB.type_supported?(:hstore)
 
 describe 'PostgreSQL json type' do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db.extension :pg_array, :pg_json
     @ds = @db[:items]
     @a = [1, 2, {'a'=>'b'}, 3.0]
     @h = {'a'=>'b', '1'=>[3, 4, 5]}
-    @native = POSTGRES_DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres
   end
   after do
     @db.drop_table?(:items)
@@ -2312,7 +2345,7 @@ describe 'PostgreSQL json type' do
     @ds.get(:i).should == j
     @ds.filter(Sequel.cast(:i, 'text[]')=>:$i).call(:first, :i=>j).should == {:i=>j}
     @ds.filter(Sequel.cast(:i, 'text[]')=>:$i).call(:first, :i=>Sequel.pg_array([])).should == nil
-  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
     @db.create_table!(:items) do
@@ -2324,13 +2357,55 @@ describe 'PostgreSQL json type' do
     c.create(:h=>Sequel.pg_json(@h)).h.should == @h
     c.create(:h=>Sequel.pg_json(@a)).h.should == @a
   end
-end if POSTGRES_DB.server_version >= 90200
+
+  specify 'operations/functions with pg_json_ops' do
+    Sequel.extension :pg_json_ops
+    jo = Sequel.pg_json('a'=>1, 'b'=>{'c'=>2, 'd'=>{'e'=>3}}).op
+    ja = Sequel.pg_json([2, 3, %w'a b']).op
+
+    @db.get(jo['a']).should == 1
+    @db.get(jo['b']['c']).should == 2
+    @db.get(jo[%w'b c']).should == 2
+    @db.get(jo['b'].get_text(%w'd e')).should == "3"
+    @db.get(jo[%w'b d'].get_text('e')).should == "3"
+    @db.get(ja[1]).should == 3
+    @db.get(ja[%w'2 1']).should == 'b'
+
+    @db.get(jo.extract('a')).should == 1
+    @db.get(jo.extract('b').extract('c')).should == 2
+    @db.get(jo.extract('b', 'c')).should == 2
+    @db.get(jo.extract('b', 'd', 'e')).should == 3
+    @db.get(jo.extract_text('b', 'd')).should == '{"e":3}'
+    @db.get(jo.extract_text('b', 'd', 'e')).should == '3'
+
+    @db.get(ja.array_length).should == 3
+    @db.from(ja.array_elements.as(:v)).select_map(:v).should == [2, 3, %w'a b']
+
+    @db.from(jo.keys.as(:k)).select_order_map(:k).should == %w'a b'
+    @db.from(jo.each).select_order_map(:key).should == %w'a b'
+    @db.from(jo.each).order(:key).select_map(:value).should == [1, {'c'=>2, 'd'=>{'e'=>3}}]
+    @db.from(jo.each_text).select_order_map(:key).should == %w'a b'
+    @db.from(jo.each_text).order(:key).where(:key=>'b').get(:value).should =~ /\{"d":\{"e":3\},"c":2\}|\{"c":2,"d":\{"e":3\}\}/
+
+    Sequel.extension :pg_row_ops
+    @db.create_table!(:items) do
+      Integer :a
+      String :b
+    end
+    j = Sequel.pg_json('a'=>1, 'b'=>'c').op
+    @db.get(j.populate(Sequel.cast(nil, :items)).pg_row[:a]).should == 1
+    @db.get(j.populate(Sequel.cast(nil, :items)).pg_row[:b]).should == 'c'
+    j = Sequel.pg_json([{'a'=>1, 'b'=>'c'}, {'a'=>2, 'b'=>'d'}]).op
+    @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:a).should == [1, 2]
+    @db.from(j.populate_set(Sequel.cast(nil, :items))).select_order_map(:b).should == %w'c d'
+  end if DB.server_version >= 90300 && DB.adapter_scheme == :postgres
+end if DB.server_version >= 90200
 
 describe 'PostgreSQL inet/cidr types' do
   ipv6_broken = (IPAddr.new('::1'); false) rescue true
 
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db.extension :pg_array, :pg_inet
     @ds = @db[:items]
     @v4 = '127.0.0.1'
@@ -2343,7 +2418,7 @@ describe 'PostgreSQL inet/cidr types' do
       @ipv6 = IPAddr.new(@v6)
       @ipv6nm = IPAddr.new(@v6nm)
     end
-    @native = POSTGRES_DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres
   end
   after do
     @db.drop_table?(:items)
@@ -2424,7 +2499,7 @@ describe 'PostgreSQL inet/cidr types' do
     @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:first, :i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']).should == {:i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']}
     @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:first, :i=>[], :c=>[], :m=>[]).should == nil
     @ds.filter(:i=>:$i, :c=>:$c, :m=>:$m).call(:delete, :i=>[@ipv4], :c=>[@ipv4nm], :m=>['12:34:56:78:90:ab']).should == 1
-  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
     @db.create_table!(:items) do
@@ -2443,7 +2518,7 @@ end
 
 describe 'PostgreSQL range types' do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db.extension :pg_array, :pg_range
     @ds = @db[:items]
     @map = {:i4=>'int4range', :i8=>'int8range', :n=>'numrange', :d=>'daterange', :t=>'tsrange', :tz=>'tstzrange'}
@@ -2454,7 +2529,7 @@ 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 = POSTGRES_DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres
   end
   after do
     @db.drop_table?(:items)
@@ -2526,7 +2601,7 @@ describe 'PostgreSQL range types' do
     @ds.filter(h).call(:first, @pgra).each{|k, v| v.should == @ra[k].to_a}
     @ds.filter(h).call(:first, r2).should == nil
     @ds.filter(h).call(:delete, @ra).should == 1
-  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
     @db.create_table!(:items){primary_key :id; int4range :i4; int8range :i8; numrange :n; daterange :d; tsrange :t; tstzrange :tz}
@@ -2614,14 +2689,14 @@ describe 'PostgreSQL range types' do
     @db.get(Sequel::Postgres::PGRange.new(1, 5, :db_type=>:int4range).op.upper_inf).should be_false
     @db.get(Sequel::Postgres::PGRange.new(1, nil, :db_type=>:int4range).op.upper_inf).should be_true
   end
-end if POSTGRES_DB.server_version >= 90200
+end if DB.server_version >= 90200
 
 describe 'PostgreSQL interval types' do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     @db.extension :pg_array, :pg_interval
     @ds = @db[:items]
-    @native = POSTGRES_DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres
   end
   after(:all) do
     Sequel::Postgres::PG_TYPES.delete(1186)
@@ -2699,7 +2774,7 @@ describe 'PostgreSQL interval types' do
     @ds.filter(:i=>:$i).call(:first, :i=>[d]).should == {:i=>[d]}
     @ds.filter(:i=>:$i).call(:first, :i=>[]).should == nil
     @ds.filter(:i=>:$i).call(:delete, :i=>[d]).should == 1
-  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'with models' do
     @db.create_table!(:items) do
@@ -2717,7 +2792,7 @@ end if (begin require 'active_support/duration'; require 'active_support/inflect
 
 describe 'PostgreSQL row-valued/composite types' do
   before(:all) do
-    @db = POSTGRES_DB
+    @db = DB
     Sequel.extension :pg_array_ops, :pg_row_ops
     @db.extension :pg_array, :pg_row
     @ds = @db[:person]
@@ -2739,7 +2814,7 @@ describe 'PostgreSQL row-valued/composite types' do
     @db.register_row_type(Sequel.qualify(:public, :person))
     @db.register_row_type(:public__company)
 
-    @native = POSTGRES_DB.adapter_scheme == :postgres
+    @native = DB.adapter_scheme == :postgres
   end
   after(:all) do
     @db.drop_table?(:company, :person, :address)
@@ -2784,7 +2859,7 @@ describe 'PostgreSQL row-valued/composite types' do
       @db.drop_table(:domain_check)
       @db << "DROP DOMAIN positive_integer"
     end
-  end if POSTGRES_DB.adapter_scheme == :postgres
+  end if DB.adapter_scheme == :postgres
 
   specify 'insert and retrieve arrays of row types' do
     @ds = @db[:company]
@@ -2814,7 +2889,7 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds.delete
     @ds.call(:insert, {:address=>Sequel.pg_row([nil, nil, nil])}, {:address=>:$address, :id=>1})
     @ds.get(:address).should == {:street=>nil, :city=>nil, :zip=>nil}
-  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'use arrays of row types in bound variables' do
     @ds = @db[:company]
@@ -2826,7 +2901,7 @@ describe 'PostgreSQL row-valued/composite types' do
     @ds.delete
     @ds.call(:insert, {:employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row([nil, nil, nil])])])}, {:employees=>:$employees, :id=>1})
     @ds.get(:employees).should == [{:address=>{:city=>nil, :zip=>nil, :street=>nil}, :id=>1}]
-  end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+  end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
   specify 'operations/functions with pg_row_ops' do
     @ds.insert(:id=>1, :address=>Sequel.pg_row(['123 Sesame St', 'Somewhere', '12345']))
@@ -2952,7 +3027,7 @@ describe 'PostgreSQL row-valued/composite types' do
       @ds.get(:address).should == @a
       @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>@a)[:id].should == 1
       @ds.filter(:address=>Sequel.cast(:$address, :address)).call(:first, :address=>Address.new(:street=>'123 Sesame St', :city=>'Somewhere', :zip=>'12356')).should == nil
-    end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+    end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
     specify 'use arrays of model objects in bound variables' do
       @ds = @db[:company]
@@ -2960,7 +3035,7 @@ describe 'PostgreSQL row-valued/composite types' do
       @ds.get(:company).should == Company.new(:id=>1, :employees=>@es)
       @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>@es)[:id].should == 1
       @ds.filter(:employees=>Sequel.cast(:$employees, 'person[]')).call(:first, :employees=>Sequel.pg_array([@db.row_type(:person, [1, Sequel.pg_row(['123 Sesame St', 'Somewhere', '12356'])])])).should == nil
-    end if POSTGRES_DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
+    end if DB.adapter_scheme == :postgres && SEQUEL_POSTGRES_USES_PG
 
     specify 'model typecasting' do
       Person.plugin :pg_typecast_on_load, :address unless @native