activerecord 7.2.3 → 8.1.3

data/lib/active_record/persistence.rb

@@ -248,18 +248,16 @@ module ActiveRecord
 
         im = Arel::InsertManager.new(arel_table)
 
-        with_connection do |c|
-          if values.empty?
-            im.insert(connection.empty_insert_statement_value(primary_key))
-          else
-            im.insert(values.transform_keys { |name| arel_table[name] })
-          end
-
-          connection.insert(
-            im, "#{self} Create", primary_key || false, primary_key_value,
-            returning: returning
-          )
+        if values.empty?
+          im.insert(connection.empty_insert_statement_value(primary_key))
+        else
+          im.insert(values.transform_keys { |name| arel_table[name] })
         end
+
+        connection.insert(
+          im, "#{self} Create", primary_key || false, primary_key_value,
+          returning: returning
+        )
       end
 
       def _update_record(values, constraints) # :nodoc:
@@ -494,6 +492,7 @@ module ActiveRecord
         becoming.instance_variable_set(:@attributes, @attributes)
         becoming.instance_variable_set(:@mutations_from_database, @mutations_from_database ||= nil)
         becoming.instance_variable_set(:@new_record, new_record?)
+        becoming.instance_variable_set(:@previously_new_record, previously_new_record?)
         becoming.instance_variable_set(:@destroyed, destroyed?)
         becoming.errors.copy!(errors)
       end
@@ -583,8 +582,8 @@ module ActiveRecord
     end
 
     # Equivalent to <code>update_columns(name => value)</code>.
-    def update_column(name, value)
-      update_columns(name => value)
+    def update_column(name, value, touch: nil)
+      update_columns(name => value, touch: touch)
     end
 
     # Updates the attributes directly in the database issuing an UPDATE SQL
@@ -598,11 +597,25 @@ module ActiveRecord
     #
     # * \Validations are skipped.
     # * \Callbacks are skipped.
-    # * +updated_at+/+updated_on+ are not updated.
+    # * +updated_at+/+updated_on+ are updated if the +touch+ option is set to +true+.
     # * However, attributes are serialized with the same rules as ActiveRecord::Relation#update_all
     #
     # This method raises an ActiveRecord::ActiveRecordError when called on new
     # objects, or when at least one of the attributes is marked as readonly.
+    #
+    # ==== Parameters
+    #
+    # * <tt>:touch</tt> option - Touch the timestamp columns when updating.
+    # * If attribute names are passed, they are updated along with +updated_at+/+updated_on+ attributes.
+    #
+    # ==== Examples
+    #
+    #   # Update a single attribute.
+    #   user.update_columns(last_request_at: Time.current)
+    #
+    #   # Update with touch option.
+    #   user.update_columns(last_request_at: Time.current, touch: true)
+
     def update_columns(attributes)
       raise ActiveRecordError, "cannot update a new record" if new_record?
       raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
@@ -614,6 +627,15 @@ module ActiveRecord
         verify_readonly_attribute(name) || name
       end
 
+      touch = attributes.delete("touch")
+      if touch
+        names = touch if touch != true
+        names = Array.wrap(names)
+        options = names.extract_options!
+        touch_updates = self.class.touch_attributes_with_time(*names, **options)
+        attributes.with_defaults!(touch_updates) unless touch_updates.empty?
+      end
+
       update_constraints = _query_constraints_hash
       attributes = attributes.each_with_object({}) do |(k, v), h|
         h[k] = @attributes.write_cast_value(k, v)
@@ -642,8 +664,15 @@ module ActiveRecord
     # This means that any other modified attributes will still be dirty.
     # Validations and callbacks are skipped. Supports the +touch+ option from
     # +update_counters+, see that for more.
+    #
+    # This method raises an ActiveRecord::ActiveRecordError when called on new
+    # objects, or when at least one of the attributes is marked as readonly.
+    #
     # Returns +self+.
     def increment!(attribute, by = 1, touch: nil)
+      raise ActiveRecordError, "cannot update a new record" if new_record?
+      raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
+
       increment(attribute, by)
       change = public_send(attribute) - (public_send(:"#{attribute}_in_database") || 0)
       self.class.update_counters(id, attribute => change, touch: touch)
@@ -812,159 +841,159 @@ module ActiveRecord
       end
     end
 
-  private
-    def init_internals
-      super
-      @_trigger_destroy_callback = @_trigger_update_callback = nil
-      @previously_new_record = false
-    end
+    private
+      def init_internals
+        super
+        @_trigger_destroy_callback = @_trigger_update_callback = nil
+        @previously_new_record = false
+      end
 
-    def strict_loaded_associations
-      @association_cache.find_all do |_, assoc|
-        assoc.owner.strict_loading? && !assoc.owner.strict_loading_n_plus_one_only?
-      end.map(&:first)
-    end
+      def strict_loaded_associations
+        @association_cache.find_all do |_, assoc|
+          assoc.owner.strict_loading? && !assoc.owner.strict_loading_n_plus_one_only?
+        end.map(&:first)
+      end
 
-    def _find_record(options)
-      all_queries = options ? options[:all_queries] : nil
-      base = self.class.all(all_queries: all_queries).preload(strict_loaded_associations)
+      def _find_record(options)
+        all_queries = options ? options[:all_queries] : nil
+        base = self.class.all(all_queries: all_queries).preload(strict_loaded_associations)
 
-      if options && options[:lock]
-        base.lock(options[:lock]).find_by!(_in_memory_query_constraints_hash)
-      else
-        base.find_by!(_in_memory_query_constraints_hash)
+        if options && options[:lock]
+          base.lock(options[:lock]).find_by!(_in_memory_query_constraints_hash)
+        else
+          base.find_by!(_in_memory_query_constraints_hash)
+        end
       end
-    end
 
-    def _in_memory_query_constraints_hash
-      if self.class.query_constraints_list.nil?
-        { @primary_key => id }
-      else
-        self.class.query_constraints_list.index_with do |column_name|
-          attribute(column_name)
+      def _in_memory_query_constraints_hash
+        if self.class.query_constraints_list.nil?
+          { @primary_key => id }
+        else
+          self.class.query_constraints_list.index_with do |column_name|
+            attribute(column_name)
+          end
         end
       end
-    end
 
-    def apply_scoping?(options)
-      !(options && options[:unscoped]) &&
-        (self.class.default_scopes?(all_queries: true) || self.class.global_current_scope)
-    end
+      def apply_scoping?(options)
+        !(options && options[:unscoped]) &&
+          (self.class.default_scopes?(all_queries: true) || self.class.global_current_scope)
+      end
 
-    def _query_constraints_hash
-      if self.class.query_constraints_list.nil?
-        { @primary_key => id_in_database }
-      else
-        self.class.query_constraints_list.index_with do |column_name|
-          attribute_in_database(column_name)
+      def _query_constraints_hash
+        if self.class.query_constraints_list.nil?
+          { @primary_key => id_in_database }
+        else
+          self.class.query_constraints_list.index_with do |column_name|
+            attribute_in_database(column_name)
+          end
         end
       end
-    end
 
-    # A hook to be overridden by association modules.
-    def destroy_associations
-    end
-
-    def destroy_row
-      _delete_row
-    end
-
-    def _delete_row
-      self.class._delete_record(_query_constraints_hash)
-    end
+      # A hook to be overridden by association modules.
+      def destroy_associations
+      end
 
-    def _touch_row(attribute_names, time)
-      time ||= current_time_from_proper_timezone
+      def destroy_row
+        _delete_row
+      end
 
-      attribute_names.each do |attr_name|
-        _write_attribute(attr_name, time)
+      def _delete_row
+        self.class._delete_record(_query_constraints_hash)
       end
 
-      _update_row(attribute_names, "touch")
-    end
+      def _touch_row(attribute_names, time)
+        time ||= current_time_from_proper_timezone
 
-    def _update_row(attribute_names, attempted_action = "update")
-      self.class._update_record(
-        attributes_with_values(attribute_names),
-        _query_constraints_hash
-      )
-    end
+        attribute_names.each do |attr_name|
+          _write_attribute(attr_name, time)
+        end
 
-    def create_or_update(**, &block)
-      _raise_readonly_record_error if readonly?
-      return false if destroyed?
-      result = new_record? ? _create_record(&block) : _update_record(&block)
-      result != false
-    end
+        _update_row(attribute_names, "touch")
+      end
 
