sequel 5.45.0 → 5.77.0

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

@@ -19,6 +19,9 @@ module Sequel
   module Postgres
     Sequel::Database.set_shared_adapter_scheme(:postgres, self)
 
+    # Exception class ranged when literalizing integers outside the bigint/int8 range.
+    class IntegerOutsideBigintRange < InvalidValue; end
+
     NAN             = 0.0/0.0
     PLUS_INFINITY   = 1.0/0.0
     MINUS_INFINITY  = -1.0/0.0
@@ -83,11 +86,22 @@ module Sequel
       def primary_key(table)
         :id
       end
+
+      private
+
+      # Handle NoMethodErrors when parsing schema due to output_identifier
+      # being called with nil when the Database fetch results are not set
+      # to what schema parsing expects.
+      def schema_parse_table(table, opts=OPTS)
+        super
+      rescue NoMethodError
+        []
+      end
     end
 
     def self.mock_adapter_setup(db)
       db.instance_exec do
-        @server_version = 90500
+        @server_version = 150000
         initialize_postgres_adapter
         extend(MockAdapterDatabaseMethods)
       end
@@ -230,7 +244,6 @@ module Sequel
     module DatabaseMethods
       include UnmodifiedIdentifiers::DatabaseMethods
 
-      PREPARED_ARG_PLACEHOLDER = LiteralString.new('$').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)
@@ -254,7 +267,7 @@ module Sequel
         WHERE cons.contype = 'p'
           AND pg_get_expr(def.adbin, attr.attrelid) ~* 'nextval'
       end_sql
-      ).strip.gsub(/\s+/, ' ').freeze
+      ).strip.gsub(/\s+/, ' ').freeze # SEQUEL6: Remove
 
       # SQL fragment for determining primary key column for the given table.  Only
       # returns the first primary key if the table has a composite primary key.
@@ -267,7 +280,7 @@ module Sequel
           AND pg_index.indkey[0] = pg_attribute.attnum
           AND pg_index.indisprimary = 't'
       end_sql
-      ).strip.gsub(/\s+/, ' ').freeze
+      ).strip.gsub(/\s+/, ' ').freeze # SEQUEL6: Remove
 
       # SQL fragment for getting sequence associated with table's
       # primary key, assuming it was a serial primary key column.
@@ -285,7 +298,7 @@ module Sequel
           AND attr.attrelid = t.oid
           AND cons.contype = 'p'
       end_sql
-      ).strip.gsub(/\s+/, ' ').freeze
+      ).strip.gsub(/\s+/, ' ').freeze # SEQUEL6: Remove
 
       # A hash of conversion procs, keyed by type integer (oid) and
       # having callable values for the conversion proc for that type.
@@ -319,14 +332,8 @@ module Sequel
       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|
+        _check_constraints_ds.where_each(:conrelid=>regclass_oid(table)) do |row|
           constraint = m.call(row[:constraint])
           entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[]}
           entry[:columns] << m.call(row[:column]) if row[:column]
@@ -365,9 +372,10 @@ module Sequel
 
         table_oid = regclass_oid(table)
         im = input_identifier_meth
-        unless column = im.call(opts[:column] || ((sch = schema(table).find{|_, sc| sc[:primary_key] && sc[:auto_increment]}) && sch[0]))
+        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).
@@ -414,6 +422,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.
@@ -479,6 +488,7 @@ 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)
@@ -488,6 +498,25 @@ module Sequel
         :postgres
       end
 
+      # For constraints that are deferrable, defer constraints until 
+      # transaction commit. Options:
+      #
+      # :constraints :: An identifier of the constraint, or an array of
+      #                 identifiers for constraints, to apply this
+      #                 change to specific constraints.
+      # :server :: The server/shard on which to run the query.
+      #
+      # Examples:
+      #
+      #   DB.defer_constraints
+      #   # SET CONSTRAINTS ALL DEFERRED
+      #
+      #   DB.defer_constraints(constraints: [:c1, Sequel[:sc][:c2]])
+      #   # SET CONSTRAINTS "c1", "sc"."s2" DEFERRED
+      def defer_constraints(opts=OPTS)
+        _set_constraints(' DEFERRED', opts)
+      end
+
       # Use PostgreSQL's DO syntax to execute an anonymous code block.  The code should
       # be the literal code string to use in the underlying procedural language.  Options:
       #
