sequel 4.47.0 → 4.48.0

data/lib/sequel/adapters/shared/db2.rb

@@ -6,11 +6,17 @@ module Sequel
   module DB2
     Sequel::Database.set_shared_adapter_scheme(:db2, self)
 
+    # SEQUEL5: Remove
     @use_clob_as_blob = false
-
     class << self
-      # Whether to use clob as the generic File type, true by default.
-      attr_accessor :use_clob_as_blob
+      def use_clob_as_blob
+        Sequel::Deprecation.deprecate("Sequel::DB2.use_clob_as_blob", "Call this method on the Database instance")
+        @use_clob_as_blob
+      end
+      def use_clob_as_blob=(v)
+        Sequel::Deprecation.deprecate("Sequel::DB2.use_clob_as_blob=", "Call this method on the Database instance")
+        @use_clob_as_blob = v
+      end
     end
 
     module DatabaseMethods
@@ -21,6 +27,16 @@ module Sequel
       NULL          = ''.freeze
       Sequel::Deprecation.deprecate_constant(self, :NULL)
 
+      # Whether to use clob as the generic File type, false by default.
+      #attr_accessor :use_clob_as_blob # SEQUEL5
+
+      # SEQUEL5: Remove
+      attr_writer :use_clob_as_blob
+      def use_clob_as_blob
+        v = @use_clob_as_blob
+        v.nil? ? Sequel::DB2.instance_variable_get(:@use_clob_as_blob) : v
+      end
+    
       # DB2 always uses :db2 as it's database type
       def database_type
         :db2
@@ -250,7 +266,7 @@ module Sequel
 
       # Treat clob as blob if use_clob_as_blob is true
       def schema_column_type(db_type)
-        (::Sequel::DB2::use_clob_as_blob && db_type.downcase == 'clob') ? :blob : super
+        (use_clob_as_blob && db_type.downcase == 'clob') ? :blob : super
       end
 
       # SQL to set the transaction isolation level
@@ -263,7 +279,7 @@ module Sequel
       # use this for blob value:
       #     cast(X'fffefdfcfbfa' as blob(2G))
       def type_literal_generic_file(column)
-        ::Sequel::DB2::use_clob_as_blob ? :clob : :blob
+        use_clob_as_blob ? :clob : :blob
       end
 
       # DB2 uses smallint to store booleans.
@@ -433,7 +449,7 @@ module Sequel
 
       # DB2 uses a literal hexidecimal number for blob strings
       def literal_blob_append(sql, v)
-        if ::Sequel::DB2.use_clob_as_blob
+        if db.use_clob_as_blob
           super
         else
           sql << "BLOB(X'" << v.unpack("H*").first << "')"

data/lib/sequel/adapters/shared/mssql.rb

@@ -540,7 +540,6 @@ module Sequel
       CONSTANT_MAP = {:CURRENT_DATE=>'CAST(CURRENT_TIMESTAMP AS DATE)'.freeze, :CURRENT_TIME=>'CAST(CURRENT_TIMESTAMP AS TIME)'.freeze}#.freeze # SEQUEL5
       EXTRACT_MAP = {:year=>"yy", :month=>"m", :day=>"d", :hour=>"hh", :minute=>"n", :second=>"s"}#.freeze # SEQUEL5
       #EXTRACT_MAP.each_value(&:freeze) # SEQUEL5
-      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:disable_insert_output, :mssql_unicode_strings]).freeze
       LIMIT_ALL = Object.new.freeze
 
       BOOL_TRUE = '1'.freeze
@@ -629,6 +628,8 @@ module Sequel
       Sequel::Deprecation.deprecate_constant(self, :ROWS_ONLY)
       FETCH_NEXT = " FETCH NEXT ".freeze
       Sequel::Deprecation.deprecate_constant(self, :FETCH_NEXT)
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:disable_insert_output, :mssql_unicode_strings]).freeze
+      Sequel::Deprecation.deprecate_constant(self, :NON_SQL_OPTIONS)
 
       Dataset.def_mutation_method(:disable_insert_output, :output, :module=>self)
       Dataset.def_sql_method(self, :delete, %w'with delete limit from output from2 where')
@@ -637,6 +638,7 @@ module Sequel
 
       # Allow overriding of the mssql_unicode_strings option at the dataset level.
       def mssql_unicode_strings=(v)
