activerecord 7.0.0 → 7.1.0

data/lib/active_record/insert_all.rb

@@ -8,15 +8,21 @@ module ActiveRecord
     attr_reader :on_duplicate, :update_only, :returning, :unique_by, :update_sql
 
     def initialize(model, inserts, on_duplicate:, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
-      raise ArgumentError, "Empty list of attributes passed" if inserts.blank?
-
-      @model, @connection, @inserts, @keys = model, model.connection, inserts, inserts.first.keys.map(&:to_s)
+      @model, @connection, @inserts = model, model.connection, inserts.map(&:stringify_keys)
       @on_duplicate, @update_only, @returning, @unique_by = on_duplicate, update_only, returning, unique_by
       @record_timestamps = record_timestamps.nil? ? model.record_timestamps : record_timestamps
 
       disallow_raw_sql!(on_duplicate)
       disallow_raw_sql!(returning)
 
+      if @inserts.empty?
+        @keys = []
+      else
+        resolve_sti
+        resolve_attribute_aliases
+        @keys = @inserts.first.keys
+      end
+
       configure_on_duplicate_update_logic
 
       if model.scope_attributes?
@@ -28,13 +34,15 @@ module ActiveRecord
       @returning = (connection.supports_insert_returning? ? primary_keys : false) if @returning.nil?
       @returning = false if @returning == []
 
-      @unique_by = find_unique_index_for(unique_by)
+      @unique_by = find_unique_index_for(@unique_by)
       @on_duplicate = :skip if @on_duplicate == :update && updatable_columns.empty?
 
       ensure_valid_options_for_connection!
     end
 
     def execute
+      return ActiveRecord::Result.empty if inserts.empty?
+
       message = +"#{model} "
       message << "Bulk " if inserts.many?
       message << (on_duplicate == :update ? "Upsert" : "Insert")
@@ -76,7 +84,7 @@ module ActiveRecord
       @record_timestamps
     end
 
-    # TODO: Consider remaining this method, as it only conditionally extends keys, not always
+    # TODO: Consider renaming this method, as it only conditionally extends keys, not always
     def keys_including_timestamps
       @keys_including_timestamps ||= if record_timestamps?
         keys + model.all_timestamp_attributes_in_model
@@ -88,6 +96,34 @@ module ActiveRecord
     private
       attr_reader :scope_attributes
 
+      def has_attribute_aliases?(attributes)
+        attributes.keys.any? { |attribute| model.attribute_alias?(attribute) }
+      end
+
+      def resolve_sti
+        return if model.descends_from_active_record?
+
+        sti_type = model.sti_name
+        @inserts = @inserts.map do |insert|
+          insert.reverse_merge(model.inheritance_column.to_s => sti_type)
+        end
+      end
+
+      def resolve_attribute_aliases
+        return unless has_attribute_aliases?(@inserts.first)
+
+        @inserts = @inserts.map do |insert|
+          insert.transform_keys { |attribute| resolve_attribute_alias(attribute) }
+        end
+
+        @update_only = Array(@update_only).map { |attribute| resolve_attribute_alias(attribute) } if @update_only
+        @unique_by = Array(@unique_by).map { |attribute| resolve_attribute_alias(attribute) } if @unique_by
+      end
+
+      def resolve_attribute_alias(attribute)
+        model.attribute_alias(attribute) || attribute
+      end
+
       def configure_on_duplicate_update_logic
         if custom_update_sql_provided? && update_only.present?
           raise ArgumentError, "You can't set :update_only and provide custom update SQL via :on_duplicate at the same time"
@@ -115,8 +151,9 @@ module ActiveRecord
 
         name_or_columns = unique_by || model.primary_key
         match = Array(name_or_columns).map(&:to_s)
+        sorted_match = match.sort
 
-        if index = unique_indexes.find { |i| match.include?(i.name) || i.columns == match }
+        if index = unique_indexes.find { |i| match.include?(i.name) || Array(i.columns).sort == sorted_match }
           index
         elsif match == primary_keys
           unique_by.nil? ? nil : ActiveRecord::ConnectionAdapters::IndexDefinition.new(model.table_name, "#{model.table_name}_primary_key", true, match)
@@ -212,7 +249,13 @@ module ActiveRecord
           if insert_all.returning.is_a?(String)
             insert_all.returning
           else
-            format_columns(insert_all.returning)
+            Array(insert_all.returning).map do |attribute|
+              if model.attribute_alias?(attribute)
+                "#{quote_column(model.attribute_alias(attribute))} AS #{quote_column(attribute)}"
+              else
+                quote_column(attribute)
+              end
+            end.join(",")
           end
         end
 
@@ -271,7 +314,11 @@ module ActiveRecord
           end
 
           def quote_columns(columns)
-            columns.map(&connection.method(:quote_column_name))
+            columns.map { |column| quote_column(column) }
+          end
+
+          def quote_column(column)
+            connection.quote_column_name(column)
           end
       end
   end

data/lib/active_record/integration.rb

@@ -10,7 +10,7 @@ module ActiveRecord
       ##
       # :singleton-method:
       # Indicates the format used to generate the timestamp in the cache key, if
-      # versioning is off. Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
+      # versioning is off. Accepts any of the symbols in +Time::DATE_FORMATS+.
       #
       # This is +:usec+, by default.
       class_attribute :cache_timestamp_format, instance_writer: false, default: :usec
@@ -20,7 +20,7 @@ module ActiveRecord
       # Indicates whether to use a stable #cache_key method that is accompanied
       # by a changing version in the #cache_version method.
       #
-      # This is +true+, by default on Rails 5.2 and above.
+      # This is +true+, by default on \Rails 5.2 and above.
       class_attribute :cache_versioning, instance_writer: false, default: false
 
       ##
@@ -28,7 +28,7 @@ module ActiveRecord
       # Indicates whether to use a stable #cache_key method that is accompanied
       # by a changing version in the #cache_version method on collections.
       #
-      # This is +false+, by default until Rails 6.1.
+      # This is +false+, by default until \Rails 6.1.
       class_attribute :collection_cache_versioning, instance_writer: false, default: false
     end
 
@@ -55,8 +55,8 @@ module ActiveRecord
     #   user = User.find_by(name: 'Phusion')
     #   user_path(user)  # => "/users/Phusion"
     def to_param
-      # We can't use alias_method here, because method 'id' optimizes itself on the fly.
-      id && id.to_s # Be sure to stringify the id for routes
+      return unless id
+      Array(id).join(self.class.param_delimiter)
     end
 
     # Returns a stable cache key that can be used to identify this record.
@@ -64,7 +64,7 @@ module ActiveRecord
     #   Product.new.cache_key     # => "products/new"
     #   Product.find(5).cache_key # => "products/5"
     #
-    # If ActiveRecord::Base.cache_versioning is turned off, as it was in Rails 5.1 and earlier,
+    # If ActiveRecord::Base.cache_versioning is turned off, as it was in \Rails 5.1 and earlier,
     # the cache key will also include a version.
     #
     #   Product.cache_versioning = false
@@ -79,7 +79,7 @@ module ActiveRecord
           timestamp = max_updated_column_timestamp
 
           if timestamp
-            timestamp = timestamp.utc.to_formatted_s(cache_timestamp_format)
+            timestamp = timestamp.utc.to_fs(cache_timestamp_format)
             "#{model_name.cache_key}/#{id}-#{timestamp}"
           else
             "#{model_name.cache_key}/#{id}"
@@ -103,10 +103,10 @@ module ActiveRecord
           raw_timestamp_to_cache_version(timestamp)
 
         elsif timestamp = updated_at
-          timestamp.utc.to_formatted_s(cache_timestamp_format)
+          timestamp.utc.to_fs(cache_timestamp_format)
         end
       elsif self.class.has_attribute?("updated_at")
-        raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"
+        raise ActiveModel::MissingAttributeError, "missing attribute 'updated_at' for #{self.class}"
       end
     end
 
@@ -178,7 +178,7 @@ module ActiveRecord
       def can_use_fast_cache_version?(timestamp)
         timestamp.is_a?(String) &&
           cache_timestamp_format == :usec &&
-          ActiveRecord.default_timezone == :utc &&
+          self.class.connection.default_timezone == :utc &&
           !updated_at_came_from_user?
       end
 

data/lib/active_record/internal_metadata.rb

@@ -9,52 +9,140 @@ module ActiveRecord
   #
   # This is enabled by default. To disable this functionality set
   # `use_metadata_table` to false in your database configuration.
-  class InternalMetadata < ActiveRecord::Base # :nodoc:
-    self.record_timestamps = true
+  class InternalMetadata # :nodoc:
+    class NullInternalMetadata
+    end
 
-    class << self
-      def enabled?
-        ActiveRecord::Base.connection.use_metadata_table?
-      end
+    attr_reader :connection, :arel_table
 
-      def primary_key
-        "key"
-      end
+    def initialize(connection)
+      @connection = connection
+      @arel_table = Arel::Table.new(table_name)
+    end
 
-      def table_name
-        "#{table_name_prefix}#{internal_metadata_table_name}#{table_name_suffix}"
-      end
+    def enabled?
+      connection.use_metadata_table?
+    end
 
-      def []=(key, value)
-        return unless enabled?
+    def primary_key
+      "key"
+    end
+
+    def value_key
+      "value"
+    end
+
+    def table_name
+      "#{ActiveRecord::Base.table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{ActiveRecord::Base.table_name_suffix}"
+    end
 
-        find_or_initialize_by(key: key).update!(value: value)
+    def []=(key, value)
+      return unless enabled?
+
+      update_or_create_entry(key, value)
+    end
+
+    def [](key)
+      return unless enabled?
+
+      if entry = select_entry(key)
+        entry[value_key]
       end
+    end
 
-      def [](key)
-        return unless enabled?
+    def delete_all_entries
+      dm = Arel::DeleteManager.new(arel_table)
+
+      connection.delete(dm, "#{self.class} Destroy")
+    end
+
+    def count
+      sm = Arel::SelectManager.new(arel_table)
+      sm.project(*Arel::Nodes::Count.new([Arel.star]))
+
+      connection.select_values(sm, "#{self.class} Count").first
+    end
 
-        where(key: key).pick(:value)
+    def create_table_and_set_flags(environment, schema_sha1 = nil)
+      create_table
+      update_or_create_entry(:environment, environment)
+      update_or_create_entry(:schema_sha1, schema_sha1) if schema_sha1
+    end
+
+    # Creates an internal metadata table with columns +key+ and +value+
+    def create_table
+      return unless enabled?
+
+      unless connection.table_exists?(table_name)
+        connection.create_table(table_name, id: false) do |t|
+          t.string :key, **connection.internal_string_options_for_primary_key
+          t.string :value
+          t.timestamps
+        end
       end
+    end
+
+    def drop_table
+      return unless enabled?
+
+      connection.drop_table table_name, if_exists: true
+    end
+
+    def table_exists?
+      connection.schema_cache.data_source_exists?(table_name)
+    end
 
-      # Creates an internal metadata table with columns +key+ and +value+
-      def create_table
-        return unless enabled?
+    private
+      def update_or_create_entry(key, value)
+        entry = select_entry(key)
 
-        unless connection.table_exists?(table_name)
-          connection.create_table(table_name, id: false) do |t|
-            t.string :key, **connection.internal_string_options_for_primary_key
-            t.string :value
-            t.timestamps
+        if entry
+          if entry[value_key] != value
+            update_entry(key, value)
+          else
+            entry[value_key]
           end
+        else
+          create_entry(key, value)
         end
       end
 
-      def drop_table
-        return unless enabled?
+      def current_time
+        connection.default_timezone == :utc ? Time.now.utc : Time.now
+      end
+
+      def create_entry(key, value)
+        im = Arel::InsertManager.new(arel_table)
+        im.insert [
+          [arel_table[primary_key], key],
+          [arel_table[value_key], value],
+          [arel_table[:created_at], current_time],
+          [arel_table[:updated_at], current_time]
+        ]
 
-        connection.drop_table table_name, if_exists: true
+        connection.insert(im, "#{self.class} Create", primary_key, key)
+      end
+
+      def update_entry(key, new_value)
+        um = Arel::UpdateManager.new(arel_table)
+        um.set [
+          [arel_table[value_key], new_value],
+          [arel_table[:updated_at], current_time]
+        ]
+
+        um.where(arel_table[primary_key].eq(key))
+
+        connection.update(um, "#{self.class} Update")
+      end
+
+      def select_entry(key)
+        sm = Arel::SelectManager.new(arel_table)
+        sm.project(Arel::Nodes::SqlLiteral.new("*"))
+        sm.where(arel_table[primary_key].eq(Arel::Nodes::BindParam.new(key)))
+        sm.order(arel_table[primary_key].asc)
+        sm.limit = 1
+
+        connection.select_all(sm, "#{self.class} Load").first
       end
-    end
   end
 end

data/lib/active_record/locking/optimistic.rb

@@ -2,14 +2,14 @@
 
 module ActiveRecord
   module Locking
-    # == What is Optimistic Locking
+    # == What is \Optimistic \Locking
     #
     # Optimistic locking allows multiple users to access the same record for edits, and assumes a minimum of
     # conflicts with the data. It does this by checking whether another process has made changes to a record since
-    # it was opened, an <tt>ActiveRecord::StaleObjectError</tt> exception is thrown if that has occurred
+    # it was opened, an ActiveRecord::StaleObjectError exception is thrown if that has occurred
     # and the update is ignored.
     #
-    # Check out <tt>ActiveRecord::Locking::Pessimistic</tt> for an alternative.
+    # Check out +ActiveRecord::Locking::Pessimistic+ for an alternative.
     #
     # == Usage
     #
@@ -69,6 +69,11 @@ module ActiveRecord
         end
       end
 
+      def initialize_dup(other) # :nodoc:
+        super
+        _clear_locking_column if locking_enabled?
+      end
+
       private
         def _create_record(attribute_names = self.attribute_names)
           if locking_enabled?
@@ -91,8 +96,7 @@ module ActiveRecord
             locking_column = self.class.locking_column
             lock_attribute_was = @attributes[locking_column]
 
-            update_constraints = _primary_key_constraints_hash
-            update_constraints[locking_column] = _lock_value_for_database(locking_column)
+            update_constraints = _query_constraints_hash
 
             attribute_names = attribute_names.dup if attribute_names.frozen?
             attribute_names << locking_column
@@ -118,16 +122,9 @@ module ActiveRecord
         end
 
         def destroy_row
-          return super unless locking_enabled?
-
-          locking_column = self.class.locking_column
+          affected_rows = super
 
-          delete_constraints = _primary_key_constraints_hash
-          delete_constraints[locking_column] = _lock_value_for_database(locking_column)
-
-          affected_rows = self.class._delete_record(delete_constraints)
-
-          if affected_rows != 1
+          if locking_enabled? && affected_rows != 1
             raise ActiveRecord::StaleObjectError.new(self, "destroy")
           end
 
@@ -142,6 +139,18 @@ module ActiveRecord
           end
         end
 
+        def _clear_locking_column
+          self[self.class.locking_column] = nil
+          clear_attribute_change(self.class.locking_column)
+        end
+
+        def _query_constraints_hash
+          return super unless locking_enabled?
+
+          locking_column = self.class.locking_column
+          super.merge(locking_column => _lock_value_for_database(locking_column))
+        end
+
         module ClassMethods
           DEFAULT_LOCKING_COLUMN = "lock_version"
 
@@ -159,10 +168,7 @@ module ActiveRecord
           end
 
           # The version column used for optimistic locking. Defaults to +lock_version+.
-          def locking_column
-            @locking_column = DEFAULT_LOCKING_COLUMN unless defined?(@locking_column)
-            @locking_column
-          end
+          attr_reader :locking_column
 
           # Reset the column used for optimistic locking back to the +lock_version+ default.
           def reset_locking_column
@@ -182,6 +188,14 @@ module ActiveRecord
             end
             super
           end
+
+          private
+            def inherited(base)
+              super
+              base.class_eval do
+                @locking_column = DEFAULT_LOCKING_COLUMN
+              end
+            end
         end
     end
 

data/lib/active_record/locking/pessimistic.rb

@@ -2,10 +2,12 @@
 
 module ActiveRecord
   module Locking
+    # = \Pessimistic \Locking
+    #
     # Locking::Pessimistic provides support for row-level locking using
     # SELECT ... FOR UPDATE and other lock types.
     #
-    # Chain <tt>ActiveRecord::Base#find</tt> to <tt>ActiveRecord::QueryMethods#lock</tt> to obtain an exclusive
+    # Chain <tt>ActiveRecord::Base#find</tt> to ActiveRecord::QueryMethods#lock to obtain an exclusive
     # lock on the selected rows:
     #   # select * from accounts where id=1 for update
     #   Account.lock.find(1)
@@ -71,6 +73,7 @@ module ActiveRecord
               Locking a record with unpersisted changes is not supported. Use
               `save` to persist the changes, or `reload` to discard them
               explicitly.
+              Changed attributes: #{changed.map(&:inspect).join(', ')}.
             MSG
           end
 
@@ -79,13 +82,13 @@ module ActiveRecord
         self
       end
 
-      # Wraps the passed block in a transaction, locking the object
-      # before yielding. You can pass the SQL locking clause
-      # as an optional argument (see <tt>#lock!</tt>).
+      # Wraps the passed block in a transaction, reloading the object with a
+      # lock before yielding. You can pass the SQL locking clause
+      # as an optional argument (see #lock!).
       #
       # You can also pass options like <tt>requires_new:</tt>, <tt>isolation:</tt>,
       # and <tt>joinable:</tt> to the wrapping transaction (see
-      # <tt>ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction</tt>).
+      # ActiveRecord::ConnectionAdapters::DatabaseStatements#transaction).
       def with_lock(*args)
         transaction_opts = args.extract_options!
         lock = args.present? ? args.first : true

data/lib/active_record/log_subscriber.rb

@@ -7,32 +7,36 @@ module ActiveRecord
     class_attribute :backtrace_cleaner, default: ActiveSupport::BacktraceCleaner.new
 
     def self.runtime=(value)
+      ActiveRecord.deprecator.warn(<<-MSG.squish)
+        ActiveRecord::LogSubscriber.runtime= is deprecated and will be removed in Rails 7.2.
+      MSG
       ActiveRecord::RuntimeRegistry.sql_runtime = value
     end
 
     def self.runtime
-      ActiveRecord::RuntimeRegistry.sql_runtime ||= 0
+      ActiveRecord.deprecator.warn(<<-MSG.squish)
+        ActiveRecord::LogSubscriber.runtime is deprecated and will be removed in Rails 7.2.
+      MSG
+      ActiveRecord::RuntimeRegistry.sql_runtime
     end
 
     def self.reset_runtime
-      rt, self.runtime = runtime, 0
-      rt
+      ActiveRecord.deprecator.warn(<<-MSG.squish)
+        ActiveRecord::LogSubscriber.reset_runtime is deprecated and will be removed in Rails 7.2.
+      MSG
+      ActiveRecord::RuntimeRegistry.reset
     end
 
     def strict_loading_violation(event)
       debug do
         owner = event.payload[:owner]
-        association = event.payload[:reflection].klass
-        name = event.payload[:reflection].name
-
-        color("Strict loading violation: #{owner} is marked for strict loading. The #{association} association named :#{name} cannot be lazily loaded.", RED)
+        reflection = event.payload[:reflection]
+        color(reflection.strict_loading_violation_message(owner), RED)
       end
     end
+    subscribe_log_level :strict_loading_violation, :debug
 
     def sql(event)
-      self.class.runtime += event.duration
-      return unless logger.debug?
-
       payload = event.payload
 
       return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
@@ -51,7 +55,14 @@ module ActiveRecord
 
         binds = []
         payload[:binds].each_with_index do |attr, i|
-          attribute_name = attr.respond_to?(:name) ? attr.name : attr[i].name
+          attribute_name = if attr.respond_to?(:name)
+            attr.name
+          elsif attr.respond_to?(:[]) && attr[i].respond_to?(:name)
+            attr[i].name
+          else
+            nil
+          end
+
           filtered_params = filter(attribute_name, casted_params[i])
 
           binds << render_bind(attr, filtered_params)
@@ -61,10 +72,11 @@ module ActiveRecord
       end
 
       name = colorize_payload_name(name, payload[:name])
-      sql  = color(sql, sql_color(sql), true) if colorize_logging
+      sql  = color(sql, sql_color(sql), bold: true) if colorize_logging
 
       debug "  #{name}  #{sql}#{binds}"
     end
+    subscribe_log_level :sql, :debug
 
     private
       def type_casted_binds(casted_binds)
@@ -88,9 +100,9 @@ module ActiveRecord
 
       def colorize_payload_name(name, payload_name)
         if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
-          color(name, MAGENTA, true)
+          color(name, MAGENTA, bold: true)
         else
-          color(name, CYAN, true)
+          color(name, CYAN, bold: true)
         end
       end
 
@@ -128,15 +140,25 @@ module ActiveRecord
       end
 
       def log_query_source
-        source = extract_query_source_location(caller)
+        source = query_source_location
 
         if source
           logger.debug("  ↳ #{source}")
         end
       end
 
-      def extract_query_source_location(locations)
-        backtrace_cleaner.clean(locations.lazy).first
+      if Thread.respond_to?(:each_caller_location)
+        def query_source_location
+          Thread.each_caller_location do |location|
+            frame = backtrace_cleaner.clean_frame(location)
+            return frame if frame
+          end
+          nil
+        end
+      else
+        def query_source_location
+          backtrace_cleaner.clean(caller(1).lazy).first
+        end
       end
 
       def filter(name, value)

data/lib/active_record/marshalling.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Marshalling
+    @format_version = 6.1
+
+    class << self
+      attr_reader :format_version
+
+      def format_version=(version)
+        case version
+        when 6.1
+          Methods.remove_method(:marshal_dump) if Methods.method_defined?(:marshal_dump)
+        when 7.1
+          Methods.alias_method(:marshal_dump, :_marshal_dump_7_1)
+        else
+          raise ArgumentError, "Unknown marshalling format: #{version.inspect}"
+        end
+        @format_version = version
+      end
+    end
+
+    module Methods
+      def _marshal_dump_7_1
+        payload = [attributes_for_database, new_record?]
+
+        cached_associations = self.class.reflect_on_all_associations.select do |reflection|
+          association_cached?(reflection.name)
+        end
+
+        unless cached_associations.empty?
+          payload << cached_associations.map do |reflection|
+            [reflection.name, association(reflection.name).target]
+          end
+        end
+
+        payload
+      end
+
+      def marshal_load(state)
+        attributes_from_database, new_record, associations = state
+
+        attributes = self.class.attributes_builder.build_from_database(attributes_from_database)
+        init_with_attributes(attributes, new_record)
+
+        if associations
+          associations.each do |name, target|
+            association(name).target = target
+          rescue ActiveRecord::AssociationNotFoundError
+            # the association no longer exist, we can just skip it.
+          end
+        end
+      end
+    end
+  end
+end