activerecord-cockroachdb-adapter 7.0.3 → 7.1.1

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

@@ -4,6 +4,13 @@ module ActiveRecord
       module SchemaStatements
         include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
 
+        # OVERRIDE: We do not want to see the crdb_internal schema in the names.
+        #
+        # Returns an array of schema names.
+        def schema_names
+          super - ["crdb_internal"]
+        end
+
         def add_index(table_name, column_name, **options)
           super
         rescue ActiveRecord::StatementInvalid => error
@@ -36,16 +43,25 @@ module ActiveRecord
         # Modified version of the postgresql foreign_keys method.
         # Replaces t2.oid::regclass::text with t2.relname since this is
         # more efficient in CockroachDB.
+        # Also, CockroachDB does not append the schema name in relname,
+        # so we append it manually.
         def foreign_keys(table_name)
           scope = quoted_scope(table_name)
-          fk_info = exec_query(<<~SQL, "SCHEMA")
-            SELECT t2.relname AS to_table, a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid
+          fk_info = internal_exec_query(<<~SQL, "SCHEMA")
+            SELECT CASE
+              WHEN n2.nspname = current_schema()
+              THEN ''
+              ELSE n2.nspname || '.'
+            END || t2.relname AS to_table,
+            a1.attname AS column, a2.attname AS primary_key, c.conname AS name, c.confupdtype AS on_update, c.confdeltype AS on_delete, c.convalidated AS valid, c.condeferrable AS deferrable, c.condeferred AS deferred,
+            c.conkey, c.confkey, c.conrelid, c.confrelid
             FROM pg_constraint c
             JOIN pg_class t1 ON c.conrelid = t1.oid
             JOIN pg_class t2 ON c.confrelid = t2.oid
             JOIN pg_attribute a1 ON a1.attnum = c.conkey[1] AND a1.attrelid = t1.oid
             JOIN pg_attribute a2 ON a2.attnum = c.confkey[1] AND a2.attrelid = t2.oid
             JOIN pg_namespace t3 ON c.connamespace = t3.oid
+            JOIN pg_namespace n2 ON t2.relnamespace = n2.oid
             WHERE c.contype = 'f'
               AND t1.relname = #{scope[:name]}
               AND t3.nspname = #{scope[:schema]}
@@ -53,17 +69,31 @@ module ActiveRecord
           SQL
 
           fk_info.map do |row|
+            to_table = PostgreSQL::Utils.unquote_identifier(row["to_table"])
+            conkey = row["conkey"].scan(/\d+/).map(&:to_i)
+            confkey = row["confkey"].scan(/\d+/).map(&:to_i)
+
+            if conkey.size > 1
+              column = column_names_from_column_numbers(row["conrelid"], conkey)
+              primary_key = column_names_from_column_numbers(row["confrelid"], confkey)
+            else
+              column = PostgreSQL::Utils.unquote_identifier(row["column"])
+              primary_key = row["primary_key"]
+            end
+
             options = {
-              column: row["column"],
+              column: column,
               name: row["name"],
-              primary_key: row["primary_key"]
+              primary_key: primary_key
             }
-
             options[:on_delete] = extract_foreign_key_action(row["on_delete"])
             options[:on_update] = extract_foreign_key_action(row["on_update"])
+            options[:deferrable] = extract_constraint_deferrable(row["deferrable"], row["deferred"])
+
             options[:validate] = row["valid"]
+            to_table = PostgreSQL::Utils.unquote_identifier(row["to_table"])
 
-            ForeignKeyDefinition.new(table_name, row["to_table"], options)
+            ForeignKeyDefinition.new(table_name, to_table, options)
           end
         end
 
@@ -76,16 +106,20 @@ module ActiveRecord
 
         # override
         # https://github.com/rails/rails/blob/6-0-stable/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L624