+        Sequel::Deprecation.deprecate("Dataset#mssql_unicode_strings=", "Switch to using with_mssql_unicode_strings, which returns a modified copy")
         @opts[:mssql_unicode_strings] = v
       end
 
@@ -1048,9 +1050,8 @@ module Sequel
         is_2008_or_later? ? :values : :union
       end
 
-      # Dataset options that do not affect the generated SQL.
-      def non_sql_options
-        NON_SQL_OPTIONS
+      def non_sql_option?(key)
+        super || key == :disable_insert_output || key == :mssql_unicode_strings
       end
 
       def select_into_sql(sql)

data/lib/sequel/adapters/shared/mysql.rb

@@ -12,32 +12,54 @@ module Sequel
       end
     end
 
+    # SEQUEL5: Remove
     @convert_tinyint_to_bool = true
-
+    @default_charset = nil
+    @default_collate = nil
+    @default_engine = nil
     class << self
-      # Sequel converts the column type tinyint(1) to a boolean by default when
-      # using the native MySQL or Mysql2 adapter.  You can turn off the conversion by setting
-      # this to false. This setting is ignored when connecting to MySQL via the do or jdbc
-      # adapters, both of which automatically do the conversion.
-      attr_accessor :convert_tinyint_to_bool
+      def convert_tinyint_to_bool
+        Sequel::Deprecation.deprecate("Sequel::MySQL.convert_tinyint_to_bool", "Call this method on the Database instance")
+        @convert_tinyint_to_bool
+      end
+      def convert_tinyint_to_bool=(v)
+        Sequel::Deprecation.deprecate("Sequel::MySQL.convert_tinyint_to_bool=", "Call this method on the Database instance")
+        @convert_tinyint_to_bool = v
+      end
 
-      # Set the default charset used for CREATE TABLE.  You can pass the
-      # :charset option to create_table to override this setting.
-      attr_accessor :default_charset
+      def default_charset
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_charset", "Call this method on the Database instance")
+        @default_charset
+      end
+      def default_charset=(v)
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_charset=", "Call this method on the Database instance")
+        @default_charset = v
+      end
 
-      # Set the default collation used for CREATE TABLE.  You can pass the
-      # :collate option to create_table to override this setting.
-      attr_accessor :default_collate
+      def default_collate
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_collate", "Call this method on the Database instance")
+        @default_collate
+      end
+      def default_collate=(v)
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_collate=", "Call this method on the Database instance")
+        @default_collate = v
+      end
 
-      # Set the default engine used for CREATE TABLE.  You can pass the
-      # :engine option to create_table to override this setting.
-      attr_accessor :default_engine
+      def default_engine
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_engine", "Call this method on the Database instance")
+        @default_engine
+      end
+      def default_engine=(v)
+        Sequel::Deprecation.deprecate("Sequel::MySQL.default_engine=", "Call this method on the Database instance")
+        @default_engine = v
+      end
     end
 
     # Methods shared by Database instances that connect to MySQL,
     # currently supported by the native and JDBC adapters.
     module DatabaseMethods
       include UnmodifiedIdentifiers::DatabaseMethods
+      include Sequel::Database::SplitAlterTable
 
       AUTO_INCREMENT = 'AUTO_INCREMENT'.freeze
       Sequel::Deprecation.deprecate_constant(self, :AUTO_INCREMENT)
@@ -49,8 +71,36 @@ module Sequel
       CAST_TYPES = {String=>:CHAR, Integer=>:SIGNED, Time=>:DATETIME, DateTime=>:DATETIME, Numeric=>:DECIMAL, BigDecimal=>:DECIMAL, File=>:BINARY}#.freeze # SEQUEL5
       COLUMN_DEFINITION_ORDER = [:collate, :null, :default, :unique, :primary_key, :auto_increment, :references]#.freeze # SEQUEL5
 
-      include Sequel::Database::SplitAlterTable
       
