activerecord-cockroachdb-adapter 8.0.3 → 8.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bb3247022d4dd7a36aaf82f09bfe1502c9106f570b14e6d09c9cd1076c2b8dc6
-  data.tar.gz: 0a8deb6f3b4741296899a08c1fc29df3afd0dcaf946538600e4e39e7f5e98170
+  metadata.gz: 3f8176b5dc25df91e28dc937133083fc0640d7485059e3a098300032e0cf7610
+  data.tar.gz: 10448b0a9437ca1b28a8ef104e5e838e2484d3a085668f3c5ef7630463af0b6b
 SHA512:
-  metadata.gz: 48c6242571df5e27fa2bc30f5a699c64bbe4d3f37c47d3ab3deedbc39050470636a664df51c1c47b74e970b6950b995746ee715e44818c91bcd1d832b400bb8f
-  data.tar.gz: 82169f6e8946a5c6ecbd82001b7fa2e163bc11f739946c184ca4aedbdb95a700e5522fa304ed302050d70e26fb61a65162cfdc8f4be934f96c31c386b8bca5d5
+  metadata.gz: 613aaf5e74fd644104aaf407894ab006ae2f46d0684920407820c83b3a7402879e90c907fd06a8d158204d66d3c7af5100e266cb2ff17979553c5fd94935c5d2
+  data.tar.gz: 96d18f7427ecec5820c579bf579bc8567178bc876c459822d8d68ce9d31dbabfd82a5a5f18b54dab79f2402ff15ea507182706eb62337d82f486c3886f81dc66

data/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 ## Ongoing
 
