activerecord 6.0.3.4 → 6.1.2

data/lib/active_record/connection_adapters/postgresql/oid/range.rb

@@ -67,15 +67,34 @@ module ActiveRecord
             end
 
             def extract_bounds(value)
-              from, to = value[1..-2].split(",")
+              from, to = value[1..-2].split(",", 2)
               {
-                from:          (value[1] == "," || from == "-infinity") ? infinity(negative: true) : from,
-                to:            (value[-2] == "," || to == "infinity") ? infinity : to,
-                exclude_start: (value[0] == "("),
-                exclude_end:   (value[-1] == ")")
+                from:          (from == "" || from == "-infinity") ? infinity(negative: true) : unquote(from),
+                to:            (to == "" || to == "infinity") ? infinity : unquote(to),
+                exclude_start: value.start_with?("("),
+                exclude_end:   value.end_with?(")")
               }
             end
 
+            # When formatting the bound values of range types, PostgreSQL quotes
+            # the bound value using double-quotes in certain conditions. Within
+            # a double-quoted string, literal " and \ characters are themselves
+            # escaped. In input, PostgreSQL accepts multiple escape styles for "
+            # (either \" or "") but in output always uses "".
+            # See:
+            # * https://www.postgresql.org/docs/current/rangetypes.html#RANGETYPES-IO
+            # * https://www.postgresql.org/docs/current/rowtypes.html#ROWTYPES-IO-SYNTAX
+            def unquote(value)
+              if value.start_with?('"') && value.end_with?('"')
+                unquoted_value = value[1..-2]
+                unquoted_value.gsub!('""', '"')
+                unquoted_value.gsub!('\\\\', '\\')
+                unquoted_value
+              else
+                value
+              end
+            end
+
             def infinity(negative: false)
               if subtype.respond_to?(:infinity)
                 subtype.infinity(negative: negative)

data/lib/active_record/connection_adapters/postgresql/oid/uuid.rb

@@ -7,12 +7,22 @@ module ActiveRecord
         class Uuid < Type::Value # :nodoc:
           ACCEPTABLE_UUID = %r{\A(\{)?([a-fA-F0-9]{4}-?){8}(?(1)\}|)\z}
 
-          alias_method :serialize, :deserialize
+          alias :serialize :deserialize
 
           def type
             :uuid
           end
 
+          def changed?(old_value, new_value, _new_value_before_type_cast)
+            old_value.class != new_value.class ||
+              new_value && old_value.casecmp(new_value) != 0
+          end
+
+          def changed_in_place?(raw_old_value, new_value)
+            raw_old_value.class != new_value.class ||
+              new_value && raw_old_value.casecmp(new_value) != 0
+          end
+
           private
             def cast_value(value)
               casted = value.to_s

data/lib/active_record/connection_adapters/postgresql/quoting.rb

@@ -18,7 +18,7 @@ module ActiveRecord
 
         # Quotes strings for use in SQL input.
         def quote_string(s) #:nodoc:
-          @connection.escape(s)
+          PG::Connection.escape(s)
         end
 
         # Checks the following cases:
@@ -67,8 +67,8 @@ module ActiveRecord
           elsif column.type == :uuid && value.is_a?(String) && /\(\)/.match?(value)
             value # Does not quote function default values for UUID columns
           elsif column.respond_to?(:array?)
-            value = type_cast_from_column(column, value)
-            quote(value)
+            type = lookup_cast_type_from_column(column)
+            quote(type.serialize(value))
           else
             super
           end
@@ -93,7 +93,7 @@ module ActiveRecord
               # "table_name"."column_name"::type_name | function(one or no argument)::type_name
               ((?:\w+\.|"\w+"\.)?(?:\w+|"\w+")(?:::\w+)?) | \w+\((?:|\g<2>)\)(?:::\w+)?
             )
-            (?:\s+AS\s+(?:\w+|"\w+"))?
+            (?:(?:\s+AS)?\s+(?:\w+|"\w+"))?
           )
           (?:\s*,\s*\g<1>)*
           \z

data/lib/active_record/connection_adapters/postgresql/referential_integrity.rb

@@ -24,7 +24,7 @@ WARNING: Rails was not able to disable referential integrity.
 This is most likely caused due to missing permissions.
 Rails needs superuser privileges to disable referential integrity.
 
