class ActiveRecord::ConnectionAdapters::PostgreSQLAdapter

Active Record PostgreSQL Adapter

The PostgreSQL adapter works with the native C (github.com/ged/ruby-pg) driver.

Options:

Any further options are used as connection parameters to libpq. See www.postgresql.org/docs/current/static/libpq-connect.html for the list of parameters.

In addition, default connection parameters of libpq can be set per environment variables. See www.postgresql.org/docs/current/static/libpq-envars.html .

Constants

ADAPTER_NAME
DEADLOCK_DETECTED
DUPLICATE_DATABASE
FOREIGN_KEY_VIOLATION
LOCK_NOT_AVAILABLE
NATIVE_DATABASE_TYPES
NOT_NULL_VIOLATION
NUMERIC_VALUE_OUT_OF_RANGE
QUERY_CANCELED
SERIALIZATION_FAILURE
UNIQUE_VIOLATION
VALUE_LIMIT_VIOLATION

See www.postgresql.org/docs/current/static/errcodes-appendix.html

Attributes

type_map[R]

Public Class Methods

create_unlogged_tables() click to toggle source

PostgreSQL allows the creation of “unlogged” tables, which do not record data in the PostgreSQL Write-Ahead Log. This can make the tables faster, but significantly increases the risk of data loss if the database crashes. As a result, this should not be used in production environments. If you would like all created tables to be unlogged in the test environment you can add the following to your test.rb file:

ActiveSupport.on_load(:active_record_postgresqladapter) do
  self.create_unlogged_tables = true
end
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 105
class_attribute :create_unlogged_tables, default: false
datetime_type() click to toggle source

PostgreSQL supports multiple types for DateTimes. By default, if you use datetime in migrations, Rails will translate this to a PostgreSQL “timestamp without time zone”. Change this in an initializer to use another NATIVE_DATABASE_TYPES. For example, to store DateTimes as “timestamp with time zone”:

ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :timestamptz

Or if you are adding a custom type:

ActiveRecord::ConnectionAdapters::PostgreSQLAdapter::NATIVE_DATABASE_TYPES[:my_custom_type] = { name: "my_custom_type_name" }
ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.datetime_type = :my_custom_type

If you’re using :ruby as your config.active_record.schema_format and you change this setting, you should immediately run bin/rails db:migrate to update the types in your schema.rb.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 123
class_attribute :datetime_type, default: :timestamp
dbconsole(config, options = {}) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 73
def dbconsole(config, options = {})
  pg_config = config.configuration_hash

  ENV["PGUSER"]         = pg_config[:username] if pg_config[:username]
  ENV["PGHOST"]         = pg_config[:host] if pg_config[:host]
  ENV["PGPORT"]         = pg_config[:port].to_s if pg_config[:port]
  ENV["PGPASSWORD"]     = pg_config[:password].to_s if pg_config[:password] && options[:include_password]
  ENV["PGSSLMODE"]      = pg_config[:sslmode].to_s if pg_config[:sslmode]
  ENV["PGSSLCERT"]      = pg_config[:sslcert].to_s if pg_config[:sslcert]
  ENV["PGSSLKEY"]       = pg_config[:sslkey].to_s if pg_config[:sslkey]
  ENV["PGSSLROOTCERT"]  = pg_config[:sslrootcert].to_s if pg_config[:sslrootcert]
  if pg_config[:variables]
    ENV["PGOPTIONS"] = pg_config[:variables].filter_map do |name, value|
      "-c #{name}=#{value.to_s.gsub(/[ \\]/, '\\\\\0')}" unless value == ":default" || value == :default
    end.join(" ")
  end
  find_cmd_and_exec(ActiveRecord.database_cli[:postgresql], config.database)
end
decode_dates() click to toggle source

Toggles automatic decoding of date columns.

ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> String
ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.decode_dates = true
ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.select_value("select '2024-01-01'::date").class #=> Date
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 132
class_attribute :decode_dates, default: false
new(...) click to toggle source

