activerecord 8.0.3 → 8.1.0.beta1

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

@@ -55,12 +55,15 @@ module ActiveRecord
       # can be used to query the database repeatedly.
       def cacheable_query(klass, arel) # :nodoc:
         if prepared_statements
+          collector = collector()
+          collector.retryable = true
           sql, binds = visitor.compile(arel.ast, collector)
-          query = klass.query(sql)
+          query = klass.query(sql, retryable: collector.retryable)
         else
           collector = klass.partial_query_collector
+          collector.retryable = true
           parts, binds = visitor.compile(arel.ast, collector)
-          query = klass.partial_query(parts)
+          query = klass.partial_query(parts, retryable: collector.retryable)
         end
         [query, binds]
       end
@@ -110,8 +113,8 @@ module ActiveRecord
         query(...).map(&:first)
       end
 
-      def query(...) # :nodoc:
-        internal_exec_query(...).rows
+      def query(sql, name = nil, allow_retry: true, materialize_transactions: true) # :nodoc:
+        internal_exec_query(sql, name, allow_retry:, materialize_transactions:).rows
       end
 
       # Determines whether the SQL statement is a write query.
@@ -351,7 +354,7 @@ module ActiveRecord
       #  :args: (requires_new: nil, isolation: nil, &block)
       def transaction(requires_new: nil, isolation: nil, joinable: true, &block)
         if !requires_new && current_transaction.joinable?
-          if isolation
+          if isolation && current_transaction.isolation != isolation
             raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
           end
           yield current_transaction.user_transaction
@@ -499,20 +502,6 @@ module ActiveRecord
         "DEFAULT VALUES"
       end
 
-      # Sanitizes the given LIMIT parameter in order to prevent SQL injection.
-      #
-      # The +limit+ may be anything that can evaluate to a string via #to_s. It
-      # should look like an integer, or an Arel SQL literal.
-      #
-      # Returns Integer and Arel::Nodes::SqlLiteral limits as is.
-      def sanitize_limit(limit)
-        if limit.is_a?(Integer) || limit.is_a?(Arel::Nodes::SqlLiteral)
-          limit
-        else
-          Integer(limit)
-        end
-      end
-
       # Fixture value is quoted by Arel, however scalar values
       # are not quotable. In this case we want to convert
       # the column value to YAML.
@@ -547,13 +536,24 @@ module ActiveRecord
         cast_result(internal_execute(...))
       end
 
+      def default_insert_value(column) # :nodoc:
+        DEFAULT_INSERT_VALUE
+      end
+
       private
+        DEFAULT_INSERT_VALUE = Arel.sql("DEFAULT").freeze
+        private_constant :DEFAULT_INSERT_VALUE
+
         # Lowest level way to execute a query. Doesn't check for illegal writes, doesn't annotate queries, yields a native result object.
         def raw_execute(sql, name = nil, binds = [], prepare: false, async: false, allow_retry: false, materialize_transactions: true, batch: false)
           type_casted_binds = type_casted_binds(binds)
-          log(sql, name, binds, type_casted_binds, async: async) do |notification_payload|
+          log(sql, name, binds, type_casted_binds, async: async, allow_retry: allow_retry) do |notification_payload|
             with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
-              perform_query(conn, sql, binds, type_casted_binds, prepare: prepare, notification_payload: notification_payload, batch: batch)
+              result = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
+                perform_query(conn, sql, binds, type_casted_binds, prepare: prepare, notification_payload: notification_payload, batch: batch)
+              end
+              handle_warnings(result, sql)
+              result
             end
           end
         end
@@ -562,6 +562,9 @@ module ActiveRecord
           raise NotImplementedError
         end
 
+        def handle_warnings(raw_result, sql)
+        end
+
         # Receive a native adapter result object and returns an ActiveRecord::Result object.
         def cast_result(raw_result)
           raise NotImplementedError
@@ -597,13 +600,6 @@ module ActiveRecord
           end
         end
 
-        DEFAULT_INSERT_VALUE = Arel.sql("DEFAULT").freeze
-        private_constant :DEFAULT_INSERT_VALUE
-
-        def default_insert_value(column)
-          DEFAULT_INSERT_VALUE
-        end
-
         def build_fixture_sql(fixtures, table_name)
           columns = schema_cache.columns_hash(table_name).reject { |_, column| supports_virtual_columns? && column.virtual? }
 
@@ -617,8 +613,8 @@ module ActiveRecord
 
             columns.map do |name, column|
               if fixture.key?(name)