-    cause: #{original_exception.try(:message)}
+    cause: #{original_exception&.message}
 
             WARNING
             raise e

data/lib/active_record/connection_adapters/postgresql/schema_creation.rb

@@ -3,7 +3,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module PostgreSQL
-      class SchemaCreation < AbstractAdapter::SchemaCreation # :nodoc:
+      class SchemaCreation < SchemaCreation # :nodoc:
         private
           def visit_AlterTable(o)
             super << o.constraint_validations.map { |fk| visit_ValidateConstraint fk }.join(" ")
@@ -13,6 +13,10 @@ module ActiveRecord
             super.dup.tap { |sql| sql << " NOT VALID" unless o.validate? }
           end
 
+          def visit_CheckConstraintDefinition(o)
+            super.dup.tap { |sql| sql << " NOT VALID" unless o.validate? }
+          end
+
           def visit_ValidateConstraint(name)
             "VALIDATE CONSTRAINT #{quote_column_name(name)}"
           end

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -54,7 +54,8 @@ module ActiveRecord
           execute "DROP DATABASE IF EXISTS #{quote_table_name(name)}"
         end
 
-        def drop_table(table_name, options = {}) # :nodoc:
+        def drop_table(table_name, **options) # :nodoc:
+          schema_cache.clear_data_source_cache!(table_name.to_s)
           execute "DROP TABLE#{' IF EXISTS' if options[:if_exists]} #{quote_table_name(table_name)}#{' CASCADE' if options[:force] == :cascade}"
         end
 
@@ -211,7 +212,7 @@ module ActiveRecord
         end
 
         # Drops the schema for the given schema name.
-        def drop_schema(schema_name, options = {})
+        def drop_schema(schema_name, **options)
           execute "DROP SCHEMA#{' IF EXISTS' if options[:if_exists]} #{quote_schema_name(schema_name)} CASCADE"
         end
 
@@ -376,6 +377,8 @@ module ActiveRecord
         #   rename_table('octopuses', 'octopi')
         def rename_table(table_name, new_name)
           clear_cache!
+          schema_cache.clear_data_source_cache!(table_name.to_s)
+          schema_cache.clear_data_source_cache!(new_name.to_s)
           execute "ALTER TABLE #{quote_table_name(table_name)} RENAME TO #{quote_table_name(new_name)}"
           pk, seq = pk_and_sequence_for(new_name)
           if pk
@@ -396,9 +399,9 @@ module ActiveRecord
           change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
         end
 
-        def change_column(table_name, column_name, type, options = {}) #:nodoc:
+        def change_column(table_name, column_name, type, **options) #:nodoc:
           clear_cache!
-          sqls, procs = Array(change_column_for_alter(table_name, column_name, type, options)).partition { |v| v.is_a?(String) }
+          sqls, procs = Array(change_column_for_alter(table_name, column_name, type, **options)).partition { |v| v.is_a?(String) }
           execute "ALTER TABLE #{quote_table_name(table_name)} #{sqls.join(", ")}"
           procs.each(&:call)
         end
@@ -434,21 +437,24 @@ module ActiveRecord
         # Renames a column in a table.
         def rename_column(table_name, column_name, new_column_name) #:nodoc:
           clear_cache!
-          execute "ALTER TABLE #{quote_table_name(table_name)} RENAME COLUMN #{quote_column_name(column_name)} TO #{quote_column_name(new_column_name)}"
+          execute("ALTER TABLE #{quote_table_name(table_name)} #{rename_column_sql(table_name, column_name, new_column_name)}")
           rename_column_indexes(table_name, column_name, new_column_name)
         end
 
-        def add_index(table_name, column_name, options = {}) #:nodoc:
-          index_name, index_type, index_columns_and_opclasses, index_options, index_algorithm, index_using, comment = add_index_options(table_name, column_name, **options)
-          execute("CREATE #{index_type} INDEX #{index_algorithm} #{quote_column_name(index_name)} ON #{quote_table_name(table_name)} #{index_using} (#{index_columns_and_opclasses})#{index_options}").tap do
-            execute "COMMENT ON INDEX #{quote_column_name(index_name)} IS #{quote(comment)}" if comment
-          end
+        def add_index(table_name, column_name, **options) #:nodoc:
+          index, algorithm, if_not_exists = add_index_options(table_name, column_name, **options)
+
+          create_index = CreateIndexDefinition.new(index, algorithm, if_not_exists)
+          result = execute schema_creation.accept(create_index)
+
+          execute "COMMENT ON INDEX #{quote_column_name(index.name)} IS #{quote(index.comment)}" if index.comment
+          result
         end
 