-        def new_column_from_field(table_name, field)
-          column_name, type, default, notnull, oid, fmod, collation, comment, generated, hidden = field
+        def new_column_from_field(table_name, field, _definition)
+          column_name, type, default, notnull, oid, fmod, collation, comment, identity, attgenerated, hidden = field
           type_metadata = fetch_type_metadata(column_name, type, oid.to_i, fmod.to_i)
           default_value = extract_value_from_default(default)
-          default_function = extract_default_function(default_value, default)
 
-          serial =
-            if (match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/))
-              sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
-            end
+          if attgenerated.present?
+            default_function = default
+          else
+            default_function = extract_default_function(default_value, default)
+          end
+
+          if match = default_function&.match(/\Anextval\('"?(?<sequence_name>.+_(?<suffix>seq\d*))"?'::regclass\)\z/)
+            serial = sequence_name_from_parts(table_name, column_name, match[:suffix]) == match[:sequence_name]
+          end
 
           # {:dimension=>2, :has_m=>false, :has_z=>false, :name=>"latlon", :srid=>0, :type=>"GEOMETRY"}
           spatial = spatial_column_info(table_name).get(column_name, type_metadata.sql_type)
@@ -99,8 +133,9 @@ module ActiveRecord
             collation: collation,
             comment: comment.presence,
             serial: serial,
+            identity: identity.presence,
             spatial: spatial,
-            generated: generated,
+            generated: attgenerated,
             hidden: hidden
           )
         end

data/lib/active_record/connection_adapters/cockroachdb/type.rb

@@ -1,15 +1,16 @@
 module ActiveRecord
   module Type
-    class << self
+    module CRDBExt
       # Return :postgresql instead of :cockroachdb for current_adapter_name so
       # we can continue using the ActiveRecord::Types defined in
       # PostgreSQLAdapter.
       def adapter_name_from(model)
-        name = model.connection_db_config.adapter.to_sym
+        name = super
         return :postgresql if name == :cockroachdb
 
         name
       end
     end
+    singleton_class.prepend CRDBExt
   end
 end

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -1,5 +1,8 @@
+# frozen_string_literal: true
+
 require "rgeo/active_record"
 
+require_relative "../../arel/nodes/join_source_ext"
 require "active_record/connection_adapters/postgresql_adapter"
 require "active_record/connection_adapters/cockroachdb/attribute_methods"
 require "active_record/connection_adapters/cockroachdb/column_methods"
@@ -15,7 +18,6 @@ require "active_record/connection_adapters/cockroachdb/type"
 require "active_record/connection_adapters/cockroachdb/column"
 require "active_record/connection_adapters/cockroachdb/spatial_column_info"
 require "active_record/connection_adapters/cockroachdb/setup"
-require "active_record/connection_adapters/cockroachdb/oid/type_map_initializer"
 require "active_record/connection_adapters/cockroachdb/oid/spatial"
 require "active_record/connection_adapters/cockroachdb/oid/interval"
 require "active_record/connection_adapters/cockroachdb/oid/date_time"
@@ -30,35 +32,15 @@ require_relative "../relation/query_methods_ext"
 ActiveRecord::ConnectionAdapters::CockroachDB.initial_setup
 
 module ActiveRecord
+  # TODO: once in rails 7.2, remove this and replace with a `#register` call.
+  # See: https://github.com/rails/rails/commit/22a26d7f74ea8f0d5f7c4169531ae38441cfd5e5#diff-2468c670eb10c24bd2823e42708489a336d6f21c6efc7e3c4a574166fa77bb22
   module ConnectionHandling
+    def cockroachdb_adapter_class
+      ConnectionAdapters::CockroachDBAdapter
+    end
+
     def cockroachdb_connection(config)