Initializes and connects a PostgreSQL adapter.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 320
def initialize(...)
  super

  conn_params = @config.compact

  # Map ActiveRecords param names to PGs.
  conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
  conn_params[:dbname] = conn_params.delete(:database) if conn_params[:database]

  # Forward only valid config params to PG::Connection.connect.
  valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:requiressl]
  conn_params.slice!(*valid_conn_param_keys)

  @connection_parameters = conn_params

  @max_identifier_length = nil
  @type_map = nil
  @raw_connection = nil
  @notice_receiver_sql_warnings = []

  @use_insert_returning = @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
end
new_client(conn_params) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 57
def new_client(conn_params)
  PG.connect(**conn_params)
rescue ::PG::Error => error
  if conn_params && conn_params[:dbname] == "postgres"
    raise ActiveRecord::ConnectionNotEstablished, error.message
  elsif conn_params && conn_params[:dbname] && error.message.include?(conn_params[:dbname])
    raise ActiveRecord::NoDatabaseError.db_error(conn_params[:dbname])
  elsif conn_params && conn_params[:user] && error.message.include?(conn_params[:user])
    raise ActiveRecord::DatabaseConnectionError.username_error(conn_params[:user])
  elsif conn_params && conn_params[:host] && error.message.include?(conn_params[:host])
    raise ActiveRecord::DatabaseConnectionError.hostname_error(conn_params[:host])
  else
    raise ActiveRecord::ConnectionNotEstablished, error.message
  end
end

Public Instance Methods

active?() click to toggle source

Is this connection alive and ready for queries?

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 348
def active?
  @lock.synchronize do
    return false unless @raw_connection
    @raw_connection.query ";"
  end
  true
rescue PG::Error
  false
end
add_enum_value(type_name, value, **options) click to toggle source

Add enum value to an existing enum type.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 587
def add_enum_value(type_name, value, **options)
  before, after = options.values_at(:before, :after)
  sql = +"ALTER TYPE #{quote_table_name(type_name)} ADD VALUE"
  sql << " IF NOT EXISTS" if options[:if_not_exists]
  sql << " #{quote(value)}"

  if before && after
    raise ArgumentError, "Cannot have both :before and :after at the same time"
  elsif before
    sql << " BEFORE #{quote(before)}"
  elsif after
    sql << " AFTER #{quote(after)}"
  end

  execute(sql).tap { reload_type_map }
end
connected?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 343
def connected?
  !(@raw_connection.nil? || @raw_connection.finished?)
end
create_enum(name, values, **options) click to toggle source

Given a name and an array of values, creates an enum type.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 540
      def create_enum(name, values, **options)
        sql_values = values.map { |s| quote(s) }.join(", ")
        scope = quoted_scope(name)
        query = <<~SQL
          DO $$
          BEGIN
              IF NOT EXISTS (
                SELECT 1
                FROM pg_type t
                JOIN pg_namespace n ON t.typnamespace = n.oid
                WHERE t.typname = #{scope[:name]}
                  AND n.nspname = #{scope[:schema]}
              ) THEN
                  CREATE TYPE #{quote_table_name(name)} AS ENUM (#{sql_values});
              END IF;
          END
          $$;
        SQL
        internal_exec_query(query).tap { reload_type_map }
      end
disable_extension(name, force: false) click to toggle source

Removes an extension from the database.

:force

Set to :cascade to drop dependent objects as well. Defaults to false.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 485
def disable_extension(name, force: false)
  _schema, name = name.to_s.split(".").values_at(-2, -1)
  internal_exec_query("DROP EXTENSION IF EXISTS \"#{name}\"#{' CASCADE' if force == :cascade}").tap {
    reload_type_map
  }
end
disconnect!() click to toggle source

Disconnects from the database if already connected. Otherwise, this method does nothing.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 385
def disconnect!
  @lock.synchronize do
    super
    @raw_connection&.close rescue nil
    @raw_connection = nil
  end
end
drop_enum(name, values = nil, **options) click to toggle source

