activerecord 5.2.8.1 → 6.1.7.3

data/lib/active_record/gem_version.rb

@@ -7,10 +7,10 @@ module ActiveRecord
   end
 
   module VERSION
-    MAJOR = 5
-    MINOR = 2
-    TINY  = 8
-    PRE   = "1"
+    MAJOR = 6
+    MINOR = 1
+    TINY  = 7
+    PRE   = "3"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

data/lib/active_record/inheritance.rb

@@ -38,6 +38,8 @@ module ActiveRecord
     extend ActiveSupport::Concern
 
     included do
+      class_attribute :store_full_class_name, instance_writer: false, default: true
+
       # 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
@@ -52,10 +54,14 @@ module ActiveRecord
           raise NotImplementedError, "#{self} is an abstract class and cannot be instantiated."
         end
 
-        if has_attribute?(inheritance_column)
+        if _has_attribute?(inheritance_column)
           subclass = subclass_from_attributes(attributes)
 
-          if subclass.nil? && base_class == self
+          if subclass.nil? && scope_attributes = current_scope&.scope_for_create
+            subclass = subclass_from_attributes(scope_attributes)
+          end
+
+          if subclass.nil? && base_class?
             subclass = subclass_from_attributes(column_defaults)
           end
         end
@@ -104,6 +110,12 @@ module ActiveRecord
         end
       end
 
+      # Returns whether the class is a base class.
+      # See #base_class for more information.
+      def base_class?
+        base_class == self
+      end
+
       # Set this to +true+ if this is an abstract class (see
       # <tt>abstract_class?</tt>).
       # If you are using inheritance with Active Record and don't want a class
@@ -152,12 +164,42 @@ module ActiveRecord
         defined?(@abstract_class) && @abstract_class == true
       end
 
+      # Returns the value to be stored in the inheritance column for STI.
       def sti_name
-        store_full_sti_class ? name : name.demodulize
+        store_full_sti_class && store_full_class_name ? name : name.demodulize
       end
 
+      # Returns the class for the provided +type_name+.
+      #
+      # 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)
+        else
+          compute_type(type_name)
+        end
+      rescue NameError
+        raise SubclassNotFound,
+          "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \
+          "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " \
+          "Please rename this column if you didn't intend it to be used for storing the inheritance class " \
+          "or overwrite #{name}.inheritance_column to use another column for that information."
+      end
+
+      # Returns the value to be stored in the polymorphic type column for Polymorphic Associations.
       def polymorphic_name
-        base_class.name
+        store_full_class_name ? base_class.name : base_class.name.demodulize
+      end
+
+      # Returns the class for the provided +name+.
+      #
+      # 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)
+        else
+          compute_type(name)
+        end
       end
 
       def inherited(subclass)
@@ -166,11 +208,10 @@ module ActiveRecord
       end
 
       protected
-
         # Returns the class type of the record using the current module as a prefix. So descendants of
         # MyApp::Business::Account would appear as MyApp::Business::AccountSubclass.
         def compute_type(type_name)
-          if type_name.start_with?("::".freeze)
+          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)
@@ -198,7 +239,6 @@ module ActiveRecord
         end
 
       private
-
         # 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.
@@ -211,35 +251,25 @@ module ActiveRecord
         end
 
         def using_single_table_inheritance?(record)
-          record[inheritance_column].present? && has_attribute?(inheritance_column)
+          record[inheritance_column].present? && _has_attribute?(inheritance_column)
         end
 
         def find_sti_class(type_name)
           type_name = base_class.type_for_attribute(inheritance_column).cast(type_name)
-          subclass = begin
-            if store_full_sti_class
-              ActiveSupport::Dependencies.constantize(type_name)
-            else
-              compute_type(type_name)
-            end
-          rescue NameError
-            raise SubclassNotFound,
-              "The single-table inheritance mechanism failed to locate the subclass: '#{type_name}'. " \
-              "This error is raised because the column '#{inheritance_column}' is reserved for storing the class in case of inheritance. " \
-              "Please rename this column if you didn't intend it to be used for storing the inheritance class " \
-              "or overwrite #{name}.inheritance_column to use another column for that information."
-          end
+          subclass = sti_class_for(type_name)
+
           unless subclass == self || descendants.include?(subclass)
             raise SubclassNotFound, "Invalid single-table inheritance type: #{subclass.name} is not a subclass of #{name}"
           end