-        def remove_index(table_name, options = {}) #:nodoc:
+        def remove_index(table_name, column_name = nil, **options) # :nodoc:
           table = Utils.extract_schema_qualified_name(table_name.to_s)
 
-          if options.is_a?(Hash) && options.key?(:name)
+          if options.key?(:name)
             provided_index = Utils.extract_schema_qualified_name(options[:name].to_s)
 
             options[:name] = provided_index.identifier
@@ -459,14 +465,11 @@ module ActiveRecord
             end
           end
 
-          index_to_remove = PostgreSQL::Name.new(table.schema, index_name_for_remove(table.to_s, options))
-          algorithm =
-            if options.is_a?(Hash) && options.key?(:algorithm)
-              index_algorithms.fetch(options[:algorithm]) do
-                raise ArgumentError.new("Algorithm must be one of the following: #{index_algorithms.keys.map(&:inspect).join(', ')}")
-              end
-            end
-          execute "DROP INDEX #{algorithm} #{quote_table_name(index_to_remove)}"
+          return if options[:if_exists] && !index_exists?(table_name, column_name, **options)
+
+          index_to_remove = PostgreSQL::Name.new(table.schema, index_name_for_remove(table.to_s, column_name, options))
+
+          execute "DROP INDEX #{index_algorithm(options[:algorithm])} #{quote_table_name(index_to_remove)}"
         end
 
         # Renames an index of a table. Raises error if length of new
@@ -516,6 +519,28 @@ module ActiveRecord
           query_values(data_source_sql(table_name, type: "FOREIGN TABLE"), "SCHEMA").any? if table_name.present?
         end
 
+        def check_constraints(table_name) # :nodoc:
+          scope = quoted_scope(table_name)
+
+          check_info = exec_query(<<-SQL, "SCHEMA")
+            SELECT conname, pg_get_constraintdef(c.oid) AS constraintdef, c.convalidated AS valid
+            FROM pg_constraint c
+            JOIN pg_class t ON c.conrelid = t.oid
+            WHERE c.contype = 'c'
+              AND t.relname = #{scope[:name]}
+          SQL
+
+          check_info.map do |row|
+            options = {
+              name: row["conname"],
+              validate: row["valid"]
+            }
+            expression = row["constraintdef"][/CHECK \({2}(.+)\){2}/, 1]
+
+            CheckConstraintDefinition.new(table_name, expression, options)
+          end
+        end
+
         # Maps logical Rails types to PostgreSQL-specific data types.
         def type_to_sql(type, limit: nil, precision: nil, scale: nil, array: nil, **) # :nodoc:
           sql = \
@@ -552,13 +577,13 @@ module ActiveRecord
         # PostgreSQL requires the ORDER BY columns in the select list for distinct queries, and
         # requires that the ORDER BY include the distinct column.
         def columns_for_distinct(columns, orders) #:nodoc:
-          order_columns = orders.reject(&:blank?).map { |s|
+          order_columns = orders.compact_blank.map { |s|
             # Convert Arel node to string
             s = visitor.compile(s) unless s.is_a?(String)
             # Remove any ASC/DESC modifiers
             s.gsub(/\s+(?:ASC|DESC)\b/i, "")
              .gsub(/\s+NULLS\s+(?:FIRST|LAST)\b/i, "")
-          }.reject(&:blank?).map.with_index { |column, i| "#{column} AS alias_#{i}" }
+          }.compact_blank.map.with_index { |column, i| "#{column} AS alias_#{i}" }
 
           (order_columns << super).join(", ")
         end
@@ -577,8 +602,6 @@ module ActiveRecord
         #
         #   validate_constraint :accounts, :constraint_name
         def validate_constraint(table_name, constraint_name)
-          return unless supports_validate_constraints?
-
           at = create_alter_table table_name
           at.validate_constraint constraint_name
 