+      # Set the default charset used for CREATE TABLE.  You can pass the
+      # :charset option to create_table to override this setting.
+      #attr_accessor :default_charset # SEQUEL5
+
+      # Set the default collation used for CREATE TABLE.  You can pass the
+      # :collate option to create_table to override this setting.
+      #attr_accessor :default_collate # SEQUEL5
+
+      # Set the default engine used for CREATE TABLE.  You can pass the
+      # :engine option to create_table to override this setting.
+      #attr_accessor :default_engine # SEQUEL5
+
+      # SEQUEL5: Remove
+      attr_writer :default_charset
+      def default_charset
+        v = @default_charset
+        v.nil? ? Sequel::MySQL.instance_variable_get(:@default_charset) : v
+      end
+      attr_writer :default_collate
+      def default_collate
+        v = @default_collate
+        v.nil? ? Sequel::MySQL.instance_variable_get(:@default_collate) : v
+      end
+      attr_writer :default_engine
+      def default_engine
+        v = @default_engine
+        v.nil? ? Sequel::MySQL.instance_variable_get(:@default_engine) : v
+      end
+
       # MySQL's cast rules are restrictive in that you can't just cast to any possible
       # database type.
       def cast_type_literal(type)
@@ -375,9 +425,9 @@ module Sequel
 
       # Use MySQL specific syntax for engine type and character encoding
       def create_table_sql(name, generator, options = OPTS)
-        engine = options.fetch(:engine, Sequel::MySQL.default_engine)
-        charset = options.fetch(:charset, Sequel::MySQL.default_charset)
-        collate = options.fetch(:collate, Sequel::MySQL.default_collate)
+        engine = options.fetch(:engine, default_engine)
+        charset = options.fetch(:charset, default_charset)
+        collate = options.fetch(:collate, default_collate)
         generator.constraints.sort_by{|c| (c[:type] == :primary_key) ? -1 : 1}
 
         # Proc for figuring out the primary key for a given table.
@@ -669,10 +719,11 @@ module Sequel
       Sequel::Deprecation.deprecate_constant(self, :CURRENT_TIMESTAMP_56)
       ONLY_OFFSET = ",18446744073709551615".freeze
       Sequel::Deprecation.deprecate_constant(self, :ONLY_OFFSET)
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:insert_ignore, :update_ignore, :on_duplicate_key_update]).freeze
+      Sequel::Deprecation.deprecate_constant(self, :NON_SQL_OPTIONS)
 
       MATCH_AGAINST = ["MATCH ".freeze, " AGAINST (".freeze, ")".freeze].freeze
       MATCH_AGAINST_BOOLEAN = ["MATCH ".freeze, " AGAINST (".freeze, " IN BOOLEAN MODE)".freeze].freeze
-      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:insert_ignore, :update_ignore, :on_duplicate_key_update]).freeze
 
       Dataset.def_sql_method(self, :delete, %w'delete from where order limit')
       Dataset.def_sql_method(self, :insert, %w'insert ignore into columns values on_duplicate_key_update')
@@ -791,7 +842,7 @@ module Sequel
       # Raises an error on use of :full_outer type, since MySQL doesn't support it.
       def join_table(type, table, expr=nil, opts=OPTS, &block)
         type = :inner if (type == :cross) && !expr.nil?
-        raise(Sequel::Error, "MySQL doesn't support FULL OUTER JOIN") if type == :full_outer
+        raise(Sequel::Error, "MySQL doesn't support FULL OUTER JOIN or NATURAL FULL JOIN") if type == :full_outer || type == :natural_full
         super(type, table, expr, opts, &block)
       end
       
@@ -802,6 +853,7 @@ module Sequel
         when :straight
           'STRAIGHT_JOIN'
         when :natural_inner
+           Sequel::Deprecation.deprecate(":natural_inner join type being converted to NATURAL LEFT JOIN on MySQL", "Use :natural_left join type for NATURAL LEFT JOIN, or :natural join type for NATURAL JOIN")
           'NATURAL LEFT JOIN'
         else
           super
@@ -1055,9 +1107,8 @@ module Sequel
         :values
       end
 
-      # Dataset options that do not affect the generated SQL.
-      def non_sql_options
-        NON_SQL_OPTIONS
+      def non_sql_option?(key)
+        super || key == :insert_ignore || key == :update_ignore || key == :on_duplicate_key_update
       end
 
       def select_only_offset_sql(sql)

data/lib/sequel/adapters/shared/postgres.rb

@@ -1,25 +1,17 @@
 # frozen-string-literal: true
 
-Sequel.require %w'pg_types unmodified_identifiers', 'adapters/utils'
+Sequel.require %w'adapters/utils/unmodified_identifiers'
 
 module Sequel
   # Top level module for holding all PostgreSQL-related modules and classes
