activerecord 8.1.3.1 → 8.1.4

data/lib/active_record/associations/association_scope.rb

@@ -149,7 +149,7 @@ module ActiveRecord
                 scope.includes_values |= item.includes_values
               end
 
-              scope.unscope!(*item.unscope_values)
+              scope.unscope!(*item.table_name_qualified_unscope_values)
               scope.where_clause += item.where_clause
               scope.order_values = item.order_values | scope.order_values
             end

data/lib/active_record/associations/belongs_to_association.rb

@@ -80,11 +80,11 @@ module ActiveRecord
       end
 
       def target_changed?
-        owner.attribute_changed?(reflection.foreign_key) || (!foreign_key_present? && target&.new_record?)
+        Array(reflection.foreign_key).any? { |fk| owner.attribute_changed?(fk) } || (!foreign_key_present? && target&.new_record?)
       end
 
       def target_previously_changed?
-        owner.attribute_previously_changed?(reflection.foreign_key)
+        Array(reflection.foreign_key).any? { |fk| owner.attribute_previously_changed?(fk) }
       end
 
       def saved_change_to_target?

data/lib/active_record/associations/builder/belongs_to.rb

@@ -43,7 +43,16 @@ module ActiveRecord::Associations::Builder # :nodoc:
     end
 
     def self.touch_record(o, changes, foreign_key, name, touch) # :nodoc:
-      old_foreign_id = changes[foreign_key] && changes[foreign_key].first
+      old_foreign_id =
+        if foreign_key.is_a?(Array)
+          if foreign_key.any? { |fk| changes[fk] }
+            foreign_key.map do |fk|
+              changes[fk] ? changes[fk].first : o.read_attribute(fk)
+            end
+          end
+        elsif changes[foreign_key]
+          changes[foreign_key].first
+        end
 
       if old_foreign_id
         association = o.association(name)
@@ -56,7 +65,7 @@ module ActiveRecord::Associations::Builder # :nodoc:
           klass = association.klass
         end
         primary_key = reflection.association_primary_key(klass)
-        old_record = klass.find_by(primary_key => old_foreign_id)
+        old_record = klass.find_by(primary_key => [old_foreign_id])
 
         if old_record
           if touch != true
@@ -140,8 +149,14 @@ module ActiveRecord::Associations::Builder # :nodoc:
             foreign_key = reflection.foreign_key
             foreign_type = reflection.foreign_type
 
-            record.read_attribute(foreign_key).nil? ||
-              record.attribute_changed?(foreign_key) ||
+            fk_missing_or_changed = if foreign_key.is_a?(Array)
+              foreign_key.any? { |fk| record.read_attribute(fk).nil? || record.attribute_changed?(fk) }
+            else
+              record.read_attribute(foreign_key).nil? ||
+                record.attribute_changed?(foreign_key)
+            end
+
+            fk_missing_or_changed ||
               (reflection.polymorphic? && (record.read_attribute(foreign_type).nil? || record.attribute_changed?(foreign_type)))
           }
 

data/lib/active_record/associations/collection_association.rb

@@ -61,15 +61,19 @@ module ActiveRecord
       # Implements the ids writer method, e.g. foo.item_ids= for Foo.has_many :items
       def ids_writer(ids)
         primary_key = reflection.association_primary_key
-        pk_type = klass.type_for_attribute(primary_key)
         ids = Array(ids).compact_blank
-        ids.map! { |id| pk_type.cast(id) }
 
         records = if klass.composite_primary_key?
+          pk_types = primary_key.map { |column| klass.type_for_attribute(column) }
+          ids.map! { |id| pk_types.zip(id).map! { |type, value| type.cast(value) } }
+
           klass.where(primary_key => ids).index_by do |record|
             primary_key.map { |primary_key| record._read_attribute(primary_key) }
           end
         else
+          pk_type = klass.type_for_attribute(primary_key)
+          ids.map! { |id| pk_type.cast(id) }
+
           klass.where(primary_key => ids).index_by do |record|
             record._read_attribute(primary_key)
           end

data/lib/active_record/associations/collection_proxy.rb

@@ -726,6 +726,10 @@ module ActiveRecord
       end
 
       def pluck(*column_names)
+        if proxy_association.violates_strict_loading?
+          Base.strict_loading_violation!(owner: proxy_association.owner.class, reflection: proxy_association.reflection)
+        end
+
         null_scope? ? scope.pluck(*column_names) : super
       end
 

