class ActiveRecord::ConnectionAdapters::PostgreSQLAdapter

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

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 line to your test.rb file:

ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables = true
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 103
class_attribute :create_unlogged_tables, default: false
database_exists?(config) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 300
def self.database_exists?(config)
  !!ActiveRecord::Base.postgresql_connection(config)
rescue ActiveRecord::NoDatabaseError
  false
end
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 121
class_attribute :datetime_type, default: :timestamp
new(connection, logger, connection_parameters, config) click to toggle source

Initializes and connects a PostgreSQL adapter.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 281
def initialize(connection, logger, connection_parameters, config)
  super(connection, logger, config)

  @connection_parameters = connection_parameters || {}

  # @local_tz is initialized as nil to avoid warnings when connect tries to use it
  @local_tz = nil
  @max_identifier_length = nil

  configure_connection
  add_pg_encoders
  add_pg_decoders

  @type_map = Type::HashLookupTypeMap.new
  initialize_type_map
  @local_tz = execute("SHOW TIME ZONE", "SCHEMA").first["TimeZone"]
  @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 77
def new_client(conn_params)
  PG.connect(**conn_params)
rescue ::PG::Error => error
  if 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[:hostname] && error.message.include?(conn_params[:hostname])
    raise ActiveRecord::DatabaseConnectionError.hostname_error(conn_params[:hostname])
  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 307
def active?
  @lock.synchronize do
    @connection.query ";"
  end
  true
rescue PG::Error
  false
end
create_enum(name, values) 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 472
      def create_enum(name, values)
        sql_values = values.map { |s| "'#{s}'" }.join(", ")
        query = <<~SQL
          DO $$
          BEGIN
              IF NOT EXISTS (
                SELECT 1 FROM pg_type t
                WHERE t.typname = '#{name}'
              ) THEN
                  CREATE TYPE \"#{name}\" AS ENUM (#{sql_values});
              END IF;
          END
          $$;
        SQL
        exec_query(query)
      end
disable_extension(name) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 439
def disable_extension(name)
  exec_query("DROP EXTENSION IF EXISTS \"#{name}\" 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 347
def disconnect!
  @lock.synchronize do
    super
    @connection.close rescue nil
  end
end
enable_extension(name) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 433
def enable_extension(name)
  exec_query("CREATE EXTENSION IF NOT EXISTS \"#{name}\"").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 458
      def enum_types
        query = <<~SQL
          SELECT
            type.typname AS name,
            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)
          GROUP BY type.typname;
        SQL
        exec_query(query, "SCHEMA").cast_values
      end
extension_available?(name) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 445
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 449
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 453
def extensions
  exec_query("SELECT extname FROM pg_extension", "SCHEMA").cast_values
end
index_algorithms() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 252
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 490
def max_identifier_length
  @max_identifier_length ||= query_value("SHOW max_identifier_length", "SCHEMA").to_i
end
reconnect!() click to toggle source

Close then reopen the connection.

# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 322
def reconnect!
  @lock.synchronize do
    super
    @connection.reset
    configure_connection
    reload_type_map
  rescue PG::ConnectionBad
    connect
  end
end
reset!() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 333
def reset!
  @lock.synchronize do
    clear_cache!
    reset_transaction
    unless @connection.transaction_status == ::PG::PQTRANS_IDLE
      @connection.query "ROLLBACK"
    end
    @connection.query "DISCARD ALL"
    configure_connection
  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 495
def session_auth=(user)
  clear_cache!
  execute("SET SESSION AUTHORIZATION #{user}")
end
set_standard_conforming_strings() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 372
def set_standard_conforming_strings
  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 380
def supports_advisory_locks?
  true
end
supports_bulk_alter?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 177
def supports_bulk_alter?
  true
end
supports_check_constraints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 205
def supports_check_constraints?
  true
end
supports_comments?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 229
def supports_comments?
  true
end
supports_common_table_expressions?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 411
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 221
def supports_datetime_with_precision?
  true
end
supports_ddl_transactions?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 376
def supports_ddl_transactions?
  true
end
supports_deferrable_constraints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 213
def supports_deferrable_constraints?
  true
end
supports_explain?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 384
def supports_explain?
  true