-                type = lookup_cast_type_from_column(column)
-                with_yaml_fallback(type.serialize(fixture[name]))
+                # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+                with_yaml_fallback(column.fetch_cast_type(self).serialize(fixture[name]))
               else
                 default_insert_value(column)
               end

data/lib/active_record/connection_adapters/abstract/query_cache.rb

@@ -31,6 +31,18 @@ module ActiveRecord
         end
       end
 
+      # This is the actual query cache store.
+      #
+      # It has an internal hash whose keys are either SQL strings, or arrays of
+      # two elements [SQL string, binds], if there are binds. The hash values
+      # are their corresponding ActiveRecord::Result objects.
+      #
+      # Keeping the hash size under max size is achieved with LRU eviction.
+      #
+      # The store gets passed a version object, which is shared among the query
+      # cache stores of a given connection pool (see ConnectionPoolConfiguration
+      # down below). The version value may be externally changed as a way to
+      # signal cache invalidation, that is why all methods have a guard for it.
       class Store # :nodoc:
         attr_accessor :enabled, :dirties
         alias_method :enabled?, :enabled
@@ -94,6 +106,12 @@ module ActiveRecord
           end
       end
 
+      # Each connection pool has one of these registries. They map execution
+      # contexts to query cache stores.
+      #
+      # The keys of the internal map are threads or fibers (whatever
+      # ActiveSupport::IsolatedExecutionState.context returns), and their
+      # associated values are their respective query cache stores.
       class QueryCacheRegistry # :nodoc:
         def initialize
           @mutex = Mutex.new
@@ -191,26 +209,15 @@ module ActiveRecord
         end
       end
 
+      attr_accessor :query_cache
+
       def initialize(*)
         super
         @query_cache = nil
       end
 
-      attr_writer :query_cache
-
-      def query_cache
-        if @pinned && @owner != ActiveSupport::IsolatedExecutionState.context
-          # With transactional tests, if the connection is pinned, any thread
-          # other than the one that pinned the connection need to go through the
-          # query cache pool, so each thread get a different cache.
-          pool.query_cache
-        else
-          @query_cache
-        end
-      end
-
       def query_cache_enabled
-        query_cache&.enabled?
+        @query_cache&.enabled?
       end
 
       # Enable the query cache within the block.
@@ -249,8 +256,8 @@ module ActiveRecord
 
         # If arel is locked this is a SELECT ... FOR UPDATE or somesuch.
         # Such queries should not be cached.
-        if query_cache_enabled && !(arel.respond_to?(:locked) && arel.locked)
-          sql, binds, preparable, allow_retry = to_sql_and_binds(arel, binds, preparable)
+        if @query_cache&.enabled? && !(arel.respond_to?(:locked) && arel.locked)
+          sql, binds, preparable, allow_retry = to_sql_and_binds(arel, binds, preparable, allow_retry)
 
           if async
             result = lookup_sql_cache(sql, name, binds) || super(sql, name, binds, preparable: preparable, async: async, allow_retry: allow_retry)
@@ -273,7 +280,7 @@ module ActiveRecord
 
           result = nil
           @lock.synchronize do
-            result = query_cache[key]
+            result = @query_cache[key]
           end
 
           if result
@@ -292,7 +299,7 @@ module ActiveRecord
           hit = true
 
           @lock.synchronize do
-            result = query_cache.compute_if_absent(key) do
+            result = @query_cache.compute_if_absent(key) do
               hit = false
               yield
             end

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

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/big_decimal/conversions"
-require "active_support/multibyte/chars"
 
 module ActiveRecord
   module ConnectionAdapters # :nodoc:
@@ -84,7 +83,8 @@ module ActiveRecord
         when Type::Time::Value then "'#{quoted_time(value)}'"
         when Date, Time then "'#{quoted_date(value)}'"
         when Class      then "'#{value}'"
-        else raise TypeError, "can't quote #{value.class.name}"
+        else
+          raise TypeError, "can't quote #{value.class.name}"
         end
       end
 
@@ -93,7 +93,7 @@ module ActiveRecord
       # to a String.
       def type_cast(value)
         case value
-        when Symbol, ActiveSupport::Multibyte::Chars, Type::Binary::Data
+        when Symbol, Type::Binary::Data, ActiveSupport::Multibyte::Chars
           value.to_s
         when true       then unquoted_true
         when false      then unquoted_false
@@ -102,7 +102,8 @@ module ActiveRecord
         when nil, Numeric, String then value
         when Type::Time::Value then quoted_time(value)
         when Date, Time then quoted_date(value)
