activerecord 6.1.6 → 7.1.2

data/lib/active_record/inheritance.rb

@@ -1,9 +1,10 @@
 # frozen_string_literal: true
 
+require "active_support/inflector"
 require "active_support/core_ext/hash/indifferent_access"
 
 module ActiveRecord
-  # == Single table inheritance
+  # = Single table inheritance
   #
   # Active Record allows inheritance by storing the name of the class in a column that by
   # default is named "type" (can be changed by overwriting <tt>Base.inheritance_column</tt>).
@@ -31,8 +32,9 @@ module ActiveRecord
   # be triggered. In that case, it'll work just like normal subclasses with no special magic
   # for differentiating between them or reloading the right type with find.
   #
-  # Note, all the attributes for all the cases are kept in the same table. Read more:
-  # https://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
+  # Note, all the attributes for all the cases are kept in the same table.
+  # Read more:
+  # * https://www.martinfowler.com/eaaCatalog/singleTableInheritance.html
   #
   module Inheritance
     extend ActiveSupport::Concern
@@ -43,6 +45,8 @@ module ActiveRecord
       # Determines whether to store the full constant name including namespace when using STI.
       # This is true, by default.
       class_attribute :store_full_sti_class, instance_writer: false, default: true
+
+      set_base_class
     end
 
     module ClassMethods
@@ -85,30 +89,30 @@ module ActiveRecord
         end
       end
 
-      def finder_needs_type_condition? #:nodoc:
+      def finder_needs_type_condition? # :nodoc:
         # This is like this because benchmarking justifies the strange :false stuff
         :true == (@finder_needs_type_condition ||= descends_from_active_record? ? :false : :true)
       end
 
-      # Returns the class descending directly from ActiveRecord::Base, or
-      # an abstract class, if any, in the inheritance hierarchy.
+      # Returns the first class in the inheritance hierarchy that descends from either an
+      # abstract class or from <tt>ActiveRecord::Base</tt>.
       #
-      # If A extends ActiveRecord::Base, A.base_class will return A. If B descends from A
-      # through some arbitrarily deep hierarchy, B.base_class will return A.
+      # Consider the following behaviour:
       #
-      # If B < A and C < B and if A is an abstract_class then both B.base_class
-      # and C.base_class would return B as the answer since A is an abstract_class.
-      def base_class
-        unless self < Base
-          raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
-        end
-
-        if superclass == Base || superclass.abstract_class?
-          self
-        else
-          superclass.base_class
-        end
-      end
+      #   class ApplicationRecord < ActiveRecord::Base
+      #     self.abstract_class = true
+      #   end
+      #   class Shape < ApplicationRecord
+      #     self.abstract_class = true
+      #   end
+      #   Polygon = Class.new(Shape)
+      #   Square = Class.new(Polygon)
+      #
+      #   ApplicationRecord.base_class # => ApplicationRecord
+      #   Shape.base_class # => Shape
+      #   Polygon.base_class # => Polygon
+      #   Square.base_class # => Polygon
+      attr_reader :base_class
 
       # Returns whether the class is a base class.
       # See #base_class for more information.
@@ -123,7 +127,7 @@ module ActiveRecord
       # true.
       # +ApplicationRecord+, for example, is generated as an abstract class.
       #
-      # Consider the following default behaviour:
+      # Consider the following default behavior:
       #
       #   Shape = Class.new(ActiveRecord::Base)
       #   Polygon = Class.new(Shape)
@@ -164,6 +168,21 @@ module ActiveRecord
         defined?(@abstract_class) && @abstract_class == true
       end
 
+      # Sets the application record class for Active Record
+      #
+      # This is useful if your application uses a different class than
+      # ApplicationRecord for your primary abstract class. This class
+      # will share a database connection with Active Record. It is the class
+      # that connects to your primary database.
+      def primary_abstract_class
+        if ActiveRecord.application_record_class && ActiveRecord.application_record_class.name != name
+          raise ArgumentError, "The `primary_abstract_class` is already set to #{ActiveRecord.application_record_class.inspect}. There can only be one `primary_abstract_class` in an application."
+        end
+
+        self.abstract_class = true
+        ActiveRecord.application_record_class = self
+      end
+
       # Returns the value to be stored in the inheritance column for STI.
       def sti_name
         store_full_sti_class && store_full_class_name ? name : name.demodulize
@@ -174,7 +193,7 @@ module ActiveRecord
       # It is used to find the class correspondent to the value stored in the inheritance column.
       def sti_class_for(type_name)
         if store_full_sti_class && store_full_class_name
