activerecord 7.2.0.beta2 → 7.2.0.beta3

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

@@ -253,6 +253,7 @@ module ActiveRecord
 
         @available = ConnectionLeasingQueue.new self
         @pinned_connection = nil
+        @pinned_connections_depth = 0
 
         @async_executor = build_async_executor
 
@@ -262,6 +263,13 @@ module ActiveRecord
         @reaper.run
       end
 
+      def inspect # :nodoc:
+        name_field = " name=#{db_config.name.inspect}" unless db_config.name == "primary"
+        shard_field = " shard=#{@shard.inspect}" unless @shard == :default
+
+        "#<#{self.class.name} env_name=#{db_config.env_name.inspect}#{name_field} role=#{role.inspect}#{shard_field}>"
+      end
+
       def schema_cache
         @schema_cache ||= BoundSchemaReflection.new(schema_reflection, self)
       end
@@ -311,9 +319,9 @@ module ActiveRecord
       end
 
       def pin_connection!(lock_thread) # :nodoc:
-        raise "There is already a pinned connection" if @pinned_connection
+        @pinned_connection ||= (connection_lease&.connection || checkout)
+        @pinned_connections_depth += 1
 
-        @pinned_connection = (connection_lease&.connection || checkout)
         # Any leased connection must be in @connections otherwise
         # some methods like #connected? won't behave correctly
         unless @connections.include?(@pinned_connection)
@@ -330,7 +338,10 @@ module ActiveRecord
 
         clean = true
         @pinned_connection.lock.synchronize do
-          connection, @pinned_connection = @pinned_connection, nil
+          @pinned_connections_depth -= 1
+          connection = @pinned_connection
+          @pinned_connection = nil if @pinned_connections_depth.zero?
+
           if connection.transaction_open?
             connection.rollback_transaction
           else
@@ -338,8 +349,11 @@ module ActiveRecord
             clean = false
             connection.reset!
           end
-          connection.lock_thread = nil
-          checkin(connection)
+
+          if @pinned_connection.nil?
+            connection.lock_thread = nil
+            checkin(connection)
+          end
         end
 
         clean
@@ -527,12 +541,14 @@ module ActiveRecord
       # - ActiveRecord::ConnectionTimeoutError no connection can be obtained from the pool.
       def checkout(checkout_timeout = @checkout_timeout)
         if @pinned_connection
-          synchronize do
-            @pinned_connection.verify!
-            # Any leased connection must be in @connections otherwise
-            # some methods like #connected? won't behave correctly
-            unless @connections.include?(@pinned_connection)
-              @connections << @pinned_connection
+          @pinned_connection.lock.synchronize do
+            synchronize do
+              @pinned_connection.verify!
+              # Any leased connection must be in @connections otherwise
+              # some methods like #connected? won't behave correctly
+              unless @connections.include?(@pinned_connection)
+                @connections << @pinned_connection
+              end
             end
           end
           @pinned_connection

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

@@ -356,7 +356,7 @@ module ActiveRecord
           if isolation
             raise ActiveRecord::TransactionIsolationError, "cannot set isolation when joining a transaction"
           end
-          yield current_transaction
+          yield current_transaction.user_transaction
         else
           transaction_manager.within_new_transaction(isolation: isolation, joinable: joinable, &block)
         end

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

@@ -277,7 +277,7 @@ module ActiveRecord
             type_casted_binds: -> { type_casted_binds(binds) },
             name: name,
             connection: self,
-            transaction: current_transaction.presence,
+            transaction: current_transaction.user_transaction.presence,
             cached: true
           }
         end

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

@@ -91,7 +91,9 @@ module ActiveRecord
         raise InstrumentationAlreadyStartedError.new("Called start on an already started transaction") if @started
         @started = true
 
-        @payload = @base_payload.dup
+        ActiveSupport::Notifications.instrument("start_transaction.active_record", @base_payload)
+
+        @payload = @base_payload.dup # We dup because the payload for a given event is mutated later to add the outcome.
         @handle = ActiveSupport::Notifications.instrumenter.build_handle("transaction.active_record", @payload)
         @handle.start
       end