Drops an enum type.

If the if_exists: true option is provided, the enum is dropped only if it exists. Otherwise, if the enum doesn’t exist, an error is raised.

The values parameter will be ignored if present. It can be helpful to provide this in a migration’s change method so it can be reverted. In that case, values will be used by create_enum.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 570
      def drop_enum(name, values = nil, **options)
        query = <<~SQL
          DROP TYPE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(name)};
        SQL
        internal_exec_query(query).tap { reload_type_map }
      end
enable_extension(name, **) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 472
def enable_extension(name, **)
  schema, name = name.to_s.split(".").values_at(-2, -1)
  sql = +"CREATE EXTENSION IF NOT EXISTS \"#{name}\""
  sql << " SCHEMA #{schema}" if schema

  internal_exec_query(sql).tap { reload_type_map }
end
enum_types() click to toggle source

Returns a list of defined enum types, and their values.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 517
      def enum_types
        query = <<~SQL
          SELECT
            type.typname AS name,
            type.OID AS oid,
            n.nspname AS schema,
            string_agg(enum.enumlabel, ',' ORDER BY enum.enumsortorder) AS value
          FROM pg_enum AS enum
          JOIN pg_type AS type ON (type.oid = enum.enumtypid)
          JOIN pg_namespace n ON type.typnamespace = n.oid
          WHERE n.nspname = ANY (current_schemas(false))
          GROUP BY type.OID, n.nspname, type.typname;
        SQL

        internal_exec_query(query, "SCHEMA", allow_retry: true, materialize_transactions: false).cast_values.each_with_object({}) do |row, memo|
          name, schema = row[0], row[2]
          schema = nil if schema == current_schema
          full_name = [schema, name].compact.join(".")
          memo[full_name] = row.last
        end.to_a
      end
extension_available?(name) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 492
def extension_available?(name)
  query_value("SELECT true FROM pg_available_extensions WHERE name = #{quote(name)}", "SCHEMA")
end
extension_enabled?(name) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 496
def extension_enabled?(name)
  query_value("SELECT installed_version IS NOT NULL FROM pg_available_extensions WHERE name = #{quote(name)}", "SCHEMA")
end
extensions() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 500
      def extensions
        query = <<~SQL
          SELECT
            pg_extension.extname,
            n.nspname AS schema
          FROM pg_extension
          JOIN pg_namespace n ON pg_extension.extnamespace = n.oid
        SQL

        internal_exec_query(query, "SCHEMA", allow_retry: true, materialize_transactions: false).cast_values.map do |row|
          name, schema = row[0], row[1]
          schema = nil if schema == current_schema
          [schema, name].compact.join(".")
        end
      end
index_algorithms() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 291
def index_algorithms
  { concurrently: "CONCURRENTLY" }
end
max_identifier_length() click to toggle source

Returns the configured supported identifier length supported by PostgreSQL

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 619
def max_identifier_length
  @max_identifier_length ||= query_value("SHOW max_identifier_length", "SCHEMA").to_i
end
rename_enum(name, new_name = nil, **options) click to toggle source

Rename an existing enum type to something else.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 578
def rename_enum(name, new_name = nil, **options)
  new_name ||= options.fetch(:to) do
    raise ArgumentError, "rename_enum requires two from/to name positional arguments."
  end

  exec_query("ALTER TYPE #{quote_table_name(name)} RENAME TO #{quote_table_name(new_name)}").tap { reload_type_map }
end
rename_enum_value(type_name, **options) click to toggle source

Rename enum value on an existing enum type.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 605
def rename_enum_value(type_name, **options)
  unless database_version >= 10_00_00 # >= 10.0
    raise ArgumentError, "Renaming enum values is only supported in PostgreSQL 10 or later"
  end

  from = options.fetch(:from) { raise ArgumentError, ":from is required" }
  to = options.fetch(:to) { raise ArgumentError, ":to is required" }

  execute("ALTER TYPE #{quote_table_name(type_name)} RENAME VALUE #{quote(from)} TO #{quote(to)}").tap {
    reload_type_map
  }