-      # This is copied from the PostgreSQL adapter.
-      conn_params = config.symbolize_keys.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)
-
-      ConnectionAdapters::CockroachDBAdapter.new(
-        ConnectionAdapters::CockroachDBAdapter.new_client(conn_params),
-        logger,
-        conn_params,
-        config
-      )
-    # This rescue flow appears in new_client, but it is needed here as well
-    # since Cockroach will sometimes not raise until a query is made.
-    rescue ActiveRecord::StatementInvalid => error
-      no_db_err_check1 = conn_params && conn_params[:dbname] && error.cause.message.include?(conn_params[:dbname])
-      no_db_err_check2 = conn_params && conn_params[:dbname] && error.cause.message.include?("pg_type")
-      if no_db_err_check1 || no_db_err_check2
-        raise ActiveRecord::NoDatabaseError
-      else
-        raise ActiveRecord::ConnectionNotEstablished, error.message
-      end
+      cockroachdb_adapter_class.new(config)
     end
   end
 end
@@ -100,7 +82,7 @@ module ActiveRecord
     ConnectionPool.prepend(CockroachDBConnectionPool)
 
     class CockroachDBAdapter < PostgreSQLAdapter
-      ADAPTER_NAME = "CockroachDB".freeze
+      ADAPTER_NAME = "CockroachDB"
       DEFAULT_PRIMARY_KEY = "rowid"
 
       SPATIAL_COLUMN_OPTIONS =
@@ -154,18 +136,21 @@ module ActiveRecord
         @max_transaction_retries ||= @config.fetch(:max_transaction_retries, 3)
       end
 
-      # CockroachDB 20.1 can run queries that work against PostgreSQL 10+.
-      def postgresql_version
-        100000
+      def get_database_version
+        major, minor, patch = query_value("SHOW crdb_version").match(/v(\d+).(\d+).(\d+)/)[1..].map(&:to_i)
+        major * 100 * 100 + minor * 100 + patch
       end
+      undef :postgresql_version
+      alias :cockroachdb_version :database_version
 
-      def supports_bulk_alter?
-        false
+      def supports_datetime_with_precision?
+        # https://github.com/cockroachdb/cockroach/pull/111400
+        database_version >= 23_01_13
       end
 
-      def supports_json?
-        # FIXME(joey): Add a version check.
-        true
+      def supports_nulls_not_distinct?
+        # https://github.com/cockroachdb/cockroach/issues/115836
+        false
       end
 
       def supports_ddl_transactions?
@@ -180,8 +165,12 @@ module ActiveRecord
         false
       end
 
-      def supports_partial_index?
-        @crdb_version >= 2020
+      def supports_index_include?
+        false
+      end
+
+      def supports_exclusion_constraints?
+        false
       end
 
       def supports_expression_index?
@@ -191,14 +180,6 @@ module ActiveRecord
         false
       end
 
-      def supports_datetime_with_precision?
-        false
-      end
-
-      def supports_comments?
-        @crdb_version >= 2010
-      end
-
       def supports_comments_in_create?
         false
       end
@@ -208,11 +189,11 @@ module ActiveRecord
       end
 
       def supports_virtual_columns?
-        @crdb_version >= 2110
+        true
       end
 
       def supports_string_to_array_coercion?
-        @crdb_version >= 2020
+        true
       end
 
       def supports_partitioned_indexes?
@@ -223,77 +204,30 @@ module ActiveRecord
         false
       end
 
-      # This is hardcoded to 63 (as previously was in ActiveRecord 5.0) to aid in
-      # migration from PostgreSQL to CockroachDB. In practice, this limitation
-      # is arbitrary since CockroachDB supports index name lengths and table alias
-      # lengths far greater than this value. For the time being though, we match
-      # the original behavior for PostgreSQL to simplify migrations.
+      # NOTE: This commented bit of code allows to have access to crdb version,
+      # which can be useful for feature detection. However, we currently don't
+      # need, hence we avoid the extra queries.
       #
-      # Note that in the migration to ActiveRecord 5.1, this was changed in
-      # PostgreSQLAdapter to use `SHOW max_identifier_length` (which does not
-      # exist in CockroachDB). Therefore, we have to redefine this here.
-      def max_identifier_length
-        63
-      end
-      alias index_name_length max_identifier_length
-      alias table_alias_length max_identifier_length
-
-      def initialize(connection, logger, conn_params, config)
-        super(connection, logger, conn_params, config)
-
-        # crdb_version is the version of the binary running on the node. We
-        # really want to use `SHOW CLUSTER SETTING version` to get the cluster
-        # version, but that is only available to admins. Instead, we can use
-        # crdb_internal.is_at_least_version, but that's only available in 22.1.
-        crdb_version_string = query_value("SHOW crdb_version")
-        if crdb_version_string.include? "v22.1"
-          version_num = query_value(<<~SQL, "VERSION")
-            SELECT
-              CASE
-              WHEN crdb_internal.is_at_least_version('22.2') THEN 2220
-              WHEN crdb_internal.is_at_least_version('22.1') THEN 2210
-              ELSE 2120
-              END;
-          SQL
-        else
-          # This branch can be removed once the dialect stops supporting v21.2
-          # and earlier.
-          if crdb_version_string.include? "v1."
-            version_num = 1
-          elsif crdb_version_string.include? "v2."
-            version_num 2
-          elsif crdb_version_string.include? "v19.1."
-            version_num = 1910
-          elsif crdb_version_string.include? "v19.2."
-            version_num = 1920
-          elsif crdb_version_string.include? "v20.1."
-            version_num = 2010
-          elsif crdb_version_string.include? "v20.2."
-            version_num = 2020
-          elsif crdb_version_string.include? "v21.1."
-            version_num = 2110
-          else
-            version_num = 2120
-          end
-        end
-        @crdb_version = version_num.to_i
-
-        # NOTE: this is normally in configure_connection, but that is run
-        # before crdb_version is determined. Once all supported versions
-        # of CockroachDB support SET intervalstyle it can safely be moved
-        # back.
-        # Set interval output format to ISO 8601 for ease of parsing by ActiveSupport::Duration.parse
-        if @crdb_version >= 2120
-          begin
-            execute("SET intervalstyle_enabled = true", "SCHEMA")
-            execute("SET intervalstyle = iso_8601", "SCHEMA")
-          rescue
-            # Ignore any error. This can happen with a cluster that has
-            # not yet finalized the v21.2 upgrade. v21.2 does not have
-            # a way to tell if the upgrade was finalized (see comment above).
-          end
-        end
-      end
+      #   def initialize(connection, logger, conn_params, config)
+      #     super(connection, logger, conn_params, config)
+
+      #     # crdb_version is the version of the binary running on the node. We
+      #     # really want to use `SHOW CLUSTER SETTING version` to get the cluster
+      #     # version, but that is only available to admins. Instead, we can use
+      #     # crdb_internal.is_at_least_version, but that's only available in 22.1.
+      #     crdb_version_string = query_value("SHOW crdb_version")
+      #     if crdb_version_string.include? "v22.1"
+      #       version_num = query_value(<<~SQL, "VERSION")
+      #         SELECT
+      #           CASE
+      #           WHEN crdb_internal.is_at_least_version('22.2') THEN 2220
+      #           WHEN crdb_internal.is_at_least_version('22.1') THEN 2210
+      #           ELSE 2120
+      #           END;
+      #       SQL
+      #     end
+      #     @crdb_version = version_num.to_i
+      #   end
 
       def self.database_exists?(config)
         !!ActiveRecord::Base.cockroachdb_connection(config)
@@ -301,17 +235,32 @@ module ActiveRecord
         false
       end
 
+      def initialize(...)
+        super
+
+      # This rescue flow appears in new_client, but it is needed here as well
+      # since Cockroach will sometimes not raise until a query is made.
+      rescue ActiveRecord::StatementInvalid => error
+        no_db_err_check1 = @connection_parameters && @connection_parameters[:dbname] && error.cause.message.include?(@connection_parameters[:dbname])
+        no_db_err_check2 = @connection_parameters && @connection_parameters[:dbname] && error.cause.message.include?("pg_type")
+        if no_db_err_check1 || no_db_err_check2
+          raise ActiveRecord::NoDatabaseError
+        else
+          raise ActiveRecord::ConnectionNotEstablished, error.message
+        end
+      end
+
       # override
       # The PostgreSQLAdapter uses syntax for an anonymous function
       # (DO $$) that CockroachDB does not support.
       #
       # Given a name and an array of values, creates an enum type.
-      def create_enum(name, values)
-        sql_values = values.map { |s| "'#{s}'" }.join(", ")
+      def create_enum(name, values, **options)
+        sql_values = values.map { |s| quote(s) }.join(", ")
         query = <<~SQL
-          CREATE TYPE IF NOT EXISTS \"#{name}\" AS ENUM (#{sql_values});
+          CREATE TYPE IF NOT EXISTS #{quote_table_name(name)} AS ENUM (#{sql_values});
         SQL
-        exec_query(query)
+        internal_exec_query(query).tap { reload_type_map }
       end
 
       class << self
@@ -369,62 +318,11 @@ module ActiveRecord
 
       private
 
-        # Configures the encoding, verbosity, schema search path, and time zone of the connection.
-        # This is called by #connect and should not be called manually.
-        #
-        # NOTE(joey): This was cradled from postgresql_adapter.rb. This
-        # was due to needing to override configuration statements.
-        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
-
-          # NOTE(joey): This is a workaround as CockroachDB 1.1.x
-          # supports SET TIME ZONE <...> and SET "time zone" = <...> but
-          # not SET timezone = <...>.
-          if variables.key?("timezone")
-            tz = variables.delete("timezone")
-            execute("SET TIME ZONE #{quote(tz)}", "SCHEMA")
-          end
-
-          # 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
-
-              # NOTE(joey): I am not sure if simply commenting this out
-              # is technically correct.
-              # execute("SET #{k} = DEFAULT", "SCHEMA")
-            elsif !v.nil?
-              execute("SET SESSION #{k} = #{quote(v)}", "SCHEMA")
-            end
-          end
-        end
-
         # Override extract_value_from_default because the upstream definition
         # doesn't handle the variations in CockroachDB's behavior.
         def extract_value_from_default(default)
           super ||
             extract_escaped_string_from_default(default) ||
-            extract_time_from_default(default) ||
             extract_empty_array_from_default(default) ||
             extract_decimal_from_default(default)
         end
@@ -442,32 +340,6 @@ module ActiveRecord
           "\"#{$1}\"".undump.gsub("\\'".freeze, "'".freeze)
         end
 
-        # This method exists to extract the correct time and date defaults for a
-        # couple of reasons.
-        # 1) There's a bug in CockroachDB where the date type is missing from
-        # the column info query.
-        # https://github.com/cockroachdb/cockroach/issues/47285
-        # 2) PostgreSQL's timestamp without time zone type maps to CockroachDB's
-        # TIMESTAMP type. TIMESTAMP includes a UTC time zone while timestamp
-        # without time zone doesn't.
-        # https://www.cockroachlabs.com/docs/v19.2/timestamp.html#variants
-        def extract_time_from_default(default)
-          return unless default =~ /\A'(.*)'\z/
-
-          # If default has a UTC time zone, we'll drop the time zone information
-          # so it acts like PostgreSQL's timestamp without time zone. Then, try
-          # to parse the resulting string to verify if it's a time.
-          time = if default =~ /\A'(.*)(\+00:00)'\z/
-            $1
-          else
-            default
-          end
-
-          Time.parse(time).to_s
-        rescue
-          nil
-        end
-
         # CockroachDB stores default values for arrays in the `ARRAY[...]` format.
         # In general, it is hard to parse that, but it is easy to handle the common
         # case of an empty array.
@@ -502,7 +374,8 @@ module ActiveRecord
               SELECT a.attname, format_type(a.atttypid, a.atttypmod),
                      pg_get_expr(d.adbin, d.adrelid), a.attnotnull, a.atttypid, a.atttypmod,
                      c.collname, NULL AS comment,
-                     #{supports_virtual_columns? ? 'attgenerated' : quote('')} as attgenerated,
+                     attidentity,
+                     attgenerated,
                      NULL as is_hidden
                 FROM pg_attribute a
                 LEFT JOIN pg_attrdef d ON a.attrelid = d.adrelid AND a.attnum = d.adnum
@@ -517,26 +390,31 @@ module ActiveRecord
 
           # Use regex comparison because if a type is an array it will
           # have [] appended to the end of it.
-          target_types = [
-            /geometry/,
-            /geography/,
-            /interval/,
-            /numeric/
-          ]
-
-          re = Regexp.union(target_types)
+          re = /\A(?:geometry|geography|interval|numeric)/
+
+          # 0: attname
+          # 1: type
+          # 2: default
+          # 3: attnotnull
+          # 4: atttypid
+          # 5: atttypmod
+          # 6: collname
+          # 7: comment
+          # 8: attidentity
+          # 9: attgenerated
+          # 10: is_hidden
           fields.map do |field|
             dtype = field[1]
             field[1] = crdb_fields[field[0]][2].downcase if re.match(dtype)
             field[7] = crdb_fields[field[0]][1]&.gsub!(/^\'|\'?$/, '')
-            field[9] = true if crdb_fields[field[0]][3]
+            field[10] = true if crdb_fields[field[0]][3]
             field
           end
           fields.delete_if do |field|
             # Don't include rowid column if it is hidden and the primary key
             # is not defined (meaning CRDB implicitly created it).
             if field[0] == CockroachDBAdapter::DEFAULT_PRIMARY_KEY
-              field[9] && !primary_key(table_name)
+              field[10] && !primary_key(table_name)
             else
               false # Keep this entry.
             end
@@ -549,11 +427,14 @@ module ActiveRecord
         # precision, and scale information in the type.
         # Ex. geometry -> geometry(point, 4326)
         def crdb_column_definitions(table_name)
+          table_name = PostgreSQL::Utils.extract_schema_qualified_name(table_name)
+          table = table_name.identifier
+          with_schema = " AND c.table_schema = #{quote(table_name.schema)}" if table_name.schema
           fields = \
           query(<<~SQL, "SCHEMA")
             SELECT c.column_name, c.column_comment, c.crdb_sql_type, c.is_hidden::BOOLEAN
-              FROM information_schema.columns c
-            WHERE c.table_name = #{quote(table_name)}
+            FROM information_schema.columns c
+            WHERE c.table_name = #{quote(table)}#{with_schema}
           SQL
 
           fields.reduce({}) do |a, e|
@@ -594,21 +475,10 @@ module ActiveRecord
         def load_additional_types(oids = nil)
           if @config[:use_follower_reads_for_type_introspection]
             initializer = OID::TypeMapInitializer.new(type_map)
-
-            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 AS OF SYSTEM TIME '-10s'
-            SQL
-
-            if oids
-              query += "WHERE t.oid IN (%s)" % oids.join(", ")
-            else
-              query += initializer.query_conditions_for_initial_load
-            end
-
-            execute_and_clear(query, "SCHEMA", []) do |records|
-              initializer.run(records)
+            load_types_queries_with_aost(initializer, oids) do |query|
+              execute_and_clear(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false) do |records|
+                initializer.run(records)
+              end
             end
           else
             super
@@ -619,6 +489,21 @@ module ActiveRecord
           super
         end
 
+        def load_types_queries_with_aost(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 AS OF SYSTEM TIME '-10s'
+          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
+
         # override
         # This method maps data types to their proper decoder.
         #
@@ -649,15 +534,13 @@ module ActiveRecord
               WHERE t.typname IN (%s)
             SQL
 
-            coders = execute_and_clear(query, "SCHEMA", []) do |result|
-              result
-                .map { |row| construct_coder(row, coders_by_name[row["typname"]]) }
-                .compact
+            coders = execute_and_clear(query, "SCHEMA", [], allow_retry: true, materialize_transactions: false) 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
+            @raw_connection.type_map_for_results = map
 
             @type_map_for_results = PG::TypeMapByOid.new
             @type_map_for_results.default_type_map = map