-  # for Sequel.  There are a few module level accessors that are added via
-  # metaprogramming.  These are:
-  #
-  # client_min_messages :: Change the minimum level of messages that PostgreSQL will send to the
-  #                        the client.  The PostgreSQL default is NOTICE, the Sequel default is
-  #                        WARNING.  Set to nil to not change the server default. Overridable on
-  #                        a per instance basis via the :client_min_messages option.
-  # force_standard_strings :: Set to false to not force the use of standard strings.  Overridable
-  #                           on a per instance basis via the :force_standard_strings option.
-  #
-  # It is not recommened you use these module-level accessors.  Instead,
-  # use the database option to make the setting per-Database.
-  #
-  # All adapters that connect to PostgreSQL support the following option in
-  # addition to those mentioned above:
+  # for Sequel.  All adapters that connect to PostgreSQL support the following options:
   #
+  # :client_min_messages :: Change the minimum level of messages that PostgreSQL will send to the
+  #                         the client.  The PostgreSQL default is NOTICE, the Sequel default is
+  #                         WARNING.  Set to nil to not change the server default. Overridable on
+  #                         a per instance basis via the :client_min_messages option.
+  # :force_standard_strings :: Set to false to not force the use of standard strings.  Overridable
+  #                            on a per instance basis via the :force_standard_strings option.
   # :search_path :: Set the schema search_path for this Database's connections.
   #                 Allows to to set which schemas do not need explicit
   #                 qualification, and in which order to check the schemas when
@@ -27,6 +19,88 @@ module Sequel
   module Postgres
     Sequel::Database.set_shared_adapter_scheme(:postgres, self)
 
+    NAN             = 0.0/0.0
+    PLUS_INFINITY   = 1.0/0.0
+    MINUS_INFINITY  = -1.0/0.0
+
+    NAN_STR             = 'NaN'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :NAN_STR)
+    PLUS_INFINITY_STR   = 'Infinity'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :PLUS_INFINITY_STR)
+    MINUS_INFINITY_STR  = '-Infinity'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :MINUS_INFINITY_STR)
+    TRUE_STR = 't'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :TRUE_STR)
+    DASH_STR = '-'.freeze
+    Sequel::Deprecation.deprecate_constant(self, :DASH_STR)
+    
+    TYPE_TRANSLATOR = tt = Class.new do
+      def boolean(s) s == 't' end
+      def integer(s) s.to_i end
+      def float(s) 
+        case s
+        when 'NaN'
+          NAN
+        when 'Infinity'
+          PLUS_INFINITY
+        when '-Infinity'
+          MINUS_INFINITY
+        else
+          s.to_f 
+        end
+      end
+      def date(s) ::Date.new(*s.split('-').map(&:to_i)) end
+      def bytea(str)
+        str = if str =~ /\A\\x/
+          # PostgreSQL 9.0+ bytea hex format
+          str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
+        else
+          # Historical PostgreSQL bytea escape format
+          str.gsub(/\\(\\|'|[0-3][0-7][0-7])/) {|s|
+            if s.size == 2 then s[1,1] else s[1,3].oct.chr end
+          }
+        end
+        ::Sequel::SQL::Blob.new(str)
+      end
+    end.new#.freeze # SEQUEL5
+
+    # Type OIDs for string types used by PostgreSQL.  These types don't
+    # have conversion procs associated with them (since the data is
+    # already in the form of a string).
+    STRING_TYPES = [18, 19, 25, 1042, 1043] # SEQUEL5: Remove
+
+    # Hash with type name strings/symbols and callable values for converting PostgreSQL types.
+    # Non-builtin types that don't have fixed numbers should use this to register
+    # conversion procs.
+    PG_NAMED_TYPES = {} unless defined?(PG_NAMED_TYPES)
+    PG_NAMED__TYPES = PG_NAMED_TYPES
+    Sequel::Deprecation.deprecate_constant(self, :PG_NAMED_TYPES)
+
+    # Hash with integer keys and callable values for converting PostgreSQL types.
+    PG_TYPES = {} unless defined?(PG_TYPES)
+
+    #CONVERSION_PROCS = {} # SEQUEL5
+
+    {
+      [16] => tt.method(:boolean),
+      [17] => tt.method(:bytea),
+      [20, 21, 23, 26] => tt.method(:integer),
+      [700, 701] => tt.method(:float),
+      [1700] => ::BigDecimal.method(:new),
+      [1083, 1266] => ::Sequel.method(:string_to_time),
+      [1082] => ::Sequel.method(:string_to_date),
+      [1184, 1114] => ::Sequel.method(:database_to_application_timestamp),
+    }.each do |k,v|
+      k.each do |n|
+        PG_TYPES[n] = v
+        #CONVERSION_PROCS[n] = v # SEQUEL5
+      end
+    end
+    PG__TYPES = PG_TYPES
+    Sequel::Deprecation.deprecate_constant(self, :PG_TYPES)
+
+    #CONVERSION_PROCS.freeze # SEQUEL5
+
     module MockAdapterDatabaseMethods
       def bound_variable_arg(arg, conn)
         arg
@@ -45,26 +119,30 @@ module Sequel
       end
     end
 
-    # Array of exceptions that need to be converted.  JDBC
-    # uses NativeExceptions, the native adapter uses PGError.
     CONVERTED_EXCEPTIONS = []
+    Sequel::Deprecation.deprecate_constant(self, :CONVERTED_EXCEPTIONS)
 
+    # SEQUEL5: Remove
     @client_min_messages = :warning
     @force_standard_strings = true
-
     class << self
-      # By default, Sequel sets the minimum level of log messages sent to the client
-      # to WARNING, where PostgreSQL uses a default of NOTICE.  This is to avoid a lot
-      # of mostly useless messages when running migrations, such as a couple of lines
-      # for every serial primary key field.
-      attr_accessor :client_min_messages
-
-      # By default, Sequel forces the use of standard strings, so that
-      # '\\' is interpreted as \\ and not \.  While PostgreSQL <9.1 defaults
-      # to interpreting plain strings, newer versions use standard strings by
-      # default.  Sequel assumes that SQL standard strings will be used.  Setting
-      # this to false means Sequel will use the database's default.
-      attr_accessor :force_standard_strings
+      def client_min_messages
+        Sequel::Deprecation.deprecate("Sequel::Postgres.client_min_messages", "Use the :client_min_messages Database option instead")
+        @client_min_messages
+      end
+      def client_min_messages=(v)
+        Sequel::Deprecation.deprecate("Sequel::Postgres.client_min_messages=", "Use the :client_min_messages Database option instead")
+        @client_min_messages = v
+      end
+
+      def force_standard_strings
+        Sequel::Deprecation.deprecate("Sequel::Postgres.force_standard_strings", "Use the :force_standard_strings Database option instead")
+        @force_standard_strings
+      end
+      def force_standard_strings=(v)
+        Sequel::Deprecation.deprecate("Sequel::Postgres.force_standard_strings=", "Use the :force_standard_strings Database option instead")
+        @force_standard_strings = v
+      end
     end
 
     class CreateTableGenerator < Sequel::Schema::CreateTableGenerator
@@ -179,6 +257,12 @@ module Sequel
       # having callable values for the conversion proc for that type.
       attr_reader :conversion_procs
 
+      # Set a conversion proc for the given oid.  The callable can
+      # be passed either as a argument or a block.
+      def add_conversion_proc(oid, callable=Proc.new)
+        conversion_procs[oid] = callable
+      end
+
       # Add a conversion proc for a named type.  This should be used 
       # for types without fixed OIDs, which includes all types that
       # are not included in a default PostgreSQL installation.  If 
@@ -190,7 +274,12 @@ module Sequel
             Sequel::Deprecation.deprecate("Sequel::PG_NAMED_TYPES", "Call Database#add_named_conversion_proc directly for each database you want to support the #{name} type")
           end
         end
-        add_named_conversion_procs(conversion_procs, name=>block)
+        add_named_conversion_procs(conversion_procs, name=>block) # SEQUEL5: Remove
+        # SEQUEL5:
+        #unless oid = from(:pg_type).where(:typtype=>['b', 'e'], :typname=>name.to_s).get(:oid)
+        #  raise Error, "No matching type in pg_type for #{name.inspect}"
+        #end
+        #add_conversion_proc(oid, block) # SEQUEL5
       end
 
       # Commit an existing prepared transaction with the given transaction
@@ -316,68 +405,67 @@ module Sequel
       def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         schema, _ = opts.fetch(:schema, schema_and_table(table))
-        range = 0...32
         oid = regclass_oid(table)
 
-        base_ds = metadata_dataset.
+        if server_version >= 90500
+          cpos = Sequel.expr{array_position(co[:conkey], att[:attnum])}
+          rpos = Sequel.expr{array_position(co[:confkey], att2[:attnum])}
+        else
+          range = 0...32
+          cpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, att[:attnum])}
+          rpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, att2[:attnum])}
+        end
+
+        ds = metadata_dataset.
           from{pg_constraint.as(:co)}.
           join(Sequel[:pg_class].as(:cl), :oid=>:conrelid).
+          join(Sequel[:pg_attribute].as(:att), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          join(Sequel[:pg_class].as(:cl2), :oid=>Sequel[:co][:confrelid]).
+          join(Sequel[:pg_attribute].as(:att2), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:confkey])).
+          order{[co[:conname], cpos]}.
           where{{
             cl[:relkind]=>'r',
             co[:contype]=>'f',
-            cl[:oid]=>oid}}
-
-        # We split the parsing into two separate queries, which are merged manually later.
-        # This is because PostgreSQL stores both the referencing and referenced columns in
-        # arrays, and I don't know a simple way to not create a cross product, as PostgreSQL
-        # doesn't appear to have a function that takes an array and element and gives you
-        # the index of that element in the array.
-
-        ds = base_ds.
-          join(Sequel[:pg_attribute].as(:att), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
-          order{[
-            co[:conname],
-            SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, att[:attnum])]}.
+            cl[:oid]=>oid,
+            cpos=>rpos
+            }}.
           select{[
             co[:conname].as(:name),
             att[:attname].as(:column),
             co[:confupdtype].as(:on_update),
             co[:confdeltype].as(:on_delete),
-            SQL::BooleanExpression.new(:AND, co[:condeferrable], co[:condeferred]).as(:deferrable)]}
-
-        ref_ds = base_ds.
-          join(Sequel[:pg_class].as(:cl2), :oid=>Sequel[:co][:confrelid]).
-          join(Sequel[:pg_attribute].as(:att2), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:confkey])).
-          order{[
-            co[:conname],
-            SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, att2[:attnum])]}.
-          select{[
-            co[:conname].as(:name),
             cl2[:relname].as(:table),
-            att2[:attname].as(:refcolumn)]}
+            att2[:attname].as(:refcolumn),
+            SQL::BooleanExpression.new(:AND, co[:condeferrable], co[:condeferred]).as(:deferrable)
+          ]}
 
         # If a schema is given, we only search in that schema, and the returned :table
         # entry is schema qualified as well.
         if schema
-          ref_ds = ref_ds.join(Sequel[:pg_namespace].as(:nsp2), :oid=>Sequel[:cl2][:relnamespace]).
+          ds = ds.join(Sequel[:pg_namespace].as(:nsp2), :oid=>Sequel[:cl2][:relnamespace]).
             select_append{nsp2[:nspname].as(:schema)}
         end
 
         h = {}
         fklod_map = FOREIGN_KEY_LIST_ON_DELETE_MAP 
+
         ds.each do |row|
           if r = h[row[:name]]
             r[:columns] << m.call(row[:column])
+            r[:key] << m.call(row[:refcolumn])
           else
-            h[row[:name]] = {:name=>m.call(row[:name]), :columns=>[m.call(row[:column])], :on_update=>fklod_map[row[:on_update]], :on_delete=>fklod_map[row[:on_delete]], :deferrable=>row[:deferrable]}
+            h[row[:name]] = {
+              :name=>m.call(row[:name]),
+              :columns=>[m.call(row[:column])],
+              :key=>[m.call(row[:refcolumn])],
+              :on_update=>fklod_map[row[:on_update]],
+              :on_delete=>fklod_map[row[:on_delete]],
+              :deferrable=>row[:deferrable],
+              :table=>schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table])
+            }
           end
         end
-        ref_ds.each do |row|
-          r = h[row[:name]]
-          r[:table] ||= schema ? SQL::QualifiedIdentifier.new(m.call(row[:schema]), m.call(row[:table])) : m.call(row[:table])
-          r[:key] ||= []
-          r[:key] << m.call(row[:refcolumn])
-        end
+
         h.values
       end
 
@@ -391,9 +479,18 @@ module Sequel
       # Use the pg_* system tables to determine indexes on a table
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
-        range = 0...32
-        attnums = server_version >= 80100 ? SQL::Function.new(:ANY, Sequel[:ind][:indkey]) : range.map{|x| SQL::Subscript.new(Sequel[:ind][:indkey], [x])}
         oid = regclass_oid(table, opts)