+
           subclass
         end
 
         def type_condition(table = arel_table)
-          sti_column = arel_attribute(inheritance_column, table)
+          sti_column = table[inheritance_column]
           sti_names  = ([self] + descendants).map(&:sti_name)
 
-          sti_column.in(sti_names)
+          predicate_builder.build(sti_column, sti_names)
         end
 
         # Detect the subclass from the inheritance column of attrs. If the inheritance column value
@@ -262,7 +292,6 @@ module ActiveRecord
     end
 
     private
-
       def initialize_internals_callback
         super
         ensure_proper_type

data/lib/active_record/insert_all.rb

@@ -0,0 +1,212 @@
+# frozen_string_literal: true
+
+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
+
+      if model.scope_attributes?
+        @scope_attributes = model.scope_attributes
+        @keys |= @scope_attributes.keys
+      end
+      @keys = @keys.to_set
+
+      @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?
+
+      ensure_valid_options_for_connection!
+    end
+
+    def execute
+      message = +"#{model} "
+      message << "Bulk " if inserts.many?
+      message << (on_duplicate == :update ? "Upsert" : "Insert")
+      connection.exec_insert_all to_sql, message
+    end
+
+    def updatable_columns
+      keys - readonly_columns - unique_by_columns
+    end
+
+    def primary_keys
+      Array(connection.schema_cache.primary_keys(model.table_name))
+    end
+
+
+    def skip_duplicates?
+      on_duplicate == :skip
+    end
+
+    def update_duplicates?
+      on_duplicate == :update
+    end
+
+    def map_key_with_value
+      inserts.map do |attributes|
+        attributes = attributes.stringify_keys
+        attributes.merge!(scope_attributes) if scope_attributes
+
+        verify_attributes(attributes)
+
+        keys.map do |key|
+          yield key, attributes[key]
+        end
+      end
+    end
+
+    private
+      attr_reader :scope_attributes
+
+      def find_unique_index_for(unique_by)
+        if !connection.supports_insert_conflict_target?
+          return if unique_by.nil?
+
+          raise ArgumentError, "#{connection.class} does not support :unique_by"
+        end
+
+        name_or_columns = unique_by || model.primary_key
+        match = Array(name_or_columns).map(&:to_s)
+
+        if index = unique_indexes.find { |i| match.include?(i.name) || i.columns == match }
+          index
+        elsif match == primary_keys
+          unique_by.nil? ? nil : ActiveRecord::ConnectionAdapters::IndexDefinition.new(model.table_name, "#{model.table_name}_primary_key", true, match)
+        else
+          raise ArgumentError, "No unique index found for #{name_or_columns}"
+        end
+      end
+
+      def unique_indexes
+        connection.schema_cache.indexes(model.table_name).select(&:unique)
+      end
+
+
+      def ensure_valid_options_for_connection!
+        if returning && !connection.supports_insert_returning?
+          raise ArgumentError, "#{connection.class} does not support :returning"
+        end
+
+        if skip_duplicates? && !connection.supports_insert_on_duplicate_skip?
+          raise ArgumentError, "#{connection.class} does not support skipping duplicates"
+        end
+
+        if update_duplicates? && !connection.supports_insert_on_duplicate_update?
+          raise ArgumentError, "#{connection.class} does not support upsert"
+        end
+
+        if unique_by && !connection.supports_insert_conflict_target?
+          raise ArgumentError, "#{connection.class} does not support :unique_by"
+        end
+      end
+
+
+      def to_sql
+        connection.build_insert_sql(ActiveRecord::InsertAll::Builder.new(self))
+      end
+
+
+      def readonly_columns
+        primary_keys + model.readonly_attributes.to_a
+      end
+
+      def unique_by_columns
+        Array(unique_by&.columns)
+      end
+
+
+      def verify_attributes(attributes)
+        if keys != attributes.keys.to_set
+          raise ArgumentError, "All objects being inserted must have the same keys"
+        end
+      end
+
+      class Builder # :nodoc:
+        attr_reader :model
+
+        delegate :skip_duplicates?, :update_duplicates?, :keys, to: :insert_all
+
+        def initialize(insert_all)
+          @insert_all, @model, @connection = insert_all, insert_all.model, insert_all.connection
+        end
+
+        def into
+          "INTO #{model.quoted_table_name} (#{columns_list})"
+        end
+
+        def values_list
+          types = extract_types_from_columns_on(model.table_name, keys: keys)
+
+          values_list = insert_all.map_key_with_value do |key, value|
+            connection.with_yaml_fallback(types[key].serialize(value))
+          end
+
+          connection.visitor.compile(Arel::Nodes::ValuesList.new(values_list))
+        end
+
+        def returning
+          format_columns(insert_all.returning) if insert_all.returning
+        end
+
+        def conflict_target
+          if index = insert_all.unique_by
+            sql = +"(#{format_columns(index.columns)})"
+            sql << " WHERE #{index.where}" if index.where
+            sql
+          elsif update_duplicates?
+            "(#{format_columns(insert_all.primary_keys)})"
+          end
+        end
+
+        def updatable_columns
+          quote_columns(insert_all.updatable_columns)
+        end
+
+        def touch_model_timestamps_unless(&block)
+          model.send(:timestamp_attributes_for_update_in_model).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),"
+            end
+          end.compact.join
+        end
+
+        private
+          attr_reader :connection, :insert_all
+
+          def touch_timestamp_attribute?(column_name)
+            update_duplicates? && !insert_all.updatable_columns.include?(column_name)
+          end
+
+          def columns_list
+            format_columns(insert_all.keys)
+          end
+
+          def extract_types_from_columns_on(table_name, keys:)
+            columns = connection.schema_cache.columns_hash(table_name)
+
+            unknown_column = (keys - columns.keys).first
+            raise UnknownAttributeError.new(model.new, unknown_column) if unknown_column
+
+            keys.index_with { |key| model.type_for_attribute(key) }
+          end
+
+          def format_columns(columns)
+            columns.respond_to?(:map) ? quote_columns(columns).join(",") : columns
+          end
+
+          def quote_columns(columns)
+            columns.map(&connection.method(:quote_column_name))
+          end
+      end
+  end
+end