@@ -549,63 +578,12 @@ module Sequel
       def foreign_key_list(table, opts=OPTS)
         m = output_identifier_meth
         schema, _ = opts.fetch(:schema, schema_and_table(table))
-        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])}
-        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])}
-        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]=>'r',
-            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 
+        reverse = opts[:reverse]
 
-        ds.each do |row|
+        (reverse ? _reverse_foreign_key_list_ds : _foreign_key_list_ds).where_each(Sequel[:cl][:oid]=>regclass_oid(table)) do |row|
           if reverse
             key = [row[:schema], row[:table], row[:name]]
           else
@@ -640,45 +618,44 @@ module Sequel
       def freeze
         server_version
         supports_prepared_transactions?
+        _schema_ds
+        _select_serial_sequence_ds
+        _select_custom_sequence_ds
+        _select_pk_ds
+        _indexes_ds
+        _check_constraints_ds
+        _foreign_key_list_ds
+        _reverse_foreign_key_list_ds
         @conversion_procs.freeze
         super
       end
 
+      # Immediately apply deferrable constraints.
+      #
+      # :constraints :: An identifier of the constraint, or an array of
+      #                 identifiers for constraints, to apply this
+      #                 change to specific constraints.
+      # :server :: The server/shard on which to run the query.
+      #
+      # Examples:
+      #
+      #   DB.immediate_constraints
+      #   # SET CONSTRAINTS ALL IMMEDIATE
+      #
+      #   DB.immediate_constraints(constraints: [:c1, Sequel[:sc][:c2]])
+      #   # SET CONSTRAINTS "c1", "sc"."s2" IMMEDIATE
+      def immediate_constraints(opts=OPTS)
+        _set_constraints(' IMMEDIATE', opts)
+      end
+
       # Use the pg_* system tables to determine indexes on a table
       def indexes(table, opts=OPTS)
         m = output_identifier_meth
-        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])]
-        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).
-          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]
-        ds = ds.where(:indisready=>true) if server_version >= 80300
-        ds = ds.where(:indislive=>true) if server_version >= 90300
+        cond = {Sequel[:tab][:oid]=>regclass_oid(table, opts)}
+        cond[:indpred] = nil unless opts[:include_partial]
 
         indexes = {}
-        ds.each do |r|
+        _indexes_ds.where_each(cond) do |r|
           i = indexes[m.call(r[:name])] ||= {:columns=>[], :unique=>r[:unique], :deferrable=>r[:deferrable]}
           i[:columns] << m.call(r[:column])
         end
@@ -711,8 +688,7 @@ module Sequel
       def primary_key(table, opts=OPTS)
         quoted_table = quote_schema_table(table)
         Sequel.synchronize{return @primary_keys[quoted_table] if @primary_keys.has_key?(quoted_table)}
-        sql = "#{SELECT_PK_SQL} AND pg_class.oid = #{literal(regclass_oid(table, opts))}"
-        value = fetch(sql).single_value
+        value = _select_pk_ds.where_single_value(Sequel[:pg_class][:oid] => regclass_oid(table, opts))
         Sequel.synchronize{@primary_keys[quoted_table] = value}
       end
 
@@ -720,24 +696,21 @@ module Sequel
       def primary_key_sequence(table, opts=OPTS)
         quoted_table = quote_schema_table(table)
         Sequel.synchronize{return @primary_key_sequences[quoted_table] if @primary_key_sequences.has_key?(quoted_table)}