-          ActiveSupport::Dependencies.constantize(type_name)
+          type_name.constantize
         else
           compute_type(type_name)
         end
@@ -196,15 +215,23 @@ module ActiveRecord
       # It is used to find the class correspondent to the value stored in the polymorphic type column.
       def polymorphic_class_for(name)
         if store_full_class_name
-          ActiveSupport::Dependencies.constantize(name)
+          name.constantize
         else
           compute_type(name)
         end
       end
 
-      def inherited(subclass)
-        subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
+      def dup # :nodoc:
+        # `initialize_dup` / `initialize_copy` don't work when defined
+        # in the `singleton_class`.
+        other = super
+        other.set_base_class
+        other
+      end
+
+      def initialize_clone(other) # :nodoc:
         super
+        set_base_class
       end
 
       protected
@@ -214,10 +241,10 @@ module ActiveRecord
           if type_name.start_with?("::")
             # If the type is prefixed with a scope operator then we assume that
             # the type_name is an absolute reference.
-            ActiveSupport::Dependencies.constantize(type_name)
+            type_name.constantize
           else
             type_candidate = @_type_candidates_cache[type_name]
-            if type_candidate && type_constant = ActiveSupport::Dependencies.safe_constantize(type_candidate)
+            if type_candidate && type_constant = type_candidate.safe_constantize
               return type_constant
             end
 
@@ -227,7 +254,7 @@ module ActiveRecord
             candidates << type_name
 
             candidates.each do |candidate|
-              constant = ActiveSupport::Dependencies.safe_constantize(candidate)
+              constant = candidate.safe_constantize
               if candidate == constant.to_s
                 @_type_candidates_cache[type_name] = candidate
                 return constant
@@ -238,7 +265,32 @@ module ActiveRecord
           end
         end
 
+        def set_base_class # :nodoc:
+          @base_class = if self == Base
+            self
+          else
+            unless self < Base
+              raise ActiveRecordError, "#{name} doesn't belong in a hierarchy descending from ActiveRecord"
+            end
+
+            if superclass == Base || superclass.abstract_class?
+              self
+            else
+              superclass.base_class
+            end
+          end
+        end
+
       private
+        def inherited(subclass)
+          super
+          subclass.set_base_class
+          subclass.instance_variable_set(:@_type_candidates_cache, Concurrent::Map.new)
+          subclass.class_eval do
+            @finder_needs_type_condition = nil
+          end
+        end
+
         # Called by +instantiate+ to decide which class to use for a new
         # record instance. For single-table inheritance, we check the record
         # for a +type+ column and return the corresponding class.

data/lib/active_record/insert_all.rb

@@ -5,13 +5,23 @@ require "active_support/core_ext/enumerable"
 module ActiveRecord
   class InsertAll # :nodoc:
     attr_reader :model, :connection, :inserts, :keys
-    attr_reader :on_duplicate, :returning, :unique_by
-
-    def initialize(model, inserts, on_duplicate:, returning: nil, unique_by: 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)
-      @on_duplicate, @returning, @unique_by = on_duplicate, returning, unique_by
+    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)
+      @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
 
       if model.scope_attributes?
         @scope_attributes = model.scope_attributes
@@ -22,13 +32,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)
-      @on_duplicate = :skip if @on_duplicate == :update && updatable_columns.empty?
+      @unique_by = find_unique_index_for(@unique_by)
 
+      configure_on_duplicate_update_logic
       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")
@@ -36,7 +48,7 @@ module ActiveRecord
     end
 
     def updatable_columns
-      keys - readonly_columns - unique_by_columns
+      @updatable_columns ||= keys - readonly_columns - unique_by_columns
     end
 
     def primary_keys
@@ -56,18 +68,80 @@ module ActiveRecord
       inserts.map do |attributes|
         attributes = attributes.stringify_keys
         attributes.merge!(scope_attributes) if scope_attributes
+        attributes.reverse_merge!(timestamps_for_create) if record_timestamps?
 
         verify_attributes(attributes)
 
-        keys.map do |key|
+        keys_including_timestamps.map do |key|
           yield key, attributes[key]
         end
       end
     end
 
+    def record_timestamps?
+      @record_timestamps
+    end
+
+    # 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
+      else
+        keys
+      end
+    end
+
     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"
+        end
+
+        if update_only.present?
+          @updatable_columns = Array(update_only)
+          @on_duplicate = :update
+        elsif custom_update_sql_provided?
+          @update_sql = on_duplicate
+          @on_duplicate = :update
+        elsif @on_duplicate == :update && updatable_columns.empty?
+          @on_duplicate = :skip
+        end
+      end
+
+      def custom_update_sql_provided?
+        @custom_update_sql_provided ||= Arel.arel_node?(on_duplicate)
+      end
+
       def find_unique_index_for(unique_by)
         if !connection.supports_insert_conflict_target?
           return if unique_by.nil?
