activerecord 8.1.0.beta1 → 8.1.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 001cba0b3b77d6277eef2a61e4b29dc9e80f57d5fcabba9e8c930e093c5aa92b
-  data.tar.gz: 4bc817edbfa741aeaaea1c77939b0554299ded73ed637e39125169997cd45e72
+  metadata.gz: 0f6a8286538d4ed09b1508bed7ded4b5b40629d71cbee9467c8926968413da05
+  data.tar.gz: ef5f9492d1efa2285bb03fdfe9d808e86ffadc768f0265257aba7d93bd5c32ad
 SHA512:
-  metadata.gz: f82cb78b1415324583ab7a4040c21d5460f0a8d7e0209e2b6b1accb68481199d61334fc9e2db07aa18270ef5b2f584d0fa25492e34ab867e3ee3005f9069aee6
-  data.tar.gz: 5639613e40ba1b80ce9202d3c25caa407e1298f2a09db29f152f84b2c4ab5bdbf81b42b1d09a5fbbc87ff117c8c081efd49aa93f57fd8a38050054afcd0ee0a2
+  metadata.gz: cad145e87e54f6bfd6cc35294e4aa25471f705e08eae4497a10c75af5ff204b8205728bf41e0ff43d1a2713c712d53b56ba35fbdfdb2df8a3204edc8c9c46eef
+  data.tar.gz: a8792d05c5c847e1c22daff04e84a662afd6847f07368fea7be61876c434f6e233f1d295c296f0c40adaa24896def1f985edc241c589489e4153554a4b15d5c7

data/CHANGELOG.md

@@ -1,3 +1,108 @@
+## Rails 8.1.0.rc1 (October 15, 2025) ##
+
+*   Add replicas to test database parallelization setup.
+
+    Setup and configuration of databases for parallel testing now includes replicas.
+
+    This fixes an issue when using a replica database, database selector middleware,
+    and non-transactional tests, where integration tests running in parallel would select
+    the base test database, i.e. `db_test`, instead of the numbered parallel worker database,
+    i.e. `db_test_{n}`.
+
+    *Adam Maas*
+
+*   Support virtual (not persisted) generated columns on PostgreSQL 18+
+
+    PostgreSQL 18 introduces virtual (not persisted) generated columns,
+    which are now the default unless the `stored: true` option is explicitly specified on PostgreSQL 18+.
+
+    ```ruby
+    create_table :users do |t|
+      t.string :name
+      t.virtual :lower_name,  type: :string,  as: "LOWER(name)", stored: false
+      t.virtual :name_length, type: :integer, as: "LENGTH(name)"
+    end
+    ```
+
+    *Yasuo Honda*
+
+*   Optimize schema dumping to prevent duplicate file generation.
+
+    `ActiveRecord::Tasks::DatabaseTasks.dump_all` now tracks which schema files
+    have already been dumped and skips dumping the same file multiple times.
+    This improves performance when multiple database configurations share the
+    same schema dump path.
+
+    *Mikey Gough*, *Hartley McGuire*
+
+*   Add structured events for Active Record:
+    - `active_record.strict_loading_violation`
+    - `active_record.sql`
+
+    *Gannon McGibbon*
+
+*   Add support for integer shard keys.
+    ```ruby
+    # Now accepts symbols as shard keys.
+    ActiveRecord::Base.connects_to(shards: {
+      1: { writing: :primary_shard_one, reading: :primary_shard_one },
+      2: { writing: :primary_shard_two, reading: :primary_shard_two},
+    })
+
+    ActiveRecord::Base.connected_to(shard: 1) do
+      # ..
+    end
+    ```
+
+    *Nony Dutton*
+
+*   Add `ActiveRecord::Base.only_columns`
+
+    Similar in use case to `ignored_columns` but listing columns to consider rather than the ones
+    to ignore.
+
+    Can be useful when working with a legacy or shared database schema, or to make safe schema change
+    in two deploys rather than three.
+
+    *Anton Kandratski*
+
+*   Use `PG::Connection#close_prepared` (protocol level Close) to deallocate
+    prepared statements when available.
+
+    To enable its use, you must have pg >= 1.6.0, libpq >= 17, and a PostgreSQL
+    database version >= 17.
+
+    *Hartley McGuire*, *Andrew Jackson*
+
+*   Fix query cache for pinned connections in multi threaded transactional tests
+
+    When a pinned connection is used across separate threads, they now use a separate cache store
+    for each thread.
+
+    This improve accuracy of system tests, and any test using multiple threads.
+
+    *Heinrich Lee Yu*, *Jean Boussier*
+
+*   Fix time attribute dirty tracking with timezone conversions.
+
+    Time-only attributes now maintain a fixed date of 2000-01-01 during timezone conversions,
+    preventing them from being incorrectly marked as changed due to date shifts.
+
+    This fixes an issue where time attributes would be marked as changed when setting the same time value
+    due to timezone conversion causing internal date shifts.
+
+    *Prateek Choudhary*
+
+*   Skip calling `PG::Connection#cancel` in `cancel_any_running_query`
+    when using libpq >= 18 with pg < 1.6.0, due to incompatibility.
+    Rollback still runs, but may take longer.
+
+    *Yasuo Honda*, *Lars Kanis*
+
+*   Don't add `id_value` attribute alias when attribute/column with that name already exists.
+
+    *Rob Lewis*
+
 ## Rails 8.1.0.beta1 (September 04, 2025) ##
 
 *   Remove deprecated `:unsigned_float` and `:unsigned_decimal` column methods for MySQL.