end
supports_expression_index?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 193
def supports_expression_index?
  true
end
supports_extensions?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 388
def supports_extensions?
  true
end
supports_foreign_keys?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 201
def supports_foreign_keys?
  true
end
supports_foreign_tables?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 396
def supports_foreign_tables?
  true
end
supports_index_sort_order?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 181
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 241
def supports_insert_on_conflict?
  database_version >= 90500 # >= 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 237
def supports_insert_returning?
  true
end
supports_json?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 225
def supports_json?
  true
end
supports_lazy_transactions?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 415
def supports_lazy_transactions?
  true
end
supports_materialized_views?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 392
def supports_materialized_views?
  true
end
supports_optimizer_hints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 404
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 189
def supports_partial_index?
  true
end
supports_partitioned_indexes?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 185
def supports_partitioned_indexes?
  database_version >= 110_000 # >= 11.0
end
supports_pgcrypto_uuid?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 400
def supports_pgcrypto_uuid?
  database_version >= 90400 # >= 9.4
end
supports_savepoints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 233
def supports_savepoints?
  true
end
supports_transaction_isolation?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 197
def supports_transaction_isolation?
  true
end
supports_validate_constraints?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 209
def supports_validate_constraints?
  true
end
supports_views?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 217
def supports_views?
  true
end
supports_virtual_columns?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 248
def supports_virtual_columns?
  database_version >= 120_000 # >= 12.0
end
use_insert_returning?() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 500
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 991
        def add_pg_decoders
          @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,
          }

          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
          coders = execute_and_clear(query, "SCHEMA", []) do |result|
            result.filter_map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
          end

          map = PG::TypeMapByOid.new
          coders.each { |coder| map.add_coder(coder) }
          @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 966
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
  @connection.type_map_for_queries = map
end
arel_visitor() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 936
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 940
def build_statement_pool
  StatementPool.new(@connection, 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 944
        def can_perform_case_insensitive_comparison_for?(column)
          @case_insensitive_cache ||= {}
          @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
            execute_and_clear(sql, "SCHEMA", []) do |result|
              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 915
        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_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 860
def configure_connection
  if @config[:encoding]
    @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]

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

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

  # If using Active Record's time zone support configure the connection to return
  # TIMESTAMP WITH ZONE types in UTC.
  unless variables["timezone"]
    if ActiveRecord.default_timezone == :utc
      variables["timezone"] = "UTC"
    elsif @local_tz
      variables["timezone"] = @local_tz
    end
  end

  # Set interval output format to ISO 8601 for ease of parsing by ActiveSupport::Duration.parse
  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
      execute("SET SESSION #{k} TO DEFAULT", "SCHEMA")
    elsif !v.nil?
      execute("SET SESSION #{k} TO #{quote(v)}", "SCHEMA")
    end
  end
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 851
def connect
  @connection = self.class.new_client(@connection_parameters)
  configure_connection
  add_pg_encoders
  add_pg_decoders
end
construct_coder(row, coder_class) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 1032
def construct_coder(row, coder_class)
  return unless coder_class
  coder_class.new(oid: row["oid"].to_i, name: row["typname"])
end
exec_cache(sql, name, binds, async: false) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 773
def exec_cache(sql, name, binds, async: false)
  materialize_transactions
  mark_transaction_written_if_write(sql)
  update_typemap_for_default_timezone

  stmt_key = prepare_statement(sql, binds)
  type_casted_binds = type_casted_binds(binds)

  log(sql, name, binds, type_casted_binds, stmt_key, async: async) do
    ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
      @connection.exec_prepared(stmt_key, type_casted_binds)
    end
  end
rescue ActiveRecord::StatementInvalid => e
  raise unless is_cached_plan_failure?(e)

  # Nothing we can do if we are in a transaction because all commands
  # will raise InFailedSQLTransaction
  if in_transaction?
    raise ActiveRecord::PreparedStatementCacheExpired.new(e.cause.message)
  else
    @lock.synchronize do
      # outside of transactions we can simply flush this query and retry
      @statements.delete sql_key(sql)
    end
    retry
  end