@@ -77,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)
@@ -126,15 +201,28 @@ module ActiveRecord
 
 
       def verify_attributes(attributes)
-        if keys != attributes.keys.to_set
+        if keys_including_timestamps != attributes.keys.to_set
           raise ArgumentError, "All objects being inserted must have the same keys"
         end
       end
 
+      def disallow_raw_sql!(value)
+        return if !value.is_a?(String) || Arel.arel_node?(value)
+
+        raise ArgumentError, "Dangerous query method (method whose arguments are used as raw " \
+                             "SQL) called: #{value}. " \
+                             "Known-safe values can be passed " \
+                             "by wrapping them in Arel.sql()."
+      end
+
+      def timestamps_for_create
+        model.all_timestamp_attributes_in_model.index_with(connection.high_precision_current_timestamp)
+      end
+
       class Builder # :nodoc:
         attr_reader :model
 
-        delegate :skip_duplicates?, :update_duplicates?, :keys, to: :insert_all
+        delegate :skip_duplicates?, :update_duplicates?, :keys, :keys_including_timestamps, :record_timestamps?, to: :insert_all
 
         def initialize(insert_all)
           @insert_all, @model, @connection = insert_all, insert_all.model, insert_all.connection
@@ -145,9 +233,10 @@ module ActiveRecord
         end
 
         def values_list
-          types = extract_types_from_columns_on(model.table_name, keys: keys)
+          types = extract_types_from_columns_on(model.table_name, keys: keys_including_timestamps)
 
           values_list = insert_all.map_key_with_value do |key, value|
+            next value if Arel::Nodes::SqlLiteral === value
             connection.with_yaml_fallback(types[key].serialize(value))
           end
 
@@ -155,7 +244,19 @@ module ActiveRecord
         end
 
         def returning
-          format_columns(insert_all.returning) if insert_all.returning
+          return unless insert_all.returning
+
+          if insert_all.returning.is_a?(String)
+            insert_all.returning
+          else
+            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
 
         def conflict_target
@@ -173,22 +274,30 @@ module ActiveRecord
         end
 
         def touch_model_timestamps_unless(&block)
-          model.send(:timestamp_attributes_for_update_in_model).map do |column_name|
+          return "" unless update_duplicates? && record_timestamps?
+
+          model.timestamp_attributes_for_update_in_model.filter_map do |column_name|
             if touch_timestamp_attribute?(column_name)
-              "#{column_name}=(CASE WHEN (#{updatable_columns.map(&block).join(" AND ")}) THEN #{model.quoted_table_name}.#{column_name} ELSE CURRENT_TIMESTAMP END),"
+              "#{column_name}=(CASE WHEN (#{updatable_columns.map(&block).join(" AND ")}) THEN #{model.quoted_table_name}.#{column_name} ELSE #{connection.high_precision_current_timestamp} END),"
             end
-          end.compact.join
+          end.join
         end
 
+        def raw_update_sql
+          insert_all.update_sql
+        end
+
+        alias raw_update_sql? raw_update_sql
+
         private
           attr_reader :connection, :insert_all
 
           def touch_timestamp_attribute?(column_name)
-            update_duplicates? && !insert_all.updatable_columns.include?(column_name)
+            insert_all.updatable_columns.exclude?(column_name)
           end
 
           def columns_list
-            format_columns(insert_all.keys)
+            format_columns(insert_all.keys_including_timestamps)
           end
 
           def extract_types_from_columns_on(table_name, keys:)
@@ -205,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_s(cache_timestamp_format)
+            timestamp = timestamp.utc.to_fs(cache_timestamp_format)
             "#{model_name.cache_key}/#{id}-#{timestamp}"
           else
             "#{model_name.cache_key}/#{id}"
@@ -101,11 +101,12 @@ module ActiveRecord
         timestamp = updated_at_before_type_cast
         if can_use_fast_cache_version?(timestamp)
           raw_timestamp_to_cache_version(timestamp)
+
         elsif timestamp = updated_at
-          timestamp.utc.to_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
 
@@ -177,7 +178,7 @@ module ActiveRecord
       def can_use_fast_cache_version?(timestamp)
         timestamp.is_a?(String) &&
           cache_timestamp_format == :usec &&
-          default_timezone == :utc &&
+          self.class.connection.default_timezone == :utc &&
           !updated_at_came_from_user?
       end