end
reset!() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 370
def reset!
  @lock.synchronize do
    return connect! unless @raw_connection

    unless @raw_connection.transaction_status == ::PG::PQTRANS_IDLE
      @raw_connection.query "ROLLBACK"
    end
    @raw_connection.query "DISCARD ALL"

    super
  end
end
session_auth=(user) click to toggle source

Set the authorized user for this session

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 624
def session_auth=(user)
  clear_cache!
  internal_execute("SET SESSION AUTHORIZATION #{user}", nil, materialize_transactions: true)
end
set_standard_conforming_strings() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 411
def set_standard_conforming_strings
  internal_execute("SET standard_conforming_strings = on", "SCHEMA")
end
supports_advisory_locks?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 419
def supports_advisory_locks?
  true
end
supports_bulk_alter?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 188
def supports_bulk_alter?
  true
end
supports_check_constraints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 220
def supports_check_constraints?
  true
end
supports_comments?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 252
def supports_comments?
  true
end
supports_common_table_expressions?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 450
def supports_common_table_expressions?
  true
end
supports_datetime_with_precision?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 244
def supports_datetime_with_precision?
  true
end
supports_ddl_transactions?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 415
def supports_ddl_transactions?
  true
end
supports_deferrable_constraints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 236
def supports_deferrable_constraints?
  true
end
supports_exclusion_constraints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 224
def supports_exclusion_constraints?
  true
end
supports_explain?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 423
def supports_explain?
  true
end
supports_expression_index?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 208
def supports_expression_index?
  true
end
supports_extensions?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 427
def supports_extensions?
  true
end
supports_foreign_keys?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 216
def supports_foreign_keys?
  true
end
supports_foreign_tables?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 435
def supports_foreign_tables?
  true
end
supports_index_include?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 204
def supports_index_include?
  database_version >= 11_00_00 # >= 11.0
end
supports_index_sort_order?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 192
def supports_index_sort_order?
  true
end
supports_insert_conflict_target?()
supports_insert_on_conflict?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 268
def supports_insert_on_conflict?
  database_version >= 9_05_00 # >= 9.5
end
supports_insert_on_duplicate_skip?()
supports_insert_on_duplicate_update?()
supports_insert_returning?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 264
def supports_insert_returning?
  true
end
supports_json?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 248
def supports_json?
  true
end
supports_lazy_transactions?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 454
def supports_lazy_transactions?
  true
end
supports_materialized_views?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 431
def supports_materialized_views?
  true
end
supports_nulls_not_distinct?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 283
def supports_nulls_not_distinct?
  database_version >= 15_00_00 # >= 15.0
end
supports_optimizer_hints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 443
def supports_optimizer_hints?
  unless defined?(@has_pg_hint_plan)
    @has_pg_hint_plan = extension_available?("pg_hint_plan")
  end
  @has_pg_hint_plan
end
supports_partial_index?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 200
def supports_partial_index?
  true
end
supports_partitioned_indexes?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 196
def supports_partitioned_indexes?
  database_version >= 11_00_00 # >= 11.0
end
supports_pgcrypto_uuid?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 439
def supports_pgcrypto_uuid?
  database_version >= 9_04_00 # >= 9.4
end
supports_restart_db_transaction?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 260
def supports_restart_db_transaction?
  database_version >= 12_00_00 # >= 12.0
end
supports_savepoints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 256
def supports_savepoints?
  true
end
supports_transaction_isolation?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 212
def supports_transaction_isolation?
  true
end
supports_unique_constraints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 228
def supports_unique_constraints?
  true
end
supports_validate_constraints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 232
def supports_validate_constraints?
  true
end
supports_views?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 240
def supports_views?
  true
end
supports_virtual_columns?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 275
def supports_virtual_columns?
  database_version >= 12_00_00 # >= 12.0
end
use_insert_returning?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 629
def use_insert_returning?
  @use_insert_returning
end

Private Instance Methods