-        else raise TypeError, "can't cast #{value.class.name}"
+        else
+          raise TypeError, "can't cast #{value.class.name}"
         end
       end
 
@@ -113,19 +114,6 @@ module ActiveRecord
         value
       end
 
-      # If you are having to call this function, you are likely doing something
-      # wrong. The column does not have sufficient type information if the user
-      # provided a custom type on the class level either explicitly (via
-      # Attributes::ClassMethods#attribute) or implicitly (via
-      # AttributeMethods::Serialization::ClassMethods#serialize, +time_zone_aware_attributes+).
-      # In almost all cases, the sql type should only be used to change quoting behavior, when the primitive to
-      # represent the type doesn't sufficiently reflect the differences
-      # (varchar vs binary) for example. The type used to get this primitive
-      # should have been provided before reaching the connection adapter.
-      def lookup_cast_type_from_column(column) # :nodoc:
-        lookup_cast_type(column.sql_type)
-      end
-
       # Quotes a string, escaping any ' (single quote) and \ (backslash)
       # characters.
       def quote_string(s)
@@ -158,7 +146,9 @@ module ActiveRecord
         if value.is_a?(Proc)
           value.call
         else
-          value = lookup_cast_type(column.sql_type).serialize(value)
+          # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+          cast_type = column.fetch_cast_type(self)
+          value = cast_type.serialize(value)
           quote(value)
         end
       end
@@ -208,10 +198,10 @@ module ActiveRecord
       end
 
       def sanitize_as_sql_comment(value) # :nodoc:
-        # Sanitize a string to appear within a SQL comment
+        # Sanitize a string to appear within an SQL comment
         # For compatibility, this also surrounding "/*+", "/*", and "*/"
         # charcacters, possibly with single surrounding space.
-        # Then follows that by replacing any internal "*/" or "/ *" with
+        # Then follows that by replacing any internal "*/" or "/*" with
         # "* /" or "/ *"
         comment = value.to_s.dup
         comment.gsub!(%r{\A\s*/\*\+?\s?|\s?\*/\s*\Z}, "")
@@ -220,6 +210,11 @@ module ActiveRecord
         comment
       end
 
+      def lookup_cast_type(sql_type) # :nodoc:
+        # TODO: Make this method private after we release 8.1.
+        type_map.lookup(sql_type)
+      end
+
       private
         def type_casted_binds(binds)
           binds&.map do |value|
@@ -230,10 +225,6 @@ module ActiveRecord
             end
           end
         end
-
-        def lookup_cast_type(sql_type)
-          type_map.lookup(sql_type)
-        end
     end
   end
 end

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

@@ -17,7 +17,7 @@ module ActiveRecord
         :options_include_default?, :supports_indexes_in_create?, :use_foreign_keys?,
         :quoted_columns_for_index, :supports_partial_index?, :supports_check_constraints?,
         :supports_index_include?, :supports_exclusion_constraints?, :supports_unique_constraints?,
-        :supports_nulls_not_distinct?,
+        :supports_nulls_not_distinct?, :lookup_cast_type,
         to: :@conn, private: true
 
       private
@@ -148,7 +148,7 @@ module ActiveRecord
         end
 
         def add_column_options!(sql, options)
-          sql << " DEFAULT #{quote_default_expression(options[:default], options[:column])}" if options_include_default?(options)
+          sql << " DEFAULT #{quote_default_expression_for_column_definition(options[:default], options[:column])}" if options_include_default?(options)
           # must explicitly check for :null to allow change_column to work on migrations
           if options[:null] == false
             sql << " NOT NULL"
@@ -162,6 +162,11 @@ module ActiveRecord
           sql
         end
 
+        def quote_default_expression_for_column_definition(default, column_definition)
+          column_definition.cast_type = lookup_cast_type(column_definition.sql_type)
+          quote_default_expression(default, column_definition)
+        end
+
         def to_sql(sql)
           sql = sql.to_sql if sql.respond_to?(:to_sql)
           sql

data/lib/active_record/connection_adapters/abstract/schema_definitions.rb

@@ -75,7 +75,7 @@ module ActiveRecord
     # are typically created by methods in TableDefinition, and added to the
     # +columns+ attribute of said TableDefinition object, in order to be used
     # for generating a number of table creation or table changing SQL statements.
