activerecord-cockroachdb-adapter 8.0.3 → 8.1.1

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

@@ -20,6 +20,91 @@ module ActiveRecord
       module SchemaStatements
         include ActiveRecord::ConnectionAdapters::PostgreSQL::SchemaStatements
 
+        # OVERRIDE(v8.1.1):
+        #   - prepend Utils with PostgreSQL::
+        #   - handle hidden attributes
+        # Returns an array of indexes for the given table.
+        def indexes(table_name) # :nodoc:
+          scope = quoted_scope(table_name)
+
+          result = query(<<~SQL, "SCHEMA")
+            SELECT distinct i.relname, d.indisunique, d.indkey, pg_get_indexdef(d.indexrelid),
+                            pg_catalog.obj_description(i.oid, 'pg_class') AS comment, d.indisvalid,
+                            ARRAY(
+                              SELECT pg_get_indexdef(d.indexrelid, k + 1, true)
+                              FROM generate_subscripts(d.indkey, 1) AS k
+                              ORDER BY k
+                            ) AS columns,
+                            ARRAY(
+                              SELECT a.attname
+                              FROM pg_attribute a
+                              WHERE a.attrelid = d.indexrelid AND a.attishidden
+                            ) AS hidden_columns
+            FROM pg_class t
+            INNER JOIN pg_index d ON t.oid = d.indrelid
+            INNER JOIN pg_class i ON d.indexrelid = i.oid
+            LEFT JOIN pg_namespace n ON n.oid = t.relnamespace
+            WHERE i.relkind IN ('i', 'I')
+              AND d.indisprimary = 'f'
+              AND t.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
+            ORDER BY i.relname
+          SQL
+
+          unquote = -> (column) {
+            PostgreSQL::Utils.unquote_identifier(column.strip.gsub('""', '"'))
+          }
+          result.map do |row|
+            index_name = row[0]
+            unique = row[1]
+            indkey = row[2].split(" ").map(&:to_i)
+            inddef = row[3]
+            comment = row[4]
+            valid = row[5]
+            columns = decode_string_array(row[6]).map(&unquote)
+            hidden_columns = decode_string_array(row[7]).map(&unquote)
+
+            using, expressions, include, nulls_not_distinct, where = inddef.scan(/ USING (\w+?) \((.+?)\)(?: INCLUDE \((.+?)\))?( NULLS NOT DISTINCT)?(?: WHERE (.+))?\z/m).flatten
+
+            orders = {}
+            opclasses = {}
+            include_columns = include ? include.split(",").map(&unquote) : []
+
+            if indkey.include?(0)
+              columns = expressions
+            else
+              # prevent INCLUDE and hidden columns from being matched
+              columns.reject! { |c| include_columns.include?(c) || hidden_columns.include?(c) }
+
+              # add info on sort order (only desc order is explicitly specified, asc is the default)
+              # and non-default opclasses
+              expressions.scan(/(?<column>\w+)"?\s?(?<opclass>\w+_ops(_\w+)?)?\s?(?<desc>DESC)?\s?(?<nulls>NULLS (?:FIRST|LAST))?/).each do |column, opclass, desc, nulls|
+                opclasses[column] = opclass.to_sym if opclass
+                if nulls
+                  orders[column] = [desc, nulls].compact.join(" ")
+                else
+                  orders[column] = :desc if desc
+                end
+              end
+            end
+
+            IndexDefinition.new(
+              table_name,
+              index_name,
+              unique,
+              columns,
+              orders: orders,
+              opclasses: opclasses,
+              where: where,
+              using: using.to_sym,
+              include: include_columns.presence,
+              nulls_not_distinct: nulls_not_distinct.present?,
+              comment: comment.presence,
+              valid: valid
+            )
+          end
+        end
+
         # OVERRIDE: We do not want to see the crdb_internal schema in the names.
         #
         # Returns an array of schema names.
@@ -27,16 +112,6 @@ module ActiveRecord
           super - ["crdb_internal"]
         end
 
-        def add_index(table_name, column_name, **options)
-          super
-        rescue ActiveRecord::StatementInvalid => error
-          if debugging? && error.cause.class == PG::FeatureNotSupported
-            warn "#{error}\n\nThis error will be ignored and the index will not be created.\n\n"
-          else
-            raise error
-          end
-        end
-
         # ActiveRecord allows for tables to exist without primary keys.
         # Databases like PostgreSQL support this behavior, but CockroachDB does
         # not. If a table is created without a primary key, CockroachDB will add
@@ -55,34 +130,18 @@ module ActiveRecord
           end
         end
 
+        # OVERRIDE(v8.1.1): handle hidden attributes
         def primary_keys(table_name)
-          return super unless database_version >= 24_02_02
-
           query_values(<<~SQL, "SCHEMA")
             SELECT a.attname
-              FROM (
-                     SELECT indrelid, indkey, generate_subscripts(indkey, 1) idx
-                       FROM pg_index
-                      WHERE indrelid = #{quote(quote_table_name(table_name))}::regclass
-                        AND indisprimary
-                   ) i
-              JOIN pg_attribute a
-                ON a.attrelid = i.indrelid
-               AND a.attnum = i.indkey[i.idx]
-               AND NOT a.attishidden
-             ORDER BY i.idx
-          SQL
-        end
-
-        def column_names_from_column_numbers(table_oid, column_numbers)
-          return super unless database_version >= 24_02_02
-
-          Hash[query(<<~SQL, "SCHEMA")].values_at(*column_numbers).compact
-            SELECT a.attnum, a.attname
-            FROM pg_attribute a
-            WHERE a.attrelid = #{table_oid}
-            AND a.attnum IN (#{column_numbers.join(", ")})
-            AND NOT a.attishidden
+            FROM pg_index i
+            JOIN pg_attribute a
+              ON a.attrelid = i.indrelid
+              AND a.attnum = ANY(i.indkey)
+              AND NOT a.attishidden
+            WHERE i.indrelid = #{quote(quote_table_name(table_name))}::regclass
+              AND i.indisprimary
+            ORDER BY array_position(i.indkey, a.attnum)
           SQL
         end
 
@@ -94,7 +153,7 @@ module ActiveRecord
           options
         end
 
-        # OVERRIDE: Added `unique_rowid` to the last line of the second query.
+        # OVERRIDE(v8.1.1): Added `unique_rowid` to the last line of the second query.
         #   This is a CockroachDB-specific function used for primary keys.
         #   Also make sure we don't consider `NOT VISIBLE` columns.
         #
@@ -108,11 +167,7 @@ module ActiveRecord
                  pg_attribute  attr,
                  pg_depend     dep,
                  pg_constraint cons,
-                 pg_namespace  nsp,
-                 -- TODO: use the pg_catalog.pg_attribute(attishidden) column when
-                 --   it is added instead of joining on crdb_internal.
-                 --   See https://github.com/cockroachdb/cockroach/pull/126397
-                 crdb_internal.table_columns tc
+                 pg_namespace  nsp
             WHERE seq.oid           = dep.objid
               AND seq.relkind       = 'S'
               AND attr.attrelid     = dep.refobjid
@@ -120,12 +175,10 @@ module ActiveRecord
               AND attr.attrelid     = cons.conrelid
               AND attr.attnum       = cons.conkey[1]
               AND seq.relnamespace  = nsp.oid
-              AND attr.attrelid     = tc.descriptor_id
-              AND attr.attname      = tc.column_name
-              AND tc.hidden         = false
               AND cons.contype      = 'p'
               AND dep.classid       = 'pg_class'::regclass
               AND dep.refobjid      = #{quote(quote_table_name(table))}::regclass
+              AND not attr.attishidden
           SQL
 
           if result.nil? || result.empty?
@@ -143,12 +196,8 @@ module ActiveRecord
               JOIN pg_attrdef     def  ON (adrelid = attrelid AND adnum = attnum)
               JOIN pg_constraint  cons ON (conrelid = adrelid AND adnum = conkey[1])
               JOIN pg_namespace   nsp  ON (t.relnamespace = nsp.oid)
-              -- TODO: use the pg_catalog.pg_attribute(attishidden) column when
-              --   it is added instead of joining on crdb_internal.
-              --   See https://github.com/cockroachdb/cockroach/pull/126397
-              JOIN crdb_internal.table_columns tc ON (attr.attrelid = tc.descriptor_id AND attr.attname = tc.column_name)
               WHERE t.oid = #{quote(quote_table_name(table))}::regclass
-                AND tc.hidden = false
+                AND NOT attr.attishidden
                 AND cons.contype = 'p'
                 AND pg_get_expr(def.adbin, def.adrelid) ~* 'nextval|uuid_generate|gen_random_uuid|unique_rowid'
             SQL
@@ -164,53 +213,66 @@ module ActiveRecord
           nil
         end
 
-        # override
-        # 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.
+        # OVERRIDE(v8.1.1):
+        #   - Replaces t2.oid::regclass::text with t2.relname
+        #     since this is more efficient in CockroachDB.
+        #   - prepend schema name to relname (see `AS to_table`)
+        #   - handle hidden attributes.
+        #
+        # NOTE: If you edit this method, you'll need to edit
+        #   the `#all_foreign_keys` method as well.
         def foreign_keys(table_name)
           scope = quoted_scope(table_name)
-          fk_info = internal_exec_query(<<~SQL, "SCHEMA")
+          fk_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
             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
+            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.conrelid, c.confrelid,
+              (
+                SELECT array_agg(a.attname ORDER BY idx)
+                FROM (
+                  SELECT idx, c.conkey[idx] AS conkey_elem
+                  FROM generate_subscripts(c.conkey, 1) AS idx
+                ) indexed_conkeys
+                JOIN pg_attribute a ON a.attrelid = t1.oid
+                AND a.attnum = indexed_conkeys.conkey_elem
+                AND NOT a.attishidden
+              ) AS conkey_names,
+              (
+                SELECT array_agg(a.attname ORDER BY idx)
+                FROM (
+                  SELECT idx, c.confkey[idx] AS confkey_elem
+                  FROM generate_subscripts(c.confkey, 1) AS idx
+                ) indexed_confkeys
+                JOIN pg_attribute a ON a.attrelid = t2.oid
+                AND a.attnum = indexed_confkeys.confkey_elem
+                AND NOT a.attishidden
+              ) AS confkey_names
             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 n1 ON t1.relnamespace = n1.oid
             JOIN pg_namespace n2 ON t2.relnamespace = n2.oid
             WHERE c.contype = 'f'
               AND t1.relname = #{scope[:name]}
-              AND t3.nspname = #{scope[:schema]}
+              AND n1.nspname = #{scope[:schema]}
             ORDER BY c.conname
           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
+            column = decode_string_array(row["conkey_names"])
+            primary_key = decode_string_array(row["confkey_names"])
 
             options = {
-              column: column,
+              column: column.size == 1 ? column.first : column,
               name: row["name"],
-              primary_key: primary_key
+              primary_key: primary_key.size == 1 ? primary_key.first : 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"])
@@ -228,8 +290,51 @@ module ActiveRecord
           nil
         end
 
-        # override
-        # https://github.com/rails/rails/blob/6-0-stable/activerecord/lib/active_record/connection_adapters/postgresql/schema_statements.rb#L624
+        # OVERRIDE(v8.1.1): handle hidden attributes
+        #
+        # Returns an array of unique constraints for the given table.
+        # The unique constraints are represented as UniqueConstraintDefinition objects.
+        def unique_constraints(table_name)
+          scope = quoted_scope(table_name)
+
+          unique_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
+            SELECT c.conname, c.conrelid, c.condeferrable, c.condeferred, pg_get_constraintdef(c.oid) AS constraintdef,
+            (
+              SELECT array_agg(a.attname ORDER BY idx)
+              FROM (
+                SELECT idx, c.conkey[idx] AS conkey_elem
+                FROM generate_subscripts(c.conkey, 1) AS idx
+              ) indexed_conkeys
+              JOIN pg_attribute a ON a.attrelid = t.oid
+              AND a.attnum = indexed_conkeys.conkey_elem
+              AND NOT a.attishidden
+            ) AS conkey_names
+            FROM pg_constraint c
+            JOIN pg_class t ON c.conrelid = t.oid
+            JOIN pg_namespace n ON n.oid = c.connamespace
+            WHERE c.contype = 'u'
+              AND t.relname = #{scope[:name]}
+              AND n.nspname = #{scope[:schema]}
+          SQL
+
+          unique_info.map do |row|
+            columns = decode_string_array(row["conkey_names"])
+
+            nulls_not_distinct = row["constraintdef"].start_with?("UNIQUE NULLS NOT DISTINCT")
+            deferrable = extract_constraint_deferrable(row["condeferrable"], row["condeferred"])
+
+            options = {
+              name: row["conname"],
+              nulls_not_distinct: nulls_not_distinct,
+              deferrable: deferrable
+            }
+
+            UniqueConstraintDefinition.new(table_name, columns, options)
+          end
+        end
+
+        # OVERRIDE(v8.1.1):
+        #   - Add hidden information
         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)
@@ -245,11 +350,9 @@ module ActiveRecord
             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)
-
           CockroachDB::Column.new(
             column_name,
+            get_oid_type(oid.to_i, fmod.to_i, column_name, type),
             default_value,
             type_metadata,
             !notnull,
@@ -258,7 +361,6 @@ module ActiveRecord
             comment: comment.presence,
             serial: serial,
             identity: identity.presence,
-            spatial: spatial,
             generated: attgenerated,
             hidden: hidden
           )
@@ -295,34 +397,11 @@ module ActiveRecord
           sql
         end
 
-        # override
-        def native_database_types
-          # Add spatial types
-          super.merge(
-            geography:           { name: "geography" },
-            geometry:            { name: "geometry" },
-            geometry_collection: { name: "geometry_collection" },
-            line_string:         { name: "line_string" },
-            multi_line_string:   { name: "multi_line_string" },
-            multi_point:         { name: "multi_point" },
-            multi_polygon:       { name: "multi_polygon" },
-            spatial:             { name: "geometry" },
-            st_point:            { name: "st_point" },
-            st_polygon:          { name: "st_polygon" }
-          )
-        end
-
         # override
         def create_table_definition(*args, **kwargs)
           CockroachDB::TableDefinition.new(self, *args, **kwargs)
         end
 
-        # memoize hash of column infos for tables
-        def spatial_column_info(table_name)
-          @spatial_column_info ||= {}
-          @spatial_column_info[table_name.to_sym] ||= SpatialColumnInfo.new(self, table_name.to_s)
-        end
-
         def create_schema_dumper(options)
           CockroachDB::SchemaDumper.create(self, options)
         end

data/lib/active_record/connection_adapters/cockroachdb_adapter.rb

@@ -30,7 +30,6 @@ require "active_record/connection_adapters/cockroachdb/table_definition"
 require "active_record/connection_adapters/cockroachdb/quoting"
 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/spatial"
 require "active_record/connection_adapters/cockroachdb/oid/interval"
@@ -111,6 +110,23 @@ module ActiveRecord
         SPATIAL_COLUMN_OPTIONS[key]
       end
 
+      def self.native_database_types
+        return @native_database_types if defined?(@native_database_types)
+        # Add spatial types
+        @native_database_types = super.merge(
+          geography:           { name: "geography" },
+          geometry:            { name: "geometry" },
+          geometry_collection: { name: "geometry_collection" },
+          line_string:         { name: "line_string" },
+          multi_line_string:   { name: "multi_line_string" },
+          multi_point:         { name: "multi_point" },
+          multi_polygon:       { name: "multi_polygon" },
+          spatial:             { name: "geometry" },
+          st_point:            { name: "st_point" },
+          st_polygon:          { name: "st_polygon" }
+        )
+      end
+
       def postgis_lib_version
         @postgis_lib_version ||= select_value("SELECT PostGIS_Lib_Version()")
       end
@@ -128,10 +144,6 @@ module ActiveRecord
         }
       end
 