+## 8.1.1 - 2026-08-18
+
+- Disabled `schema_locked` by default on connect for CockroachDB v25.3+ and unlocked tables around batched foreign key changes ([#404](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/404))
+- Improved error classification by detecting cached plan failures from the error message instead of the source function ([#403](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/403))
+- Stopped advertising support for restarting database transactions ([#398](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/398))
+- Fixed enum columns being misdetected as spatial columns ([#396](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/396))
+
+## 8.1.0 - 2025-11-25
+- Add support for Rails 8.1 ([#386](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/386))
+
 ## 8.0.3 - 2025-08-19
 
 - Fixed the handling of column comments that end in a single quote ([#382](https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/382))

data/CONTRIBUTING.md

@@ -61,23 +61,16 @@ Only do it if you know the schema was left in a correct state.
 
 ### Run Tests from a Backup
 
-Loading the full test schema every time a test runs can take a while, so for cases where loading the schema sequentially is unimportant, it is possible to use a backup to set up the database. This is significantly faster than the standard method and is provided to run individual tests faster, but should not be used to validate a build.
-
-First create the template database.
-
-```bash
-bundle exec rake db:create_test_template
-```
-
-This will create a template database for the current version (ex. `activerecord_test_template611` for version 6.1.1) and create a `BACKUP` in the `nodelocal://self/activerecord-crdb-adapter/#{activerecord_version}` directory.
-
-To load from the template, use the `COCKROACH_LOAD_FROM_TEMPLATE` flag.
-
-```bash
-COCKROACH_LOAD_FROM_TEMPLATE=1 TEST_FILES="test/cases/adapters/postgresql/ddl_test.rb" bundle exec rake test
-```
-
-And the `activerecord_unittest` database will use the `RESTORE` command to load the schema from the template database.
+Loading the full test schema every time a test runs can take
+a while, so for cases where loading the schema sequentially
+is unimportant, it is possible to use a backup to set up the
+database. This is significantly faster than the standard
+method and is provided to run individual tests faster, but
+should not be used to validate a build.
+
+To do so, just set the env variable `COCKROACH_LOAD_FROM_TEMPLATE`.
+First run will generate and cache a template, latter runs will use
+it.
 
 # Improvements
 

data/Gemfile

@@ -52,10 +52,11 @@ group :development, :test do
   gem "msgpack", ">= 1.7.0"
   gem "mutex_m", "~> 0.2.0"
 
+  gem "tracer"
   gem "rake"
   gem "debug"
+  gem "minitest-bisect", github: "BuonOmo/minitest-bisect", branch: "main"
   gem "minitest-excludes", "~> 2.0.1"
-  gem "minitest-github_action_reporter", github: "BuonOmo/minitest-github_action_reporter", require: "minitest/github_action_reporter_plugin"
   gem "ostruct", "~> 0.6"
 
   # Gems used for tests meta-programming.

data/Rakefile

@@ -2,28 +2,9 @@ require "bundler/gem_tasks"
 require "rake/testtask"
 require_relative 'test/support/paths_cockroachdb'
 require_relative 'test/support/rake_helpers'
-require_relative 'test/support/template_creator'
 
 task default: [:test]
 
-namespace :db do
-  task "create_test_template" do
-    ENV['DEBUG_COCKROACHDB_ADAPTER'] = "1"
-    ENV['COCKROACH_SKIP_LOAD_SCHEMA'] = "1"
-
-    TemplateCreator.connect
-    require_relative 'test/cases/helper'
-
-    # TODO: look into this more, but for some reason the blob alias
-    # is not defined while running this task.
-    ActiveRecord::ConnectionAdapters::CockroachDB::TableDefinition.class_eval do
-      alias :blob :binary
-    end
-
-    TemplateCreator.create_test_template
-  end
-end
-
 Rake::TestTask.new do |t|
   t.libs = ARTest::CockroachDB.test_load_paths
   t.test_files = RakeHelpers.test_files

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

@@ -20,33 +20,32 @@ module ActiveRecord
       class Column < PostgreSQL::Column
         # most functions taken from activerecord-postgis-adapter spatial_column
         # https://github.com/rgeo/activerecord-postgis-adapter/blob/master/lib/active_record/connection_adapters/postgis/spatial_column.rb
-        def initialize(name, default, sql_type_metadata = nil, null = true,
+        def initialize(name, cast_type, default, sql_type_metadata = nil, null = true,
                        default_function = nil, collation: nil, comment: nil, identity: nil,
-                       serial: nil, spatial: nil, generated: nil, hidden: nil)
-          @sql_type_metadata = sql_type_metadata
-          @geographic = !!(sql_type_metadata.sql_type =~ /geography\(/i)
+                       serial: nil, generated: nil, hidden: nil)
+
+          super(name, cast_type, default, sql_type_metadata, null, default_function,
+            collation: collation, comment: comment, serial: serial, generated: generated, identity: identity)
+
           @hidden = hidden
 
-          if spatial
-            # This case comes from an entry in the geometry_columns table
-            set_geometric_type_from_name(spatial[:type])
-            @srid = spatial[:srid].to_i
-            @has_z = !!spatial[:has_z]
-            @has_m = !!spatial[:has_m]
-          elsif @geographic
+          return unless spatial?
+
+          @geographic = sql_type_metadata.sql_type.match?(/geography\(/i)
+
+          if @geographic
             # Geographic type information is embedded in the SQL type
             @srid = 4326
             @has_z = @has_m = false
             build_from_sql_type(sql_type_metadata.sql_type)
-          elsif sql_type =~ /geography|geometry|point|linestring|polygon/i
+          elsif sql_type.match?(/geography|geometry|point|linestring|polygon/i)
             build_from_sql_type(sql_type_metadata.sql_type)
-          elsif sql_type_metadata.sql_type =~ /geography|geometry|point|linestring|polygon/i
+          elsif sql_type_metadata.sql_type.match?(/geography|geometry|point|linestring|polygon/i)
             # A geometry column with no geometry_columns entry.
             # @geometric_type = geo_type_from_sql_type(sql_type)
             build_from_sql_type(sql_type_metadata.sql_type)
           end
-          super(name, default, sql_type_metadata, null, default_function,
-            collation: collation, comment: comment, serial: serial, generated: generated, identity: identity)
+
           if spatial? && @srid
             @limit = { srid: @srid, type: to_type_name(geometric_type) }
             @limit[:has_z] = true if @has_z
@@ -59,20 +58,18 @@ module ActiveRecord
                     :geometric_type,
                     :has_m,
                     :has_z,
-                    :srid
+                    :srid,
+                    :hidden
 
         alias geographic? geographic
         alias has_z? has_z
         alias has_m? has_m
+        alias hidden? hidden
 
         def limit
           spatial? ? @limit : super
         end
 
-        def hidden?
-          @hidden
-        end
-
         def spatial?
           %i[geometry geography].include?(@sql_type_metadata.type)
         end
@@ -81,15 +78,63 @@ module ActiveRecord
           default_function == 'unique_rowid()'
         end
 
-        private
+        # TODO: add tests (see #390)
+        def init_with(coder)
+          @geographic = coder["geographic"]
+          @geometric_type = coder["geometric_type"]
+          @has_m = coder["has_m"]
+          @has_z = coder["has_z"]
+          @srid = coder["srid"]
+          @hidden = coder["hidden"]
+          @limit = coder["limit"]
+          super
+        end
+
+        # TODO: add tests (see #390)
+        def encode_with(coder)
+          coder["geographic"] = @geographic
+          coder["geometric_type"] = @geometric_type
+          coder["has_m"] = @has_m
+          coder["has_z"] = @has_z
+          coder["srid"] = @srid
+          coder["hidden"] = @hidden
+          coder["limit"] = @limit
+          super
+        end
+
+        # TODO: add tests (see #390)
+        def ==(other)
+          other.is_a?(Column) &&
+            super &&
+            other.geographic == geographic &&
+            other.geometric_type == geometric_type &&
+            other.has_m == has_m &&
+            other.has_z == has_z &&
+            other.srid == srid &&
+            other.hidden == hidden &&
+            other.limit == limit
 
-        def set_geometric_type_from_name(name)
-          @geometric_type = RGeo::ActiveRecord.geometric_type_from_name(name) || RGeo::Feature::Geometry
         end
+        alias :eql? :==
+
+        # TODO: add tests (see #390)
+        def hash
+          Column.hash ^
+            super.hash ^
+            geographic.hash ^
+            geometric_type.hash ^
+            has_m.hash ^
+            has_z.hash ^
+            srid.hash ^
+            hidden.hash ^
+            limit.hash
+        end
+
+        private
 
         def build_from_sql_type(sql_type)
           geo_type, @srid, @has_z, @has_m = OID::Spatial.parse_sql_type(sql_type)
-          set_geometric_type_from_name(geo_type)
+          @geometric_type = RGeo::ActiveRecord.geometric_type_from_name(geo_type) || RGeo::Feature::Geometry
         end
 
         def to_type_name(geometric_type)

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

@@ -22,15 +22,25 @@ module ActiveRecord
         def insert_fixtures_set(fixture_set, tables_to_delete = [])
           fixture_inserts = build_fixture_statements(fixture_set)
           table_deletes = tables_to_delete.map { |table| "DELETE FROM #{quote_table_name(table)}" }
-          statements = table_deletes + fixture_inserts
+          statements = (table_deletes + fixture_inserts).join(";")
 
+          # Since [rails pull request #52428][1], `#execute_batch` does not
+          # trigger a cache clear anymore. However, `#insert_fixtures_set`
+          # relies on that clear to ensure consistency. In the postgresql
+          # adapter, this is ensured by a call to `#execute` rather than
+          # `#execute_batch` in `#disable_referential_integrity`. Since
+          # we are not always calling `#disable_referential_integrity`,
+          # we need to ensure that the cache is cleared when running
+          # our statements by calling `#execute` instead of `#execute_batch`.
+          #
+          # [1]: https://github.com/rails/rails/pull/52428
           begin # much faster without disabling referential integrity, worth trying.
             transaction(requires_new: true) do
-              execute_batch(statements, "Fixtures Load")
+              execute(statements, "Fixtures Load")
             end
           rescue
             disable_referential_integrity do
-              execute_batch(statements, "Fixtures Load")
+              execute(statements, "Fixtures Load")
             end
           end
         end

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

@@ -74,7 +74,7 @@ module ActiveRecord
               "https://github.com/cockroachdb/activerecord-cockroachdb-adapter/issues/new"
           end
 
-          run_cmd("cockroach", ["sql", "--set", "errexit=false", "--file", filename], "loading")
+          run_cmd("cockroach", "sql", "--set", "errexit=false", "--file", filename)
         end
 
         private

data/lib/active_record/connection_adapters/cockroachdb/oid/spatial.rb

@@ -26,9 +26,22 @@ module ActiveRecord
           #   "geometry(Polygon,4326) NOT NULL"
           #   "geometry(Geography,4326)"
           def initialize(oid, sql_type)
-            @sql_type = sql_type
-            @geo_type, @srid, @has_z, @has_m = self.class.parse_sql_type(sql_type)
+            super()
+            @sql_type = sql_type.freeze
+            @factory_attrs = self.class
+              .parse_sql_type(sql_type)
+              .then { |geo_type, srid, has_z, has_m|
+                {
+                  geo_type: geo_type.underscore.freeze,
+                  srid: srid.freeze,
+                  has_z: has_z.freeze,
+                  has_m: has_m.freeze,
+                  sql_type: type.to_s.freeze
+                }
+              }
+              .freeze
           end
+          protected attr_reader :sql_type, :factory_attrs
 
           # sql_type: geometry, geometry(Point), geometry(Point,4326), ...
           #
@@ -59,15 +72,8 @@ module ActiveRecord
             [geo_type, srid, has_z, has_m]
           end
 
-          def spatial_factory
-            @spatial_factory ||=
-              RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
-                factory_attrs
-              )
-          end
-
           def geographic?
-            @sql_type =~ /geography/
+            @sql_type.start_with?("geography")
           end
 
           def spatial?
@@ -92,6 +98,19 @@ module ActiveRecord
                                      .generate(geo_value)
           end
 
+          # TODO: add tests (see #390)
+          def ==(other)
+            super &&
+              @sql_type == other.sql_type &&
+              @factory_attrs == other.factory_attrs
+          end
+          alias eql? ==
+
+          # TODO: add tests (see #390)
+          def hash
+            super ^ [@sql_type, @factory_attrs].hash
+          end
+
           private
 
           def cast_value(value)
@@ -108,7 +127,7 @@ module ActiveRecord
           end
 
           def binary_string?(string)
-            string[0] == "\x00" || string[0] == "\x01" || string[0, 4] =~ /[0-9a-fA-F]{4}/
+            string[0] == "\x00" || string[0] == "\x01" || string[0, 4].match?(/[0-9a-fA-F]{4}/)
           end
 
           def wkt_parser(string)
@@ -119,14 +138,10 @@ module ActiveRecord
             end
           end
 
-          def factory_attrs
-            {
-              geo_type: @geo_type.underscore,
-              has_m: @has_m,
-              has_z: @has_z,
-              srid: @srid,
-              sql_type: type.to_s
-            }
+          def spatial_factory
+            RGeo::ActiveRecord::SpatialFactoryStore.instance.factory(
+              factory_attrs
+            )
           end
         end
       end

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

@@ -34,7 +34,8 @@ module ActiveRecord
         # but when creating objects, using RGeo features is more convenient than
         # converting to WKB, so this does it automatically.
         def quote(value)
-          if value.is_a?(Numeric)
+          case value
+          when Numeric
             # NOTE: The fact that integers are quoted is important and helps
             # mitigate a potential vulnerability.
             #
@@ -42,9 +43,9 @@ module ActiveRecord
             # - https://nvd.nist.gov/vuln/detail/CVE-2022-44566
             # - https://github.com/cockroachdb/activerecord-cockroachdb-adapter/pull/280#discussion_r1288692977
             "'#{quote_string(value.to_s)}'"
-          elsif RGeo::Feature::Geometry.check_type(value)
+          when RGeo::Feature::Geometry
             "'#{RGeo::WKRep::WKBGenerator.new(hex_format: true, type_format: :ewkb, emit_ewkb_srid: true).generate(value)}'"
-          elsif value.is_a?(RGeo::Cartesian::BoundingBox)
+          when RGeo::Cartesian::BoundingBox
             "'#{value.min_x},#{value.min_y},#{value.max_x},#{value.max_y}'::box"
           else
             super
@@ -58,6 +59,21 @@ module ActiveRecord
           # This is tested by `BasicsTest#test_default_in_local_time`.
           super + value.strftime("%z")
         end
+
+        # NOTE: This method should be private in future rails versions.
+        #   Hence we should also make it private then.
+        #
+        # See https://github.com/rails/rails/blob/v8.1.1/activerecord/lib/active_record/connection_adapters/postgresql/quoting.rb#L190
+        def lookup_cast_type(sql_type)
+          type_map.lookup(
+            # oid
+            query_value("SELECT #{quote(sql_type)}::regtype::oid", "SCHEMA").to_i,
+            # fmod, not needed.
+            nil,
+            # details needed for `..::CockroachDB::OID::Spatial` (e.g. `geometry(point,3857)`)
+            sql_type
+          )
+        end
       end
     end
   end

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

@@ -34,8 +34,47 @@ module ActiveRecord
         end
 
         def disable_referential_integrity
-          foreign_keys = all_foreign_keys
+          if transaction_open? && query_value("SHOW autocommit_before_ddl") == "off"
+            begin
+              yield
+            rescue ActiveRecord::InvalidForeignKey => e
+              warn <<-WARNING
+WARNING: Rails was not able to disable referential integrity.
+
+This is due to CockroachDB's need of committing transactions
+before a schema change occurs. To bypass this, you can set
+`autocommit_before_ddl: "on"` in your database configuration.
+WARNING
+              raise e
+            end
+          else
+            foreign_keys = all_foreign_keys
+
+            remove_foreign_keys(foreign_keys)
+
+            # Prefixes and suffixes are added in add_foreign_key
+            # in AR7+ so we need to temporarily disable them here,
+            # otherwise prefixes/suffixes will be erroneously added.
+            old_prefix = ActiveRecord::Base.table_name_prefix
+            old_suffix = ActiveRecord::Base.table_name_suffix
+
+            begin
+              yield
+            ensure
+              ActiveRecord::Base.table_name_prefix = ""
+              ActiveRecord::Base.table_name_suffix = ""
 
+              add_foreign_keys(foreign_keys) # Never raises.
+
+              ActiveRecord::Base.table_name_prefix = old_prefix if defined?(old_prefix)
+              ActiveRecord::Base.table_name_suffix = old_suffix if defined?(old_suffix)
+            end
+          end
+        end
+
+        private
+
+        def remove_foreign_keys(foreign_keys)
           statements = foreign_keys.map do |foreign_key|
             # We do not use the `#remove_foreign_key` method here because it
             # checks for foreign keys existance in the schema cache. This method
@@ -45,48 +84,85 @@ module ActiveRecord
 
             schema_creation.accept(at)
           end
-          execute_batch(statements, "Disable referential integrity -> remove foreign keys")
-
-          yield
+          with_schema_unlocked(foreign_keys.flat_map { |fk| [fk.from_table, fk.to_table] }) do
+            execute_batch(statements, "Disable referential integrity -> remove foreign keys")
+          end
+        end
 
-          # Prefixes and suffixes are added in add_foreign_key
-          # in AR7+ so we need to temporarily disable them here,
-          # otherwise prefixes/suffixes will be erroneously added.
-          old_prefix = ActiveRecord::Base.table_name_prefix
-          old_suffix = ActiveRecord::Base.table_name_suffix
+        # NOTE: This method should never raise, otherwise we risk polluting table name
+        #   prefixes and suffixes. The good thing is: if this happens, tests will crash
+        #   hard, no way we miss it.
+        def add_foreign_keys(foreign_keys)
+          # We avoid using `foreign_key_exists?` here because it checks the schema cache
+          # for every key. This method is performance critical for the test suite, hence
+          # we use the `#all_foreign_keys` method that only make one query to the database.
+          already_inserted_foreign_keys = all_foreign_keys
+          foreign_keys_to_add = foreign_keys.reject do |foreign_key|
+            already_inserted_foreign_keys.any? { |fk| fk.from_table == foreign_key.from_table && fk.options[:name] == foreign_key.options[:name] }
+          end
+          statements = foreign_keys_to_add.map do |foreign_key|
+            options = foreign_key_options(foreign_key.from_table, foreign_key.to_table, foreign_key.options)
+            at = create_alter_table foreign_key.from_table
+            at.add_foreign_key foreign_key.to_table, options
 
-          ActiveRecord::Base.table_name_prefix = ""
-          ActiveRecord::Base.table_name_suffix = ""
+            schema_creation.accept(at)
+          end
+          with_schema_unlocked(foreign_keys_to_add.flat_map { |fk| [fk.from_table, fk.to_table] }) do
+            execute_batch(statements, "Disable referential integrity -> add foreign keys")
+          end
+        end
 
+        # Starting in CockroachDB v26.x, tables are created with the
+        # `schema_locked` storage parameter enabled by default (it improves
+        # changefeed performance). CockroachDB transparently unlocks a table to
+        # run a single-statement DDL, but it cannot do so for the multi-statement
+        # batches used to drop and re-add foreign keys above: it raises instead
+        # of unlocking automatically. So we unlock the affected tables ourselves,
+        # run the batch, then restore their locked state. Adding a foreign key
+        # also writes a back-reference into the referenced table, so callers must
+        # pass both the referencing and referenced tables.
+        #
+        # See https://www.cockroachlabs.com/docs/stable/schema-locked
+        def with_schema_unlocked(tables)
+          locked = schema_locked_tables(tables.uniq)
+          return yield if locked.empty?
+
+          set_schema_locked(locked, false)
           begin
-            # Avoid having PG:DuplicateObject error if a test is ran in transaction.
-            # TODO: verify that there is no cache issue related to running this (e.g: fk
-            #   still in cache but not in db)
-            #
-            # We avoid using `foreign_key_exists?` here because it checks the schema cache
-            # for every key. This method is performance critical for the test suite, hence
-            # we use the `#all_foreign_keys` method that only make one query to the database.
-            already_inserted_foreign_keys = all_foreign_keys
-            statements = foreign_keys.map do |foreign_key|
-              next if already_inserted_foreign_keys.any? { |fk| fk.from_table == foreign_key.from_table && fk.options[:name] == foreign_key.options[:name] }
-
-              options = foreign_key_options(foreign_key.from_table, foreign_key.to_table, foreign_key.options)
-              at = create_alter_table foreign_key.from_table
-              at.add_foreign_key foreign_key.to_table, options
-
-              schema_creation.accept(at)
-            end
-            execute_batch(statements.compact, "Disable referential integrity -> add foreign keys")
+            yield
           ensure
-            ActiveRecord::Base.table_name_prefix = old_prefix
-            ActiveRecord::Base.table_name_suffix = old_suffix
+            set_schema_locked(locked, true)
           end
         end
 
-        private
+        # Returns the subset of +tables+ whose `schema_locked` storage parameter
+        # is currently enabled. CockroachDB exposes storage parameters through
+        # `pg_class.reloptions`. On versions (or configurations) that do not lock
+        # tables this returns an empty array, so callers stay on the fast path.
+        def schema_locked_tables(tables)
+          return [] if tables.empty?
+
+          locked = query_values(<<~SQL, "SCHEMA")
+            SELECT (CASE WHEN n.nspname = current_schema() THEN '' ELSE n.nspname || '.' END) || c.relname
+            FROM pg_class c
+            JOIN pg_namespace n ON n.oid = c.relnamespace
+            WHERE c.relkind = 'r' AND 'schema_locked=true' = ANY (c.reloptions)
+          SQL
+          tables & locked
+        end
+
+        # Toggles the `schema_locked` storage parameter for the given tables.
+        # CockroachDB only allows changing `schema_locked` in a single-statement
+        # implicit transaction, so unlike the foreign key statements above these
+        # cannot be batched together.
+        def set_schema_locked(tables, value)
+          tables.each do |table|
+            execute("ALTER TABLE #{quote_table_name(table)} SET (schema_locked = #{value})", "Toggle schema_locked")
+          end
+        end
 
-        # Copy/paste of the `#foreign_keys(table)` method adapted to return every single
-        # foreign key in the database.
+        # NOTE: Copy/paste of the `#foreign_keys(table)` method adapted
+        #   to return every single foreign key in the database.
         def all_foreign_keys
           fk_info = internal_exec_query(<<~SQL, "SCHEMA")
             SELECT CASE
@@ -99,14 +175,30 @@ module ActiveRecord
               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'
@@ -116,22 +208,16 @@ module ActiveRecord
           fk_info.map do |row|
             from_table = PostgreSQL::Utils.unquote_identifier(row["from_table"])
             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"])