-        sql = "#{SELECT_SERIAL_SEQUENCE_SQL} AND t.oid = #{literal(regclass_oid(table, opts))}"
-        if pks = fetch(sql).single_record
-          value = literal(SQL::QualifiedIdentifier.new(pks[:schema], pks[:sequence]))
-          Sequel.synchronize{@primary_key_sequences[quoted_table] = value}
-        else
-          sql = "#{SELECT_CUSTOM_SEQUENCE_SQL} AND t.oid = #{literal(regclass_oid(table, opts))}"
-          if pks = fetch(sql).single_record
-            value = literal(SQL::QualifiedIdentifier.new(pks[:schema], LiteralString.new(pks[:sequence])))
-            Sequel.synchronize{@primary_key_sequences[quoted_table] = value}
-          end
+        cond = {Sequel[:t][:oid] => regclass_oid(table, opts)}
+        value = if pks = _select_serial_sequence_ds.first(cond)
+          literal(SQL::QualifiedIdentifier.new(pks[:schema], pks[:sequence]))
+        elsif pks = _select_custom_sequence_ds.first(cond)
+          literal(SQL::QualifiedIdentifier.new(pks[:schema], LiteralString.new(pks[:sequence])))
         end
+
+        Sequel.synchronize{@primary_key_sequences[quoted_table] = value} if value
       end
 
       # Refresh the materialized view with the given name.
       # 
       #   DB.refresh_view(:items_view)
       #   # REFRESH MATERIALIZED VIEW items_view
-      #   DB.refresh_view(:items_view, :concurrently=>true)
+      #   DB.refresh_view(:items_view, concurrently: true)
       #   # REFRESH MATERIALIZED VIEW CONCURRENTLY items_view
       def refresh_view(name, opts=OPTS)
         run "REFRESH MATERIALIZED VIEW#{' CONCURRENTLY' if opts[:concurrently]} #{quote_schema_table(name)}"
@@ -756,10 +729,12 @@ module Sequel
           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)}
@@ -772,7 +747,9 @@ module Sequel
       # PostgreSQL uses SERIAL psuedo-type instead of AUTOINCREMENT for
       # managing incrementing primary keys.
       def serial_primary_key_options
+        # :nocov:
         auto_increment_key = server_version >= 100002 ? :identity : :serial
+        # :nocov:
         {:primary_key => true, auto_increment_key => true, :type=>Integer}
       end
 
@@ -865,6 +842,7 @@ module Sequel
       #   DB.values([[1, 2], [3, 4]]).order(:column2).limit(1, 1)
       #   # VALUES ((1, 2), (3, 4)) ORDER BY column2 LIMIT 1 OFFSET 1
       def values(v)
+        raise Error, "Cannot provide an empty array for values" if v.empty?
         @default_dataset.clone(:values=>v)
       end
 
@@ -883,6 +861,245 @@ module Sequel
 
       private
 
+      # Dataset used to retrieve CHECK constraint information
+      def _check_constraints_ds
+        @_check_constraints_ds ||= 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(:contype=>'c').
+          select{[co[:conname].as(:constraint), att[:attname].as(:column), pg_get_constraintdef(co[:oid]).as(:definition)]}
+      end
+
+      # Dataset used to retrieve foreign keys referenced by a table
+      def _foreign_key_list_ds
+        @_foreign_key_list_ds ||= __foreign_key_list_ds(false)
+      end
+
+      # Dataset used to retrieve foreign keys referencing a table
+      def _reverse_foreign_key_list_ds
+        @_reverse_foreign_key_list_ds ||= __foreign_key_list_ds(true)
+      end
+
+      # Build dataset used for foreign key list methods.
+      def __foreign_key_list_ds(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',
+            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
+
+        ds
+      end
+
+      # Dataset used to retrieve index information
+      def _indexes_ds
+        @_indexes_ds ||= begin
+          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
+
+          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]=>%w'i I',
+              ind[:indisprimary]=>false,
+              :indexprs=>nil,
+              :indisvalid=>true}}.
+            order(*order).
+            select{[indc[:relname].as(:name), ind[:indisunique].as(:unique), att[:attname].as(:column), con[:condeferrable].as(:deferrable)]}
+
+          # :nocov:
+          ds = ds.where(:indisready=>true) if server_version >= 80300
+          ds = ds.where(:indislive=>true) if server_version >= 90300
+          # :nocov:
+
+          ds
+        end
+      end
+
+      # Dataset used to determine custom serial sequences for tables
+      def _select_custom_sequence_ds
+        @_select_custom_sequence_ds ||= metadata_dataset.
+          from{pg_class.as(:t)}.
+          join(:pg_namespace, {:oid => :relnamespace}, :table_alias=>:name).
+          join(:pg_attribute, {:attrelid => Sequel[:t][:oid]}, :table_alias=>:attr).
+          join(:pg_attrdef, {:adrelid => :attrelid, :adnum => :attnum}, :table_alias=>:def).
+          join(:pg_constraint, {:conrelid => :adrelid, Sequel[:cons][:conkey].sql_subscript(1) => :adnum}, :table_alias=>:cons).
+          where{{cons[:contype] => 'p', pg_get_expr(self.def[:adbin], attr[:attrelid]) => /nextval/i}}.
+          select{
+            expr = split_part(pg_get_expr(self.def[:adbin], attr[:attrelid]), "'", 2)
+            [
+              name[:nspname].as(:schema),
+              Sequel.case({{expr => /./} => substr(expr, strpos(expr, '.')+1)}, expr).as(:sequence)
+            ]
+          }
+      end
+
+      # Dataset used to determine normal serial sequences for tables
+      def _select_serial_sequence_ds
+        @_serial_sequence_ds ||= metadata_dataset.
+          from{[
+            pg_class.as(:seq),
+            pg_attribute.as(:attr),
+            pg_depend.as(:dep),
+            pg_namespace.as(:name),
+            pg_constraint.as(:cons),
+            pg_class.as(:t)
+          ]}.
+          where{[
+            [seq[:oid], dep[:objid]],
+            [seq[:relnamespace], name[:oid]],
+            [seq[:relkind], 'S'],
+            [attr[:attrelid], dep[:refobjid]],
+            [attr[:attnum], dep[:refobjsubid]],
+            [attr[:attrelid], cons[:conrelid]],
+            [attr[:attnum], cons[:conkey].sql_subscript(1)],
+            [attr[:attrelid], t[:oid]],
+            [cons[:contype], 'p']
+          ]}.
+          select{[
+            name[:nspname].as(:schema),
+            seq[:relname].as(:sequence)
+          ]}
+      end
+
+      # Dataset used to determine primary keys for tables
+      def _select_pk_ds
+        @_select_pk_ds ||= metadata_dataset.
+          from(:pg_class, :pg_attribute, :pg_index, :pg_namespace).
+          where{[
+            [pg_class[:oid], pg_attribute[:attrelid]],
+            [pg_class[:relnamespace], pg_namespace[:oid]],
+            [pg_class[:oid], pg_index[:indrelid]],
+            [pg_index[:indkey].sql_subscript(0), pg_attribute[:attnum]],
+            [pg_index[:indisprimary], 't']
+          ]}.
+          select{pg_attribute[:attname].as(:pk)}
+      end
+
+      # Dataset used to get schema for tables
+      def _schema_ds
+        @_schema_ds ||= begin
+          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),
+              Sequel[:pg_type][:typtype],
+              (~Sequel[Sequel[:elementtype][:oid]=>nil]).as(:is_array),
+            ]}.
+            from(:pg_class).
+            join(:pg_attribute, :attrelid=>:oid).
+            join(:pg_type, :oid=>:atttypid).
+            left_outer_join(Sequel[:pg_type].as(:basetype), :oid=>:typbasetype).
+            left_outer_join(Sequel[:pg_type].as(:elementtype), :typarray=>Sequel[:pg_type][:oid]).
+            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}.
+            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
+        end
+      end
+
+      # Internals of defer_constraints/immediate_constraints
+      def _set_constraints(type, opts)
+        execute_ddl(_set_constraints_sql(type, opts), opts)
+      end
+
+      # SQL to use for SET CONSTRAINTS
+      def _set_constraints_sql(type, opts)
+        sql = String.new
+        sql << "SET CONSTRAINTS "
+        if constraints = opts[:constraints]
+          dataset.send(:source_list_append, sql, Array(constraints))
+        else
+          sql << "ALL"
+        end
+        sql << type
+      end
+
+      # Consider lock or statement timeout errors as evidence that the table exists
+      # but is locked.
+      def _table_exists?(ds)
+        super
+      rescue DatabaseError => e    
+        raise e unless /canceling statement due to (?:statement|lock) timeout/ =~ e.message 
+      end
+    
       def alter_table_add_column_sql(table, op)
         "ADD COLUMN#{' IF NOT EXISTS' if op[:if_not_exists]} #{column_definition_sql(op)}"
       end