-      def debugging?
-        !!ENV["DEBUG_COCKROACHDB_ADAPTER"]
-      end
-
       def max_transaction_retries
         @max_transaction_retries ||= @config.fetch(:max_transaction_retries, 3)
       end
@@ -190,6 +202,12 @@ module ActiveRecord
         false
       end
 
+      def supports_restart_db_transaction?
+        # In PostgreSQL, this would call 'ROLLBACK AND CHAIN'
+        # which is not available with CRDB.
+        false
+      end
+
       # OVERRIDE: UNIQUE CONSTRAINTS will create indexes anyway, so we only consider
       #   then as indexes.
       # See https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/347.
@@ -233,6 +251,10 @@ module ActiveRecord
         false
       end
 
+      def supports_close_prepared?
+        true
+      end
+
       def check_version # :nodoc:
         # https://www.cockroachlabs.com/docs/releases/release-support-policy
         if database_version < 23_01_12 # < 23.1.12
@@ -243,6 +265,26 @@ module ActiveRecord
       def configure_connection(...)
         super
 
+        # Starting in CockroachDB v26.x, tables are created with the
+        # `schema_locked` storage parameter enabled by default (controlled by the
+        # `sql.create_table_with_schema_locked.enabled` cluster setting). While it
+        # improves changefeed performance, it blocks the transactional DDL that
+        # Active Record migrations and the test suite rely on: CockroachDB can
+        # only auto-unlock a locked table for single-statement implicit
+        # transactions, not for DDL run inside a transaction. Opt out at the
+        # session level so Active Record keeps working out of the box; users who
+        # want the changefeed benefit can still lock individual tables or set
+        # `create_table_with_schema_locked: true` in their connection variables.
+        #
+        # The session variable was introduced in CockroachDB v25.3, and we let an
+        # explicit `:variables` entry take precedence over this default.
+        #
+        # See https://www.cockroachlabs.com/docs/stable/schema-locked
+        variables = @config.fetch(:variables, {}).stringify_keys
+        if database_version >= 25_03_00 && !variables.key?("create_table_with_schema_locked")
+          internal_execute("SET create_table_with_schema_locked = false", "SCHEMA")
+        end
+
       # 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.
       #