@@ -106,10 +108,8 @@ module ActiveRecord
     end
 
     class NullTransaction # :nodoc:
-      def initialize; end
       def state; end
       def closed?; true; end
-      alias_method :blank?, :closed?
       def open?; false; end
       def joinable?; false; end
       def add_record(record, _ = true); end
@@ -121,12 +121,31 @@ module ActiveRecord
       def materialized?; false; end
       def before_commit; yield; end
       def after_commit; yield; end
-      def after_rollback; end # noop
-      def uuid; Digest::UUID.nil_uuid; end
+      def after_rollback; end
+      def user_transaction; ActiveRecord::Transaction::NULL_TRANSACTION; end
     end
 
-    class Transaction < ActiveRecord::Transaction # :nodoc:
-      attr_reader :connection, :state, :savepoint_name, :isolation_level
+    class Transaction # :nodoc:
+      class Callback # :nodoc:
+        def initialize(event, callback)
+          @event = event
+          @callback = callback
+        end
+
+        def before_commit
+          @callback.call if @event == :before_commit
+        end
+
+        def after_commit
+          @callback.call if @event == :after_commit
+        end
+
+        def after_rollback
+          @callback.call if @event == :after_rollback
+        end
+      end
+
+      attr_reader :connection, :state, :savepoint_name, :isolation_level, :user_transaction
       attr_accessor :written
 
       delegate :invalidate!, :invalidated?, to: :@state
@@ -135,6 +154,7 @@ module ActiveRecord
         super()
         @connection = connection
         @state = TransactionState.new
+        @callbacks = nil
         @records = nil
         @isolation_level = isolation
         @materialized = false
@@ -142,7 +162,8 @@ module ActiveRecord
         @run_commit_callbacks = run_commit_callbacks
         @lazy_enrollment_records = nil
         @dirty = false
-        @instrumenter = TransactionInstrumenter.new(connection: connection, transaction: self)
+        @user_transaction = joinable ? ActiveRecord::Transaction.new(self) : ActiveRecord::Transaction::NULL_TRANSACTION
+        @instrumenter = TransactionInstrumenter.new(connection: connection, transaction: @user_transaction)
       end
 
       def dirty!
@@ -153,6 +174,14 @@ module ActiveRecord
         @dirty
       end
 
+      def open?
+        true
+      end
+
+      def closed?
+        false
+      end
+
       def add_record(record, ensure_finalize = true)
         @records ||= []
         if ensure_finalize
@@ -163,6 +192,30 @@ module ActiveRecord
         end
       end
 
+      def before_commit(&block)
+        if @state.finalized?
+          raise ActiveRecordError, "Cannot register callbacks on a finalized transaction"
+        end
+
+        (@callbacks ||= []) << Callback.new(:before_commit, block)
+      end
+
+      def after_commit(&block)
+        if @state.finalized?
+          raise ActiveRecordError, "Cannot register callbacks on a finalized transaction"
+        end
+
+        (@callbacks ||= []) << Callback.new(:after_commit, block)
+      end
+
+      def after_rollback(&block)
+        if @state.finalized?
+          raise ActiveRecordError, "Cannot register callbacks on a finalized transaction"
+        end
+
+        (@callbacks ||= []) << Callback.new(:after_rollback, block)
+      end
+
       def records
         if @lazy_enrollment_records
           @records.concat @lazy_enrollment_records.values
@@ -274,6 +327,11 @@ module ActiveRecord
       def full_rollback?; true; end
       def joinable?; @joinable; end
 
+      protected
+        def append_callbacks(callbacks) # :nodoc:
+          (@callbacks ||= []).concat(callbacks)
+        end
+
       private
         def unique_records
           records.uniq(&:__id__)
@@ -555,7 +613,7 @@ module ActiveRecord
         @connection.lock.synchronize do
           transaction = begin_transaction(isolation: isolation, joinable: joinable)
           begin
-            yield transaction
+            yield transaction.user_transaction
           rescue Exception => error
             rollback_transaction
             after_failure_actions(transaction, error)

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -172,6 +172,13 @@ module ActiveRecord
         @verified = false
       end
 