add_pg_decoders() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1107
        def add_pg_decoders
          @mapped_default_timezone = nil
          @timestamp_decoder = nil

          coders_by_name = {
            "int2" => PG::TextDecoder::Integer,
            "int4" => PG::TextDecoder::Integer,
            "int8" => PG::TextDecoder::Integer,
            "oid" => PG::TextDecoder::Integer,
            "float4" => PG::TextDecoder::Float,
            "float8" => PG::TextDecoder::Float,
            "numeric" => PG::TextDecoder::Numeric,
            "bool" => PG::TextDecoder::Boolean,
            "timestamp" => PG::TextDecoder::TimestampUtc,
            "timestamptz" => PG::TextDecoder::TimestampWithTimeZone,
          }
          coders_by_name["date"] = PG::TextDecoder::Date if decode_dates

          known_coder_types = coders_by_name.keys.map { |n| quote(n) }
          query = <<~SQL % known_coder_types.join(", ")
            SELECT t.oid, t.typname
            FROM pg_type as t
            WHERE t.typname IN (%s)
          SQL
          result = internal_execute(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false)
          coders = result.filter_map { |row| construct_coder(row, coders_by_name[row["typname"]]) }

          map = PG::TypeMapByOid.new
          coders.each { |coder| map.add_coder(coder) }
          @raw_connection.type_map_for_results = map

          @type_map_for_results = PG::TypeMapByOid.new
          @type_map_for_results.default_type_map = map
          @type_map_for_results.add_coder(PG::TextDecoder::Bytea.new(oid: 17, name: "bytea"))
          @type_map_for_results.add_coder(MoneyDecoder.new(oid: 790, name: "money"))

          # extract timestamp decoder for use in update_typemap_for_default_timezone
          @timestamp_decoder = coders.find { |coder| coder.name == "timestamp" }
          update_typemap_for_default_timezone
        end
add_pg_encoders() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1080
def add_pg_encoders
  map = PG::TypeMapByClass.new
  map[Integer] = PG::TextEncoder::Integer.new
  map[TrueClass] = PG::TextEncoder::Boolean.new
  map[FalseClass] = PG::TextEncoder::Boolean.new
  @raw_connection.type_map_for_queries = map
end
arel_visitor() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1046
def arel_visitor
  Arel::Visitors::PostgreSQL.new(self)
end
build_statement_pool() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1050
def build_statement_pool
  StatementPool.new(self, self.class.type_cast_config_to_integer(@config[:statement_limit]))