+
+        if server_version >= 90500
+          order = [Sequel[:indc][:relname], Sequel.function(:array_position, Sequel[:ind][:indkey], Sequel[:att][:attnum])]
+        else
+          range = 0...32
+          order = [Sequel[:indc][:relname], SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(Sequel[:ind][:indkey], [x]), x]}, 32, Sequel[:att][:attnum])]
+          attnums = range.map{|x| SQL::Subscript.new(Sequel[:ind][:indkey], [x])} unless server_version >= 80100 
+        end
+
+        attnums ||= SQL::Function.new(:ANY, Sequel[:ind][:indkey])
+
         ds = metadata_dataset.
           from{pg_class.as(:tab)}.
           join(Sequel[:pg_index].as(:ind), :indrelid=>:oid).
@@ -407,7 +504,7 @@ module Sequel
             :indpred=>nil,
             :indisvalid=>true,
             tab[:oid]=>oid}}.
-          order{[indc[:relname], SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(ind[:indkey], [x]), x]}, 32, att[:attnum])]}.
+          order(*order).
           select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
 
         ds = ds.where(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
@@ -478,9 +575,9 @@ module Sequel
         run "REFRESH MATERIALIZED VIEW#{' CONCURRENTLY' if opts[:concurrently]} #{quote_schema_table(name)}"
       end
       
-      # Reset the database's conversion procs, requires a server query if there
-      # any named types.
+      # SEQUEL5: Remove
       def reset_conversion_procs
+        Sequel::Deprecation.deprecate('Database#reset_conversion_procs', 'There should no longer be a need to reset conversion procs')
         @conversion_procs = get_conversion_procs
         conversion_procs_updated
         @conversion_procs
@@ -626,8 +723,7 @@ module Sequel
 
       private
 
-      # Do a type name-to-oid lookup using the database and update the procs
-      # with the related proc if the database supports the type.
+      # SEQUEL5: Remove
       def add_named_conversion_procs(procs, named_procs)
         unless (named_procs).empty?
           convert_named_procs_to_procs(named_procs).each do |oid, pr|
@@ -730,9 +826,10 @@ module Sequel
       def connection_configuration_sqls
         sqls = []
 
-        sqls << "SET standard_conforming_strings = ON" if typecast_value_boolean(@opts.fetch(:force_standard_strings, Postgres.force_standard_strings))
+        sqls << "SET standard_conforming_strings = ON" if typecast_value_boolean(@opts.fetch(:force_standard_strings, Postgres.instance_variable_get(:@force_standard_strings))) # , true)) # SEQUEL5
 
-        if (cmm = @opts.fetch(:client_min_messages, Postgres.client_min_messages)) && !cmm.to_s.empty?
+        cmm = @opts.fetch(:client_min_messages, Postgres.instance_variable_get(:@client_min_messages)) # , :warning) # SEQUEL5
+        if cmm && !cmm.to_s.empty?
           cmm = cmm.to_s.upcase.strip
           unless VALID_CLIENT_MIN_MESSAGES.include?(cmm)
             raise Error, "Unsupported client_min_messages setting: #{cmm}"
@@ -775,12 +872,12 @@ module Sequel
         end
       end
 
-      # Callback used when conversion procs are updated.
+      # SEQUEL5: Remove
       def conversion_procs_updated
         nil
       end
 
-      # Convert the hash of named conversion procs into a hash a oid conversion procs. 
+      # SEQUEL5: Remove
       def convert_named_procs_to_procs(named_procs)
         h = {}
         from(:pg_type).where(:typtype=>['b', 'e'], :typname=>named_procs.keys.map(&:to_s)).select_map([:oid, :typname]).each do |oid, name|
@@ -789,12 +886,12 @@ module Sequel
         h
       end
 
-      # Copy the conversion procs related to the given oids from PG_TYPES into
-      # the conversion procs for this instance.
+      # SEQUEL5: Remove
       def copy_conversion_procs(oids)
+        Sequel::Deprecation.deprecate("Database#copy_conversion_procs", "There is no reason to use this anymore")
         procs = conversion_procs
         oids.each do |oid|
-          procs[oid] = PG_TYPES[oid]
+          procs[oid] = PG__TYPES[oid]
         end
         conversion_procs_updated
       end
@@ -965,11 +1062,6 @@ module Sequel
         create_view_sql_append_columns("CREATE #{'OR REPLACE 'if options[:replace]}#{'TEMPORARY 'if options[:temp]}#{'RECURSIVE ' if options[:recursive]}#{'MATERIALIZED ' if options[:materialized]}VIEW #{quote_schema_table(name)}", options[:columns] || options[:recursive])
       end
 
-      # The errors that the main adapters can raise, depends on the adapter being used
-      def database_error_classes
-        CONVERTED_EXCEPTIONS
-      end
-
       # SQL for dropping a function from the database.
       def drop_function_sql(name, opts=OPTS)
         "DROP FUNCTION#{' IF EXISTS' if opts[:if_exists]} #{name}#{sql_function_args(opts[:args])}#{' CASCADE' if opts[:cascade]}"
@@ -1017,9 +1109,9 @@ module Sequel
         ds.where{{pg_namespace[:nspname]=>expr}}
       end
 
-      # Return a hash with oid keys and callable values, used for converting types.
+      # SEQUEL5: Remove
       def get_conversion_procs
-        procs = PG_TYPES.dup
+        procs = PG__TYPES.dup
         procs[1184] = procs[1114] = method(:to_application_timestamp)
         unless PG_NAMED__TYPES.empty?
           Sequel::Deprecation.deprecate("Sequel::PG_NAMED_TYPES", "Call Database#add_named_conversion_proc directly for each Database instance where you want to support the following type(s): #{PG_NAMED__TYPES.keys.join(', ')}")
@@ -1056,8 +1148,10 @@ module Sequel
         @primary_keys = {}
         @primary_key_sequences = {}
         @supported_types = {}
-        @conversion_procs = PG_TYPES.dup
-        reset_conversion_procs
+        @conversion_procs = get_conversion_procs # SEQUEL5: Remove
+        conversion_procs_updated # SEQUEL5: Remove
+        # @conversion_procs = CONVERSION_PROCS.dup # SEQUEL5
+        # procs[1184] = procs[1114] = method(:to_application_timestamp) # SEQUEL5
       end
 
       # Backbone of the tables and views support.
@@ -1299,16 +1393,24 @@ module Sequel
       AS = ' AS '.freeze
       Sequel::Deprecation.deprecate_constant(self, :AS)
       XOR_OP = ' # '.freeze
+      Sequel::Deprecation.deprecate_constant(self, :XOR_OP)
       CRLF = "\r\n".freeze
+      Sequel::Deprecation.deprecate_constant(self, :CRLF)
       BLOB_RE = /[\000-\037\047\134\177-\377]/n.freeze
+      Sequel::Deprecation.deprecate_constant(self, :BLOB_RE)
       WINDOW = " WINDOW ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :WINDOW)
       SELECT_VALUES = "VALUES ".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SELECT_VALUES)
       EMPTY_STRING = ''.freeze