+      def inspect # :nodoc:
+        name_field = " name=#{pool.db_config.name.inspect}" unless pool.db_config.name == "primary"
+        shard_field = " shard=#{shard.inspect}" unless shard == :default
+
+        "#<#{self.class.name}:#{'%#016x' % (object_id << 1)} env_name=#{pool.db_config.env_name.inspect}#{name_field} role=#{role.inspect}#{shard_field}>"
+      end
+
       def lock_thread=(lock_thread) # :nodoc:
         @lock =
         case lock_thread
@@ -1118,7 +1125,7 @@ module ActiveRecord
             statement_name:    statement_name,
             async:             async,
             connection:        self,
-            transaction:       current_transaction.presence,
+            transaction:       current_transaction.user_transaction.presence,
             row_count:         0,
             &block
           )

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -644,7 +644,7 @@ module ActiveRecord
         # MySQL 8.0.19 replaces `VALUES(<expression>)` clauses with row and column alias names, see https://dev.mysql.com/worklog/task/?id=6312 .
         # then MySQL 8.0.20 deprecates the `VALUES(<expression>)` see https://dev.mysql.com/worklog/task/?id=13325 .
         if supports_insert_raw_alias_syntax?
-          values_alias = quote_table_name("#{insert.model.table_name}_values")
+          values_alias = quote_table_name("#{insert.model.table_name.parameterize}_values")
           sql = +"INSERT #{insert.into} #{insert.values_list} AS #{values_alias}"
 
           if insert.skip_duplicates?

data/lib/active_record/database_configurations/database_config.rb

@@ -18,6 +18,10 @@ module ActiveRecord
         @adapter_class ||= ActiveRecord::ConnectionAdapters.resolve(adapter)
       end
 
+      def inspect # :nodoc:
+        "#<#{self.class.name} env_name=#{@env_name} name=#{@name} adapter_class=#{adapter_class}>"
+      end
+
       def new_connection
         adapter_class.new(configuration_hash)
       end

data/lib/active_record/errors.rb

@@ -130,9 +130,17 @@ module ActiveRecord
 
   # Raised by {ActiveRecord::Base#save!}[rdoc-ref:Persistence#save!] and
   # {ActiveRecord::Base.update_attribute!}[rdoc-ref:Persistence#update_attribute!]
-  # methods when a record is failed to validate or cannot be saved due to any of the
+  # methods when a record failed to validate or cannot be saved due to any of the
   # <tt>before_*</tt> callbacks throwing +:abort+. See
-  # ActiveRecord::Callbacks for further details
+  # ActiveRecord::Callbacks for further details.
+  #
+  #   class Product < ActiveRecord::Base
+  #     before_save do
+  #       throw :abort if price < 0
+  #     end
+  #   end
+  #
+  #   Product.create! # => raises an ActiveRecord::RecordNotSaved
   class RecordNotSaved < ActiveRecordError
     attr_reader :record
 
@@ -143,15 +151,17 @@ module ActiveRecord
   end
 
   # Raised by {ActiveRecord::Base#destroy!}[rdoc-ref:Persistence#destroy!]
-  # when a call to {#destroy}[rdoc-ref:Persistence#destroy]
-  # would return false.
+  # when a record cannot be destroyed due to any of the
+  # <tt>before_destroy</tt> callbacks throwing +:abort+. See
+  # ActiveRecord::Callbacks for further details.
   #
-  #   begin
-  #     complex_operation_that_internally_calls_destroy!
-  #   rescue ActiveRecord::RecordNotDestroyed => invalid
-  #     puts invalid.record.errors
+  #   class User < ActiveRecord::Base
+  #     before_destroy do
+  #       throw :abort if still_active?
+  #     end
   #   end
   #
+  #   User.first.destroy! # => raises an ActiveRecord::RecordNotDestroyed
   class RecordNotDestroyed < ActiveRecordError
     attr_reader :record
 