@@ -299,7 +341,7 @@ module ActiveRecord
             st_polygon
           ).each do |geo_type|
             m.register_type(geo_type) do |oid, _, sql_type|
-              CockroachDB::OID::Spatial.new(oid, sql_type)
+              CockroachDB::OID::Spatial.new(oid, sql_type).freeze
             end
           end
 
@@ -378,18 +420,10 @@ module ActiveRecord
           nil
         end
 
-        # override
-        # This method makes a query to gather information about columns
-        # in a table. It returns an array of arrays (one for each col) and
-        # passes each to the SchemaStatements#new_column_from_field method
-        # as the field parameter. This data is then used to format the column
-        # objects for the model and sent to the OID for data casting.
-        #
-        # Sometimes there are differences between how data is formatted
-        # in Postgres and CockroachDB, so additional queries for certain types
-        # may be necessary to properly form the column definition.
-        #
-        # @see: https://github.com/rails/rails/blob/8695b028261bdd244e254993255c6641bdbc17a5/activerecord/lib/active_record/connection_adapters/postgresql_adapter.rb#L829
+        # OVERRIDE(v8.1.1):
+        #   - comment is retrieved differently than PG for performance
+        #   - gather detailed information about spatial columns. See
+        #     `#crdb_column_definitions`
         def column_definitions(table_name)
           fields = query(<<~SQL, "SCHEMA")
               SELECT a.attname, format_type(a.atttypid, a.atttypmod),