-    # Updates the associated record with values matching those of the instance attributes.
-    # Returns the number of affected rows.
-    def _update_record(attribute_names = self.attribute_names)
-      attribute_names = attributes_for_update(attribute_names)
+      def _update_row(attribute_names, attempted_action = "update")
+        self.class._update_record(
+          attributes_with_values(attribute_names),
+          _query_constraints_hash
+        )
+      end
 
-      if attribute_names.empty?
-        affected_rows = 0
-        @_trigger_update_callback = true
-      else
-        affected_rows = _update_row(attribute_names)
-        @_trigger_update_callback = affected_rows == 1
+      def create_or_update(**, &block)
+        _raise_readonly_record_error if readonly?
+        return false if destroyed?
+        result = new_record? ? _create_record(&block) : _update_record(&block)
+        result != false
       end
 
-      @previously_new_record = false
+      # Updates the associated record with values matching those of the instance attributes.
+      # Returns the number of affected rows.
+      def _update_record(attribute_names = self.attribute_names)
+        attribute_names = attributes_for_update(attribute_names)
+
+        if attribute_names.empty?
+          affected_rows = 0
+          @_trigger_update_callback = true
+        else
+          affected_rows = _update_row(attribute_names)
+          @_trigger_update_callback = affected_rows == 1
+        end
 
-      yield(self) if block_given?
+        @previously_new_record = false
 
-      affected_rows
-    end
+        yield(self) if block_given?
 
-    # Creates a record with values matching those of the instance attributes
-    # and returns its id.
-    def _create_record(attribute_names = self.attribute_names)
-      attribute_names = attributes_for_create(attribute_names)
+        affected_rows
+      end
 
-      self.class.with_connection do |connection|
-        returning_columns = self.class._returning_columns_for_insert(connection)
+      # Creates a record with values matching those of the instance attributes
+      # and returns its id.
+      def _create_record(attribute_names = self.attribute_names)
+        attribute_names = attributes_for_create(attribute_names)
 
-        returning_values = self.class._insert_record(
-          connection,
-          attributes_with_values(attribute_names),
-          returning_columns
-        )
+        self.class.with_connection do |connection|
+          returning_columns = self.class._returning_columns_for_insert(connection)
 
-        returning_columns.zip(returning_values).each do |column, value|
-          _write_attribute(column, value) if !_read_attribute(column)
-        end if returning_values
-      end
+          returning_values = self.class._insert_record(
+            connection,
+            attributes_with_values(attribute_names),
+            returning_columns
+          )
 
-      @new_record = false
-      @previously_new_record = true
+          returning_columns.zip(returning_values).each do |column, value|
+            _write_attribute(column, type_for_attribute(column).deserialize(value)) if !_read_attribute(column)
+          end if returning_values
+        end
 
-      yield(self) if block_given?
+        @new_record = false
+        @previously_new_record = true
 
-      id
-    end
+        yield(self) if block_given?
 
-    def verify_readonly_attribute(name)
-      raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attribute?(name)
-    end
+        id
+      end
 
-    def _raise_record_not_destroyed
-      @_association_destroy_exception ||= nil
-      key = self.class.primary_key
-      raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy #{self.class} with #{key}=#{id}", self)
-    ensure
-      @_association_destroy_exception = nil
-    end
+      def verify_readonly_attribute(name)
+        raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attribute?(name)
+      end
 
-    def _raise_readonly_record_error
-      raise ReadOnlyRecord, "#{self.class} is marked as readonly"
-    end
+      def _raise_record_not_destroyed
+        @_association_destroy_exception ||= nil
+        key = self.class.primary_key
+        raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy #{self.class} with #{key}=#{id}", self)
+      ensure
+        @_association_destroy_exception = nil
+      end
 
-    def _raise_record_not_touched_error
-      raise ActiveRecordError, <<~MSG.squish
-        Cannot touch on a new or destroyed record object. Consider using
-        persisted?, new_record?, or destroyed? before touching.
-      MSG
-    end
+      def _raise_readonly_record_error
+        raise ReadOnlyRecord, "#{self.class} is marked as readonly"
+      end
+
+      def _raise_record_not_touched_error
+        raise ActiveRecordError, <<~MSG.squish
+          Cannot touch on a new or destroyed record object. Consider using
+          persisted?, new_record?, or destroyed? before touching.
+        MSG
+      end
   end
 end