@@ -71,10 +176,6 @@
 
     *Kir Shatrov*
 
-*   Emit a warning for pg gem < 1.6.0 when using PostgreSQL 18+
-
-    *Yasuo Honda*
-
 *   Fix `#merge` with `#or` or `#and` and a mixture of attributes and SQL strings resulting in an incorrect query.
 
     ```ruby

data/lib/active_record/associations/belongs_to_association.rb

@@ -135,7 +135,9 @@ module ActiveRecord
             target_key_values = record ? Array(primary_key(record.class)).map { |key| record._read_attribute(key) } : []
 
             if force || reflection_fk.map { |fk| owner._read_attribute(fk) } != target_key_values
+              owner_pk = Array(owner.class.primary_key)
               reflection_fk.each_with_index do |key, index|
+                next if record.nil? && owner_pk.include?(key)
                 owner[key] = target_key_values[index]
               end
             end

data/lib/active_record/attribute_methods/time_zone_conversion.rb

@@ -21,7 +21,11 @@ module ActiveRecord
             set_time_zone_without_conversion(super)
           elsif value.respond_to?(:in_time_zone)
             begin
-              super(user_input_in_time_zone(value)) || super
+              result = super(user_input_in_time_zone(value)) || super
+              if result && type == :time
+                result = result.change(year: 2000, month: 1, day: 1)
+              end
+              result
             rescue ArgumentError
               nil
             end
@@ -41,7 +45,11 @@ module ActiveRecord
             return if value.nil?
 
             if value.acts_like?(:time)
-              value.in_time_zone
+              converted = value.in_time_zone
+              if type == :time && converted
+                converted = converted.change(year: 2000, month: 1, day: 1)
+              end
+              converted
             elsif value.respond_to?(:infinite?) && value.infinite?
               value
             else

data/lib/active_record/attribute_methods.rb

@@ -113,7 +113,7 @@ module ActiveRecord
           unless abstract_class?
             load_schema
             super(attribute_names)
-            alias_attribute :id_value, :id if _has_attribute?("id")
+            alias_attribute :id_value, :id if _has_attribute?("id") && !_has_attribute?("id_value")
           end
 
           generate_alias_attributes

data/lib/active_record/autosave_association.rb

@@ -374,7 +374,7 @@ module ActiveRecord
         context = validation_context if custom_validation_context?
         return true if record.valid?(context)
 
-        if record.changed? || record.new_record? || context
+        if context || record.changed_for_autosave?
           associated_errors = record.errors.objects
         else
           # If there are existing invalid records in the DB, we should still be able to reference them.
@@ -527,7 +527,7 @@ module ActiveRecord
         return false unless reflection.inverse_of&.polymorphic?
 
         class_name = record._read_attribute(reflection.inverse_of.foreign_type)
-        reflection.active_record != record.class.polymorphic_class_for(class_name)
+        reflection.active_record.polymorphic_name != class_name
       end
 
       # Saves the associated record if it's new or <tt>:autosave</tt> is enabled.

data/lib/active_record/base.rb

@@ -6,7 +6,6 @@ require "active_support/descendants_tracker"
 require "active_support/time"
 require "active_support/core_ext/class/subclasses"
 require "active_record/log_subscriber"
-require "active_record/explain_subscriber"
 require "active_record/relation/delegation"
 require "active_record/attributes"
 require "active_record/type_caster"
@@ -256,13 +255,13 @@ module ActiveRecord # :nodoc:
   # * AssociationTypeMismatch - The object assigned to the association wasn't of the type
   #   specified in the association definition.
   # * AttributeAssignmentError - An error occurred while doing a mass assignment through the
-  #   {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
+  #   {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
   #   You can inspect the +attribute+ property of the exception object to determine which attribute
   #   triggered the error.
   # * ConnectionNotEstablished - No connection has been established.
   #   Use {ActiveRecord::Base.establish_connection}[rdoc-ref:ConnectionHandling#establish_connection] before querying.
   # * MultiparameterAssignmentErrors - Collection of errors that occurred during a mass assignment using the
-  #   {ActiveRecord::Base#attributes=}[rdoc-ref:AttributeAssignment#attributes=] method.
+  #   {ActiveRecord::Base#attributes=}[rdoc-ref:ActiveModel::AttributeAssignment#attributes=] method.
   #   The +errors+ property of this exception contains an array of
   #   AttributeAssignmentError
   #   objects that should be inspected to determine which attributes triggered the errors.

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

@@ -129,9 +129,7 @@ module ActiveRecord
             t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
             elapsed = 0
             loop do
-              ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                @cond.wait(timeout - elapsed)
-              end
+              @cond.wait(timeout - elapsed)
 
               return remove if any?
 

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

@@ -8,12 +8,7 @@ require "active_record/connection_adapters/abstract/connection_pool/reaper"
 
 module ActiveRecord
   module ConnectionAdapters
-    module AbstractPool # :nodoc:
-    end
-
     class NullPool # :nodoc:
-      include ConnectionAdapters::AbstractPool
-
       class NullConfig
         def method_missing(...)
           nil
@@ -36,6 +31,7 @@ module ActiveRecord
       end
 
       def schema_cache; end
+      def query_cache; end
       def connection_descriptor; end
       def checkin(_); end
       def remove(_); end
@@ -116,6 +112,7 @@ module ActiveRecord
     # * +max_age+: number of seconds the pool will allow the connection to
     #   exist before retiring it at next checkin. (default Float::INFINITY).
     # * +max_connections+: maximum number of connections the pool may manage (default 5).
+    #   Set to +nil+ or -1 for unlimited connections.
     # * +min_connections+: minimum number of connections the pool will open and maintain (default 0).
     # * +pool_jitter+: maximum reduction factor to apply to +max_age+ and
     #   +keepalive+ intervals (default 0.2; range 0.0-1.0).
@@ -183,21 +180,30 @@ module ActiveRecord
         end
       end
 
-      class LeaseRegistry # :nodoc:
-        def initialize
-          @mutex = Mutex.new
-          @map = WeakThreadKeyMap.new
+      if RUBY_ENGINE == "ruby"
+        # Thanks to the GVL, the LeaseRegistry doesn't need to be synchronized on MRI
+        class LeaseRegistry < WeakThreadKeyMap # :nodoc:
+          def [](context)
+            super || (self[context] = Lease.new)
+          end
         end
+      else
+        class LeaseRegistry # :nodoc:
+          def initialize
+            @mutex = Mutex.new
+            @map = WeakThreadKeyMap.new
+          end
 
-        def [](context)
-          @mutex.synchronize do
-            @map[context] ||= Lease.new
+          def [](context)
+            @mutex.synchronize do
+              @map[context] ||= Lease.new
+            end
           end
-        end
 
-        def clear
-          @mutex.synchronize do
-            @map.clear
+          def clear
+            @mutex.synchronize do
+              @map.clear
+            end
           end
         end
       end
@@ -229,7 +235,6 @@ module ActiveRecord
 
       include MonitorMixin
       prepend QueryCache::ConnectionPoolConfiguration
-      include ConnectionAdapters::AbstractPool
 
       attr_accessor :automatic_reconnect, :checkout_timeout
       attr_reader :db_config, :max_connections, :min_connections, :max_age, :keepalive, :reaper, :pool_config, :async_executor, :role, :shard
@@ -349,8 +354,9 @@ module ActiveRecord
       # held in a cache keyed by a thread.
       def lease_connection
         lease = connection_lease
-        lease.sticky = true
         lease.connection ||= checkout
+        lease.sticky = true
+        lease.connection
       end
 
       def permanent_lease? # :nodoc:
@@ -368,6 +374,7 @@ module ActiveRecord
         end
 
         @pinned_connection.lock_thread = ActiveSupport::IsolatedExecutionState.context if lock_thread
+        @pinned_connection.pinned = true
         @pinned_connection.verify! # eagerly validate the connection
         @pinned_connection.begin_transaction joinable: false, _lazy: false
       end
@@ -390,6 +397,7 @@ module ActiveRecord
           end
 
           if @pinned_connection.nil?
+            connection.pinned = false
             connection.steal!
             connection.lock_thread = nil
             checkin(connection)
@@ -653,11 +661,7 @@ module ActiveRecord
         conn.lock.synchronize do
           synchronize do
             connection_lease.clear(conn)
-
-            conn._run_checkin_callbacks do
-              conn.expire
-            end
-
+            conn.expire
             @available.add conn
           end
         end
@@ -784,6 +788,7 @@ module ActiveRecord
 
         if need_new_connections
           while new_conn = try_to_checkout_new_connection { @connections.size < @min_connections }
+            new_conn.allow_preconnect = true
             checkin(new_conn)
           end
         end
@@ -929,7 +934,7 @@ module ActiveRecord
         # Each connection will only be processed once per call to this method,
         # but (particularly in the async case) there is no protection against
         # a second call to this method starting to work through the list
-        # before the first call has completed. (Though regular pool behaviour
+        # before the first call has completed. (Though regular pool behavior
         # will prevent two instances from working on the same specific
         # connection at the same time.)
         def sequential_maintenance(candidate_selector, &maintenance_work)
@@ -1220,7 +1225,7 @@ module ActiveRecord
           do_checkout = synchronize do
             return if self.discarded?
 
-            if @threads_blocking_new_connections.zero? && (@connections.size + @now_connecting) < @max_connections && (!block_given? || yield)
+            if @threads_blocking_new_connections.zero? && (@max_connections.nil? || (@connections.size + @now_connecting) < @max_connections) && (!block_given? || yield)
               if @connections.size > 0 || @original_context != ActiveSupport::IsolatedExecutionState.context
                 @activated = true
               end
@@ -1267,10 +1272,7 @@ module ActiveRecord
         end
 
         def checkout_and_verify(c)
-          c._run_checkout_callbacks do
-            c.clean!
-          end
-          c
+          c.clean!
         rescue Exception
           remove c
           c.disconnect!

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

@@ -353,6 +353,22 @@ module ActiveRecord
       # isolation level.
       #  :args: (requires_new: nil, isolation: nil, &block)
       def transaction(requires_new: nil, isolation: nil, joinable: true, &block)
+        # If we're running inside the single, non-joinable transaction that
+        # ActiveRecord::TestFixtures starts around each example (depth == 1),
+        # an `isolation:` hint must be validated then ignored so that the
+        # adapter isn't asked to change the isolation level mid-transaction.
+        if isolation && !requires_new && open_transactions == 1 && !current_transaction.joinable?
+          iso = isolation.to_sym
+
+          unless transaction_isolation_levels.include?(iso)
+            raise ActiveRecord::TransactionIsolationError,
+                  "invalid transaction isolation level: #{iso.inspect}"
+          end
+
+          current_transaction.isolation = iso
+          isolation = nil
+        end
+
         if !requires_new && current_transaction.joinable?
           if isolation && current_transaction.isolation != isolation
             raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
@@ -372,10 +388,10 @@ module ActiveRecord
                :disable_lazy_transactions!, :enable_lazy_transactions!, :dirty_current_transaction,
                to: :transaction_manager
 
-      def mark_transaction_written_if_write(sql) # :nodoc:
+      def mark_transaction_written # :nodoc:
         transaction = current_transaction
         if transaction.open?
-          transaction.written ||= write_query?(sql)
+          transaction.written ||= true
         end
       end
 
@@ -420,13 +436,16 @@ module ActiveRecord
         end
       end
 
+      TRANSACTION_ISOLATION_LEVELS = {
+        read_uncommitted: "READ UNCOMMITTED",
+        read_committed:   "READ COMMITTED",
+        repeatable_read:  "REPEATABLE READ",
+        serializable:     "SERIALIZABLE"
+      }.freeze
+      private_constant :TRANSACTION_ISOLATION_LEVELS
+
       def transaction_isolation_levels
-        {
-          read_uncommitted: "READ UNCOMMITTED",
-          read_committed:   "READ COMMITTED",
-          repeatable_read:  "REPEATABLE READ",
-          serializable:     "SERIALIZABLE"
-        }
+        TRANSACTION_ISOLATION_LEVELS
       end
 
       # Begins the transaction with the isolation level set. Raises an error by
@@ -549,9 +568,7 @@ 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 = ActiveSupport::Dependencies.interlock.permit_concurrent_loads do
-                perform_query(conn, sql, binds, type_casted_binds, prepare: prepare, notification_payload: notification_payload, batch: batch)
-              end
+              result = perform_query(conn, sql, binds, type_casted_binds, prepare: prepare, notification_payload: notification_payload, batch: batch)
               handle_warnings(result, sql)
               result
             end
@@ -575,8 +592,10 @@ module ActiveRecord
         end
 
         def preprocess_query(sql)
-          check_if_write_query(sql)
-          mark_transaction_written_if_write(sql)
+          if write_query?(sql)
+            ensure_writes_are_allowed(sql)
+            mark_transaction_written
+          end
 
           # We call tranformers after the write checks so we don't add extra parsing work.
           # This means we assume no transformer whille change a read for a write

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

@@ -13,8 +13,6 @@ module ActiveRecord
           dirties_query_cache base, :exec_query, :execute, :create, :insert, :update, :delete, :truncate,
             :truncate_tables, :rollback_to_savepoint, :rollback_db_transaction, :restart_db_transaction,
             :exec_insert_all
-
-          base.set_callback :checkin, :after, :unset_query_cache!
         end
 
         def dirties_query_cache(base, *method_names)
@@ -209,15 +207,26 @@ 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.
@@ -256,7 +265,7 @@ 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)
+        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
@@ -280,7 +289,7 @@ module ActiveRecord
 
           result = nil
           @lock.synchronize do
-            result = @query_cache[key]
+            result = query_cache[key]
           end
 
           if result
@@ -299,7 +308,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/transaction.rb

@@ -124,6 +124,7 @@ module ActiveRecord
       def after_commit; yield; end
       def after_rollback; end
       def user_transaction; ActiveRecord::Transaction::NULL_TRANSACTION; end
+      def isolation=(_); end
     end
 
     class Transaction # :nodoc:
@@ -156,6 +157,10 @@ module ActiveRecord
         @isolation_level
       end
 
+      def isolation=(isolation) # :nodoc:
+        @isolation_level = isolation
+      end
+
       def initialize(connection, isolation: nil, joinable: true, run_commit_callbacks: false)
         super()
         @connection = connection
@@ -426,6 +431,10 @@ module ActiveRecord
         @parent_transaction.isolation
       end
 
+      def isolation=(isolation) # :nodoc:
+        @parent_transaction.isolation = isolation
+      end
+
       def materialize!
         connection.create_savepoint(savepoint_name)
         super

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -5,6 +5,7 @@ require "active_record/connection_adapters/abstract/schema_dumper"
 require "active_record/connection_adapters/abstract/schema_creation"
 require "active_support/concurrency/null_lock"
 require "active_support/concurrency/load_interlock_aware_monitor"
+require "active_support/concurrency/thread_monitor"
 require "arel/collectors/bind"
 require "arel/collectors/composite"
 require "arel/collectors/sql_string"
@@ -42,7 +43,8 @@ module ActiveRecord
 
       attr_reader :pool
       attr_reader :visitor, :owner, :logger, :lock
-      attr_accessor :allow_preconnect
+      attr_reader :allow_preconnect # :nodoc:
+      attr_accessor :pinned # :nodoc:
       alias :in_use? :owner
 
       def pool=(value)
@@ -51,7 +53,11 @@ module ActiveRecord
         @pool = value
       end
 
-      set_callback :checkin, :after, :enable_lazy_transactions!
+      def allow_preconnect=(value) # :nodoc:
+        @lock.synchronize do
+          @allow_preconnect = value
+        end
+      end
 
       def self.type_cast_config_to_integer(config)
         if config.is_a?(Integer)
@@ -153,9 +159,10 @@ module ActiveRecord
         end
 
         @owner = nil
+        @pinned = false
         @pool = ActiveRecord::ConnectionAdapters::NullPool.new
         @idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-        @allow_preconnect = true
+        @allow_preconnect = false
         @visitor = arel_visitor
         @statements = build_statement_pool
         self.lock_thread = nil
@@ -188,16 +195,16 @@ module ActiveRecord
         @lock =
         case lock_thread
         when Thread
-          ActiveSupport::Concurrency::ThreadLoadInterlockAwareMonitor.new
+          ActiveSupport::Concurrency::ThreadMonitor.new
         when Fiber
-          ActiveSupport::Concurrency::LoadInterlockAwareMonitor.new
+          ::Monitor.new
         else
           ActiveSupport::Concurrency::NullLock
         end
       end
 
-      def check_if_write_query(sql) # :nodoc:
-        if preventing_writes? && write_query?(sql)
+      def ensure_writes_are_allowed(sql) # :nodoc:
+        if preventing_writes?
           raise ActiveRecord::ReadOnlyError, "Write query attempted while in readonly mode: #{sql}"
         end
       end
@@ -327,8 +334,12 @@ module ActiveRecord
               "Current thread: #{ActiveSupport::IsolatedExecutionState.context}."
           end
 
-          @idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC) if update_idle
-          @owner = nil
+          _run_checkin_callbacks do
+            @idle_since = Process.clock_gettime(Process::CLOCK_MONOTONIC) if update_idle
+            @owner = nil
+            enable_lazy_transactions!
+            unset_query_cache!
+          end
         else
           raise ActiveRecordError, "Cannot expire connection, it is not currently leased."
         end
@@ -825,8 +836,11 @@ module ActiveRecord
       end
 
       def clean! # :nodoc:
-        @raw_connection_dirty = false
-        @verified = nil
+        _run_checkout_callbacks do
+          @raw_connection_dirty = false
+          @verified = nil
+        end
+        self
       end
 
       def verified? # :nodoc:

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -209,8 +209,6 @@ module ActiveRecord
         }
       end
 
-      # HELPER METHODS ===========================================
-
       # Must return the MySQL error number from the exception, if the exception has an
       # error number.
       def error_number(exception) # :nodoc:

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

@@ -48,7 +48,7 @@ module ActiveRecord
       end
 
       # = Active Record MySQL Adapter \Index Definition
-      class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition
+      class IndexDefinition < ActiveRecord::ConnectionAdapters::IndexDefinition # :nodoc:
         attr_accessor :enabled
 
         def initialize(*args, **kwargs)