@@ -397,7 +431,7 @@ module ActiveRecord
                      c.collname, NULL AS comment,
                      attidentity,
                      attgenerated,
-                     NULL as is_hidden
+                     a.attishidden
                 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
@@ -428,7 +462,6 @@ module ActiveRecord
             dtype = field[f_type]
             field[f_type] = crdb_fields[field[f_attname]][2].downcase if re.match(dtype)
             field[f_comment] = crdb_fields[field[f_attname]][1]
-            field[f_is_hidden] = true if crdb_fields[field[f_attname]][3]
             field
           end
           fields.delete_if do |field|
@@ -444,13 +477,24 @@ module ActiveRecord
         # column_definitions. This will include limit,
         # precision, and scale information in the type.
         # Ex. geometry -> geometry(point, 4326)
+        #
+        # The performance difference to fetch comments is very
+        # significant. On a M1 Mac, CockroachDB v25.2.2 and
+        # data from the test suite, it is 20x times faster.
+        #
+        #     SELECT col_description(a.attrelid, a.attnum)
+        #     FROM pg_attribute a; -- 1.052s
+        #
+        #     SELECT c.column_comment
+        #     FROM information_schema.columns c; -- 50ms
+        #
         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
+            SELECT c.column_name, c.column_comment, c.crdb_sql_type
             FROM information_schema.columns c
             WHERE c.table_name = #{quote(table)}#{with_schema}
           SQL