data/lib/active_record/query_cache.rb

@@ -3,6 +3,7 @@
 module ActiveRecord
   # = Active Record Query Cache
   class QueryCache
+    # ActiveRecord::Base extends this module, so these methods are available in models.
     module ClassMethods
       # Enable the query cache within the block if Active Record is configured.
       # If it's not, it will execute the given block.
@@ -20,11 +21,15 @@ module ActiveRecord
         end
       end
 
-      # Disable the query cache within the block if Active Record is configured.
-      # If it's not, it will execute the given block.
+      # Runs the block with the query cache disabled.
+      #
+      # If the query cache was enabled before the block was executed, it is
+      # enabled again after it.
       #
-      # Set <tt>dirties: false</tt> to prevent query caches on all connections from being cleared by write operations.
-      # (By default, write operations dirty all connections' query caches in case they are replicas whose cache would now be outdated.)
+      # Set <tt>dirties: false</tt> to prevent query caches on all connections
+      # from being cleared by write operations. (By default, write operations
+      # dirty all connections' query caches in case they are replicas whose
+      # cache would now be outdated.)
       def uncached(dirties: true, &block)
         if connected? || !configurations.empty?
           connection_pool.disable_query_cache(dirties: dirties, &block)
@@ -34,22 +39,24 @@ module ActiveRecord
       end
     end
 
-    def self.run
-      ActiveRecord::Base.connection_handler.each_connection_pool.reject(&:query_cache_enabled).each do |pool|
-        next if pool.db_config&.query_cache == false
-        pool.enable_query_cache!
+    module ExecutorHooks # :nodoc:
+      def self.run
+        ActiveRecord::Base.connection_handler.each_connection_pool.reject(&:query_cache_enabled).each do |pool|
+          next if pool.db_config&.query_cache == false
+          pool.enable_query_cache!
+        end
       end
-    end
 
-    def self.complete(pools)
-      pools.each do |pool|
-        pool.disable_query_cache!
-        pool.clear_query_cache
+      def self.complete(pools)
+        pools.each do |pool|
+          pool.disable_query_cache!
+          pool.clear_query_cache
+        end
       end
     end
 
-    def self.install_executor_hooks(executor = ActiveSupport::Executor)
-      executor.register_hook(self)
+    def self.install_executor_hooks(executor = ActiveSupport::Executor) # :nodoc:
+      executor.register_hook(ExecutorHooks)
     end
   end
 end

data/lib/active_record/query_logs.rb

@@ -69,21 +69,77 @@ module ActiveRecord
   #
   # Tag comments can be prepended to the query:
   #
-  #    ActiveRecord::QueryLogs.prepend_comment = true
+  #     config.active_record.query_log_tags_prepend_comment = true
   #
   # For applications where the content will not change during the lifetime of
   # the request or job execution, the tags can be cached for reuse in every query:
   #
   #    config.active_record.cache_query_log_tags = true
   module QueryLogs
-    mattr_accessor :taggings, instance_accessor: false, default: {}
-    mattr_accessor :tags, instance_accessor: false, default: [ :application ]
-    mattr_accessor :prepend_comment, instance_accessor: false, default: false
-    mattr_accessor :cache_query_log_tags, instance_accessor: false, default: false
-    mattr_accessor :tags_formatter, instance_accessor: false
+    class GetKeyHandler # :nodoc:
+      def initialize(name)
+        @name = name
+      end
+
+      def call(context)
+        context[@name]
+      end
+    end
+
+    class IdentityHandler # :nodoc:
+      def initialize(value)
+        @value = value
+      end
+
+      def call(_context)
+        @value
+      end
+    end
+
+    class ZeroArityHandler # :nodoc:
+      def initialize(proc)
+        @proc = proc
+      end
+
+      def call(_context)
+        @proc.call
+      end
+    end
+
+    @taggings = {}.freeze
+    @tags = [ :application ].freeze
+    @prepend_comment = false
+    @cache_query_log_tags = false
+    @tags_formatter = false
+
     thread_mattr_accessor :cached_comment, instance_accessor: false
 
     class << self