data/lib/active_record/associations/foreign_association.rb

@@ -4,7 +4,9 @@ module ActiveRecord::Associations
   module ForeignAssociation # :nodoc:
     def foreign_key_present?
       if reflection.klass.primary_key
-        owner.attribute_present?(reflection.active_record_primary_key)
+        Array(reflection.active_record_primary_key).all? do |key|
+          owner.attribute_present?(key)
+        end
       else
         false
       end

data/lib/active_record/associations/has_one_association.rb

@@ -120,6 +120,7 @@ module ActiveRecord
           Array(reflection.foreign_key).each do |foreign_key_column|
             record[foreign_key_column] = nil unless foreign_key_column.in?(Array(record.class.primary_key))
           end
+          record[reflection.type] = nil if reflection.type.present?
         end
 
         def transaction_if(value, &block)

data/lib/active_record/associations/join_dependency.rb

@@ -168,8 +168,7 @@ module ActiveRecord
         def aliases
           @aliases ||= Aliases.new join_root.each_with_index.map { |join_part, i|
             column_names = if join_part == join_root && !join_root_alias
-              primary_key = join_root.primary_key
-              primary_key ? [primary_key] : []
+              Array(join_root.primary_key)
             else
               join_part.column_names
             end

data/lib/active_record/associations/preloader/association.rb

@@ -169,7 +169,7 @@ module ActiveRecord
         def owners_by_key
           @owners_by_key ||= owners.each_with_object({}) do |owner, result|
             key = derive_key(owner, owner_key_name)
-            (result[key] ||= []) << owner if key
+            (result[key] ||= []) << owner if key.is_a?(Array) ? key.all? : key
           end
         end
 

data/lib/active_record/attribute_methods/serialization.rb

@@ -205,7 +205,7 @@ module ActiveRecord
           attribute(attr_name, **options)
 
           decorate_attributes([attr_name]) do |attr_name, cast_type|
-            if type_incompatible_with_serialize?(cast_type, coder, type)
+            if type_incompatible_with_serialize?(cast_type, column_serializer, type)
               raise ColumnNotSerializableError.new(attr_name, cast_type)
             end
 
@@ -236,7 +236,7 @@ module ActiveRecord
           end
 
           def type_incompatible_with_serialize?(cast_type, coder, type)
-            cast_type.is_a?(ActiveRecord::Type::Json) && coder == ::JSON ||
+            cast_type.is_a?(ActiveRecord::Type::Json) && Coders::JSON === coder ||
               cast_type.respond_to?(:type_cast_array, true) && type == ::Array
           end
       end

data/lib/active_record/attribute_methods.rb

@@ -480,10 +480,12 @@ module ActiveRecord
         self.class.define_attribute_methods
 
         # So in all cases we must behave as if the method was just defined.
-        method = begin
-          self.class.public_instance_method(name)
-        rescue NameError
-          nil
+        method = if self.class.public_method_defined?(name)
+          begin
+            self.class.public_instance_method(name)
+          rescue NameError
+            nil
+          end
         end
 
         # The method might be explicitly defined in the model, but call a generated

data/lib/active_record/callbacks.rb

@@ -173,8 +173,7 @@ module ActiveRecord
   #
   # If a <tt>before_*</tt> callback throws +:abort+, all the later callbacks and
   # the associated action are cancelled.
-  # \Callbacks are generally run in the order they are defined, with the exception of callbacks defined as
-  # methods on the model, which are called last.
+  # \Callbacks are run in the order they are defined.
   #
   # == Ordering callbacks
   #

data/lib/active_record/coders/column_serializer.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  module Coders # :nodoc:
+  module Coders
     class ColumnSerializer # :nodoc:
       attr_reader :object_class
       attr_reader :coder

data/lib/active_record/coders/json.rb

@@ -3,13 +3,14 @@
 require "active_support/json"
 
 module ActiveRecord
-  module Coders # :nodoc:
+  module Coders
     class JSON # :nodoc:
-      DEFAULT_OPTIONS = { escape: false }.freeze
+      DEFAULT_ENCODE_OPTIONS = { escape: false }.freeze
 
-      def initialize(options = nil)
-        @options = options ? DEFAULT_OPTIONS.merge(options) : DEFAULT_OPTIONS
-        @encoder = ActiveSupport::JSON::Encoding.json_encoder.new(options)
+      def initialize(encode_options: nil, decode_options: nil)
+        encode_options = encode_options ? DEFAULT_ENCODE_OPTIONS.merge(encode_options) : DEFAULT_ENCODE_OPTIONS
+        @decode_options = decode_options
+        @encoder = ActiveSupport::JSON::Encoding.json_encoder.new(encode_options)
       end
 
       def dump(obj)
@@ -17,7 +18,7 @@ module ActiveRecord
       end
 
       def load(json)
-        ActiveSupport::JSON.decode(json, @options) unless json.blank?
+        ActiveSupport::JSON.decode(json, @decode_options) unless json.blank?
       end
     end
   end

data/lib/active_record/coders/yaml_column.rb

@@ -3,9 +3,9 @@
 require "yaml"
 
 module ActiveRecord
-  module Coders # :nodoc:
+  module Coders
     class YAMLColumn < ColumnSerializer # :nodoc:
-      class SafeCoder
+      class SafeCoder # :nodoc:
         def initialize(permitted_classes: [], unsafe_load: nil)
           @permitted_classes = permitted_classes
           @unsafe_load = unsafe_load

data/lib/active_record/connection_adapters/abstract/connection_pool/reaper.rb

@@ -53,6 +53,23 @@ module ActiveRecord
             end
           end
 
+          def discard_pool(pool) # :nodoc:
+            @mutex.synchronize do
+              @pools.each do |frequency, refs|
+                refs.reject! do |ref|
+                  ref.__getobj__ == pool
+                rescue WeakRef::RefError
+                  true
+                end
+
+                if refs.empty?
+                  @pools.delete(frequency)
+                  @threads.delete(frequency)&.tap { |t| t.kill; t.join }
+                end
+              end
+            end
+          end
+
           def pools(refs = nil) # :nodoc:
             refs ||= @mutex.synchronize { @pools.values.flatten(1) }
 

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

@@ -18,12 +18,12 @@ module ActiveRecord
 
       def initialize
         super()
-        @mutex = Mutex.new
+        @monitor = Monitor.new
         @server_version = nil
       end
 
       def server_version(connection) # :nodoc:
-        @server_version || @mutex.synchronize { @server_version ||= connection.get_database_version }
+        @server_version || @monitor.synchronize { @server_version ||= connection.get_database_version }
       end
 
       def schema_reflection
@@ -129,14 +129,14 @@ module ActiveRecord
     class ConnectionPool
       # Prior to 3.3.5, WeakKeyMap had a use after free bug
       # https://bugs.ruby-lang.org/issues/20688
-      if ObjectSpace.const_defined?(:WeakKeyMap) && Gem::Version.new(RUBY_VERSION) >= "3.3.5"
+      if ObjectSpace.const_defined?(:WeakKeyMap) && Gem::Version.new(RUBY_VERSION) >= Gem::Version.new("3.3.5")
         WeakThreadKeyMap = ObjectSpace::WeakKeyMap
       else
         class WeakThreadKeyMap # :nodoc:
           # FIXME: On 3.3 we could use ObjectSpace::WeakKeyMap
           # but it currently causes GC crashes: https://github.com/byroot/rails/pull/3
           def initialize
-            @map = {}
+            @map = Concurrent::Map.new
           end
 
           def clear
@@ -148,7 +148,9 @@ module ActiveRecord
           end
 
           def []=(key, value)
-            @map.select! { |c, _| c&.alive? }
+            @map.each_pair do |thread, _|
+              @map.delete(thread) unless thread&.alive?
+            end
             @map[key] = value
           end
         end
@@ -456,13 +458,13 @@ module ActiveRecord
           begin
             yield lease.connection
           ensure
-            lease.sticky = sticky_was if prevent_permanent_checkout && !sticky_was
+            lease.sticky = sticky_was if prevent_permanent_checkout
           end
         else
           begin
             yield lease.connection = checkout
           ensure
-            lease.sticky = sticky_was if prevent_permanent_checkout && !sticky_was
+            lease.sticky = sticky_was if prevent_permanent_checkout
             release_connection(lease) unless lease.sticky
           end
         end
@@ -522,9 +524,15 @@ module ActiveRecord
               @connections.each do |conn|
                 if conn.in_use?
                   conn.steal!
-                  checkin conn
+
+                  ActiveSupport.error_reporter.handle(source: "active_record.connection_pool") do
+                    checkin conn
+                  end
+                end
+
+                ActiveSupport.error_reporter.handle(source: "active_record.connection_pool") do
+                  conn.disconnect!
                 end
-                conn.disconnect!
               end
               @connections = @pinned_connection ? [@pinned_connection] : []
               @leases.clear
@@ -556,6 +564,7 @@ module ActiveRecord
         @reaper_lock.synchronize do
           synchronize do
             return if self.discarded?
+            Reaper.discard_pool(self)
             @connections.each do |conn|
               conn.discard!
             end
@@ -808,13 +817,15 @@ module ActiveRecord
       # having to wait for a connection to be established when first using it
       # after checkout.
       def preconnect
-        sequential_maintenance -> c { (!c.connected? || !c.verified?) && c.allow_preconnect } do |conn|
-          conn.connect!
-        rescue
-          # Wholesale rescue: there's nothing we can do but move on. The
-          # connection will go back to the pool, and the next consumer will
-          # presumably try to connect again -- which will either work, or
-          # fail and they'll be able to report the exception.
+        reaper_lock do
+          sequential_maintenance -> c { (!c.connected? || !c.verified?) && c.allow_preconnect } do |conn|
+            conn.connect!
+          rescue
+            # Wholesale rescue: there's nothing we can do but move on. The
+            # connection will go back to the pool, and the next consumer will
+            # presumably try to connect again -- which will either work, or
+            # fail and they'll be able to report the exception.
+          end
         end
       end
 
@@ -1194,10 +1205,11 @@ module ActiveRecord
           synchronize do
             return unless @maintaining > @available.num_waiting
 
-            # We are guaranteed the "maintaining" thread will return its promised
-            # connection within one maintenance-unit of time. Thus we can safely
-            # do a blocking wait with (functionally) no timeout.
-            @available.poll(100)
+            # Maintenance work (e.g. a keepalive ping) can stall for reasons outside
+            # our control, such as a slow or unresponsive database server, so this
+            # wait must stay bounded by the caller's own checkout_timeout rather than
+            # assume maintenance always finishes quickly.
+            @available.poll(checkout_timeout)
           end
         end
 

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

@@ -568,8 +568,20 @@ module ActiveRecord
           type_casted_binds = type_casted_binds(binds)
           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|
-              result = perform_query(conn, sql, binds, type_casted_binds, prepare: prepare, notification_payload: notification_payload, batch: batch)
-              handle_warnings(result, sql)
+              begin
+                result = perform_query(conn, sql, binds, type_casted_binds, prepare: prepare, notification_payload: notification_payload, batch: batch)
+                query_completed = true
+              ensure
+                begin
+                  handle_warnings(result, sql)
+                rescue
+                  raise if query_completed
+
+                  # The query failed, so we need to swallow this exception
+                  # from handle_warnings to avoid masking the original.
+                end
+              end
+
               result
             end
           end

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

@@ -1017,7 +1017,7 @@ module ActiveRecord
         # this is a naive implementation; some DBs may support this more efficiently (PostgreSQL, for instance)
         old_index_def = indexes(table_name).detect { |i| i.name == old_name }
         return unless old_index_def
-        add_index(table_name, old_index_def.columns, name: new_name, unique: old_index_def.unique)
+        add_index(table_name, old_index_def.columns, name: new_name, unique: old_index_def.unique, where: old_index_def.where)
         remove_index(table_name, name: old_name)
       end
 
@@ -1357,7 +1357,7 @@ module ActiveRecord
       def remove_check_constraint(table_name, expression = nil, if_exists: false, **options)
         return unless supports_check_constraints?
 
-        return if if_exists && !check_constraint_exists?(table_name, **options)
+        return if if_exists && !check_constraint_exists?(table_name, expression: expression, **options)
 
         chk_name_to_delete = check_constraint_for!(table_name, expression: expression, **options).name
 

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -649,6 +649,11 @@ module ActiveRecord
       def drop_virtual_table(*) # :nodoc:
       end
 
+      # Lock used to read an existing record after a duplicate INSERT in a transaction.
+      def create_or_find_by_lock # :nodoc:
+        true
+      end
+
       def advisory_locks_enabled? # :nodoc:
         supports_advisory_locks? && @advisory_locks_enabled
       end
@@ -1113,6 +1118,13 @@ module ActiveRecord
               end
 
               raise translated_exception
+            rescue Exception
+              # A non-StandardError (a Timeout, or a fiber scheduler's cancel) abandoned
+              # the query partway through, so we mark the connection unverified, just as
+              # a failed query would, forcing a reconnect before it's used again.
+              @last_activity = nil
+              @verified = false
+              raise
             ensure
               dirty_current_transaction if materialize_transactions
             end

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -28,6 +28,21 @@ module ActiveRecord
       #   ActiveRecord::ConnectionAdapters::Mysql2Adapter.emulate_booleans = false
       class_attribute :emulate_booleans, default: true
 
+      class_attribute :cli_arg_map, instance_accessor: false, default: {
+        host: "--host",
+        port: "--port",
+        socket: "--socket",
+        username: "--user",
+        password: "--password",
+        encoding: "--default-character-set",
+        sslca: "--ssl-ca",
+        sslcert: "--ssl-cert",
+        sslcapath: "--ssl-capath",
+        sslcipher: "--ssl-cipher",
+        sslkey: "--ssl-key",
+        ssl_mode: "--ssl-mode"
+      }.freeze
+
       NATIVE_DATABASE_TYPES = {
         primary_key: "bigint auto_increment PRIMARY KEY",
         string:      { name: "varchar", limit: 255 },
@@ -54,22 +69,14 @@ module ActiveRecord
       end
 
       class << self
+        def cli_args(config) # :nodoc:
+          cli_arg_map.filter_map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }
+        end
+
         def dbconsole(config, options = {})
           mysql_config = config.configuration_hash
 
-          args = {
-            host: "--host",
-            port: "--port",
-            socket: "--socket",
-            username: "--user",
-            encoding: "--default-character-set",
-            sslca: "--ssl-ca",
-            sslcert: "--ssl-cert",
-            sslcapath: "--ssl-capath",
-            sslcipher: "--ssl-cipher",
-            sslkey: "--ssl-key",
-            ssl_mode: "--ssl-mode"
-          }.filter_map { |opt, arg| "#{arg}=#{mysql_config[opt]}" if mysql_config[opt] }
+          args = cli_args(mysql_config.except(:password))
 
           if mysql_config[:password] && options[:include_password]
             args << "--password=#{mysql_config[:password]}"
@@ -192,6 +199,16 @@ module ActiveRecord
         end
       end
 
+      def create_or_find_by_lock # :nodoc:
+        # A shared lock provides a current read under REPEATABLE READ without
+        # upgrading the shared record lock acquired by a duplicate INSERT.
+        if mariadb? || database_version < "8.0.1"
+          "LOCK IN SHARE MODE"
+        else
+          "FOR SHARE"
+        end
+      end
+
       def get_advisory_lock(lock_name, timeout = 0) # :nodoc:
         query_value("SELECT GET_LOCK(#{quote(lock_name.to_s)}, #{timeout})") == 1
       end
@@ -239,12 +256,24 @@ module ActiveRecord
       def begin_isolated_db_transaction(isolation) # :nodoc:
         # From MySQL manual: The [SET TRANSACTION] statement applies only to the next single transaction performed within the session.
         # So we don't need to implement #reset_isolation_level
-        execute_batch(
-          ["SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "BEGIN"],
-          "TRANSACTION",
-          allow_retry: true,
-          materialize_transactions: false,
-        )
+        if multi_statements_enabled?
+          execute_batch(
+            ["SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}", "BEGIN"],
+            "TRANSACTION",
+            allow_retry: true,
+            materialize_transactions: false,
+          )
+        else
+          with_raw_connection(allow_retry: true, materialize_transactions: false) do
+            internal_execute(
+              "SET TRANSACTION ISOLATION LEVEL #{transaction_isolation_levels.fetch(isolation)}",
+              "TRANSACTION",
+              allow_retry: false,
+              materialize_transactions: false,
+            )
+            internal_execute("BEGIN", "TRANSACTION", allow_retry: false, materialize_transactions: false)
+          end
+        end
       end
 
       def commit_db_transaction # :nodoc:
@@ -469,7 +498,7 @@ module ActiveRecord
         raise NotImplementedError unless supports_disabling_indexes?
 
         query = <<~SQL
-          ALTER TABLE #{quote_table_name(table_name)} ALTER INDEX #{index_name} #{mariadb? ? "NOT IGNORED" : "VISIBLE"}
+          ALTER TABLE #{quote_table_name(table_name)} ALTER INDEX #{quote_column_name(index_name)} #{mariadb? ? "NOT IGNORED" : "VISIBLE"}
         SQL
         execute(query)
       end
@@ -478,7 +507,7 @@ module ActiveRecord
         raise NotImplementedError unless supports_disabling_indexes?
 
         query = <<~SQL
-          ALTER TABLE #{quote_table_name(table_name)} ALTER INDEX #{index_name} #{mariadb? ? "IGNORED" : "INVISIBLE"}
+          ALTER TABLE #{quote_table_name(table_name)} ALTER INDEX #{quote_column_name(index_name)} #{mariadb? ? "IGNORED" : "INVISIBLE"}
         SQL
         execute(query)
       end
@@ -816,6 +845,7 @@ module ActiveRecord
         # See https://dev.mysql.com/doc/mysql-errors/en/server-error-reference.html
         ER_DB_CREATE_EXISTS     = 1007
         ER_FILSORT_ABORT        = 1028
+        ER_NO_DB_ERROR          = 1046
         ER_DUP_ENTRY            = 1062
         ER_SERVER_SHUTDOWN      = 1053
         ER_NOT_NULL_VIOLATION   = 1048
@@ -848,7 +878,7 @@ module ActiveRecord
             else
               super
             end
-          when ER_CONNECTION_KILLED, ER_SERVER_SHUTDOWN, CR_SERVER_GONE_ERROR, CR_SERVER_LOST, ER_CLIENT_INTERACTION_TIMEOUT
+          when ER_CONNECTION_KILLED, ER_SERVER_SHUTDOWN, CR_SERVER_GONE_ERROR, CR_SERVER_LOST, ER_CLIENT_INTERACTION_TIMEOUT, ER_NO_DB_ERROR
             ConnectionFailed.new(message, sql: sql, binds: binds, connection_pool: @pool)
           when ER_DB_CREATE_EXISTS
             DatabaseAlreadyExists.new(message, sql: sql, binds: binds, connection_pool: @pool)
@@ -990,7 +1020,33 @@ module ActiveRecord
         end
 
         def column_definitions(table_name) # :nodoc:
-          internal_exec_query("SHOW FULL FIELDS FROM #{quote_table_name(table_name)}", "SCHEMA", allow_retry: true)
+          fields = internal_exec_query("SHOW FULL FIELDS FROM #{quote_table_name(table_name)}", "SCHEMA", allow_retry: true)
+
+          update_fields_for_mariadb(table_name, fields) if mariadb?
+
+          fields
+        end
+
+        def update_fields_for_mariadb(table_name, fields)
+          has_function_default_candidate = fields.any? do |field|
+            default = field["Default"]
+            default&.match?(/[a-zA-Z_]\w*\(/) && !/\ACURRENT_TIMESTAMP/i.match?(default)
+          end
+
+          if has_function_default_candidate
+            table_info = create_table_info(table_name)
+            fields.each do |field|
+              default = field["Default"]
+              next unless default&.match?(/[a-zA-Z_]\w*\(/)
+              next if /\ACURRENT_TIMESTAMP/i.match?(default)
+
+              field_name = field["Field"]
+              match = table_info&.match(/`#{field_name}` .+ DEFAULT ('|\d+|[A-z]+)/)
+              if match && match[1].match?(/\A[A-z]/)
+                field["Extra"] = "DEFAULT_GENERATED"
+              end
+            end
+          end
         end
 
         def create_table_info(table_name) # :nodoc:

data/lib/active_record/connection_adapters/column.rb

@@ -7,7 +7,7 @@ module ActiveRecord
     class Column
       include Deduplicable
 
-      attr_reader :name, :default, :sql_type_metadata, :null, :default_function, :collation, :comment
+      attr_reader :name, :default, :sql_type_metadata, :null, :default_function, :collation, :comment, :cast_type
 
       delegate :precision, :scale, :limit, :type, :sql_type, to: :sql_type_metadata, allow_nil: true
 
@@ -22,7 +22,7 @@ module ActiveRecord
         @cast_type = cast_type
         @sql_type_metadata = sql_type_metadata
         @null = null
-        @default = default.nil? || cast_type.mutable? ? default : cast_type.deserialize(default)
+        @default = default
         @default_function = default_function
         @collation = collation
         @comment = comment
@@ -110,9 +110,6 @@ module ActiveRecord
         false
       end
 
-      protected
-        attr_reader :cast_type
-
       private
         def deduplicated
           @name = -name