-    ColumnDefinition = Struct.new(:name, :type, :options, :sql_type) do # :nodoc:
+    ColumnDefinition = Struct.new(:name, :type, :options, :sql_type, :cast_type) do # :nodoc:
       self::OPTION_NAMES = [
         :limit,
         :precision,
@@ -108,6 +108,10 @@ module ActiveRecord
       def aliased_types(name, fallback)
         "timestamp" == name ? :datetime : fallback
       end
+
+      def fetch_cast_type(connection)
+        cast_type
+      end
     end
 
     AddColumnDefinition = Struct.new(:column) # :nodoc:
@@ -303,44 +307,32 @@ module ActiveRecord
     module ColumnMethods
       extend ActiveSupport::Concern
 
-      # Appends a primary key definition to the table definition.
-      # Can be called multiple times, but this is probably not a good idea.
-      def primary_key(name, type = :primary_key, **options)
-        column(name, type, **options.merge(primary_key: true))
-      end
-
-      ##
-      # :method: column
-      # :call-seq: column(name, type, **options)
-      #
-      # Appends a column or columns of a specified type.
-      #
-      #  t.string(:goat)
-      #  t.string(:goat, :sheep)
-      #
-      # See TableDefinition#column
-
-      included do
-        define_column_methods :bigint, :binary, :boolean, :date, :datetime, :decimal,
-          :float, :integer, :json, :string, :text, :time, :timestamp, :virtual
-
-        alias :blob :binary
-        alias :numeric :decimal
-      end
-
       class_methods do
-        def define_column_methods(*column_types) # :nodoc:
-          column_types.each do |column_type|
-            module_eval <<-RUBY, __FILE__, __LINE__ + 1
+        private
+          def define_column_methods(*column_types) # :nodoc:
+            column_types.each do |column_type|
+              module_eval <<-RUBY, __FILE__, __LINE__ + 1
               def #{column_type}(*names, **options)
                 raise ArgumentError, "Missing column name(s) for #{column_type}" if names.empty?
                 names.each { |name| column(name, :#{column_type}, **options) }
               end
-            RUBY
+              RUBY
+            end
           end
-        end
-        private :define_column_methods
       end
+      extend ClassMethods
+
+      # Appends a primary key definition to the table definition.
+      # Can be called multiple times, but this is probably not a good idea.
+      def primary_key(name, type = :primary_key, **options)
+        column(name, type, **options, primary_key: true)
+      end
+
+      define_column_methods :bigint, :binary, :boolean, :date, :datetime, :decimal,
+        :float, :integer, :json, :string, :text, :time, :timestamp, :virtual
+
+      alias :blob :binary
+      alias :numeric :decimal
     end
 
     # = Active Record Connection Adapters \Table \Definition
@@ -351,7 +343,7 @@ module ActiveRecord
     # Inside migration files, the +t+ object in {create_table}[rdoc-ref:SchemaStatements#create_table]
     # is actually of this type:
     #
-    #   class SomeMigration < ActiveRecord::Migration[8.0]
+    #   class SomeMigration < ActiveRecord::Migration[8.1]
     #     def up
     #       create_table :foo do |t|
     #         puts t.class  # => "ActiveRecord::ConnectionAdapters::TableDefinition"
@@ -765,7 +757,7 @@ module ActiveRecord
       #  end
       #
       # See {connection.index_exists?}[rdoc-ref:SchemaStatements#index_exists?]
-      def index_exists?(column_name, **options)
+      def index_exists?(column_name = nil, **options)
         @base.index_exists?(name, column_name, **options)
       end
 

data/lib/active_record/connection_adapters/abstract/schema_dumper.rb

@@ -85,7 +85,8 @@ module ActiveRecord
 
         def schema_default(column)
           return unless column.has_default?
-          type = @connection.lookup_cast_type_from_column(column)
+          # TODO: Remove fetch_cast_type and the need for connection after we release 8.1.
+          type = column.fetch_cast_type(@connection)
           default = type.deserialize(column.default)
           if default.nil?
             schema_expression(column)

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/string/access"
+require "active_support/core_ext/string/filters"
 require "openssl"
 
 module ActiveRecord
@@ -99,7 +100,7 @@ module ActiveRecord
       #   # Check a valid index exists (PostgreSQL only)
       #   index_exists?(:suppliers, :company_id, valid: true)
       #
-      def index_exists?(table_name, column_name, **options)
+      def index_exists?(table_name, column_name = nil, **options)
         indexes(table_name).any? { |i| i.defined_for?(column_name, **options) }
       end
 
@@ -357,11 +358,13 @@ module ActiveRecord
       #   # Creates a table called 'music_artists_records' with no id.
       #   create_join_table('music_artists', 'music_records')
       #
+      # See {connection.add_reference}[rdoc-ref:SchemaStatements#add_reference]
+      # for details of the options you can use in +column_options+. +column_options+
+      # will be applied to both columns.
+      #
       # You can pass an +options+ hash which can include the following keys:
       # [<tt>:table_name</tt>]
       #   Sets the table name, overriding the default.
-      # [<tt>:column_options</tt>]
-      #   Any extra options you want appended to the columns definition.
       # [<tt>:options</tt>]
       #   Any extra options you want appended to the table definition.
       # [<tt>:temporary</tt>]
@@ -378,6 +381,19 @@ module ActiveRecord
       #     t.index :category_id
       #   end
       #
+      # ====== Add foreign keys with delete cascade
+      #
+      #   create_join_table(:assemblies, :parts, column_options: { foreign_key: { on_delete: :cascade } })
+      #
+      # generates:
+      #
+      #   CREATE TABLE assemblies_parts (
+      #     assembly_id bigint NOT NULL,
+      #     part_id bigint NOT NULL,
+      #     CONSTRAINT fk_rails_0d8a572d89 FOREIGN KEY ("assembly_id") REFERENCES "assemblies" ("id") ON DELETE CASCADE,
+      #     CONSTRAINT fk_rails_ec7b48402b FOREIGN KEY ("part_id") REFERENCES "parts" ("id") ON DELETE CASCADE
+      #   )
+      #
       # ====== Add a backend specific option to the generated SQL (MySQL)
       #
       #   create_join_table(:assemblies, :parts, options: 'ENGINE=InnoDB DEFAULT CHARSET=utf8')
@@ -915,6 +931,19 @@ module ActiveRecord
       # Concurrently adding an index is not supported in a transaction.
       #
       # For more information see the {"Transactional Migrations" section}[rdoc-ref:Migration].
+      #
+      # ====== Creating an index that is not used by queries
+      #
+      #   add_index(:developers, :name, enabled: false)
+      #
+      # generates:
+      #
+      #   CREATE INDEX index_developers_on_name ON developers (name) INVISIBLE -- MySQL
+      #
+      #   CREATE INDEX index_developers_on_name ON developers (name) IGNORED -- MariaDB
+      #
+      # Note: only supported by MySQL version 8.0.0 and greater, and MariaDB version 10.6.0 and greater.
+      #
       def add_index(table_name, column_name, **options)
         create_index = build_create_index_definition(table_name, column_name, **options)
         execute schema_creation.accept(create_index)
@@ -1175,9 +1204,10 @@ module ActiveRecord
       #   +:deferred+ or +:immediate+ to specify the default behavior. Defaults to +false+.
       def add_foreign_key(from_table, to_table, **options)
         return unless use_foreign_keys?
-        return if options[:if_not_exists] == true && foreign_key_exists?(from_table, to_table, **options.slice(:column))
 
         options = foreign_key_options(from_table, to_table, options)
+        return if options[:if_not_exists] == true && foreign_key_exists?(from_table, to_table, **options.slice(:column, :primary_key))
+
         at = create_alter_table from_table
         at.add_foreign_key to_table, options
 
@@ -1216,7 +1246,7 @@ module ActiveRecord
       #   The name of the table that contains the referenced primary key.
       def remove_foreign_key(from_table, to_table = nil, **options)
         return unless use_foreign_keys?
-        return if options.delete(:if_exists) == true && !foreign_key_exists?(from_table, to_table)
+        return if options.delete(:if_exists) == true && !foreign_key_exists?(from_table, to_table, **options.slice(:column))
 
         fk_name_to_delete = foreign_key_for!(from_table, to_table: to_table, **options).name
 
@@ -1355,7 +1385,7 @@ module ActiveRecord
         execute schema_creation.accept(at)
       end
 
-      def dump_schema_information # :nodoc:
+      def dump_schema_versions # :nodoc:
         versions = pool.schema_migration.versions
         insert_versions_sql(versions) if versions.any?
       end
@@ -1477,7 +1507,7 @@ module ActiveRecord
       end
 
       def add_index_options(table_name, column_name, name: nil, if_not_exists: false, internal: false, **options) # :nodoc:
-        options.assert_valid_keys(:unique, :length, :order, :opclass, :where, :type, :using, :comment, :algorithm, :include, :nulls_not_distinct)
+        options.assert_valid_keys(valid_index_options)
 
         column_names = index_column_names(column_name)
 
@@ -1486,7 +1516,7 @@ module ActiveRecord
 
         validate_index_length!(table_name, index_name, internal)
 
-        index = IndexDefinition.new(
+        index = create_index_definition(
           table_name, index_name,
           options[:unique],
           column_names,
@@ -1541,6 +1571,20 @@ module ActiveRecord
         raise NotImplementedError, "#{self.class} does not support changing column comments"
       end
 
+      # Enables an index to be used by queries.
+      #
+      #   enable_index(:users, :email)
+      def enable_index(table_name, index_name)
+        raise NotImplementedError, "#{self.class} does not support enabling indexes"
+      end
+
+      # Prevents an index from being used by queries.
+      #
+      #   disable_index(:users, :email)
+      def disable_index(table_name, index_name)
+        raise NotImplementedError, "#{self.class} does not support disabling indexes"
+      end
+
       def create_schema_dumper(options) # :nodoc:
         SchemaDumper.create(self, options)
       end
@@ -1607,7 +1651,7 @@ module ActiveRecord
           name = "idx_on_#{Array(column) * '_'}"
 
           short_limit = max_index_name_size - hashed_identifier.bytesize
-          short_name = name.mb_chars.limit(short_limit).to_s
+          short_name = name.truncate_bytes(short_limit, omission: nil)
 
           "#{short_name}#{hashed_identifier}"
         end
@@ -1629,6 +1673,10 @@ module ActiveRecord
           end
         end
 
+        def valid_index_options
+          [:unique, :length, :order, :opclass, :where, :type, :using, :comment, :algorithm, :include, :nulls_not_distinct]
+        end
+
         def options_for_index_columns(options)
           if options.is_a?(Hash)
             options.symbolize_keys
@@ -1705,6 +1753,10 @@ module ActiveRecord
           TableDefinition.new(self, name, **options)
         end
 
+        def create_index_definition(table_name, name, unique, columns, **options)
+          IndexDefinition.new(table_name, name, unique, columns, **options)
+        end
+
         def create_alter_table(name)
           AlterTable.new create_table_definition(name)
         end
@@ -1767,7 +1819,20 @@ module ActiveRecord
 
         def foreign_key_for(from_table, **options)
           return unless use_foreign_keys?
-          foreign_keys(from_table).detect { |fk| fk.defined_for?(**options) }
+
+          keys = foreign_keys(from_table)
+
+          if options[:_skip_column_match]
+            return keys.find { |fk| fk.defined_for?(**options) }
+          end
+
+          if options[:column].nil?
+            default_column = foreign_key_column_for(options[:to_table], "id")
+            matches = keys.select { |fk| fk.column == default_column }
+            keys = matches if matches.any?
+          end
+
+          keys.find { |fk| fk.defined_for?(**options) }
         end
 
         def foreign_key_for!(from_table, to_table: nil, **options)
@@ -1810,13 +1875,19 @@ module ActiveRecord
 
         def validate_index_length!(table_name, new_name, internal = false)
           if new_name.length > index_name_length
-            raise ArgumentError, "Index name '#{new_name}' on table '#{table_name}' is too long; the limit is #{index_name_length} characters"
+            raise ArgumentError, <<~MSG.squish
+              Index name '#{new_name}' on table '#{table_name}' is too long (#{new_name.length} characters); the limit
+              is #{index_name_length} characters
+            MSG
           end
         end
 
         def validate_table_length!(table_name)
           if table_name.length > table_name_length
-            raise ArgumentError, "Table name '#{table_name}' is too long; the limit is #{table_name_length} characters"
+            raise ArgumentError, <<~MSG.squish
+              Table name '#{table_name}' is too long (#{table_name.length} characters); the limit is
+              #{table_name_length} characters
+            MSG
           end
         end
 
@@ -1878,16 +1949,8 @@ module ActiveRecord
         end
 
         def insert_versions_sql(versions)
-          sm_table = quote_table_name(pool.schema_migration.table_name)
-
-          if versions.is_a?(Array)
-            sql = +"INSERT INTO #{sm_table} (version) VALUES\n"
-            sql << versions.reverse.map { |v| "(#{quote(v)})" }.join(",\n")
-            sql << ";"
-            sql
-          else
-            "INSERT INTO #{sm_table} (version) VALUES (#{quote(versions)});"
-          end
+          versions_formatter = ActiveRecord.schema_versions_formatter.new(self)
+          versions_formatter.format(versions)
         end
 
         def data_source_sql(name = nil, type: nil)