@@ -461,22 +505,22 @@ module ActiveRecord
         end
 
         # override
-        # This method is used to determine if a
-        # FEATURE_NOT_SUPPORTED error from the PG gem should
-        # be an ActiveRecord::PreparedStatementCacheExpired
-        # error.
-        #
-        # ActiveRecord handles this by checking that the sql state matches the
-        # FEATURE_NOT_SUPPORTED code and that the source function
-        # is "RevalidateCachedQuery" since that is the only function
-        # in postgres that will create this error.
+        # Classifies a FEATURE_NOT_SUPPORTED error from the PG gem as an
+        # ActiveRecord::PreparedStatementCacheExpired.
         #
-        # That method will not work for CockroachDB because the error
-        # originates from the "runExecBuilder" function, so we need
-        # to modify the original to match the CockroachDB behavior.
+        # Upstream matches PG_DIAG_SOURCE_FUNCTION == "RevalidateCachedQuery",
+        # the one PostgreSQL C function that raises this error. CockroachDB's
+        # raising function is an internal detail that has already moved
+        # (runExecBuilder before cockroachdb/cockroach#164406, execBind after),
+        # so match the message instead. The message is not formally guaranteed,
+        # but it has been unchanged in PostgreSQL since 8.3 and drivers such as
+        # pgx assert the exact string. Upstream avoids message matching because
+        # PostgreSQL localizes messages via lc_messages (rails/rails@d507ae2a74);
+        # CockroachDB does not localize, so that concern does not apply.
+        CACHED_PLAN_HEURISTIC = "cached plan must not change result type"
         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) == "runExecBuilder"
+            pgerror.result.result_error_field(PG::PG_DIAG_MESSAGE_PRIMARY).include?(CACHED_PLAN_HEURISTIC)
         rescue
           false
         end

data/lib/version.rb

@@ -15,5 +15,5 @@
 # limitations under the License.
 
 module ActiveRecord
-  COCKROACH_DB_ADAPTER_VERSION = "8.0.3"
+  COCKROACH_DB_ADAPTER_VERSION = "8.1.1"
 end