sequel 4.36.0 → 5.61.0

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

@@ -1,63 +1,113 @@
 # frozen-string-literal: true
 
-Sequel.require 'adapters/utils/pg_types'
+require_relative '../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
   #                 an unqualified object is referenced.
   module Postgres
-    # Array of exceptions that need to be converted.  JDBC
-    # uses NativeExceptions, the native adapter uses PGError.
-    CONVERTED_EXCEPTIONS = []
-
-    @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
+    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
+
+    boolean = Object.new
+    def boolean.call(s) s == 't' end
+    integer = Object.new
+    def integer.call(s) s.to_i end
+    float = Object.new
+    def float.call(s) 
+      case s
+      when 'NaN'
+        NAN
+      when 'Infinity'
+        PLUS_INFINITY
+      when '-Infinity'
+        MINUS_INFINITY
+      else
+        s.to_f 
+      end
+    end
+    date = Object.new
+    def date.call(s) ::Date.new(*s.split('-').map(&:to_i)) end
+    TYPE_TRANSLATOR_DATE = date.freeze
+    bytea = Object.new
+    def bytea.call(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
+
+    CONVERSION_PROCS = {}
+
+    {
+      [16] => boolean,
+      [17] => bytea,
+      [20, 21, 23, 26] => integer,
+      [700, 701] => float,
+      [1700] => ::Kernel.method(:BigDecimal),
+      [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|
+        CONVERSION_PROCS[n] = v
+      end
+    end
+    CONVERSION_PROCS.freeze
+
+    module MockAdapterDatabaseMethods
+      def bound_variable_arg(arg, conn)
+        arg
+      end
+
+      def primary_key(table)
+        :id
+      end
     end
 
-    class CreateTableGenerator < Sequel::Schema::Generator
+    def self.mock_adapter_setup(db)
+      db.instance_exec do
+        @server_version = 140000
+        initialize_postgres_adapter
+        extend(MockAdapterDatabaseMethods)
+      end
+    end
+
+    class CreateTableGenerator < Sequel::Schema::CreateTableGenerator
       # Add an exclusion constraint when creating the table. Elements should be
       # an array of 2 element arrays, with the first element being the column or
       # expression the exclusion constraint is applied to, and the second element
-      # being the operator to use for the column/expression to check for exclusion.
-      #
-      # Example:
+      # being the operator to use for the column/expression to check for exclusion:
       #
       #   exclude([[:col1, '&&'], [:col2, '=']])
       #   # EXCLUDE USING gist (col1 WITH &&, col2 WITH =)
       #
+      # To use a custom operator class, you need to use Sequel.lit with the expression
+      # and operator class:
+      #
+      #   exclude([[Sequel.lit('col1 inet_ops'), '&&'], [:col2, '=']])
+      #   # EXCLUDE USING gist (col1 inet_ops WITH &&, col2 WITH =)
+      #
       # Options supported:
       #
       # :name :: Name the constraint with the given name (useful if you may
@@ -84,21 +134,105 @@ module Sequel
       end
     end
 
+    # Generator used for creating tables that are partitions of other tables.
+    class CreatePartitionOfTableGenerator
+      MINVALUE = Sequel.lit('MINVALUE').freeze
+      MAXVALUE = Sequel.lit('MAXVALUE').freeze
+
+      def initialize(&block)
+        instance_exec(&block)
+      end
+
+      # The minimum value of the data type used in range partitions, useful
+      # as an argument to #from.
+      def minvalue
+        MINVALUE
+      end
+
+      # The minimum value of the data type used in range partitions, useful
+      # as an argument to #to.
+      def maxvalue
+        MAXVALUE
+      end
+
+      # Assumes range partitioning, sets the inclusive minimum value of the range for
+      # this partition.
+      def from(*v)
+        @from = v
+      end
+
+      # Assumes range partitioning, sets the exclusive maximum value of the range for
+      # this partition.
+      def to(*v)
+        @to = v
+      end
+
+      # Assumes list partitioning, sets the values to be included in this partition.
+      def values_in(*v)
+        @in = v
+      end
+
+      # Assumes hash partitioning, sets the modulus for this parition.
+      def modulus(v)
+        @modulus = v
+      end
+
+      # Assumes hash partitioning, sets the remainder for this parition.
+      def remainder(v)
+        @remainder = v
+      end
+
+      # Sets that this is a default partition, where values not in other partitions
+      # are stored.
+      def default
+        @default = true
+      end
+
+      # The from and to values of this partition for a range partition.
+      def range
+        [@from, @to]
+      end
+
+      # The values to include in this partition for a list partition.
+      def list
+        @in
+      end
+
+      # The modulus and remainder to use for this partition for a hash partition.
+      def hash_values
+        [@modulus, @remainder]
+      end
+
+      # Determine the appropriate partition type for this partition by which methods
+      # were called on it.
+      def partition_type
+        raise Error, "Unable to determine partition type, multiple different partitioning methods called" if [@from || @to, @list, @modulus || @remainder, @default].compact.length > 1
+
+        if @from || @to
+          raise Error, "must call both from and to when creating a partition of a table if calling either" unless @from && @to
+          :range
+        elsif @in
+          :list
+        elsif @modulus || @remainder
+          raise Error, "must call both modulus and remainder when creating a partition of a table if calling either" unless @modulus && @remainder
+          :hash
+        elsif @default
+          :default
+        else
+          raise Error, "unable to determine partition type, no partitioning methods called"
+        end
+      end
+    end
+
     # Error raised when Sequel determines a PostgreSQL exclusion constraint has been violated.
     class ExclusionConstraintViolation < Sequel::ConstraintViolation; end
 
-    # Methods shared by Database instances that connect to PostgreSQL.
     module DatabaseMethods
-      extend Sequel::Database::ResetIdentifierMangling
+      include UnmodifiedIdentifiers::DatabaseMethods
 
-      PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').freeze
-      RE_CURRVAL_ERROR = /currval of sequence "(.*)" is not yet defined in this session|relation "(.*)" does not exist/.freeze
-      FOREIGN_KEY_LIST_ON_DELETE_MAP = {'a'.freeze=>:no_action, 'r'.freeze=>:restrict, 'c'.freeze=>:cascade, 'n'.freeze=>:set_null, 'd'.freeze=>:set_default}.freeze
-      POSTGRES_DEFAULT_RE = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/
-      UNLOGGED = 'UNLOGGED '.freeze
-      ON_COMMIT = {
-        :drop => 'DROP', :delete_rows => 'DELETE ROWS', :preserve_rows => 'PRESERVE ROWS',
-      }.freeze
+      FOREIGN_KEY_LIST_ON_DELETE_MAP = {'a'=>:no_action, 'r'=>:restrict, 'c'=>:cascade, 'n'=>:set_null, 'd'=>:set_default}.freeze
+      ON_COMMIT = {:drop => 'DROP', :delete_rows => 'DELETE ROWS', :preserve_rows => 'PRESERVE ROWS'}.freeze
+      ON_COMMIT.each_value(&:freeze)
 
       # SQL fragment for custom sequences (ones not created by serial primary key),
       # Returning the schema and literal form of the sequence name, by parsing
@@ -106,10 +240,10 @@ module Sequel
       SELECT_CUSTOM_SEQUENCE_SQL = (<<-end_sql
         SELECT name.nspname AS "schema",
             CASE
-            WHEN split_part(def.adsrc, '''', 2) ~ '.' THEN
-              substr(split_part(def.adsrc, '''', 2),
-                     strpos(split_part(def.adsrc, '''', 2), '.')+1)
-            ELSE split_part(def.adsrc, '''', 2)
+            WHEN split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2) ~ '.' THEN
+              substr(split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2),
+                     strpos(split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2), '.')+1)
+            ELSE split_part(pg_get_expr(def.adbin, attr.attrelid), '''', 2)
           END AS "sequence"
         FROM pg_class t
         JOIN pg_namespace  name ON (t.relnamespace = name.oid)
@@ -117,7 +251,7 @@ module Sequel
         JOIN pg_attrdef    def  ON (adrelid = attrelid AND adnum = attnum)
         JOIN pg_constraint cons ON (conrelid = adrelid AND adnum = conkey[1])
         WHERE cons.contype = 'p'
-          AND def.adsrc ~* 'nextval'
+          AND pg_get_expr(def.adbin, attr.attrelid) ~* 'nextval'
       end_sql
       ).strip.gsub(/\s+/, ' ').freeze
 
@@ -156,21 +290,121 @@ module Sequel
       # having callable values for the conversion proc for that type.
       attr_reader :conversion_procs
 
-      # 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 
-      # a block is given, it is used as the conversion proc, otherwise
-      # the conversion proc is looked up in the PG_NAMED_TYPES hash.
+      # 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=nil, &block)
+        conversion_procs[oid] = callable || block
+      end
+
+      # Add a conversion proc for a named type, using the given block.
+      # This should be used for types without fixed OIDs, which includes all types that
+      # are not included in a default PostgreSQL installation.
       def add_named_conversion_proc(name, &block)
-        add_named_conversion_procs(conversion_procs, name=>(block || PG_NAMED_TYPES[name]))
+        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)
       end
 
-      # Commit an existing prepared transaction with the given transaction
-      # identifier string.
       def commit_prepared_transaction(transaction_id, opts=OPTS)
         run("COMMIT PREPARED #{literal(transaction_id)}", opts)
       end
 
+      # A hash of metadata for CHECK constraints on the table.
+      # Keys are CHECK constraint name symbols.  Values are hashes with the following keys:
+      # :definition :: An SQL fragment for the definition of the constraint
+      # :columns :: An array of column symbols for the columns referenced in the constraint,
+      #             can be an empty array if the database cannot deteremine the column symbols.
+      def check_constraints(table)
+        m = output_identifier_meth
+
+        rows = metadata_dataset.
+          from{pg_constraint.as(:co)}.
+          left_join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          where(:conrelid=>regclass_oid(table), :contype=>'c').
+          select{[co[:conname].as(:constraint), att[:attname].as(:column), pg_get_constraintdef(co[:oid]).as(:definition)]}
+
+        hash = {}
+        rows.each do |row|
+          constraint = m.call(row[:constraint])
+          entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[]}
+          entry[:columns] << m.call(row[:column]) if row[:column]
+        end
+        
+        hash
+      end
+
+      # Convert the first primary key column in the +table+ from being a serial column to being an identity column.
+      # If the column is already an identity column, assume it was already converted and make no changes.
+      #
+      # Only supported on PostgreSQL 10.2+, since on those versions Sequel will use identity columns
+      # instead of serial columns for auto incrementing primary keys. Only supported when running as
+      # a superuser, since regular users cannot modify system tables, and there is no way to keep an
+      # existing sequence when changing an existing column to be an identity column.
+      #
+      # This method can raise an exception in at least the following cases where it may otherwise succeed
+      # (there may be additional cases not listed here):
+      #
+      # * The serial column was added after table creation using PostgreSQL <7.3
+      # * A regular index also exists on the column (such an index can probably be dropped as the
+      #   primary key index should suffice)
+      #
+      # Options:
+      # :column :: Specify the column to convert instead of using the first primary key column
+      # :server :: Run the SQL on the given server
+      def convert_serial_to_identity(table, opts=OPTS)
+        raise Error, "convert_serial_to_identity is only supported on PostgreSQL 10.2+" unless server_version >= 100002
+
+        server = opts[:server]
+        server_hash = server ? {:server=>server} : OPTS
+        ds = dataset
+        ds = ds.server(server) if server
+
+        raise Error, "convert_serial_to_identity requires superuser permissions" unless ds.get{current_setting('is_superuser')} == 'on'
+
+        table_oid = regclass_oid(table)
+        im = input_identifier_meth
+        unless column = (opts[:column] || ((sch = schema(table).find{|_, sc| sc[:primary_key] && sc[:auto_increment]}) && sch[0]))
+          raise Error, "could not determine column to convert from serial to identity automatically"
+        end
+        column = im.call(column)
+
+        column_num = ds.from(:pg_attribute).
+          where(:attrelid=>table_oid, :attname=>column).
+          get(:attnum)
+
+        pg_class = Sequel.cast('pg_class', :regclass)
+        res = ds.from(:pg_depend).
+          where(:refclassid=>pg_class, :refobjid=>table_oid, :refobjsubid=>column_num, :classid=>pg_class, :objsubid=>0, :deptype=>%w'a i').
+          select_map([:objid, Sequel.as({:deptype=>'i'}, :v)])
+
+        case res.length
+        when 0
+          raise Error, "unable to find related sequence when converting serial to identity"
+        when 1
+          seq_oid, already_identity = res.first
+        else
+          raise Error, "more than one linked sequence found when converting serial to identity"
+        end
+
+        return if already_identity
+
+        transaction(server_hash) do
+          run("ALTER TABLE #{quote_schema_table(table)} ALTER COLUMN #{quote_identifier(column)} DROP DEFAULT", server_hash)
+
+          ds.from(:pg_depend).
+            where(:classid=>pg_class, :objid=>seq_oid, :objsubid=>0, :deptype=>'a').
+            update(:deptype=>'i')
+
+          ds.from(:pg_attribute).
+            where(:attrelid=>table_oid, :attname=>column).
+            update(:attidentity=>'d')
+        end
+
+        remove_cached_schema(table)
+        nil
+      end
+
       # Creates the function in the database.  Arguments:
       # name :: name of the function to create
       # definition :: string definition of the function, or object file for a dynamically loaded C function.
@@ -180,6 +414,7 @@ module Sequel
       #                  2 :: argument name
       #                  3 :: argument mode (e.g. in, out, inout)
       #         :behavior :: Should be IMMUTABLE, STABLE, or VOLATILE.  PostgreSQL assumes VOLATILE by default.
+      #         :parallel :: The thread safety attribute of the function. Should be SAFE, UNSAFE, RESTRICTED. PostgreSQL assumes UNSAFE by default.
       #         :cost :: The estimated cost of the function, used by the query planner.
       #         :language :: The language the function uses.  SQL is the default.
       #         :link_symbol :: For a dynamically loaded see function, the function's link symbol if different from the definition argument.
@@ -215,6 +450,26 @@ module Sequel
         self << create_schema_sql(name, opts)
       end
 
+      # Support partitions of tables using the :partition_of option.
+      def create_table(name, options=OPTS, &block)
+        if options[:partition_of]
+          create_partition_of_table_from_generator(name, CreatePartitionOfTableGenerator.new(&block), options)
+          return
+        end
+
+        super
+      end
+
+      # Support partitions of tables using the :partition_of option.
+      def create_table?(name, options=OPTS, &block)
+        if options[:partition_of]
+          create_table(name, options.merge!(:if_not_exists=>true), &block)
+          return
+        end
+
+        super
+      end
+
       # Create a trigger in the database.  Arguments:
       # table :: the table on which this trigger operates
       # name :: the name of this trigger
@@ -225,12 +480,12 @@ module Sequel
       #         :each_row :: Calls the trigger for each row instead of for each statement.
       #         :events :: Can be :insert, :update, :delete, or an array of any of those. Calls the trigger whenever that type of statement is used.  By default,
       #                    the trigger is called for insert, update, or delete.
+      #         :replace :: Replace the trigger with the same name if it already exists (PostgreSQL 14+).
       #         :when :: A filter to use for the trigger
       def create_trigger(table, name, function, opts=OPTS)
         self << create_trigger_sql(table, name, function, opts)
       end
 
-      # PostgreSQL uses the :postgres database type.
       def database_type
         :postgres
       end
@@ -285,75 +540,150 @@ module Sequel
 
       # Return full foreign key information using the pg system tables, including
       # :name, :on_delete, :on_update, and :deferrable entries in the hashes.
+      #
+      # Supports additional options:
+      # :reverse :: Instead of returning foreign keys in the current table, return
+      #             foreign keys in other tables that reference the current table.
+      # :schema :: Set to true to have the :table value in the hashes be a qualified
+      #            identifier.  Set to false to use a separate :schema value with
+      #            the related schema.  Defaults to whether the given table argument
+      #            is a qualified identifier.
       def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         schema, _ = opts.fetch(:schema, schema_and_table(table))
-        range = 0...32
-
-        base_ds = metadata_dataset.
-          from(:pg_constraint___co).
-          join(:pg_class___cl, :oid=>:conrelid).
-          where(:cl__relkind=>'r', :co__contype=>'f', :cl__oid=>regclass_oid(table))
-
-        # 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(:pg_attribute___att, :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, :co__conkey)).
-          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__conkey, [x]), x]}, 32, :att__attnum)).
-          select(:co__conname___name, :att__attname___column, :co__confupdtype___on_update, :co__confdeltype___on_delete,
-                 SQL::BooleanExpression.new(:AND, :co__condeferrable, :co__condeferred).as(:deferrable))
-
-        ref_ds = base_ds.
-          join(:pg_class___cl2, :oid=>:co__confrelid).
-          join(:pg_attribute___att2, :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, :co__confkey)).
-          order(:co__conname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:co__confkey, [x]), x]}, 32, :att2__attnum)).
-          select(:co__conname___name, :cl2__relname___table, :att2__attname___refcolumn)
-
-        # 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(:pg_namespace___nsp2, :oid=>:cl2__relnamespace).
-            select_more(:nsp2__nspname___schema)
+        oid = regclass_oid(table)
+        reverse = opts[:reverse]
+
+        if reverse
+          ctable = Sequel[:att2]
+          cclass = Sequel[:cl2]
+          rtable = Sequel[:att]
+          rclass = Sequel[:cl]
+        else
+          ctable = Sequel[:att]
+          cclass = Sequel[:cl]
+          rtable = Sequel[:att2]
+          rclass = Sequel[:cl2]
+        end
+
+        if server_version >= 90500
+          cpos = Sequel.expr{array_position(co[:conkey], ctable[:attnum])}
+          rpos = Sequel.expr{array_position(co[:confkey], rtable[:attnum])}
+        # :nocov:
+        else
+          range = 0...32
+          cpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:conkey], [x]), x]}, 32, ctable[:attnum])}
+          rpos = Sequel.expr{SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(co[:confkey], [x]), x]}, 32, rtable[:attnum])}
+        # :nocov:
+        end
+
+        ds = metadata_dataset.
+          from{pg_constraint.as(:co)}.
+          join(Sequel[:pg_class].as(cclass), :oid=>:conrelid).
+          join(Sequel[:pg_attribute].as(ctable), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          join(Sequel[:pg_class].as(rclass), :oid=>Sequel[:co][:confrelid]).
+          join(Sequel[:pg_attribute].as(rtable), :attrelid=>:oid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:confkey])).
+          join(Sequel[:pg_namespace].as(:nsp), :oid=>Sequel[:cl2][:relnamespace]).
+          order{[co[:conname], cpos]}.
+          where{{
+            cl[:relkind]=>%w'r p',
+            co[:contype]=>'f',
+            cl[:oid]=>oid,
+            cpos=>rpos
+          }}.
+          select{[
+            co[:conname].as(:name),
+            ctable[:attname].as(:column),
+            co[:confupdtype].as(:on_update),
+            co[:confdeltype].as(:on_delete),
+            cl2[:relname].as(:table),
+            rtable[:attname].as(:refcolumn),
+            SQL::BooleanExpression.new(:AND, co[:condeferrable], co[:condeferred]).as(:deferrable),
+            nsp[:nspname].as(:schema)
+          ]}
+
+        if reverse
+          ds = ds.order_append(Sequel[:nsp][:nspname], Sequel[:cl2][:relname])
         end
 
         h = {}
         fklod_map = FOREIGN_KEY_LIST_ON_DELETE_MAP 
+
         ds.each do |row|
-          if r = h[row[:name]]
+          if reverse
+            key = [row[:schema], row[:table], row[:name]]
+          else
+            key = row[:name]
+          end
+
+          if r = h[key]
             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]}
+            entry = h[key] = {
+              :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]),
+            }
+
+            unless schema
+              # If not combining schema information into the :table entry
+              # include it as a separate entry.
+              entry[:schema] = m.call(row[:schema])
+            end
           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
 
+      def freeze
+        server_version
+        supports_prepared_transactions?
+        @conversion_procs.freeze
+        super
+      end
+
       # 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, :ind__indkey) : range.map{|x| SQL::Subscript.new(:ind__indkey, [x])}
-        ds = metadata_dataset.
-          from(:pg_class___tab).
-          join(:pg_index___ind, :indrelid=>:oid).
-          join(:pg_class___indc, :oid=>:indexrelid).
-          join(:pg_attribute___att, :attrelid=>:tab__oid, :attnum=>attnums).
-          left_join(:pg_constraint___con, :conname=>:indc__relname).
-          filter(:indc__relkind=>'i', :ind__indisprimary=>false, :indexprs=>nil, :indpred=>nil, :indisvalid=>true, :tab__oid=>regclass_oid(table, opts)).
-          order(:indc__relname, SQL::CaseExpression.new(range.map{|x| [SQL::Subscript.new(:ind__indkey, [x]), x]}, 32, :att__attnum)).
-          select(:indc__relname___name, :ind__indisunique___unique, :att__attname___column, :con__condeferrable___deferrable)
+        oid = regclass_oid(table, opts)
+
+        if server_version >= 90500
+          order = [Sequel[:indc][:relname], Sequel.function(:array_position, Sequel[:ind][:indkey], Sequel[:att][:attnum])]
+        # :nocov:
+        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])]
+        # :nocov:
+        end
 
-        ds.filter!(:indisready=>true, :indcheckxmin=>false) if server_version >= 80300
+        attnums = SQL::Function.new(:ANY, Sequel[:ind][:indkey])
+
+        ds = metadata_dataset.
+          from{pg_class.as(:tab)}.
+          join(Sequel[:pg_index].as(:ind), :indrelid=>:oid).
+          join(Sequel[:pg_class].as(:indc), :oid=>:indexrelid).
+          join(Sequel[:pg_attribute].as(:att), :attrelid=>Sequel[:tab][:oid], :attnum=>attnums).
+          left_join(Sequel[:pg_constraint].as(:con), :conname=>Sequel[:indc][:relname]).
+          where{{
+            indc[:relkind]=>'i',
+            ind[:indisprimary]=>false,
+            :indexprs=>nil,
+            :indisvalid=>true,
+            tab[:oid]=>oid}}.
+          order(*order).
+          select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
+
+        ds = ds.where(:indpred=>nil) unless opts[:include_partial]
+        # :nocov:
+        ds = ds.where(:indisready=>true) if server_version >= 80300
+        ds = ds.where(:indislive=>true) if server_version >= 90300
+        # :nocov:
 
         indexes = {}
         ds.each do |r|
@@ -365,7 +695,7 @@ module Sequel
 
       # Dataset containing all current database locks
       def locks
-        dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select(:pg_class__relname, Sequel::SQL::ColumnAll.new(:pg_locks))
+        dataset.from(:pg_class).join(:pg_locks, :relation=>:relfilenode).select{[pg_class[:relname], Sequel::SQL::ColumnAll.new(:pg_locks)]}
       end
 
       # Notifies the given channel.  See the PostgreSQL NOTIFY documentation. Options:
@@ -421,28 +751,30 @@ 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.
-      def reset_conversion_procs
-        @conversion_procs = get_conversion_procs
-        conversion_procs_updated
-        @conversion_procs
-      end
-
       # Reset the primary key sequence for the given table, basing it on the
       # maximum current value of the table's primary key.
       def reset_primary_key_sequence(table)
         return unless seq = primary_key_sequence(table)
         pk = SQL::Identifier.new(primary_key(table))
         db = self
-        seq_ds = db.from(LiteralString.new(seq))
         s, t = schema_and_table(table)
         table = Sequel.qualify(s, t) if s
-        get{setval(seq, db[table].select{coalesce(max(pk)+seq_ds.select{:increment_by}, seq_ds.select(:min_value))}, false)}
+
+        if server_version >= 100000
+          seq_ds = metadata_dataset.from(:pg_sequence).where(:seqrelid=>regclass_oid(LiteralString.new(seq)))
+          increment_by = :seqincrement
+          min_value = :seqmin
+        # :nocov:
+        else
+          seq_ds = metadata_dataset.from(LiteralString.new(seq))
+          increment_by = :increment_by
+          min_value = :min_value
+        # :nocov:
+        end
+
+        get{setval(seq, db[table].select(coalesce(max(pk)+seq_ds.select(increment_by), seq_ds.select(min_value))), false)}
       end
 
-      # Rollback an existing prepared transaction with the given transaction
-      # identifier string.
       def rollback_prepared_transaction(transaction_id, opts=OPTS)
         run("ROLLBACK PREPARED #{literal(transaction_id)}", opts)
       end
@@ -450,24 +782,18 @@ module Sequel
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
       def serial_primary_key_options
-        {:primary_key => true, :serial => true, :type=>Integer}
+        # :nocov:
+        auto_increment_key = server_version >= 100002 ? :identity : :serial
+        # :nocov:
+        {:primary_key => true, auto_increment_key => true, :type=>Integer}
       end
 
       # The version of the PostgreSQL server, used for determining capability.
       def server_version(server=nil)
         return @server_version if @server_version
-        @server_version = synchronize(server) do |conn|
-          (conn.server_version rescue nil) if conn.respond_to?(:server_version)
-        end
-        unless @server_version
-          @server_version = if m = /PostgreSQL (\d+)\.(\d+)(?:(?:rc\d+)|\.(\d+))?/.match(fetch('SELECT version()').single_value)
-            (m[1].to_i * 10000) + (m[2].to_i * 100) + m[3].to_i
-          else
-            0
-          end
-        end
-        warn 'Sequel no longer supports PostgreSQL <8.2, some things may not work' if @server_version < 80200
-        @server_version
+        ds = dataset
+        ds = ds.server(server) if server
+        @server_version = swallow_database_error{ds.with_sql("SELECT CAST(current_setting('server_version_num') AS integer) AS v").single_value} || 0
       end
 
       # PostgreSQL supports CREATE TABLE IF NOT EXISTS on 9.1+
@@ -532,23 +858,24 @@ module Sequel
       # :schema :: The schema to search
       # :server :: The server to use
       def tables(opts=OPTS, &block)
-        pg_class_relname('r', opts, &block)
+        pg_class_relname(['r', 'p'], opts, &block)
       end
 
       # Check whether the given type name string/symbol (e.g. :hstore) is supported by
       # the database.
       def type_supported?(type)
-        @supported_types ||= {}
-        @supported_types.fetch(type){@supported_types[type] = (from(:pg_type).filter(:typtype=>'b', :typname=>type.to_s).count > 0)}
+        Sequel.synchronize{return @supported_types[type] if @supported_types.has_key?(type)}
+        supported = from(:pg_type).where(:typtype=>'b', :typname=>type.to_s).count > 0
+        Sequel.synchronize{return @supported_types[type] = supported}
       end
 
       # Creates a dataset that uses the VALUES clause:
       #
       #   DB.values([[1, 2], [3, 4]])
-      #   VALUES ((1, 2), (3, 4))
+      #   # VALUES ((1, 2), (3, 4))
       #
       #   DB.values([[1, 2], [3, 4]]).order(:column2).limit(1, 1)
-      #   VALUES ((1, 2), (3, 4)) ORDER BY column2 LIMIT 1 OFFSET 1
+      #   # VALUES ((1, 2), (3, 4)) ORDER BY column2 LIMIT 1 OFFSET 1
       def values(v)
         @default_dataset.clone(:values=>v)
       end
@@ -556,28 +883,22 @@ module Sequel
       # Array of symbols specifying view names in the current database.
       #
       # Options:
+      # :materialized :: Return materialized views
       # :qualify :: Return the views as Sequel::SQL::QualifiedIdentifier instances,
       #             using the schema the view is located in as the qualifier.
       # :schema :: The schema to search
       # :server :: The server to use
       def views(opts=OPTS)
-        pg_class_relname('v', opts)
+        relkind = opts[:materialized] ? 'm' : 'v'
+        pg_class_relname(relkind, opts)
       end
 
       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.
-      def add_named_conversion_procs(procs, named_procs)
-        unless (named_procs).empty?
-          convert_named_procs_to_procs(named_procs).each do |oid, pr|
-            procs[oid] ||= pr
-          end
-          conversion_procs_updated
-        end
+      def alter_table_add_column_sql(table, op)
+        "ADD COLUMN#{' IF NOT EXISTS' if op[:if_not_exists]} #{column_definition_sql(op)}"
       end
 
-      # Use a PostgreSQL-specific alter table generator
       def alter_table_generator_class
         Postgres::AlterTableGenerator
       end
@@ -637,9 +958,24 @@ module Sequel
         end
       end
 
+      # Support identity columns, but only use the identity SQL syntax if no
+      # default value is given.
+      def column_definition_default_sql(sql, column)
+        super
+        if !column[:serial] && !['smallserial', 'serial', 'bigserial'].include?(column[:type].to_s) && !column[:default]
+          if (identity = column[:identity])
+            sql << " GENERATED "
+            sql << (identity == :always ? "ALWAYS" : "BY DEFAULT")
+            sql << " AS IDENTITY"
+          elsif (generated = column[:generated_always_as])
+            sql << " GENERATED ALWAYS AS (#{literal(generated)}) STORED"
+          end
+        end
+      end
+
       # Handle PostgreSQL specific default format.
       def column_schema_normalize_default(default, type)
-        if m = POSTGRES_DEFAULT_RE.match(default)
+        if m = /\A(?:B?('.*')::[^']+|\((-?\d+(?:\.\d+)?)\))\z/.match(default)
           default = m[1] || m[2]
         end
         super(default, type)
@@ -661,14 +997,15 @@ module Sequel
         (super || op[:op] == :validate_constraint) && op[:op] != :rename_column
       end
 
-      VALID_CLIENT_MIN_MESSAGES = %w'DEBUG5 DEBUG4 DEBUG3 DEBUG2 DEBUG1 LOG NOTICE WARNING ERROR FATAL PANIC'.freeze
+      VALID_CLIENT_MIN_MESSAGES = %w'DEBUG5 DEBUG4 DEBUG3 DEBUG2 DEBUG1 LOG NOTICE WARNING ERROR FATAL PANIC'.freeze.each(&:freeze)
       # The SQL queries to execute when starting a new connection.
-      def connection_configuration_sqls
+      def connection_configuration_sqls(opts=@opts)
         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, true))
 
-        if (cmm = @opts.fetch(:client_min_messages, Postgres.client_min_messages)) && !cmm.to_s.empty?
+        cmm = opts.fetch(:client_min_messages, :warning)
+        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}"
@@ -676,7 +1013,7 @@ module Sequel
           sqls << "SET client_min_messages = '#{cmm.to_s.upcase}'"
         end
 
-        if search_path = @opts[:search_path]
+        if search_path = opts[:search_path]
           case search_path
           when String
             search_path = search_path.split(",").map(&:strip)
@@ -711,37 +1048,13 @@ module Sequel
         end
       end
 
-      # Callback used when conversion procs are updated.
-      def conversion_procs_updated
-        nil
-      end
-
-      # Convert the hash of named conversion procs into a hash a oid conversion procs. 
-      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|
-          h[oid.to_i] = named_procs[name.untaint.to_sym]
-        end
-        h
-      end
-
-      # Copy the conversion procs related to the given oids from PG_TYPES into
-      # the conversion procs for this instance.
-      def copy_conversion_procs(oids)
-        procs = conversion_procs
-        oids.each do |oid|
-          procs[oid] = PG_TYPES[oid]
-        end
-        conversion_procs_updated
-      end
-
-      EXCLUSION_CONSTRAINT_SQL_STATE = '23P01'.freeze
-      DEADLOCK_SQL_STATE = '40P01'.freeze
       def database_specific_error_class_from_sqlstate(sqlstate)
-        if sqlstate == EXCLUSION_CONSTRAINT_SQL_STATE
+        if sqlstate == '23P01'
           ExclusionConstraintViolation
-        elsif sqlstate == DEADLOCK_SQL_STATE
+        elsif sqlstate == '40P01'
           SerializationFailure
+        elsif sqlstate == '55P03'
+          DatabaseLockTimeout
         else
           super
         end
@@ -757,6 +1070,7 @@ module Sequel
         [/violates not-null constraint/, NotNullConstraintViolation],
         [/conflicting key value violates exclusion constraint/, ExclusionConstraintViolation],
         [/could not serialize access/, SerializationFailure],
+        [/could not obtain lock on row in relation/, DatabaseLockTimeout],
       ].freeze
       def database_error_regexps
         DATABASE_ERROR_REGEXPS
@@ -814,6 +1128,7 @@ module Sequel
         #{opts[:behavior].to_s.upcase if opts[:behavior]}
         #{'STRICT' if opts[:strict]}
         #{'SECURITY DEFINER' if opts[:security_definer]}
+        #{"PARALLEL #{opts[:parallel].to_s.upcase}" if opts[:parallel]}
         #{"COST #{opts[:cost]}" if opts[:cost]}
         #{"ROWS #{opts[:rows]}" if opts[:rows]}
         #{opts[:set].map{|k,v| " SET #{k} = #{v}"}.join("\n") if opts[:set]}
@@ -826,6 +1141,36 @@ module Sequel
         "CREATE#{' OR REPLACE' if opts[:replace] && server_version >= 90000}#{' TRUSTED' if opts[:trusted]} LANGUAGE #{name}#{" HANDLER #{opts[:handler]}" if opts[:handler]}#{" VALIDATOR #{opts[:validator]}" if opts[:validator]}"
       end
 
+      # Create a partition of another table, used when the create_table with
+      # the :partition_of option is given.
+      def create_partition_of_table_from_generator(name, generator, options)
+        execute_ddl(create_partition_of_table_sql(name, generator, options))
+      end
+
+      # SQL for creating a partition of another table.
+      def create_partition_of_table_sql(name, generator, options)
+        sql = create_table_prefix_sql(name, options).dup
+
+        sql << " PARTITION OF #{quote_schema_table(options[:partition_of])}"
+
+        case generator.partition_type
+        when :range
+          from, to = generator.range
+          sql << " FOR VALUES FROM #{literal(from)} TO #{literal(to)}"
+        when :list
+          sql << " FOR VALUES IN #{literal(generator.list)}"
+        when :hash
+          mod, remainder = generator.hash_values
+          sql << " FOR VALUES WITH (MODULUS #{literal(mod)}, REMAINDER #{literal(remainder)})"
+        else # when :default
+          sql << " DEFAULT"
+        end
+
+        sql << create_table_suffix_sql(name, options)
+
+        sql
+      end
+
       # SQL for creating a schema.
       def create_schema_sql(name, opts=OPTS)
         "CREATE SCHEMA #{'IF NOT EXISTS ' if opts[:if_not_exists]}#{quote_identifier(name)}#{" AUTHORIZATION #{literal(opts[:owner])}" if opts[:owner]}"
@@ -841,27 +1186,42 @@ module Sequel
           raise(Error, "can't provide both :foreign and :unlogged to create_table") if options[:unlogged]
           'FOREIGN '
         elsif options[:unlogged]
-          UNLOGGED
+          'UNLOGGED '
         end
 
         "CREATE #{prefix_sql}TABLE#{' IF NOT EXISTS' if options[:if_not_exists]} #{options[:temp] ? quote_identifier(name) : quote_schema_table(name)}"
       end
 
+      # SQL for creating a table with PostgreSQL specific options
       def create_table_sql(name, generator, options)
-        sql = super
+        "#{super}#{create_table_suffix_sql(name, options)}"
+      end
+
+      # Handle various PostgreSQl specific table extensions such as inheritance,
+      # partitioning, tablespaces, and foreign tables.
+      def create_table_suffix_sql(name, options)
+        sql = String.new
 
         if inherits = options[:inherits]
-          sql += " INHERITS (#{Array(inherits).map{|t| quote_schema_table(t)}.join(', ')})"
+          sql << " INHERITS (#{Array(inherits).map{|t| quote_schema_table(t)}.join(', ')})"
+        end
+
+        if partition_by = options[:partition_by]
+          sql << " PARTITION BY #{options[:partition_type]||'RANGE'} #{literal(Array(partition_by))}"
         end
 
         if on_commit = options[:on_commit]
           raise(Error, "can't provide :on_commit without :temp to create_table") unless options[:temp]
           raise(Error, "unsupported on_commit option: #{on_commit.inspect}") unless ON_COMMIT.has_key?(on_commit)
-          sql += " ON COMMIT #{ON_COMMIT[on_commit]}"
+          sql << " ON COMMIT #{ON_COMMIT[on_commit]}"
+        end
+
+        if tablespace = options[:tablespace]
+          sql << " TABLESPACE #{quote_identifier(tablespace)}"
         end
 
         if server = options[:foreign]
-          sql += " SERVER #{quote_identifier(server)}"
+          sql << " SERVER #{quote_identifier(server)}"
           if foreign_opts = options[:options]
             sql << " OPTIONS (#{foreign_opts.map{|k, v| "#{k} #{literal(v.to_s)}"}.join(', ')})"
           end
@@ -878,7 +1238,6 @@ module Sequel
         result += " AS #{sql}"
       end
 
-      # Use a PostgreSQL-specific create table generator
       def create_table_generator_class
         Postgres::CreateTableGenerator
       end
@@ -891,17 +1250,22 @@ module Sequel
           raise Error, "Trigger conditions are not supported for this database" unless supports_trigger_conditions?
           filter = " WHEN #{filter_expr(filter)}"
         end
-        "CREATE TRIGGER #{name} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}#{' FOR EACH ROW' if opts[:each_row]}#{filter} EXECUTE PROCEDURE #{function}(#{Array(opts[:args]).map{|a| literal(a)}.join(', ')})"
+        "CREATE #{'OR REPLACE ' if opts[:replace]}TRIGGER #{name} #{whence} #{events.map{|e| e.to_s.upcase}.join(' OR ')} ON #{quote_schema_table(table)}#{' FOR EACH ROW' if opts[:each_row]}#{filter} EXECUTE PROCEDURE #{function}(#{Array(opts[:args]).map{|a| literal(a)}.join(', ')})"
       end
 
       # DDL fragment for initial part of CREATE VIEW statement
       def create_view_prefix_sql(name, options)
-        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
+        sql = 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])
 
-      # The errors that the main adapters can raise, depends on the adapter being used
-      def database_error_classes
-        CONVERTED_EXCEPTIONS
+        if options[:security_invoker]
+          sql += " WITH (security_invoker)"
+        end
+
+        if tablespace = options[:tablespace]
+          sql += " TABLESPACE #{quote_identifier(tablespace)}"
+        end
+
+        sql
       end
 
       # SQL for dropping a function from the database.
@@ -940,48 +1304,34 @@ module Sequel
         "DROP #{'MATERIALIZED ' if opts[:materialized]}VIEW#{' IF EXISTS' if opts[:if_exists]} #{quote_schema_table(name)}#{' CASCADE' if opts[:cascade]}"
       end
 
-      # If opts includes a :schema option, or a default schema is used, restrict the dataset to
-      # that schema.  Otherwise, just exclude the default PostgreSQL schemas except for public.
+      # If opts includes a :schema option, use it, otherwise restrict the filter to only the
+      # currently visible schemas.
       def filter_schema(ds, opts)
         expr = if schema = opts[:schema]
           schema.to_s
         else
           Sequel.function(:any, Sequel.function(:current_schemas, false))
         end
-        ds.where(:pg_namespace__nspname=>expr)
-      end
-
-      # Return a hash with oid keys and callable values, used for converting types.
-      def get_conversion_procs
-        procs = PG_TYPES.dup
-        procs[1184] = procs[1114] = method(:to_application_timestamp)
-        add_named_conversion_procs(procs, PG_NAMED_TYPES)
-        procs
+        ds.where{{pg_namespace[:nspname]=>expr}}
       end
 
-      # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on input.
-      def identifier_input_method_default
-        nil
-      end
-
-      # PostgreSQL folds unquoted identifiers to lowercase, so it shouldn't need to upcase identifiers on output.
-      def identifier_output_method_default
-        nil
-      end
-
-      # PostgreSQL specific index SQL.
       def index_definition_sql(table_name, index)
         cols = index[:columns]
         index_name = index[:name] || default_index_name(table_name, cols)
+
         expr = if o = index[:opclass]
           "(#{Array(cols).map{|c| "#{literal(c)} #{o}"}.join(', ')})"
         else
           literal(Array(cols))
         end
+
+        if_not_exists = " IF NOT EXISTS" if index[:if_not_exists]
         unique = "UNIQUE " if index[:unique]
         index_type = index[:type]
         filter = index[:where] || index[:filter]
         filter = " WHERE #{filter_expr(filter)}" if filter
+        nulls_distinct = " NULLS#{' NOT' if index[:nulls_distinct] == false} DISTINCT" unless index[:nulls_distinct].nil?
+
         case index_type
         when :full_text
           expr = "(to_tsvector(#{literal(index[:language] || 'simple')}::regconfig, #{literal(dataset.send(:full_text_string_join, cols))}))"
@@ -989,37 +1339,33 @@ module Sequel
         when :spatial
           index_type = :gist
         end
-        "CREATE #{unique}INDEX#{' CONCURRENTLY' if index[:concurrently]} #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{filter}"
+
+        "CREATE #{unique}INDEX#{' CONCURRENTLY' if index[:concurrently]}#{if_not_exists} #{quote_identifier(index_name)} ON #{quote_schema_table(table_name)} #{"USING #{index_type} " if index_type}#{expr}#{" INCLUDE #{literal(Array(index[:include]))}" if index[:include]}#{nulls_distinct}#{" TABLESPACE #{quote_identifier(index[:tablespace])}" if index[:tablespace]}#{filter}"
       end
 
       # Setup datastructures shared by all postgres adapters.
       def initialize_postgres_adapter
         @primary_keys = {}
         @primary_key_sequences = {}
-        @conversion_procs = PG_TYPES.dup
-        reset_conversion_procs
+        @supported_types = {}
+        procs = @conversion_procs = CONVERSION_PROCS.dup
+        procs[1184] = procs[1114] = method(:to_application_timestamp)
       end
 
       # Backbone of the tables and views support.
       def pg_class_relname(type, opts)
-        ds = metadata_dataset.from(:pg_class).filter(:relkind=>type).select(:relname).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
+        ds = metadata_dataset.from(:pg_class).where(:relkind=>type).select(:relname).server(opts[:server]).join(:pg_namespace, :oid=>:relnamespace)
         ds = filter_schema(ds, opts)
         m = output_identifier_meth
-        if block_given?
+        if defined?(yield)
           yield(ds)
         elsif opts[:qualify]
-          ds.select_append(:pg_namespace__nspname).map{|r| Sequel.qualify(m.call(r[:nspname]), m.call(r[:relname]))}
+          ds.select_append{pg_namespace[:nspname]}.map{|r| Sequel.qualify(m.call(r[:nspname]).to_s, m.call(r[:relname]).to_s)}
         else
           ds.map{|r| m.call(r[:relname])}
         end
       end
 
-      # Use a dollar sign instead of question mark for the argument
-      # placeholder.
-      def prepared_arg_placeholder
-        PREPARED_ARG_PLACEHOLDER
-      end
-
       # Return an expression the oid for the table expr.  Used by the metadata parsing
       # code to disambiguate unqualified tables.
       def regclass_oid(expr, opts=OPTS)
@@ -1042,8 +1388,7 @@ module Sequel
         Sequel.cast(expr.to_s,:regclass).cast(:oid)
       end
 
-      # Remove the cached entries for primary keys and sequences when a table is
-      # changed.
+      # Remove the cached entries for primary keys and sequences when a table is changed.
       def remove_cached_schema(table)
         tab = quote_schema_table(table)
         Sequel.synchronize do
@@ -1059,7 +1404,6 @@ module Sequel
         "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_identifier(schema_and_table(new_name).last)}"
       end
 
-      # Recognize PostgreSQL interval type.
       def schema_column_type(db_type)
         case db_type
         when /\Ainterval\z/io
@@ -1074,24 +1418,39 @@ module Sequel
       # The dataset used for parsing table schemas, using the pg_* system catalogs.
       def schema_parse_table(table_name, opts)
         m = output_identifier_meth(opts[:dataset])
-        ds = metadata_dataset.select(:pg_attribute__attname___name,
-            SQL::Cast.new(:pg_attribute__atttypid, :integer).as(:oid),
-            SQL::Cast.new(:basetype__oid, :integer).as(:base_oid),
-            SQL::Function.new(:format_type, :basetype__oid, :pg_type__typtypmod).as(:db_base_type),
-            SQL::Function.new(:format_type, :pg_type__oid, :pg_attribute__atttypmod).as(:db_type),
-            SQL::Function.new(:pg_get_expr, :pg_attrdef__adbin, :pg_class__oid).as(:default),
-            SQL::BooleanExpression.new(:NOT, :pg_attribute__attnotnull).as(:allow_null),
-            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(:pg_attribute__attnum => SQL::Function.new(:ANY, :pg_index__indkey)), false).as(:primary_key)).
+        oid = regclass_oid(table_name, opts)
+        ds = metadata_dataset.select{[
+            pg_attribute[:attname].as(:name),
+            SQL::Cast.new(pg_attribute[:atttypid], :integer).as(:oid),
+            SQL::Cast.new(basetype[:oid], :integer).as(:base_oid),
+            SQL::Function.new(:format_type, basetype[:oid], pg_type[:typtypmod]).as(:db_base_type),
+            SQL::Function.new(:format_type, pg_type[:oid], pg_attribute[:atttypmod]).as(:db_type),
+            SQL::Function.new(:pg_get_expr, pg_attrdef[:adbin], pg_class[:oid]).as(:default),
+            SQL::BooleanExpression.new(:NOT, pg_attribute[:attnotnull]).as(:allow_null),
+            SQL::Function.new(:COALESCE, SQL::BooleanExpression.from_value_pairs(pg_attribute[:attnum] => SQL::Function.new(:ANY, pg_index[:indkey])), false).as(:primary_key)]}.
           from(:pg_class).
           join(:pg_attribute, :attrelid=>:oid).
           join(:pg_type, :oid=>:atttypid).
-          left_outer_join(:pg_type___basetype, :oid=>:typbasetype).
-          left_outer_join(:pg_attrdef, :adrelid=>:pg_class__oid, :adnum=>:pg_attribute__attnum).
-          left_outer_join(:pg_index, :indrelid=>:pg_class__oid, :indisprimary=>true).
-          filter(:pg_attribute__attisdropped=>false).
-          filter{|o| o.pg_attribute__attnum > 0}.
-          filter(:pg_class__oid=>regclass_oid(table_name, opts)).
-          order(:pg_attribute__attnum)
+          left_outer_join(Sequel[:pg_type].as(:basetype), :oid=>:typbasetype).
+          left_outer_join(:pg_attrdef, :adrelid=>Sequel[:pg_class][:oid], :adnum=>Sequel[:pg_attribute][:attnum]).
+          left_outer_join(:pg_index, :indrelid=>Sequel[:pg_class][:oid], :indisprimary=>true).
+          where{{pg_attribute[:attisdropped]=>false}}.
+          where{pg_attribute[:attnum] > 0}.
+          where{{pg_class[:oid]=>oid}}.
+          order{pg_attribute[:attnum]}
+
+        # :nocov:
+        if server_version > 100000
+        # :nocov:
+          ds = ds.select_append{pg_attribute[:attidentity]}
+
+          # :nocov:
+          if server_version > 120000
+          # :nocov:
+            ds = ds.select_append{Sequel.~(pg_attribute[:attgenerated]=>'').as(:generated)}
+          end
+        end
+
         ds.map do |row|
           row[:default] = nil if blank_object?(row[:default])
           if row[:base_oid]
@@ -1104,8 +1463,9 @@ module Sequel
             row.delete(:db_base_type)
           end
           row[:type] = schema_column_type(row[:db_type])
+          identity = row.delete(:attidentity)
           if row[:primary_key]
-            row[:auto_increment] = !!(row[:default] =~ /\Anextval/io)
+            row[:auto_increment] = !!(row[:default] =~ /\A(?:nextval)/i) || identity == 'a' || identity == 'd'
           end
           [m.call(row.delete(:name)), row]
         end
@@ -1159,12 +1519,14 @@ module Sequel
       # PostgreSQL prefers the text datatype.  If a fixed size is requested,
       # the char type is used.  If the text type is specifically
       # disallowed or there is a size specified, use the varchar type.
-      # Otherwise use the type type.
+      # Otherwise use the text type.
       def type_literal_generic_string(column)
-        if column[:fixed]
-          "char(#{column[:size]||255})"
-        elsif column[:text] == false or column[:size]
-          "varchar(#{column[:size]||255})"
+        if column[:text]
+          :text
+        elsif column[:fixed]
+          "char(#{column[:size]||default_string_column_size})"
+        elsif column[:text] == false || column[:size]
+          "varchar(#{column[:size]||default_string_column_size})"
         else
           :text
         end
@@ -1172,77 +1534,23 @@ module Sequel
 
       # PostgreSQL 9.4+ supports views with check option.
       def view_with_check_option_support
+        # :nocov:
         :local if server_version >= 90400
+        # :nocov:
       end
     end
 
-    # Instance methods for datasets that connect to a PostgreSQL database.
     module DatasetMethods
-      ACCESS_SHARE = 'ACCESS SHARE'.freeze
-      ACCESS_EXCLUSIVE = 'ACCESS EXCLUSIVE'.freeze
-      BOOL_FALSE = 'false'.freeze
-      BOOL_TRUE = 'true'.freeze
-      COMMA_SEPARATOR = ', '.freeze
-      EXCLUSIVE = 'EXCLUSIVE'.freeze
-      EXPLAIN = 'EXPLAIN '.freeze
-      EXPLAIN_ANALYZE = 'EXPLAIN ANALYZE '.freeze
-      FOR_SHARE = ' FOR SHARE'.freeze
+      include UnmodifiedIdentifiers::DatasetMethods
+
       NULL = LiteralString.new('NULL').freeze
-      PG_TIMESTAMP_FORMAT = "TIMESTAMP '%Y-%m-%d %H:%M:%S".freeze
-      QUERY_PLAN = 'QUERY PLAN'.to_sym
-      ROW_EXCLUSIVE = 'ROW EXCLUSIVE'.freeze
-      ROW_SHARE = 'ROW SHARE'.freeze
-      SHARE = 'SHARE'.freeze
-      SHARE_ROW_EXCLUSIVE = 'SHARE ROW EXCLUSIVE'.freeze
-      SHARE_UPDATE_EXCLUSIVE = 'SHARE UPDATE EXCLUSIVE'.freeze
-      SQL_WITH_RECURSIVE = "WITH RECURSIVE ".freeze
-      SPACE = Dataset::SPACE
-      FROM = Dataset::FROM
-      APOS = Dataset::APOS
-      APOS_RE = Dataset::APOS_RE
-      DOUBLE_APOS = Dataset::DOUBLE_APOS
-      PAREN_OPEN = Dataset::PAREN_OPEN
-      PAREN_CLOSE = Dataset::PAREN_CLOSE
-      COMMA = Dataset::COMMA
-      ESCAPE = Dataset::ESCAPE
-      BACKSLASH = Dataset::BACKSLASH
-      AS = Dataset::AS
-      XOR_OP = ' # '.freeze
-      CRLF = "\r\n".freeze
-      BLOB_RE = /[\000-\037\047\134\177-\377]/n.freeze
-      WINDOW = " WINDOW ".freeze
-      SELECT_VALUES = "VALUES ".freeze
-      EMPTY_STRING = ''.freeze
-      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze)
-      SKIP_LOCKED = " SKIP LOCKED".freeze
+      LOCK_MODES = ['ACCESS SHARE', 'ROW SHARE', 'ROW EXCLUSIVE', 'SHARE UPDATE EXCLUSIVE', 'SHARE', 'SHARE ROW EXCLUSIVE', 'EXCLUSIVE', 'ACCESS EXCLUSIVE'].each(&:freeze).freeze
 
       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']])
+      Dataset.def_sql_method(self, :insert, [['if server_version >= 90500', %w'with insert into columns override values conflict returning'], ['elsif server_version >= 90100', %w'with insert into columns values returning'], ['else', %w'insert into columns values returning']])
       Dataset.def_sql_method(self, :select, [['if opts[:values]', %w'values order limit'], ['elsif server_version >= 80400', %w'with select distinct columns from join where group having window compounds order limit lock'], ['else', %w'select distinct columns from join where group having compounds order limit lock']])
       Dataset.def_sql_method(self, :update, [['if server_version >= 90100', %w'with update table set from where returning'], ['else', %w'update table set from where returning']])
 
-      # Shared methods for prepared statements when used with PostgreSQL databases.
-      module PreparedStatementMethods
-        # Override insert action to use RETURNING if the server supports it.
-        def run
-          if @prepared_type == :insert && (opts[:returning_pk] || !opts[:returning])
-            fetch_rows(prepared_sql){|r| return r.values.first}
-          else
-            super
-          end
-        end
-
-        def prepared_sql
-          return @prepared_sql if @prepared_sql
-          if @prepared_type == :insert && !opts[:returning]
-            @opts[:returning] = insert_pk
-            @opts[:returning_pk] = true
-          end
-          super
-          @prepared_sql
-        end
-      end
-
       # Return the results of an EXPLAIN ANALYZE query as a string
       def analyze
         explain(:analyze=>true)
@@ -1254,7 +1562,7 @@ module Sequel
       def complex_expression_sql_append(sql, op, args)
         case op
         when :^
-          j = XOR_OP
+          j = ' # '
           c = false
           args.each do |a|
             sql << j if c
@@ -1262,13 +1570,13 @@ module Sequel
             c ||= true
           end
         when :ILIKE, :'NOT ILIKE'
-          sql << PAREN_OPEN
-          literal_append(sql, args.at(0))
-          sql << SPACE << op.to_s << SPACE
-          literal_append(sql, args.at(1))
-          sql << ESCAPE
-          literal_append(sql, BACKSLASH)
-          sql << PAREN_CLOSE
+          sql << '('
+          literal_append(sql, args[0])
+          sql << ' ' << op.to_s << ' '
+          literal_append(sql, args[1])
+          sql << " ESCAPE "
+          literal_append(sql, "\\")
+          sql << ')'
         else
           super
         end
@@ -1294,7 +1602,7 @@ module Sequel
 
       # Return the results of an EXPLAIN query as a string
       def explain(opts=OPTS)
-        with_sql((opts[:analyze] ? EXPLAIN_ANALYZE : EXPLAIN) + select_sql).map(QUERY_PLAN).join(CRLF)
+        with_sql((opts[:analyze] ? 'EXPLAIN ANALYZE ' : 'EXPLAIN ') + select_sql).map(:'QUERY PLAN').join("\r\n")
       end
 
       # Return a cloned dataset which will use FOR SHARE to lock returned rows.
@@ -1315,6 +1623,8 @@ module Sequel
       # :phrase :: Similar to :plain, but also adding an ILIKE filter to ensure that
       #            returned rows also include the exact phrase used.
       # :rank :: Set to true to order by the rank, so that closer matches are returned first.
+      # :to_tsquery :: Can be set to :plain or :phrase to specify the function to use to
+      #                convert the terms to a ts_query.
       # :tsquery :: Specifies the terms argument is already a valid SQL expression returning a
       #             tsquery, and can be used directly in the query.
       # :tsvector :: Specifies the cols argument is already a valid SQL expression returning a
@@ -1329,11 +1639,18 @@ module Sequel
 
         unless opts[:tsquery]
           phrase_terms = terms.is_a?(Array) ? terms.join(' | ') : terms
-          query_func = (opts[:phrase] || opts[:plain]) ? :plainto_tsquery : :to_tsquery
+
+          query_func = case to_tsquery = opts[:to_tsquery]
+          when :phrase, :plain
+            :"#{to_tsquery}to_tsquery"
+          else
+            (opts[:phrase] || opts[:plain]) ? :plainto_tsquery : :to_tsquery
+          end
+
           terms = Sequel.function(query_func, lang, phrase_terms)
         end
 
-        ds = where(Sequel.lit(["(", " @@ ", ")"], cols, terms))
+        ds = where(Sequel.lit(["", " @@ ", ""], cols, terms))
 
         if opts[:phrase]
           raise Error, "can't use :phrase with either :tsvector or :tsquery arguments to full_text_search together" if opts[:tsvector] || opts[:tsquery]
@@ -1370,6 +1687,7 @@ module Sequel
 
       # Handle uniqueness violations when inserting, by updating the conflicting row, using
       # ON CONFLICT. With no options, uses ON CONFLICT DO NOTHING.  Options:
+      # :conflict_where :: The index filter, when using a partial index to determine uniqueness.
       # :constraint :: An explicit constraint name, has precendence over :target.
       # :target :: The column name or expression to handle uniqueness violations on.
       # :update :: A hash of columns and values to set.  Uses ON CONFLICT DO UPDATE.
@@ -1377,24 +1695,28 @@ module Sequel
       #
       # Examples:
       #
-      #   DB[:table].insert_conflict.insert(:a=>1, :b=>2)
+      #   DB[:table].insert_conflict.insert(a: 1, b: 2)
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
       #   # ON CONFLICT DO NOTHING
       #   
-      #   DB[:table].insert_conflict(:constraint=>:table_a_uidx).insert(:a=>1, :b=>2)
+      #   DB[:table].insert_conflict(constraint: :table_a_uidx).insert(a: 1, b: 2)
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
       #   # ON CONFLICT ON CONSTRAINT table_a_uidx DO NOTHING
       #   
-      #   DB[:table].insert_conflict(:target=>:a).insert(:a=>1, :b=>2)
+      #   DB[:table].insert_conflict(target: :a).insert(a: 1, b: 2)
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
       #   # ON CONFLICT (a) DO NOTHING
+      #
+      #   DB[:table].insert_conflict(target: :a, conflict_where: {c: true}).insert(a: 1, b: 2)
+      #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
+      #   # ON CONFLICT (a) WHERE (c IS TRUE) DO NOTHING
       #   
-      #   DB[:table].insert_conflict(:target=>:a, :update=>{:b=>:excluded__b}).insert(:a=>1, :b=>2)
+      #   DB[:table].insert_conflict(target: :a, update: {b: Sequel[:excluded][:b]}).insert(a: 1, b: 2)
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
       #   # ON CONFLICT (a) DO UPDATE SET b = excluded.b
       #   
-      #   DB[:table].insert_conflict(:constraint=>:table_a_uidx,
-      #     :update=>{:b=>:excluded__b}, :update_where=>{:table__status_id=>1}).insert(:a=>1, :b=>2)
+      #   DB[:table].insert_conflict(constraint: :table_a_uidx,
+      #     update: {b: Sequel[:excluded][:b]}, update_where: {Sequel[:table][:status_id] => 1}).insert(a: 1, b: 2)
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
       #   # ON CONFLICT ON CONSTRAINT table_a_uidx
       #   # DO UPDATE SET b = excluded.b WHERE (table.status_id = 1)
@@ -1405,18 +1727,20 @@ module Sequel
       # Ignore uniqueness/exclusion violations when inserting, using ON CONFLICT DO NOTHING.
       # Exists mostly for compatibility to MySQL's insert_ignore. Example:
       #
-      #   DB[:table].insert_ignore.insert(:a=>1, :b=>2)
+      #   DB[:table].insert_ignore.insert(a: 1, b: 2)
       #   # INSERT INTO TABLE (a, b) VALUES (1, 2)
       #   # ON CONFLICT DO NOTHING
       def insert_ignore
         insert_conflict
       end
 
-      # Insert a record returning the record inserted.  Always returns nil without
-      # inserting a query if disable_insert_returning is used.
+      # Insert a record, returning the record inserted, using RETURNING.  Always returns nil without
+      # running an INSERT statement if disable_insert_returning is used.  If the query runs
+      # but returns no values, returns false.
       def insert_select(*values)
         return unless supports_insert_select?
-        server?(:default).with_sql_first(insert_select_sql(*values))
+        # Handle case where query does not return a row
+        server?(:default).with_sql_first(insert_select_sql(*values)) || false
       end
 
       # The SQL to use for an insert_select, adds a RETURNING clause to the insert
@@ -1426,13 +1750,22 @@ module Sequel
         ds.insert_sql(*values)
       end
 
+      # Support SQL::AliasedExpression as expr to setup a USING join with a table alias for the
+      # USING columns.
+      def join_table(type, table, expr=nil, options=OPTS, &block)
+        if expr.is_a?(SQL::AliasedExpression) && expr.expression.is_a?(Array) && !expr.expression.empty? && expr.expression.all?
+          options = options.merge(:join_using=>true)
+        end
+        super
+      end
+
       # Locks all tables in the dataset's FROM clause (but not in JOINs) with
       # the specified mode (e.g. 'EXCLUSIVE').  If a block is given, starts
-      # a new transaction, locks the table, and yields.  If a block is not given
+      # a new transaction, locks the table, and yields.  If a block is not given,
       # just locks the tables.  Note that PostgreSQL will probably raise an error
       # if you lock the table outside of an existing transaction.  Returns nil.
       def lock(mode, opts=OPTS)
-        if block_given? # perform locking inside a transaction and yield to block
+        if defined?(yield) # perform locking inside a transaction and yield to block
           @db.transaction(opts){lock(mode, opts); yield}
         else
           sql = 'LOCK TABLE '.dup
@@ -1447,6 +1780,54 @@ module Sequel
         nil
       end
 
+      # Return a dataset with a WHEN MATCHED THEN DO NOTHING clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_do_nothing_when_matched
+      #   # WHEN MATCHED THEN DO NOTHING
+      #
+      #   merge_do_nothing_when_matched{a > 30}
+      #   # WHEN MATCHED AND (a > 30) THEN DO NOTHING
+      def merge_do_nothing_when_matched(&block)
+        _merge_when(:type=>:matched, &block)
+      end
+
+      # Return a dataset with a WHEN NOT MATCHED THEN DO NOTHING clause added to the
+      # MERGE statement.  If a block is passed, treat it as a virtual row and
+      # use it as additional conditions for the match.
+      #
+      #   merge_do_nothing_when_not_matched
+      #   # WHEN NOT MATCHED THEN DO NOTHING
+      #
+      #   merge_do_nothing_when_not_matched{a > 30}
+      #   # WHEN NOT MATCHED AND (a > 30) THEN DO NOTHING
+      def merge_do_nothing_when_not_matched(&block)
+        _merge_when(:type=>:not_matched, &block)
+      end
+
+      # Support OVERRIDING USER|SYSTEM VALUE for MERGE INSERT.
+      def merge_insert(*values, &block)
+        h = {:type=>:insert, :values=>values}
+        if override = @opts[:override]
+          h[:override] = insert_override_sql(String.new)
+        end
+        _merge_when(h, &block)
+      end
+    
+      # Use OVERRIDING USER VALUE for INSERT statements, so that identity columns
+      # always use the user supplied value, and an error is not raised for identity
+      # columns that are GENERATED ALWAYS.
+      def overriding_system_value
+        clone(:override=>:system)
+      end
+
+      # Use OVERRIDING USER VALUE for INSERT statements, so that identity columns
+      # always use the sequence value instead of the user supplied value.
+      def overriding_user_value
+        clone(:override=>:user)
+      end
+
       def supports_cte?(type=:select)
         if type == :select
           server_version >= 80400
@@ -1491,7 +1872,7 @@ module Sequel
         server_version >= 90500
       end
 
-      # PostgreSQL 9.3rc1+ supports lateral subqueries
+      # PostgreSQL 9.3+ supports lateral subqueries
       def supports_lateral_subqueries?
         server_version >= 90300
       end
@@ -1501,6 +1882,16 @@ module Sequel
         true
       end
 
+      # PostgreSQL 15+ supports MERGE.
+      def supports_merge?
+        server_version >= 150000
+      end
+
+      # PostgreSQL supports NOWAIT.
+      def supports_nowait?
+        true
+      end
+
       # Returning is always supported.
       def supports_returning?(type)
         true
@@ -1521,11 +1912,31 @@ module Sequel
         true
       end
 
+      # PostgreSQL 8.4+ supports WINDOW clause.
+      def supports_window_clause?
+        server_version >= 80400
+      end
+
       # PostgreSQL 8.4+ supports window functions
       def supports_window_functions?
         server_version >= 80400
       end
 
+      # Base support added in 8.4, offset supported added in 9.0,
+      # GROUPS and EXCLUDE support added in 11.0.
+      def supports_window_function_frame_option?(option)
+        case option
+        when :rows, :range
+          true
+        when :offset
+          server_version >= 90000
+        when :groups, :exclude
+          server_version >= 110000
+        else
+          false
+        end
+      end
+    
       # Truncates the dataset.  Returns nil.
       #
       # Options:
@@ -1537,10 +1948,11 @@ module Sequel
       # :only and :restart only work correctly on PostgreSQL 8.4+.
       #
       # Usage:
-      #   DB[:table].truncate # TRUNCATE TABLE "table"
-      #   # => nil
-      #   DB[:table].truncate(:cascade => true, :only=>true, :restart=>true) # TRUNCATE TABLE ONLY "table" RESTART IDENTITY CASCADE
-      #   # => nil
+      #   DB[:table].truncate
+      #   # TRUNCATE TABLE "table"
+      #
+      #   DB[:table].truncate(cascade: true, only: true, restart: true)
+      #   # TRUNCATE TABLE ONLY "table" RESTART IDENTITY CASCADE
       def truncate(opts = OPTS)
         if opts.empty?
           super()
@@ -1549,9 +1961,11 @@ module Sequel
         end
       end
 
-      # Return a clone of the dataset with an addition named window that can be referenced in window functions.
-      def window(name, opts)
-        clone(:window=>(@opts[:window]||[]) + [[name, SQL::Window.new(opts)]])
+      # Use WITH TIES when limiting the result set to also include additional
+      # rules that have the same results for the order column as the final row.
+      # Requires PostgreSQL 13.
+      def with_ties
+        clone(:limit_with_ties=>true)
       end
 
       protected
@@ -1563,7 +1977,9 @@ module Sequel
       def _import(columns, values, opts=OPTS)
         if @opts[:returning]
           statements = multi_insert_sql(columns, values)
-          @db.transaction(Hash[opts].merge!(:server=>@opts[:server])) do
+          trans_opts = Hash[opts]
+          trans_opts[:server] = @opts[:server]
+          @db.transaction(trans_opts) do
             statements.map{|st| returning_fetch_rows(st)}
           end.first.map{|v| v.length == 1 ? v.values.first : v}
         elsif opts[:return] == :primary_key
@@ -1573,11 +1989,35 @@ module Sequel
         end
       end
 
+      def to_prepared_statement(type, *a)
+        if type == :insert && !@opts.has_key?(:returning)
+          returning(insert_pk).send(:to_prepared_statement, :insert_pk, *a)
+        else
+          super
+        end
+      end
+
       private
 
+      # Append the INSERT sql used in a MERGE
+      def _merge_insert_sql(sql, data)
+        sql << " THEN INSERT "
+        columns, values = _parse_insert_sql_args(data[:values])
+        _insert_columns_sql(sql, columns)
+        if override = data[:override]
+          sql << override
+        end
+        _insert_values_sql(sql, values)
+      end
+
+      def _merge_matched_sql(sql, data)
+        sql << " THEN DO NOTHING"
+      end
+      alias _merge_not_matched_sql _merge_matched_sql
+
       # Format TRUNCATE statement with PostgreSQL specific options.
       def _truncate_sql(table)
-        to = @opts[:truncate_opts] || {}
+        to = @opts[:truncate_opts] || OPTS
         "TRUNCATE TABLE#{' ONLY' if to[:only]} #{table}#{' RESTART IDENTITY' if to[:restart]}#{' CASCADE' if to[:cascade]}"
       end
 
@@ -1589,7 +2029,7 @@ module Sequel
 
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
-        sql << FROM
+        sql << ' FROM '
         source_list_append(sql, @opts[:from][0..0])
       end
 
@@ -1609,54 +2049,87 @@ module Sequel
           elsif target = opts[:target]
             sql << ' '
             identifier_append(sql, Array(target))
+            if conflict_where = opts[:conflict_where]
+              sql << " WHERE "
+              literal_append(sql, conflict_where)
+            end
           end
 
           if values = opts[:update]
             sql << " DO UPDATE SET "
             update_sql_values_hash(sql, values)
-            if where = opts[:update_where]
+            if update_where = opts[:update_where]
               sql << " WHERE "
-              literal_append(sql, where)
+              literal_append(sql, update_where)
             end
           else
             sql << " DO NOTHING"
           end
+        end
+      end
 
+      # Include aliases when inserting into a single table on PostgreSQL 9.5+.
+      def insert_into_sql(sql)
+        sql << " INTO "
+        if (f = @opts[:from]) && f.length == 1
+          identifier_append(sql, server_version >= 90500 ? f.first : unaliased_identifier(f.first))
+        else
+          source_list_append(sql, f)
         end
       end
 
       # Return the primary key to use for RETURNING in an INSERT statement
       def insert_pk
-        if (f = opts[:from]) && !f.empty?
-          case t = f.first
-          when Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier
-            if pk = db.primary_key(t)
-              Sequel::SQL::Identifier.new(pk)
-            end
+        (f = opts[:from]) && !f.empty? && (t = f.first)
+        case t
+        when Symbol, String, SQL::Identifier, SQL::QualifiedIdentifier
+          if pk = db.primary_key(t)
+            Sequel::SQL::Identifier.new(pk)
           end
         end
       end
 
+      # Support OVERRIDING SYSTEM|USER VALUE in insert statements
+      def insert_override_sql(sql)
+        case opts[:override]
+        when :system
+          sql << " OVERRIDING SYSTEM VALUE"
+        when :user
+          sql << " OVERRIDING USER VALUE"
+        end
+      end
+
       # For multiple table support, PostgreSQL requires at least
       # two from tables, with joins allowed.
       def join_from_sql(type, sql)
         if(from = @opts[:from][1..-1]).empty?
           raise(Error, 'Need multiple FROM tables if updating/deleting a dataset with JOINs') if @opts[:join]
         else
-          sql << SPACE << type.to_s << SPACE
+          sql << ' ' << type.to_s << ' '
           source_list_append(sql, from)
           select_join_sql(sql)
         end
       end
 
+      # Support table aliases for USING columns
+      def join_using_clause_using_sql_append(sql, using_columns)
+        if using_columns.is_a?(SQL::AliasedExpression)
+          super(sql, using_columns.expression)
+          sql << ' AS '
+          identifier_append(sql, using_columns.alias)
+        else
+          super
+        end
+      end
+    
       # Use a generic blob quoting method, hopefully overridden in one of the subadapter methods
       def literal_blob_append(sql, v)
-        sql << APOS << v.gsub(BLOB_RE){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"} << APOS
+        sql << "'" << v.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"} << "'"
       end
 
       # PostgreSQL uses FALSE for false values
       def literal_false
-        BOOL_FALSE
+        'false'
       end
       
       # PostgreSQL quotes NaN and Infinity.
@@ -1674,12 +2147,12 @@ module Sequel
 
       # Assume that SQL standard quoting is on, per Sequel's defaults
       def literal_string_append(sql, v)
-        sql << APOS << v.gsub(APOS_RE, DOUBLE_APOS) << APOS
+        sql << "'" << v.gsub("'", "''") << "'"
       end
 
-      # PostgreSQL uses FALSE for false values
+      # PostgreSQL uses true for true values
       def literal_true
-        BOOL_TRUE
+        'true'
       end
 
       # PostgreSQL supports multiple rows in INSERT.
@@ -1687,54 +2160,116 @@ module Sequel
         :values
       end
 
+      # Dataset options that do not affect the generated SQL.
+      def non_sql_option?(key)
+        super || key == :cursor || key == :insert_conflict
+      end
+
       # PostgreSQL requires parentheses around compound datasets if they use
       # CTEs, and using them in other places doesn't hurt.
       def compound_dataset_sql_append(sql, ds)
-        sql << PAREN_OPEN
+        sql << '('
         super
-        sql << PAREN_CLOSE
+        sql << ')'
+      end
+
+      # Backslash is supported by default as the escape character on PostgreSQL,
+      # and using ESCAPE can break LIKE ANY() usage.
+      def requires_like_escape?
+        false
+      end
+
+      # Support FETCH FIRST WITH TIES on PostgreSQL 13+.
+      def select_limit_sql(sql)
+        l = @opts[:limit]
+        o = @opts[:offset]
+
+        return unless l || o
+
+        if @opts[:limit_with_ties]
+          if o
+            sql << " OFFSET "
+            literal_append(sql, o)
+          end
+
+          if l
+            sql << " FETCH FIRST "
+            literal_append(sql, l)
+            sql << " ROWS WITH TIES"
+          end
+        else
+          if l
+            sql << " LIMIT "
+            literal_append(sql, l)
+          end
+
+          if o
+            sql << " OFFSET "
+            literal_append(sql, o)
+          end
+        end
       end
 
       # Support FOR SHARE locking when using the :share lock style.
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
-        if @opts[:lock] == :share
-          sql << FOR_SHARE
+        lock = @opts[:lock]
+        if lock == :share
+          sql << ' FOR SHARE'
         else
           super
         end
 
-        if @opts[:skip_locked]
-          sql << SKIP_LOCKED
+        if lock
+          if @opts[:skip_locked]
+            sql << " SKIP LOCKED"
+          elsif @opts[:nowait]
+            sql << " NOWAIT"
+          end
         end
       end
 
       # Support VALUES clause instead of the SELECT clause to return rows.
       def select_values_sql(sql)
-        sql << SELECT_VALUES
+        sql << "VALUES "
         expression_list_append(sql, opts[:values])
       end
 
-      # SQL fragment for named window specifications
-      def select_window_sql(sql)
-        if ws = @opts[:window]
-          sql << WINDOW
-          c = false
-          co = COMMA
-          as = AS
-          ws.map do |name, window|
-            sql << co if c
-            literal_append(sql, name)
-            sql << as
-            literal_append(sql, window)
-            c ||= true
+      # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
+      def select_with_sql_base
+        opts[:with].any?{|w| w[:recursive]} ? "WITH RECURSIVE " : super
+      end
+
+      # Support PostgreSQL 14+ CTE SEARCH/CYCLE clauses
+      def select_with_sql_cte(sql, cte)
+        super
+
+        if search_opts = cte[:search]
+          sql << if search_opts[:type] == :breadth
+            " SEARCH BREADTH FIRST BY "
+          else
+            " SEARCH DEPTH FIRST BY "
           end
+
+          identifier_list_append(sql, Array(search_opts[:by]))
+          sql << " SET "
+          identifier_append(sql, search_opts[:set] || :ordercol)
         end
-      end
 
-      # Use WITH RECURSIVE instead of WITH if any of the CTEs is recursive
-      def select_with_sql_base
-        opts[:with].any?{|w| w[:recursive]} ? SQL_WITH_RECURSIVE : super
+        if cycle_opts = cte[:cycle]
+          sql << " CYCLE "
+          identifier_list_append(sql, Array(cycle_opts[:columns]))
+          sql << " SET "
+          identifier_append(sql, cycle_opts[:cycle_column] || :is_cycle)
+          if cycle_opts.has_key?(:cycle_value)
+            sql << " TO "
+            literal_append(sql, cycle_opts[:cycle_value])
+            sql << " DEFAULT "
+            literal_append(sql, cycle_opts.fetch(:noncycle_value, false))
+          end
+          sql << " USING "
+          identifier_append(sql, cycle_opts[:path_column] || :path)
+        end
       end
 
       # The version of the database server
@@ -1742,6 +2277,11 @@ module Sequel
         db.server_version(@opts[:server])
       end
 
+      # PostgreSQL 9.4+ supports the FILTER clause for aggregate functions.
+      def supports_filtered_aggregates?
+        server_version >= 90400
+      end
+
       # PostgreSQL supports quoted function names.
       def supports_quoted_function_names?
         true
@@ -1749,8 +2289,8 @@ module Sequel
 
       # Concatenate the expressions with a space in between
       def full_text_string_join(cols)
-        cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, EMPTY_STRING)}
-        cols = cols.zip([SPACE] * cols.length).flatten
+        cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, '')}
+        cols = cols.zip([' '] * cols.length).flatten
         cols.pop
         SQL::StringExpression.new(:'||', *cols)
       end
@@ -1762,7 +2302,7 @@ module Sequel
 
       # Only include the primary table in the main update clause
       def update_table_sql(sql)
-        sql << SPACE
+        sql << ' '
         source_list_append(sql, @opts[:from][0..0])
       end
     end