@@ -583,3 +593,5 @@ module ActiveRecord
   class DatabaseVersionError < ActiveRecordError
   end
 end
+
+require "active_record/associations/errors"

data/lib/active_record/gem_version.rb

@@ -10,7 +10,7 @@ module ActiveRecord
     MAJOR = 7
     MINOR = 2
     TINY  = 0
-    PRE   = "beta2"
+    PRE   = "beta3"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/railtie.rb

@@ -241,8 +241,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
       end
 
       ActiveSupport.on_load(:active_record) do
-        # Configs used in other initializers
-        configs = configs.except(
+        configs_used_in_other_initializers = configs.except(
           :migration_error,
           :database_selector,
           :database_resolver,
@@ -259,7 +258,7 @@ To keep using the current cache store, you can turn off cache versioning entirel
           :postgresql_adapter_decode_dates,
         )
 
-        configs.each do |k, v|
+        configs_used_in_other_initializers.each do |k, v|
           next if k == :encryption
           setter = "#{k}="
           # Some existing initializers might rely on Active Record configuration

data/lib/active_record/railties/databases.rake

@@ -89,7 +89,7 @@ db_namespace = namespace :db do
   task migrate: :load_config do
     db_configs = ActiveRecord::Base.configurations.configs_for(env_name: ActiveRecord::Tasks::DatabaseTasks.env)
 
-    if db_configs.size == 1
+    if db_configs.size == 1 && db_configs.first.primary?
       ActiveRecord::Tasks::DatabaseTasks.migrate
     else
       mapped_versions = ActiveRecord::Tasks::DatabaseTasks.db_configs_with_versions

data/lib/active_record/relation/calculations.rb

@@ -604,7 +604,7 @@ module ActiveRecord
               klass.attribute_types.fetch(name = result.columns[i]) do
                 join_dependencies ||= build_join_dependencies
                 lookup_cast_type_from_join_dependencies(name, join_dependencies) ||
-                  result.column_types[name] || Type.default_value
+                  result.column_types[i] || Type.default_value
               end
           end
         end

data/lib/active_record/relation/query_methods.rb

@@ -2063,17 +2063,29 @@ module ActiveRecord
         order_args.flat_map do |arg|
           case arg
           when String, Symbol
-            arg
+            extract_table_name_from(arg)
           when Hash
-            arg.keys.select { |e| e.is_a?(String) || e.is_a?(Symbol) }
+            arg
+              .map do |key, value|
+                case value
+                when Hash
+                  key.to_s
+                else
+                  extract_table_name_from(key) if key.is_a?(String) || key.is_a?(Symbol)
+                end
+              end
+          when Arel::Attribute
+            arg.relation.name
+          when Arel::Nodes::Ordering
+            if arg.expr.is_a?(Arel::Attribute)
+              arg.expr.relation.name
+            end
           end
-        end.filter_map do |arg|
-          arg =~ /^\W?(\w+)\W?\./ && $1
-        end +
-        order_args
-          .select { |e| e.is_a?(Hash) }
-          .flat_map { |e| e.map { |k, v| k if v.is_a?(Hash) } }
-          .compact
+        end.compact
+      end
+
+      def extract_table_name_from(string)
+        string.match(/^\W?(\w+)\W?\./) && $1
       end
 
       def order_column(field)

data/lib/active_record/signed_id.rb

@@ -106,7 +106,16 @@ module ActiveRecord
 
 
     # Returns a signed id that's generated using a preconfigured +ActiveSupport::MessageVerifier+ instance.
+    #
     # This signed id is tamper proof, so it's safe to send in an email or otherwise share with the outside world.
+    # However, as with any message signed with a +ActiveSupport::MessageVerifier+,
+    # {the signed id is not encrypted}[link:classes/ActiveSupport/MessageVerifier.html#class-ActiveSupport::MessageVerifier-label-Signing+is+not+encryption].
+    # It's just encoded and protected against tampering.
+    #
+    # This means that the ID can be decoded by anyone; however, if tampered with (so to point to a different ID),
+    # the cryptographic signature will no longer match, and the signed id will be considered invalid and return nil
+    # when passed to +find_signed+ (or raise with +find_signed!+).
+    #
     # It can furthermore be set to expire (the default is not to expire), and scoped down with a specific purpose.
     # If the expiration date has been exceeded before +find_signed+ is called, the id won't find the designated
     # record. If a purpose is set, this too must match.

data/lib/active_record/test_fixtures.rb

@@ -96,6 +96,14 @@ module ActiveRecord
       end
     end
 
+    # Generic fixture accessor for fixture names that may conflict with other methods.
+    #
+    #   assert_equal "Ruby on Rails", web_sites(:rubyonrails).name
+    #   assert_equal "Ruby on Rails", fixture(:web_sites, :rubyonrails).name
+    def fixture(fixture_set_name, *fixture_names)
+      active_record_fixture(fixture_set_name, *fixture_names)
+    end
+
     private
       def run_in_transaction?
         use_transactional_tests &&
@@ -255,7 +263,7 @@ module ActiveRecord
 
       def method_missing(method, ...)
         if fixture_sets.key?(method.name)
-          _active_record_fixture(method, ...)
+          active_record_fixture(method, ...)
         else
           super
         end
@@ -269,14 +277,13 @@ module ActiveRecord
         end
       end
 
-      def _active_record_fixture(fixture_set_name, *fixture_names)
+      def active_record_fixture(fixture_set_name, *fixture_names)
         if fs_name = fixture_sets[fixture_set_name.name]
           access_fixture(fs_name, *fixture_names)
         else
           raise StandardError, "No fixture set named '#{fixture_set_name.inspect}'"
         end
       end
-      alias_method :fixture, :_active_record_fixture
 
       def access_fixture(fs_name, *fixture_names)
         force_reload = fixture_names.pop if fixture_names.last == true || fixture_names.last == :reload

data/lib/active_record/timestamp.rb

@@ -162,7 +162,7 @@ module ActiveRecord
 
     def max_updated_column_timestamp
       timestamp_attributes_for_update_in_model
-        .filter_map { |attr| self[attr]&.to_time }
+        .filter_map { |attr| (v = self[attr]) && (v.is_a?(::Time) ? v : v.to_time) }
         .max
     end
 

data/lib/active_record/transaction.rb

@@ -3,9 +3,30 @@
 require "active_support/core_ext/digest"
 
 module ActiveRecord
-  # This abstract class specifies the interface to interact with the current transaction state.
+  # Class specifies the interface to interact with the current transaction state.
   #
-  # Any other methods not specified here are considered to be private interfaces.
+  # It can either map to an actual transaction/savepoint, or represent the
+  # absence of a transaction.
+  #
+  # == State
+  #
+  # We say that a transaction is _finalized_ when it wraps a real transaction
+  # that has been either committed or rolled back.
+  #
+  # A transaction is _open_ if it wraps a real transaction that is not finalized.
+  #
+  # On the other hand, a transaction is _closed_ when it is not open. That is,
+  # when it represents absence of transaction, or it wraps a real but finalized
+  # one.
+  #
+  # You can check whether a transaction is open or closed with the +open?+ and
+  # +closed?+ predicates:
+  #
+  #  if Article.current_transaction.open?
+  #    # We are inside a real and not finalized transaction.
+  #  end
+  #
+  # Closed transactions are `blank?` too.
   #
   # == Callbacks
   #
@@ -42,90 +63,70 @@ module ActiveRecord
   # == Caveats
   #
   # When using after_commit callbacks, it is important to note that if the callback raises an error, the transaction
-  # won't be rolled back. Relying solely on these to synchronize state between multiple systems may lead to consistency issues.
+  # won't be rolled back as it was already committed. Relying solely on these to synchronize state between multiple
+  # systems may lead to consistency issues.
   class Transaction
-    class Callback # :nodoc:
-      def initialize(event, callback)
-        @event = event
-        @callback = callback
-      end
-
-      def before_commit
-        @callback.call if @event == :before_commit
-      end
-
-      def after_commit
-        @callback.call if @event == :after_commit
-      end
-
-      def after_rollback
-        @callback.call if @event == :after_rollback
-      end
-    end
-
-    def initialize # :nodoc:
-      @callbacks = nil
+    def initialize(internal_transaction) # :nodoc:
+      @internal_transaction = internal_transaction
       @uuid = nil
     end
 
-    # Registers a block to be called before the current transaction is fully committed.
-    #
-    # If there is no currently open transactions, the block is called immediately.
-    #
-    # If the current transaction has a parent transaction, the callback is transferred to
-    # the parent when the current transaction commits, or dropped when the current transaction
-    # is rolled back. This operation is repeated until the outermost transaction is reached.
-    #
-    # If the callback raises an error, the transaction is rolled back.
-    def before_commit(&block)
-      (@callbacks ||= []) << Callback.new(:before_commit, block)
-    end
-
-    # Registers a block to be called after the current transaction is fully committed.
+    # Registers a block to be called after the transaction is fully committed.
     #
-    # If there is no currently open transactions, the block is called immediately.
+    # If there is no currently open transactions, the block is called
+    # immediately, unless the transaction is finalized, in which case attempting
+    # to register the callback raises ActiveRecord::ActiveRecordError.
     #
-    # If the current transaction has a parent transaction, the callback is transferred to
+    # If the transaction has a parent transaction, the callback is transferred to
     # the parent when the current transaction commits, or dropped when the current transaction
     # is rolled back. This operation is repeated until the outermost transaction is reached.
     #
     # If the callback raises an error, the transaction remains committed.
     def after_commit(&block)
-      (@callbacks ||= []) << Callback.new(:after_commit, block)
+      if @internal_transaction.nil?
+        yield
+      else
+        @internal_transaction.after_commit(&block)
+      end
     end
 
-    # Registers a block to be called after the current transaction is rolled back.
+    # Registers a block to be called after the transaction is rolled back.
     #
-    # If there is no currently open transactions, the block is never called.
+    # If there is no currently open transactions, the block is not called. But
+    # if the transaction is finalized, attempting to register the callback
+    # raises ActiveRecord::ActiveRecordError.
     #
-    # If the current transaction is successfully committed but has a parent
+    # If the transaction is successfully committed but has a parent
     # transaction, the callback is automatically added to the parent transaction.
     #
     # If the entire chain of nested transactions are all successfully committed,
     # the block is never called.
+    #
+    # If the transaction is already finalized, attempting to register a callback
+    # will raise ActiveRecord::ActiveRecordError.
     def after_rollback(&block)
-      (@callbacks ||= []) << Callback.new(:after_rollback, block)
+      @internal_transaction&.after_rollback(&block)
     end
 
-    # Returns true if a transaction was started.
+    # Returns true if the transaction exists and isn't finalized yet.
     def open?
-      true
+      !closed?
     end
 
-    # Returns true if no transaction is currently active.
+    # Returns true if the transaction doesn't exist or is finalized.
     def closed?
-      false
+      @internal_transaction.nil? || @internal_transaction.state.finalized?
     end
+
     alias_method :blank?, :closed?
 
-    # Returns a UUID for this transaction.
+    # Returns a UUID for this transaction or +nil+ if no transaction is open.
     def uuid
-      @uuid ||= Digest::UUID.uuid_v4
+      if @internal_transaction
+        @uuid ||= Digest::UUID.uuid_v4
+      end
     end
 
-    protected
-      def append_callbacks(callbacks) # :nodoc:
-        (@callbacks ||= []).concat(callbacks)
-      end
+    NULL_TRANSACTION = new(nil).freeze
   end
 end

data/lib/active_record/transactions.rb

@@ -243,7 +243,7 @@ module ActiveRecord
       #
       # See the ActiveRecord::Transaction documentation for detailed behavior.
       def current_transaction
-        connection_pool.active_connection&.current_transaction || ConnectionAdapters::TransactionManager::NULL_TRANSACTION
+        connection_pool.active_connection&.current_transaction&.user_transaction || Transaction::NULL_TRANSACTION
       end
 
       def before_commit(*args, &block) # :nodoc: