sequel 5.8.0 → 5.38.0

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

@@ -103,12 +103,18 @@ module Sequel
           map{|r| m.call(r[:view_name])}
       end 
  
-      def view_exists?(name) 
-        m = input_identifier_meth
-        metadata_dataset.from(:all_views).
-          exclude(:owner=>IGNORE_OWNERS).
-          where(:view_name=>m.call(name)).
-          count > 0
+      # Whether a view with a given name exists.  By default, looks in all schemas other than system
+      # schemas.  If the :current_schema option is given, looks in the schema for the current user.
+      def view_exists?(name, opts=OPTS) 
+        ds = metadata_dataset.from(:all_views).where(:view_name=>input_identifier_meth.call(name))
+        
+        if opts[:current_schema]
+          ds = ds.where(:owner=>Sequel.function(:SYS_CONTEXT, 'userenv', 'current_schema'))
+        else
+          ds = ds.exclude(:owner=>IGNORE_OWNERS)
+        end
+
+        ds.count > 0
       end 
 
       # The version of the Oracle server, used for determining capability.
@@ -178,7 +184,7 @@ module Sequel
 
       def create_table_from_generator(name, generator, options)
         drop_statement, create_statements = create_table_sql_list(name, generator, options)
-        (execute_ddl(drop_statement) rescue nil) if drop_statement
+        swallow_database_error{execute_ddl(drop_statement)} if drop_statement
         create_statements.each{|sql| execute_ddl(sql)}
       end
 
@@ -422,22 +428,6 @@ module Sequel
         end
       end
 
-      def select_limit_sql(sql)
-        return unless supports_fetch_next_rows?
-
-        if offset = @opts[:offset]
-          sql << " OFFSET "
-          literal_append(sql, offset)
-          sql << " ROWS"
-        end
-
-        if limit = @opts[:limit]
-          sql << " FETCH NEXT "
-          literal_append(sql, limit)
-          sql << " ROWS ONLY"
-        end
-      end
-
       # Oracle requires recursive CTEs to have column aliases.
       def recursive_cte_requires_column_aliases?
         true
@@ -624,6 +614,22 @@ module Sequel
         :union
       end
 
+      def select_limit_sql(sql)
+        return unless supports_fetch_next_rows?
+
+        if offset = @opts[:offset]
+          sql << " OFFSET "
+          literal_append(sql, offset)
+          sql << " ROWS"
+        end
+
+        if limit = @opts[:limit]
+          sql << " FETCH NEXT "
+          literal_append(sql, limit)
+          sql << " ROWS ONLY"
+        end
+      end
+
       # Use SKIP LOCKED if skipping locked rows.
       def select_lock_sql(sql)
         super

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

@@ -23,44 +23,48 @@ module Sequel
     PLUS_INFINITY   = 1.0/0.0
     MINUS_INFINITY  = -1.0/0.0
 
-    TYPE_TRANSLATOR = tt = Class.new do
-      def boolean(s) s == 't' end
-      def integer(s) s.to_i end
-      def float(s) 
-        case s
-        when 'NaN'
-          NAN
-        when 'Infinity'
-          PLUS_INFINITY
-        when '-Infinity'
-          MINUS_INFINITY
-        else
-          s.to_f 
-        end
-      end
-      def date(s) ::Date.new(*s.split('-').map(&:to_i)) end
-      def bytea(str)
-        str = if str =~ /\A\\x/
-          # PostgreSQL 9.0+ bytea hex format
-          str[2..-1].gsub(/(..)/){|s| s.to_i(16).chr}
-        else
-          # Historical PostgreSQL bytea escape format
-          str.gsub(/\\(\\|'|[0-3][0-7][0-7])/) {|s|
-            if s.size == 2 then s[1,1] else s[1,3].oct.chr end
-          }
-        end
-        ::Sequel::SQL::Blob.new(str)
+    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.new.freeze
+    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] => tt.method(:boolean),
-      [17] => tt.method(:bytea),
-      [20, 21, 23, 26] => tt.method(:integer),
-      [700, 701] => tt.method(:float),
-      [1700] => ::BigDecimal.method(:new),
+      [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),
@@ -93,13 +97,17 @@ module Sequel
       # 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
@@ -126,6 +134,96 @@ 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
 
@@ -143,10 +241,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)
@@ -154,7 +252,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
 
@@ -195,8 +293,8 @@ module Sequel
 
       # Set a conversion proc for the given oid.  The callable can
       # be passed either as a argument or a block.