@@ -601,20 +624,29 @@ module ActiveRecord
         #
         # The +options+ hash accepts the same keys as SchemaStatements#add_foreign_key.
         def validate_foreign_key(from_table, to_table = nil, **options)
-          return unless supports_validate_constraints?
-
           fk_name_to_validate = foreign_key_for!(from_table, to_table: to_table, **options).name
 
           validate_constraint from_table, fk_name_to_validate
         end
 
+        # Validates the given check constraint.
+        #
+        #   validate_check_constraint :products, name: "price_check"
+        #
+        # The +options+ hash accepts the same keys as add_check_constraint[rdoc-ref:ConnectionAdapters::SchemaStatements#add_check_constraint].
+        def validate_check_constraint(table_name, **options)
+          chk_name_to_validate = check_constraint_for!(table_name, **options).name
+
+          validate_constraint table_name, chk_name_to_validate
+        end
+
         private
           def schema_creation
             PostgreSQL::SchemaCreation.new(self)
           end
 
-          def create_table_definition(*args, **options)
-            PostgreSQL::TableDefinition.new(self, *args, **options)
+          def create_table_definition(name, **options)
+            PostgreSQL::TableDefinition.new(self, name, **options)
           end
 
           def create_alter_table(name)
@@ -684,7 +716,7 @@ module ActiveRecord
             [super, Proc.new { change_column_comment(table_name, column_name, options[:comment]) }]
           end
 
-          def change_column_for_alter(table_name, column_name, type, options = {})
+          def change_column_for_alter(table_name, column_name, type, **options)
             td = create_table_definition(table_name)
             cd = td.new_column_definition(column_name, type, **options)
             sqls = [schema_creation.accept(ChangeColumnDefinition.new(cd, column_name))]

data/lib/active_record/connection_adapters/postgresql/type_metadata.rb

@@ -7,6 +7,8 @@ module ActiveRecord
       class TypeMetadata < DelegateClass(SqlTypeMetadata)
         undef to_yaml if method_defined?(:to_yaml)
 
+        include Deduplicable
+
         attr_reader :oid, :fmod
 
         def initialize(type_metadata, oid: nil, fmod: nil)
@@ -29,6 +31,12 @@ module ActiveRecord
             oid.hash ^
             fmod.hash
         end
+
+        private
+          def deduplicated
+            __setobj__(__getobj__.deduplicate)
+            super
+          end
       end
     end
     PostgreSQLTypeMetadata = PostgreSQL::TypeMetadata

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -1,17 +1,9 @@
 # frozen_string_literal: true
 
-# Make sure we're using pg high enough for type casts and Ruby 2.2+ compatibility
-gem "pg", ">= 0.18", "< 2.0"
+gem "pg", "~> 1.1"
 require "pg"
 
-# Use async_exec instead of exec_params on pg versions before 1.1
-class ::PG::Connection # :nodoc:
-  unless self.public_method_defined?(:async_exec_params)
-    remove_method :exec_params
-    alias exec_params async_exec
-  end
-end
-
+require "active_support/core_ext/object/try"
 require "active_record/connection_adapters/abstract_adapter"
 require "active_record/connection_adapters/statement_pool"
 require "active_record/connection_adapters/postgresql/column"
@@ -31,9 +23,7 @@ module ActiveRecord
   module ConnectionHandling # :nodoc:
     # Establishes a connection to the database that's used by all Active Record objects
     def postgresql_connection(config)
-      conn_params = config.symbolize_keys
-
-      conn_params.delete_if { |_, v| v.nil? }
+      conn_params = config.symbolize_keys.compact
 
       # Map ActiveRecords param names to PGs.
       conn_params[:user] = conn_params.delete(:username) if conn_params[:username]
@@ -43,19 +33,17 @@ module ActiveRecord
       valid_conn_param_keys = PG::Connection.conndefaults_hash.keys + [:requiressl]
       conn_params.slice!(*valid_conn_param_keys)
 
-      conn = PG.connect(conn_params)
-      ConnectionAdapters::PostgreSQLAdapter.new(conn, logger, conn_params, config)
-    rescue ::PG::Error => error
-      if error.message.include?(conn_params[:dbname])
-        raise ActiveRecord::NoDatabaseError
-      else
-        raise
-      end
+      ConnectionAdapters::PostgreSQLAdapter.new(
+        ConnectionAdapters::PostgreSQLAdapter.new_client(conn_params),
+        logger,
+        conn_params,
+        config,
+      )
     end
   end
 
   module ConnectionAdapters
-    # The PostgreSQL adapter works with the native C (https://bitbucket.org/ged/ruby-pg) driver.
+    # The PostgreSQL adapter works with the native C (https://github.com/ged/ruby-pg) driver.
     #
     # Options:
     #
@@ -85,6 +73,18 @@ module ActiveRecord
     class PostgreSQLAdapter < AbstractAdapter
       ADAPTER_NAME = "PostgreSQL"
 
+      class << self
+        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
+          else
+            raise ActiveRecord::ConnectionNotEstablished, error.message
+          end
+        end
+      end
+
       ##
       # :singleton-method:
       # PostgreSQL allows the creation of "unlogged" tables, which do not record
@@ -176,6 +176,10 @@ module ActiveRecord
         true
       end
 
+      def supports_check_constraints?
+        true
+      end
+
       def supports_validate_constraints?
         true
       end
@@ -341,11 +345,6 @@ module ActiveRecord
         true
       end
 
-      def supports_ranges?
-        true
-      end
-      deprecate :supports_ranges?
-
       def supports_materialized_views?
         true
       end
@@ -426,16 +425,6 @@ module ActiveRecord
         @use_insert_returning
       end
 
-      def column_name_for_operation(operation, node) # :nodoc:
-        OPERATION_ALIASES.fetch(operation) { operation.downcase }
-      end
-
-      OPERATION_ALIASES = { # :nodoc:
-        "maximum" => "max",
-        "minimum" => "min",
-        "average" => "avg",
-      }
-
       # Returns the version of the connected PostgreSQL server.
       def get_database_version # :nodoc:
         @connection.server_version
@@ -453,6 +442,7 @@ module ActiveRecord
           sql << " ON CONFLICT #{insert.conflict_target} DO NOTHING"
         elsif insert.update_duplicates?
           sql << " ON CONFLICT #{insert.conflict_target} DO UPDATE SET "
+          sql << insert.touch_model_timestamps_unless { |column| "#{insert.model.quoted_table_name}.#{column} IS NOT DISTINCT FROM excluded.#{column}" }
           sql << insert.updatable_columns.map { |column| "#{column}=excluded.#{column}" }.join(",")
         end
 
@@ -475,6 +465,7 @@ module ActiveRecord
         UNIQUE_VIOLATION      = "23505"
         SERIALIZATION_FAILURE = "40001"
         DEADLOCK_DETECTED     = "40P01"
+        DUPLICATE_DATABASE    = "42P04"
         LOCK_NOT_AVAILABLE    = "55P03"
         QUERY_CANCELED        = "57014"
 
@@ -482,6 +473,12 @@ module ActiveRecord
           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
@@ -496,6 +493,8 @@ module ActiveRecord
             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
@@ -547,7 +546,7 @@ module ActiveRecord
           m.register_type "uuid", OID::Uuid.new
           m.register_type "xml", OID::Xml.new
           m.register_type "tsvector", OID::SpecializedString.new(:tsvector)
-          m.register_type "macaddr", OID::SpecializedString.new(:macaddr)
+          m.register_type "macaddr", OID::Macaddr.new
           m.register_type "citext", OID::SpecializedString.new(:citext)
           m.register_type "ltree", OID::SpecializedString.new(:ltree)
           m.register_type "line", OID::SpecializedString.new(:line)
@@ -557,11 +556,6 @@ module ActiveRecord
           m.register_type "polygon", OID::SpecializedString.new(:polygon)
           m.register_type "circle", OID::SpecializedString.new(:circle)
 
-          m.register_type "interval" do |_, _, sql_type|
-            precision = extract_precision(sql_type)
-            OID::SpecializedString.new(:interval, precision: precision)
-          end
-
           register_class_with_precision m, "time", Type::Time
           register_class_with_precision m, "timestamp", OID::DateTime
 
@@ -585,6 +579,11 @@ module ActiveRecord
             end
           end
 
+          m.register_type "interval" do |*args, sql_type|
+            precision = extract_precision(sql_type)
+            OID::Interval.new(precision: precision)
+          end
+
           load_additional_types
         end
 
@@ -650,20 +649,22 @@ module ActiveRecord
             raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
           end
 
-          if without_prepared_statement?(binds)
-            result = exec_no_cache(sql, name, [])
-          elsif !prepare
+          if !prepare || without_prepared_statement?(binds)
             result = exec_no_cache(sql, name, binds)
           else
             result = exec_cache(sql, name, binds)
           end
-          ret = yield result
-          result.clear
+          begin
+            ret = yield result
+          ensure
+            result.clear
+          end
           ret
         end
 
         def exec_no_cache(sql, name, binds)
           materialize_transactions
+          mark_transaction_written_if_write(sql)
 
           # make sure we carry over any changes to ActiveRecord::Base.default_timezone that have been
           # made since we established the connection
@@ -679,6 +680,7 @@ module ActiveRecord
 
         def exec_cache(sql, name, binds)
           materialize_transactions
+          mark_transaction_written_if_write(sql)
           update_typemap_for_default_timezone
 
           stmt_key = prepare_statement(sql, binds)
@@ -714,11 +716,10 @@ module ActiveRecord
         #
         # Check here for more details:
         # https://git.postgresql.org/gitweb/?p=postgresql.git;a=blob;f=src/backend/utils/cache/plancache.c#l573
-        CACHED_PLAN_HEURISTIC = "cached plan must not change result type"
         def is_cached_plan_failure?(e)
           pgerror = e.cause
-          code = pgerror.result.result_error_field(PG::PG_DIAG_SQLSTATE)
-          code == FEATURE_NOT_SUPPORTED && pgerror.message.include?(CACHED_PLAN_HEURISTIC)
+          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
@@ -756,7 +757,7 @@ module ActiveRecord
         # Connects to a PostgreSQL server and sets up the adapter depending on the
         # connected server's characteristics.
         def connect
-          @connection = PG.connect(@connection_parameters)
+          @connection = self.class.new_client(@connection_parameters)
           configure_connection
           add_pg_encoders
           add_pg_decoders
@@ -786,6 +787,9 @@ module ActiveRecord
             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|
@@ -897,15 +901,12 @@ module ActiveRecord
             "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,
           }
 
-          if defined?(PG::TextDecoder::TimestampUtc)
-            # Use native PG encoders available since pg-1.1
-            coders_by_name["timestamp"] = PG::TextDecoder::TimestampUtc
-            coders_by_name["timestamptz"] = PG::TextDecoder::TimestampWithTimeZone
-          end
-
           known_coder_types = coders_by_name.keys.map { |n| quote(n) }
           query = <<~SQL % known_coder_types.join(", ")
             SELECT t.oid, t.typname
@@ -922,6 +923,11 @@ module ActiveRecord
           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
@@ -932,6 +938,14 @@ module ActiveRecord
           coder_class.new(oid: row["oid"].to_i, name: row["typname"])
         end
 
+        class MoneyDecoder < PG::SimpleDecoder # :nodoc:
+          TYPE = OID::Money.new
+
+          def decode(value, tuple = nil, field = nil)
+            TYPE.deserialize(value)
+          end
+        end
+
         ActiveRecord::Type.add_modifier({ array: true }, OID::Array, adapter: :postgresql)
         ActiveRecord::Type.add_modifier({ range: true }, OID::Range, adapter: :postgresql)
         ActiveRecord::Type.register(:bit, OID::Bit, adapter: :postgresql)
@@ -944,6 +958,7 @@ module ActiveRecord
         ActiveRecord::Type.register(:enum, OID::Enum, adapter: :postgresql)
         ActiveRecord::Type.register(:hstore, OID::Hstore, adapter: :postgresql)
         ActiveRecord::Type.register(:inet, OID::Inet, adapter: :postgresql)
+        ActiveRecord::Type.register(:interval, OID::Interval, adapter: :postgresql)
         ActiveRecord::Type.register(:jsonb, OID::Jsonb, adapter: :postgresql)
         ActiveRecord::Type.register(:money, OID::Money, adapter: :postgresql)
         ActiveRecord::Type.register(:point, OID::Point, adapter: :postgresql)