data/lib/active_record/integration.rb

@@ -20,8 +20,16 @@ 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 +false+, by default until Rails 6.0.
+      # This is +true+, by default on Rails 5.2 and above.
       class_attribute :cache_versioning, instance_writer: false, default: false
+
+      ##
+      # :singleton-method:
+      # 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.
+      class_attribute :collection_cache_versioning, instance_writer: false, default: false
     end
 
     # Returns a +String+, which Action Pack uses for constructing a URL to this
@@ -60,24 +68,15 @@ module ActiveRecord
     # the cache key will also include a version.
     #
     #   Product.cache_versioning = false
-    #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
-    def cache_key(*timestamp_names)
+    #   Product.find(5).cache_key  # => "products/5-20071224150000" (updated_at available)
+    def cache_key
       if new_record?
         "#{model_name.cache_key}/new"
       else
-        if cache_version && timestamp_names.none?
+        if cache_version
           "#{model_name.cache_key}/#{id}"
         else
-          timestamp = if timestamp_names.any?
-            ActiveSupport::Deprecation.warn(<<-MSG.squish)
-              Specifying a timestamp name for #cache_key has been deprecated in favor of
-              the explicit #cache_version method that can be overwritten.
-            MSG
-
-            max_updated_column_timestamp(timestamp_names)
-          else
-            max_updated_column_timestamp
-          end
+          timestamp = max_updated_column_timestamp
 
           if timestamp
             timestamp = timestamp.utc.to_s(cache_timestamp_format)
@@ -94,10 +93,19 @@ module ActiveRecord
     # cache_version, but this method can be overwritten to return something else.
     #
     # Note, this method will return nil if ActiveRecord::Base.cache_versioning is set to
-    # +false+ (which it is by default until Rails 6.0).
+    # +false+.
     def cache_version
-      if cache_versioning && timestamp = try(:updated_at)
-        timestamp.utc.to_s(:usec)
+      return unless cache_versioning
+
+      if has_attribute?("updated_at")
+        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)
+        end
+      elsif self.class.has_attribute?("updated_at")
+        raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"
       end
     end
 