end
can_perform_case_insensitive_comparison_for?(column) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1054
        def can_perform_case_insensitive_comparison_for?(column)
          # NOTE: citext is an exception. It is possible to perform a
          #       case-insensitive comparison using `LOWER()`, but it is
          #       unnecessary, as `citext` is case-insensitive by definition.
          @case_insensitive_cache ||= { "citext" => false }
          @case_insensitive_cache.fetch(column.sql_type) do
            @case_insensitive_cache[column.sql_type] = begin
              sql = <<~SQL
                SELECT exists(
                  SELECT * FROM pg_proc
                  WHERE proname = 'lower'
                    AND proargtypes = ARRAY[#{quote column.sql_type}::regtype]::oidvector
                ) OR exists(
                  SELECT * FROM pg_proc
                  INNER JOIN pg_cast
                    ON ARRAY[casttarget]::oidvector = proargtypes
                  WHERE proname = 'lower'
                    AND castsource = #{quote column.sql_type}::regtype
                )
              SQL
              result = internal_execute(sql, "SCHEMA", [], allow_retry: true, materialize_transactions: false)
              result.getvalue(0, 0)
            end
          end
        end
column_definitions(table_name) click to toggle source

Returns the list of a table’s column names, data types, and default values.

The underlying query is roughly:

SELECT column.name, column.type, default.value, column.comment
  FROM column LEFT JOIN default
    ON column.table_id = default.table_id
   AND column.num = default.column_num
 WHERE column.table_id = get_table_id('table_name')
   AND column.num > 0
   AND NOT column.is_dropped
 ORDER BY column.num

If the table name is not prefixed with a schema, the database will take the first match from the schema search path.

Query implementation notes:

- format_type includes the column size constraint, e.g. varchar(50)
- ::regclass is a function that gives the id for a table name
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1029
        def column_definitions(table_name)
          query(<<~SQL, "SCHEMA")
              SELECT a.attname, format_type(a.atttypid, a.atttypmod),
                     pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
                     c.collname, col_description(a.attrelid, a.attnum) AS comment,
                     #{supports_identity_columns? ? 'attidentity' : quote('')} AS identity,
                     #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated
                FROM pg_attribute a
                LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
                LEFT JOIN pg_type t ON a.atttypid = t.oid
                LEFT JOIN pg_collation c ON a.attcollation = c.oid AND a.attcollation <> t.typcollation
               WHERE a.attrelid = #{quote(quote_table_name(table_name))}::regclass
                 AND a.attnum > 0 AND NOT a.attisdropped
               ORDER BY a.attnum
          SQL
        end
configure_connection() click to toggle source

Configures the encoding, verbosity, schema search path, and time zone of the connection. This is called by connect and should not be called manually.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 951
def configure_connection
  super

  if @config[:encoding]
    @raw_connection.set_client_encoding(@config[:encoding])
  end
  self.client_min_messages = @config[:min_messages] || "warning"
  self.schema_search_path = @config[:schema_search_path] || @config[:schema_order]

  unless ActiveRecord.db_warnings_action.nil?
    @raw_connection.set_notice_receiver do |result|
      message = result.error_field(PG::Result::PG_DIAG_MESSAGE_PRIMARY)
      code = result.error_field(PG::Result::PG_DIAG_SQLSTATE)
      level = result.error_field(PG::Result::PG_DIAG_SEVERITY)
      @notice_receiver_sql_warnings << SQLWarning.new(message, code, level, nil, @pool)
    end
  end

  # Use standard-conforming strings so we don't have to do the E'...' dance.
  set_standard_conforming_strings

  variables = @config.fetch(:variables, {}).stringify_keys

  # Set interval output format to ISO 8601 for ease of parsing by ActiveSupport::Duration.parse
  internal_execute("SET intervalstyle = iso_8601", "SCHEMA")

  # SET statements from :variables config hash
  # https://www.postgresql.org/docs/current/static/sql-set.html
  variables.map do |k, v|
    if v == ":default" || v == :default
      # Sets the value to the global or compile default
      internal_execute("SET SESSION #{k} TO DEFAULT", "SCHEMA")
    elsif !v.nil?
      internal_execute("SET SESSION #{k} TO #{quote(v)}", "SCHEMA")
    end
  end

  add_pg_encoders
  add_pg_decoders

  reload_type_map
end
connect() click to toggle source

Connects to a PostgreSQL server and sets up the adapter depending on the connected server’s characteristics.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 933
def connect
  @raw_connection = self.class.new_client(@connection_parameters)
rescue ConnectionNotEstablished => ex
  raise ex.set_pool(@pool)
end
construct_coder(row, coder_class) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1148
def construct_coder(row, coder_class)
  return unless coder_class
  coder_class.new(oid: row["oid"].to_i, name: row["typname"])
end
extract_default_function(default_value, default) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 776
def extract_default_function(default_value, default)
  default if has_default_function?(default_value, default)
end
extract_value_from_default(default) click to toggle source

Extracts the value from a PostgreSQL column default definition.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 750
def extract_value_from_default(default)
  case default
    # Quoted types
  when /\A[(B]?'(.*)'.*::"?([\w. ]+)"?(?:\[\])?\z/m
    # The default 'now'::date is CURRENT_DATE
    if $1 == "now" && $2 == "date"
      nil
    else
      $1.gsub("''", "'")
    end
    # Boolean types
  when "true", "false"
    default
    # Numeric types
  when /\A\(?(-?\d+(\.\d*)?)\)?(::bigint)?\z/
    $1
    # Object identifier types
  when /\A-?\d+\z/
    $1
  else
    # Anything else is blank, some user type, or some function
    # and we can't know the value of that, so return nil.
    nil
  end
end
get_oid_type(oid, fmod, column_name, sql_type = "") click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 849
def get_oid_type(oid, fmod, column_name, sql_type = "")
  if !type_map.key?(oid)
    load_additional_types([oid])
  end

  type_map.fetch(oid, fmod, sql_type) {
    warn "unknown OID #{oid}: failed to recognize type of '#{column_name}'. It will be treated as String."
    Type.default_value.tap do |cast_type|
      type_map.register_type(oid, cast_type)
    end
  }
end
has_default_function?(default_value, default) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 780
def has_default_function?(default_value, default)
  !default_value && %r{\w+\(.*\)|\(.*\)::\w+|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
end
in_transaction?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 903
def in_transaction?
  open_transactions > 0
end
initialize_type_map(m = type_map) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 739
def initialize_type_map(m = type_map)
  self.class.initialize_type_map(m)

  self.class.register_class_with_precision m, "time", Type::Time, timezone: @default_timezone
  self.class.register_class_with_precision m, "timestamp", OID::Timestamp, timezone: @default_timezone
  self.class.register_class_with_precision m, "timestamptz", OID::TimestampWithTimeZone

  load_additional_types
end
is_cached_plan_failure?(pgerror) click to toggle source

Annoyingly, the code for prepared statements whose return value may have changed is FEATURE_NOT_SUPPORTED.

This covers various different error types so we need to do additional work to classify the exception definitively as a ActiveRecord::PreparedStatementCacheExpired

Check here for more details: git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/cache/plancache.c#l573

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 896
def is_cached_plan_failure?(pgerror)
  pgerror.result.result_error_field(PG::PG_DIAG_SQLSTATE) == FEATURE_NOT_SUPPORTED &&
    pgerror.result.result_error_field(PG::PG_DIAG_SOURCE_FUNCTION) == "RevalidateCachedQuery"
rescue
  false
end
load_additional_types(oids = nil) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 862
def load_additional_types(oids = nil)
  initializer = OID::TypeMapInitializer.new(type_map)
  load_types_queries(initializer, oids) do |query|
    records = internal_execute(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false)
    initializer.run(records)
  end
end
load_types_queries(initializer, oids) { |query| ... } click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 870
        def load_types_queries(initializer, oids)
          query = <<~SQL
            SELECT t.oid, t.typname, t.typelem, t.typdelim, t.typinput, r.rngsubtype, t.typtype, t.typbasetype
            FROM pg_type as t
            LEFT JOIN pg_range as r ON oid = rngtypid
          SQL
          if oids
            yield query + "WHERE t.oid IN (%s)" % oids.join(", ")
          else
            yield query + initializer.query_conditions_for_known_type_names
            yield query + initializer.query_conditions_for_known_type_types
            yield query + initializer.query_conditions_for_array_types
          end
        end
prepare_statement(sql, binds, conn) click to toggle source

Prepare the statement if it hasn’t been prepared, return the statement key.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 915
def prepare_statement(sql, binds, conn)
  sql_key = sql_key(sql)
  unless @statements.key? sql_key
    nextkey = @statements.next_key
    begin
      conn.prepare nextkey, sql
    rescue => e
      raise translate_exception_class(e, sql, binds)
    end
    # Clear the queue
    conn.get_last_result
    @statements[sql_key] = nextkey
  end
  @statements[sql_key]
end
reconfigure_connection_timezone() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 994
def reconfigure_connection_timezone
  variables = @config.fetch(:variables, {}).stringify_keys

  # If it's been directly configured as a connection variable, we don't
  # need to do anything here; it will be set up by configure_connection
  # and then never changed.
  return if variables["timezone"]

  # If using Active Record's time zone support configure the connection
  # to return TIMESTAMP WITH ZONE types in UTC.
  if default_timezone == :utc
    raw_execute("SET SESSION timezone TO 'UTC'", "SCHEMA")
  else
    raw_execute("SET SESSION timezone TO DEFAULT", "SCHEMA")
  end
end
reconnect() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 939
def reconnect
  begin
    @raw_connection&.reset
  rescue PG::ConnectionBad
    @raw_connection = nil
  end

  connect unless @raw_connection
end
retryable_query_error?(exception) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 842
def retryable_query_error?(exception)
  # We cannot retry anything if we're inside a broken transaction; we need to at
  # least raise until the innermost savepoint is rolled back
  @raw_connection&.transaction_status != ::PG::PQTRANS_INERROR &&
    super
end
sql_key(sql) click to toggle source

Returns the statement identifier for the client side cache of statements

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 909
def sql_key(sql)
  "#{schema_search_path}-#{sql}"
end
translate_exception(exception, message:, sql:, binds:) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 796
def translate_exception(exception, message:, sql:, binds:)
  return exception unless exception.respond_to?(:result)

  case exception.result.try(:error_field, PG::PG_DIAG_SQLSTATE)
  when nil
    if exception.message.match?(/connection is closed/i) || exception.message.match?(/no connection to the server/i)
      ConnectionNotEstablished.new(exception, connection_pool: @pool)
    elsif exception.is_a?(PG::ConnectionBad)
      # libpq message style always ends with a newline; the pg gem's internal
      # errors do not. We separate these cases because a pg-internal
      # ConnectionBad means it failed before it managed to send the query,
      # whereas a libpq failure could have occurred at any time (meaning the
      # server may have already executed part or all of the query).
      if exception.message.end_with?("\n")
        ConnectionFailed.new(exception, connection_pool: @pool)
      else
        ConnectionNotEstablished.new(exception, connection_pool: @pool)
      end
    else
      super
    end
  when UNIQUE_VIOLATION
    RecordNotUnique.new(message, sql: sql, binds: binds, connection_pool: @pool)
  when FOREIGN_KEY_VIOLATION
    InvalidForeignKey.new(message, sql: sql, binds: binds, connection_pool: @pool)
  when VALUE_LIMIT_VIOLATION
    ValueTooLong.new(message, sql: sql, binds: binds, connection_pool: @pool)
  when NUMERIC_VALUE_OUT_OF_RANGE
    RangeError.new(message, sql: sql, binds: binds, connection_pool: @pool)
  when NOT_NULL_VIOLATION
    NotNullViolation.new(message, sql: sql, binds: binds, connection_pool: @pool)
  when SERIALIZATION_FAILURE
    SerializationFailure.new(message, sql: sql, binds: binds, connection_pool: @pool)
  when DEADLOCK_DETECTED
    Deadlocked.new(message, sql: sql, binds: binds, connection_pool: @pool)
  when DUPLICATE_DATABASE
    DatabaseAlreadyExists.new(message, sql: sql, binds: binds, connection_pool: @pool)
  when LOCK_NOT_AVAILABLE
    LockWaitTimeout.new(message, sql: sql, binds: binds, connection_pool: @pool)
  when QUERY_CANCELED
    QueryCanceled.new(message, sql: sql, binds: binds, connection_pool: @pool)
  else
    super
  end
end
update_typemap_for_default_timezone() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1088
def update_typemap_for_default_timezone
  if @raw_connection && @mapped_default_timezone != default_timezone && @timestamp_decoder
    decoder_class = default_timezone == :utc ?
      PG::TextDecoder::TimestampUtc :
      PG::TextDecoder::TimestampWithoutTimeZone

    @timestamp_decoder = decoder_class.new(**@timestamp_decoder.to_h)
    @raw_connection.type_map_for_results.add_coder(@timestamp_decoder)

    @mapped_default_timezone = default_timezone

    # if default timezone has changed, we need to reconfigure the connection
    # (specifically, the session time zone)
    reconfigure_connection_timezone

    true
  end
end