end
exec_no_cache(sql, name, binds, async: false) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 757
def exec_no_cache(sql, name, binds, async: false)
  materialize_transactions
  mark_transaction_written_if_write(sql)

  # make sure we carry over any changes to ActiveRecord.default_timezone that have been
  # made since we established the connection
  update_typemap_for_default_timezone

  type_casted_binds = type_casted_binds(binds)
  log(sql, name, binds, type_casted_binds, async: async) do
    ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
      @connection.exec_params(sql, type_casted_binds)
    end
  end
end
execute_and_clear(sql, name, binds, prepare: false, async: false) { |result| ... } click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 740
def execute_and_clear(sql, name, binds, prepare: false, async: false)
  sql = transform_query(sql)
  check_if_write_query(sql)

  if !prepare || without_prepared_statement?(binds)
    result = exec_no_cache(sql, name, binds, async: async)
  else
    result = exec_cache(sql, name, binds, async: async)
  end
  begin
    ret = yield result
  ensure
    result.clear
  end
  ret
end
extract_default_function(default_value, default) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 646
def extract_default_function(default_value, default)
  default if has_default_function?(default_value, default)
end
extract_table_ref_from_insert_sql(sql) click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 931
def extract_table_ref_from_insert_sql(sql)
  sql[/into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im]
  $1.strip if $1
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 620
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 701
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 650
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 819
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 614
def initialize_type_map(m = type_map)
  self.class.initialize_type_map(m)
  load_additional_types
end
is_cached_plan_failure?(e) 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 811
def is_cached_plan_failure?(e)
  pgerror = e.cause
  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 714
def load_additional_types(oids = nil)
  initializer = OID::TypeMapInitializer.new(type_map)
  load_types_queries(initializer, oids) do |query|
    execute_and_clear(query, "SCHEMA", []) do |records|
      initializer.run(records)
    end
  end
end
load_types_queries(initializer, oids) { |query| ... } click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 723
        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) 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 831
def prepare_statement(sql, binds)
  @lock.synchronize do
    sql_key = sql_key(sql)
    unless @statements.key? sql_key
      nextkey = @statements.next_key
      begin
        @connection.prepare nextkey, sql
      rescue => e
        raise translate_exception_class(e, sql, binds)
      end
      # Clear the queue
      @connection.get_last_result
      @statements[sql_key] = nextkey
    end
    @statements[sql_key]
  end
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 825
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 666
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)
      ConnectionNotEstablished.new(exception)
    else
      super
    end
  when UNIQUE_VIOLATION
    RecordNotUnique.new(message, sql: sql, binds: binds)
  when FOREIGN_KEY_VIOLATION
    InvalidForeignKey.new(message, sql: sql, binds: binds)
  when VALUE_LIMIT_VIOLATION
    ValueTooLong.new(message, sql: sql, binds: binds)
  when NUMERIC_VALUE_OUT_OF_RANGE
    RangeError.new(message, sql: sql, binds: binds)
  when NOT_NULL_VIOLATION
    NotNullViolation.new(message, sql: sql, binds: binds)
  when SERIALIZATION_FAILURE
    SerializationFailure.new(message, sql: sql, binds: binds)
  when DEADLOCK_DETECTED
    Deadlocked.new(message, sql: sql, binds: binds)
  when DUPLICATE_DATABASE
    DatabaseAlreadyExists.new(message, sql: sql, binds: binds)
  when LOCK_NOT_AVAILABLE
    LockWaitTimeout.new(message, sql: sql, binds: binds)
  when QUERY_CANCELED
    QueryCanceled.new(message, sql: sql, binds: binds)
  else
    super
  end
end
type_map() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 610
def type_map
  @type_map ||= Type::HashLookupTypeMap.new
end
update_typemap_for_default_timezone() click to toggle source
# File lib/active_record/connection_adapters/postgresql_adapter.rb, line 974
def update_typemap_for_default_timezone
  if @default_timezone != ActiveRecord.default_timezone && @timestamp_decoder
    decoder_class = ActiveRecord.default_timezone == :utc ?
      PG::TextDecoder::TimestampUtc :
      PG::TextDecoder::TimestampWithoutTimeZone

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

    @default_timezone = ActiveRecord.default_timezone

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