+      Sequel::Deprecation.deprecate_constant(self, :EMPTY_STRING)
       SKIP_LOCKED = " SKIP LOCKED".freeze
+      Sequel::Deprecation.deprecate_constant(self, :SKIP_LOCKED)
+      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:cursor, :insert_conflict]).freeze
+      Sequel::Deprecation.deprecate_constant(self, :NON_SQL_OPTIONS)
 
       NULL = LiteralString.new('NULL').freeze
-      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze)
-      NON_SQL_OPTIONS = (Dataset::NON_SQL_OPTIONS + [:cursor, :insert_conflict]).freeze
+      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze)#.freeze # SEQUEL5
 
       Dataset.def_sql_method(self, :delete, [['if server_version >= 90100', %w'with delete from using where returning'], ['else', %w'delete from using where returning']])
       Dataset.def_sql_method(self, :insert, [['if server_version >= 90500', %w'with insert into columns values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
@@ -1768,7 +1870,7 @@ module Sequel
         sql << "'" << v.gsub("'", "''") << "'"
       end
 
-      # PostgreSQL uses FALSE for false values
+      # PostgreSQL uses true for true values
       def literal_true
         'true'
       end
@@ -1779,8 +1881,8 @@ module Sequel
       end
 
       # Dataset options that do not affect the generated SQL.
-      def non_sql_options
-        NON_SQL_OPTIONS
+      def non_sql_option?(key)
+        super || key == :cursor || key == :insert_conflict
       end
 
       # PostgreSQL requires parentheses around compound datasets if they use