@@ -150,6 +158,48 @@ module ActiveRecord
           end
         end
       end
+
+      def collection_cache_key(collection = all, timestamp_column = :updated_at) # :nodoc:
+        collection.send(:compute_cache_key, timestamp_column)
+      end
     end
+
+    private
+      # Detects if the value before type cast
+      # can be used to generate a cache_version.
+      #
+      # The fast cache version only works with a
+      # string value directly from the database.
+      #
+      # We also must check if the timestamp format has been changed
+      # or if the timezone is not set to UTC then
+      # we cannot apply our transformations correctly.
+      def can_use_fast_cache_version?(timestamp)
+        timestamp.is_a?(String) &&
+          cache_timestamp_format == :usec &&
+          default_timezone == :utc &&
+          !updated_at_came_from_user?
+      end
+
+      # Converts a raw database string to `:usec`
+      # format.
+      #
+      # Example:
+      #
+      #   timestamp = "2018-10-15 20:02:15.266505"
+      #   raw_timestamp_to_cache_version(timestamp)
+      #   # => "20181015200215266505"
+      #
+      # PostgreSQL truncates trailing zeros,
+      # https://github.com/postgres/postgres/commit/3e1beda2cde3495f41290e1ece5d544525810214
+      # to account for this we pad the output with zeros
+      def raw_timestamp_to_cache_version(timestamp)
+        key = timestamp.delete("- :.")
+        if key.length < 20
+          key.ljust(20, "0")
+        else
+          key
+        end
+      end
   end
 end

data/lib/active_record/internal_metadata.rb

@@ -6,40 +6,59 @@ require "active_record/scoping/named"
 module ActiveRecord
   # This class is used to create a table that keeps track of values and keys such
   # as which environment migrations were run in.
+  #
+  # 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 << self
+      def enabled?
+        ActiveRecord::Base.connection.use_metadata_table?
+      end
+
+      def _internal?
+        true
+      end
+
       def primary_key
         "key"
       end
 
       def table_name
-        "#{table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{table_name_suffix}"
+        "#{table_name_prefix}#{internal_metadata_table_name}#{table_name_suffix}"
       end
 
       def []=(key, value)
-        find_or_initialize_by(key: key).update_attributes!(value: value)
+        return unless enabled?
+
+        find_or_initialize_by(key: key).update!(value: value)
       end
 
       def [](key)
-        where(key: key).pluck(:value).first
-      end
+        return unless enabled?
 
-      def table_exists?
-        connection.table_exists?(table_name)
+        where(key: key).pluck(:value).first
       end
 
       # Creates an internal metadata table with columns +key+ and +value+
       def create_table
-        unless table_exists?
-          key_options = connection.internal_string_options_for_primary_key
+        return unless enabled?
 
+        unless connection.table_exists?(table_name)
           connection.create_table(table_name, id: false) do |t|
-            t.string :key, key_options
+            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
     end
   end
 end

data/lib/active_record/legacy_yaml_adapter.rb

@@ -1,13 +1,17 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  module LegacyYamlAdapter
+  module LegacyYamlAdapter # :nodoc:
     def self.convert(klass, coder)
       return coder unless coder.is_a?(Psych::Coder)
 
       case coder["active_record_yaml_version"]
       when 1, 2 then coder
       else
+        ActiveSupport::Deprecation.warn(<<-MSG.squish)
+          YAML loading from legacy format older than Rails 5.0 is deprecated
+          and will be removed in Rails 7.0.
+        MSG
         if coder["attributes"].is_a?(ActiveModel::AttributeSet)
           Rails420.convert(klass, coder)
         else
@@ -16,7 +20,7 @@ module ActiveRecord
       end
     end
 
-    module Rails420
+    module Rails420 # :nodoc:
       def self.convert(klass, coder)
         attribute_set = coder["attributes"]
 
@@ -32,7 +36,7 @@ module ActiveRecord
       end
     end
 
-    module Rails41
+    module Rails41 # :nodoc:
       def self.convert(klass, coder)
         attributes = klass.attributes_builder
           .build_from_database(coder["attributes"])