@@ -1116,6 +1333,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]}
@@ -1149,7 +1367,7 @@ module Sequel
         when :hash
           mod, remainder = generator.hash_values
           sql << " FOR VALUES WITH (MODULUS #{literal(mod)}, REMAINDER #{literal(remainder)})"
-        when :default
+        else # when :default
           sql << " DEFAULT"
         end
 
@@ -1237,13 +1455,17 @@ 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)
         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])
 
+        if options[:security_invoker]
+          sql += " WITH (security_invoker)"
+        end
+
         if tablespace = options[:tablespace]
           sql += " TABLESPACE #{quote_identifier(tablespace)}"
         end
@@ -1291,7 +1513,11 @@ module Sequel
       # currently visible schemas.
       def filter_schema(ds, opts)
         expr = if schema = opts[:schema]
-          schema.to_s
+          if schema.is_a?(SQL::Identifier)
+            schema.value.to_s
+          else
+            schema.to_s
+          end
         else
           Sequel.function(:any, Sequel.function(:current_schemas, false))
         end
@@ -1301,16 +1527,20 @@ module Sequel
       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))}))"
@@ -1318,7 +1548,8 @@ module Sequel
         when :spatial
           index_type = :gist
         end
-        "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]}#{" TABLESPACE #{quote_identifier(index[:tablespace])}" if index[:tablespace]}#{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.
@@ -1335,7 +1566,7 @@ module Sequel
         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]).to_s, m.call(r[:relname]).to_s)}
@@ -1344,11 +1575,6 @@ module Sequel
         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)
@@ -1382,11 +1608,12 @@ module Sequel
       end
 
       # SQL DDL statement for renaming a table. PostgreSQL doesn't allow you to change a table's schema in
-      # a rename table operation, so speciying a new schema in new_name will not have an effect.
+      # a rename table operation, so specifying a new schema in new_name will not have an effect.
       def rename_table_sql(name, new_name)
         "ALTER TABLE #{quote_schema_table(name)} RENAME TO #{quote_identifier(schema_and_table(new_name).last)}"
       end
 
+      # Handle interval and citext types.
       def schema_column_type(db_type)
         case db_type
         when /\Ainterval\z/io
@@ -1398,39 +1625,48 @@ module Sequel
         end
       end
 
+      # The schema :type entry to use for array types.
+      def schema_array_type(db_type)
+        :array
+      end
+
+      # The schema :type entry to use for row/composite types.
+      def schema_composite_type(db_type)
+        :composite
+      end
+
+      # The schema :type entry to use for enum types.
+      def schema_enum_type(db_type)
+        :enum
+      end
+
+      # The schema :type entry to use for range types.
+      def schema_range_type(db_type)
+        :range
+      end
+
+      # The schema :type entry to use for multirange types.
+      def schema_multirange_type(db_type)
+        :multirange
+      end
+
+      MIN_DATE = Date.new(-4713, 11, 24)
+      MAX_DATE = Date.new(5874897, 12, 31)
+      MIN_TIMESTAMP = Time.utc(-4713, 11, 24).freeze
+      MAX_TIMESTAMP = (Time.utc(294277) - Rational(1, 1000000)).freeze
+      TYPTYPE_METHOD_MAP = {
+        'c' => :schema_composite_type,
+        'e' => :schema_enum_type,
+        'r' => :schema_range_type,
+        'm' => :schema_multirange_type,
+      }
+      TYPTYPE_METHOD_MAP.default = :schema_column_type
+      TYPTYPE_METHOD_MAP.freeze
       # 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])
-        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(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]}
-
-        if server_version > 100000
-          ds = ds.select_append{pg_attribute[:attidentity]}
-
-          if server_version > 120000
-            ds = ds.select_append{Sequel.~(pg_attribute[:attgenerated]=>'').as(:generated)}
-          end
-        end
 
-        ds.map do |row|
+        _schema_ds.where_all(Sequel[:pg_class][:oid]=>regclass_oid(table_name, opts)).map do |row|
           row[:default] = nil if blank_object?(row[:default])
           if row[:base_oid]
             row[:domain_oid] = row[:oid]
@@ -1441,11 +1677,33 @@ module Sequel
             row.delete(:base_oid)
             row.delete(:db_base_type)
           end
-          row[:type] = schema_column_type(row[:db_type])
+
+          db_type = row[:db_type]
+          row[:type] = if row.delete(:is_array)
+            schema_array_type(db_type)
+          else
+            send(TYPTYPE_METHOD_MAP[row.delete(:typtype)], db_type)
+          end
           identity = row.delete(:attidentity)
           if row[:primary_key]
             row[:auto_increment] = !!(row[:default] =~ /\A(?:nextval)/i) || identity == 'a' || identity == 'd'
           end
+
+          # :nocov:
+          if server_version >= 90600
+          # :nocov:
+            case row[:oid]
+            when 1082
+              row[:min_value] = MIN_DATE
+              row[:max_value] = MAX_DATE
+            when 1184, 1114
+              if Sequel.datetime_class == Time
+                row[:min_value] = MIN_TIMESTAMP
+                row[:max_value] = MAX_TIMESTAMP
+              end
+            end
+          end
+
           [m.call(row.delete(:name)), row]
         end
       end
@@ -1503,9 +1761,9 @@ module Sequel
         if column[:text]
           :text
         elsif column[:fixed]
-          "char(#{column[:size]||255})"
+          "char(#{column[:size]||default_string_column_size})"
         elsif column[:text] == false || column[:size]
-          "varchar(#{column[:size]||255})"
+          "varchar(#{column[:size]||default_string_column_size})"
         else
           :text
         end
@@ -1513,7 +1771,9 @@ 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
 
@@ -1524,7 +1784,7 @@ module Sequel
       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']])
 
@@ -1551,8 +1811,6 @@ module Sequel
           literal_append(sql, args[0])
           sql << ' ' << op.to_s << ' '
           literal_append(sql, args[1])
-          sql << " ESCAPE "
-          literal_append(sql, "\\")
           sql << ')'
         else
           super
@@ -1577,6 +1835,12 @@ module Sequel
         clone(:disable_insert_returning=>true)
       end
 
+      # Always return false when using VALUES
+      def empty?
+        return false if @opts[:values]
+        super
+      end
+
       # 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("\r\n")
@@ -1600,7 +1864,7 @@ 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
+      # :to_tsquery :: Can be set to :plain, :phrase, or :websearch 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.
@@ -1620,6 +1884,8 @@ module Sequel
           query_func = case to_tsquery = opts[:to_tsquery]
           when :phrase, :plain
             :"#{to_tsquery}to_tsquery"
+          when :websearch
+            :"websearch_to_tsquery"
           else
             (opts[:phrase] || opts[:plain]) ? :plainto_tsquery : :to_tsquery
           end
@@ -1727,13 +1993,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,
       # 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
@@ -1748,6 +2023,41 @@ 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.
@@ -1815,6 +2125,11 @@ module Sequel
         true
       end
 
+      # PostgreSQL 15+ supports MERGE.
+      def supports_merge?
+        server_version >= 150000
+      end
+
       # PostgreSQL supports NOWAIT.
       def supports_nowait?
         true
@@ -1835,10 +2150,14 @@ module Sequel
         server_version >= 90500
       end
 
+      # :nocov:
+
       # PostgreSQL supports timezones in literal timestamps
       def supports_timestamp_timezones?
+        # SEQUEL6: Remove
         true
       end
+      # :nocov:
 
       # PostgreSQL 8.4+ supports WINDOW clause.
       def supports_window_clause?
@@ -1860,6 +2179,8 @@ module Sequel
           server_version >= 90000
         when :groups, :exclude
           server_version >= 110000
+        else
+          false
         end
       end
     
@@ -1902,12 +2223,10 @@ module Sequel
       # Otherwise, return an array of hashes.
       def _import(columns, values, opts=OPTS)
         if @opts[:returning]
-          statements = multi_insert_sql(columns, values)
-          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}
+          # no transaction: our multi_insert_sql_strategy should guarantee
+          # that there's only ever a single statement.
+          sql = multi_insert_sql(columns, values)[0]
+          returning_fetch_rows(sql).map{|v| v.length == 1 ? v.values.first : v}
         elsif opts[:return] == :primary_key
           returning(insert_pk)._import(columns, values, opts)
         else
@@ -1925,18 +2244,44 @@ module Sequel
 
       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] || OPTS
         "TRUNCATE TABLE#{' ONLY' if to[:only]} #{table}#{' RESTART IDENTITY' if to[:restart]}#{' CASCADE' if to[:cascade]}"
       end
 
+      # Use from_self for aggregate dataset using VALUES.
+      def aggreate_dataset_use_from_self?
+        super || @opts[:values]
+      end
+      
       # Allow truncation of multiple source tables.
       def check_truncation_allowed!
         raise(InvalidOperation, "Grouped datasets cannot be truncated") if opts[:group]
         raise(InvalidOperation, "Joined datasets cannot be truncated") if opts[:join]
       end
 
+      # The strftime format to use when literalizing the time.
+      def default_timestamp_format
+        "'%Y-%m-%d %H:%M:%S.%6N%z'"
+      end
+
       # Only include the primary table in the main delete clause
       def delete_from_sql(sql)
         sql << ' FROM '
@@ -1990,25 +2335,23 @@ module Sequel
 
       # 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_values_sql(sql)
+      def insert_override_sql(sql)
         case opts[:override]
         when :system
           sql << " OVERRIDING SYSTEM VALUE"
         when :user
           sql << " OVERRIDING USER VALUE"
         end
-        super
       end
 
       # For multiple table support, PostgreSQL requires at least
@@ -2023,6 +2366,17 @@ module Sequel
         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 << "'" << v.gsub(/[\000-\037\047\134\177-\377]/n){|b| "\\#{("%o" % b[0..1].unpack("C")[0]).rjust(3, '0')}"} << "'"
@@ -2046,6 +2400,22 @@ module Sequel
         end
       end 
 
+      # Handle Ruby integers outside PostgreSQL bigint range specially.
+      def literal_integer(v)
+        if v > 9223372036854775807 || v < -9223372036854775808
+          literal_integer_outside_bigint_range(v)
+        else
+          v.to_s
+        end
+      end
+
+      # Raise IntegerOutsideBigintRange when attempting to literalize Ruby integer
+      # outside PostgreSQL bigint range, so PostgreSQL doesn't treat
+      # the value as numeric.
+      def literal_integer_outside_bigint_range(v)
+        raise IntegerOutsideBigintRange, "attempt to literalize Ruby integer outside PostgreSQL bigint range: #{v}"
+      end
+
       # Assume that SQL standard quoting is on, per Sequel's defaults
       def literal_string_append(sql, v)
         sql << "'" << v.gsub("'", "''") << "'"
@@ -2141,6 +2511,41 @@ module Sequel
         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
+        select_with_sql_cte_search_cycle(sql, cte)
+      end
+
+      def select_with_sql_cte_search_cycle(sql, cte)
+        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
+
+        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
       def server_version
         db.server_version(@opts[:server])