+      attr_reader :tags, :taggings, :tags_formatter # :nodoc:
+      attr_accessor :prepend_comment, :cache_query_log_tags # :nodoc:
+
+      def taggings=(taggings) # :nodoc:
+        @taggings = taggings.freeze
+        @handlers = rebuild_handlers
+      end
+
+      def tags=(tags) # :nodoc:
+        @tags = tags.freeze
+        @handlers = rebuild_handlers
+      end
+
+      def tags_formatter=(format) # :nodoc:
+        @formatter = case format
+        when :legacy
+          LegacyFormatter
+        when :sqlcommenter
+          SQLCommenter
+        else
+          raise ArgumentError, "Formatter is unsupported: #{format}"
+        end
+        @tags_formatter = format
+      end
+
       def call(sql, connection) # :nodoc:
         comment = self.comment(connection)
 
@@ -100,36 +156,42 @@ module ActiveRecord
         self.cached_comment = nil
       end
 
-      # Updates the formatter to be what the passed in format is.
-      def update_formatter(format)
-        self.tags_formatter =
-          case format
-          when :legacy
-            LegacyFormatter.new
-          when :sqlcommenter
-            SQLCommenter.new
-          else
-            raise ArgumentError, "Formatter is unsupported: #{formatter}"
-          end
+      def query_source_location # :nodoc:
+        LogSubscriber.backtrace_cleaner.first_clean_frame
       end
 
-      if Thread.respond_to?(:each_caller_location)
-        def query_source_location # :nodoc:
-          Thread.each_caller_location do |location|
-            frame = LogSubscriber.backtrace_cleaner.clean_frame(location)
-            return frame if frame
+      ActiveSupport::ExecutionContext.after_change { ActiveRecord::QueryLogs.clear_cache }
+
+      private
+        def rebuild_handlers
+          handlers = []
+          @tags.each do |i|
+            if i.is_a?(Hash)
+              i.each do |k, v|
+                handlers << [k, build_handler(k, v)]
+              end
+            else
+              handlers << [i, build_handler(i)]
+            end
           end
-          nil
-        end
-      else
-        def query_source_location # :nodoc:
-          LogSubscriber.backtrace_cleaner.clean(caller_locations(1).each).first
+          handlers.sort_by! { |(key, _)| key.to_s }
         end
-      end
 
-      ActiveSupport::ExecutionContext.after_change { ActiveRecord::QueryLogs.clear_cache }
+        def build_handler(name, handler = nil)
+          handler ||= @taggings[name]
+          if handler.nil?
+            GetKeyHandler.new(name)
+          elsif handler.respond_to?(:call)
+            if handler.arity == 0
+              ZeroArityHandler.new(handler)
+            else
+              handler
+            end
+          else
+            IdentityHandler.new(handler)
+          end
+        end
 
-      private
         # Returns an SQL comment +String+ containing the query log tags.
         # Sets and returns a cached comment if <tt>cache_query_log_tags</tt> is +true+.
         def comment(connection)
@@ -140,10 +202,6 @@ module ActiveRecord
           end
         end
 
-        def formatter
-          self.tags_formatter || self.update_formatter(:legacy)
-        end
-
         def uncached_comment(connection)
           content = tag_content(connection)
 
@@ -153,7 +211,7 @@ module ActiveRecord
         end
 
         def escape_sql_comment(content)
-          # Sanitize a string to appear within a SQL comment
+          # Sanitize a string to appear within an SQL comment
           # For compatibility, this also surrounding "/*+", "/*", and "*/"
           # characters, possibly with single surrounding space.
           # Then follows that by replacing any internal "*/" or "/ *" with
@@ -169,25 +227,15 @@ module ActiveRecord
           context = ActiveSupport::ExecutionContext.to_h
           context[:connection] ||= connection
 
-          pairs = tags.flat_map { |i| [*i] }.filter_map do |tag|
-            key, handler = tag
-            handler ||= taggings[key]
-
-            val = if handler.nil?
-              context[key]
-            elsif handler.respond_to?(:call)
-              if handler.arity == 0
-                handler.call
-              else
-                handler.call(context)
-              end
-            else
-              handler
-            end
-            [key, val] unless val.nil?
+          pairs = @handlers.filter_map do |(key, handler)|
+            val = handler.call(context)
+            @formatter.format(key, val) unless val.nil?
           end
-          self.formatter.format(pairs)
+          @formatter.join(pairs)
         end
     end
+
+    @handlers = rebuild_handlers
+    self.tags_formatter = :legacy
   end
 end