-      def add_conversion_proc(oid, callable=Proc.new)
-        conversion_procs[oid] = callable
+      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.
@@ -216,24 +314,22 @@ module Sequel
       # 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
+      # :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)}.
-          join(Sequel[:pg_attribute].as(:att), :attrelid=>:conrelid, :attnum=>SQL::Function.new(:ANY, Sequel[:co][:conkey])).
+          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])
-          if entry = hash[constraint]
-            entry[:columns] << m.call(row[:column])
-          else
-            hash[constraint] = {:definition=>row[:definition], :columns=>[m.call(row[:column])]}
-          end
+          entry = hash[constraint] ||= {:definition=>row[:definition], :columns=>[]}
+          entry[:columns] << m.call(row[:column]) if row[:column]
         end
         
         hash
@@ -261,7 +357,7 @@ module Sequel
         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} : {}
+        server_hash = server ? {:server=>server} : OPTS
         ds = dataset
         ds = ds.server(server) if server
 
@@ -269,7 +365,7 @@ module Sequel
 
         table_oid = regclass_oid(table)
         im = input_identifier_meth
-        unless column = im.call(opts[:column] || ((sch = schema(table).find{|col, sch| sch[:primary_key] && sch[:auto_increment]}) && sch[0]))
+        unless column = im.call(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
 
@@ -353,6 +449,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
@@ -482,6 +598,10 @@ module Sequel
             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 
 
@@ -661,7 +781,7 @@ module Sequel
         return @server_version if @server_version
         ds = dataset
         ds = ds.server(server) if server
-        @server_version ||= ds.with_sql("SELECT CAST(current_setting('server_version_num') AS integer) AS v").single_value rescue 0
+        @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+
@@ -830,10 +950,14 @@ module Sequel
       # default value is given.
       def column_definition_default_sql(sql, column)
         super
-        if !column[:serial] && !['serial', 'bigserial'].include?(column[:type].to_s) && !column[:default] && (identity = column[:identity])
-          sql << " GENERATED "
-          sql << (identity == :always ? "ALWAYS" : "BY DEFAULT")
-          sql << " AS IDENTITY"
+        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
 
@@ -1004,6 +1128,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)})"
+        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]}"
@@ -1025,21 +1179,36 @@ module Sequel
         "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
@@ -1073,7 +1242,13 @@ module Sequel
 
       # 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])
+        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 tablespace = options[:tablespace]
+          sql += " TABLESPACE #{quote_identifier(tablespace)}"
+        end
+
+        sql
       end
 
       # SQL for dropping a function from the database.
@@ -1143,7 +1318,7 @@ 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}#{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]}#{" TABLESPACE #{quote_identifier(index[:tablespace])}" if index[:tablespace]}#{filter}"
       end
 
       # Setup datastructures shared by all postgres adapters.
@@ -1249,6 +1424,10 @@ module Sequel
 
         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|
@@ -1659,11 +1838,29 @@ 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
+        end
+      end
+    
       # Truncates the dataset.  Returns nil.
       #
       # Options:
@@ -1688,11 +1885,11 @@ module Sequel
         end
       end
 
-      # Return a clone of the dataset with an addition named window that can be
-      # referenced in window functions. See {SQL::Window} for a list of options
-      # that can be passed in.
-      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
@@ -1704,7 +1901,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
@@ -1714,11 +1913,19 @@ 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
 
       # 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
 
@@ -1769,6 +1976,16 @@ module Sequel
         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?
@@ -1855,6 +2072,43 @@ module Sequel
         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)
@@ -1880,46 +2134,38 @@ module Sequel
         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 = ', '
-          as = ' AS '
-          ws.map do |name, window|
-            sql << co if c
-            literal_append(sql, name)
-            sql << as
-            literal_append(sql, window)
-            c ||= true
-          end
-        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]} ? "WITH RECURSIVE " : super
       end
 
+      # Support WITH AS [NOT] MATERIALIZED if :materialized option is used.
+      def select_with_sql_prefix(sql, w)
+        super
+
+        case w[:materialized]
+        when true
+          sql << "MATERIALIZED "
+        when false
+          sql << "NOT MATERIALIZED "
+        end
+      end
+
       # The version of the database server
       def server_version
         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
       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
-
       # Concatenate the expressions with a space in between
       def full_text_string_join(cols)
         cols = Array(cols).map{|x| SQL::Function.new(:COALESCE, x, '')}