activerecord 6.0.0 → 7.2.3

data/lib/active_record/insert_all.rb

@@ -1,41 +1,67 @@
 # 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
+    attr_reader :on_duplicate, :update_only, :returning, :unique_by, :update_sql
 
-    def initialize(model, inserts, on_duplicate:, returning: nil, unique_by: nil)
-      raise ArgumentError, "Empty list of attributes passed" if inserts.blank?
+    class << self
+      def execute(relation, ...)
+        relation.model.with_connection do |c|
+          new(relation, c, ...).execute
+        end
+      end
+    end
 
-      @model, @connection, @inserts, @keys = model, model.connection, inserts, inserts.first.keys.map(&:to_s).to_set
-      @on_duplicate, @returning, @unique_by = on_duplicate, returning, unique_by
+    def initialize(relation, connection, inserts, on_duplicate:, update_only: nil, returning: nil, unique_by: nil, record_timestamps: nil)
+      @relation = relation
+      @model, @connection, @inserts = relation.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
+
+      @scope_attributes = relation.scope_for_create.except(@model.inheritance_column)
+      @keys |= @scope_attributes.keys
+      @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) if 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")
-      connection.exec_query to_sql, message
+      connection.exec_insert_all to_sql, message
     end
 
     def updatable_columns
-      keys - readonly_columns - unique_by_columns
+      @updatable_columns ||= keys - readonly_columns - unique_by_columns
     end
 
     def primary_keys
-      Array(model.primary_key)
+      Array(@model.schema_cache.primary_keys(model.table_name))
     end
 
-
     def skip_duplicates?
       on_duplicate == :skip
     end
@@ -47,30 +73,103 @@ module ActiveRecord
     def map_key_with_value
       inserts.map do |attributes|
         attributes = attributes.stringify_keys
+        attributes.merge!(@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
+      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)
-        match = Array(unique_by).map(&:to_s)
+        if !connection.supports_insert_conflict_target?
+          return if unique_by.nil?
+
+          raise ArgumentError, "#{connection.class} does not support :unique_by"
+        end
 
-        if index = unique_indexes.find { |i| match.include?(i.name) || i.columns == match }
+        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) || 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)
         else
-          raise ArgumentError, "No unique index found for #{unique_by}"
+          raise ArgumentError, "No unique index found for #{name_or_columns}"
         end
       end
 
       def unique_indexes
-        connection.schema_cache.indexes(model.table_name).select(&:unique)
+        @model.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"
@@ -96,7 +195,7 @@ module ActiveRecord
 
 
       def readonly_columns
-        primary_keys + model.readonly_attributes.to_a
+        primary_keys + model.readonly_attributes
       end
 
       def unique_by_columns
@@ -105,36 +204,62 @@ 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
         end
 
         def into
-          "INTO #{model.quoted_table_name}(#{columns_list})"
+          "INTO #{model.quoted_table_name} (#{columns_list})"
         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
 
-          Arel::InsertManager.new.create_values_list(values_list).to_sql
+          connection.visitor.compile(Arel::Nodes::ValuesList.new(values_list))
         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
@@ -151,28 +276,52 @@ module ActiveRecord
           quote_columns(insert_all.updatable_columns)
         end
 
+        def touch_model_timestamps_unless(&block)
+          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 #{connection.high_precision_current_timestamp} END),"
+            end
+          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)
+            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:)
-            columns = connection.schema_cache.columns_hash(table_name)
+            columns = @model.schema_cache.columns_hash(table_name)
 
             unknown_column = (keys - columns.keys).first
             raise UnknownAttributeError.new(model.new, unknown_column) if unknown_column
 
-            keys.map { |key| [ key, connection.lookup_cast_type_from_column(columns[key]) ] }.to_h
+            keys.index_with { |key| model.type_for_attribute(key) }
           end
 
           def format_columns(columns)
-            quote_columns(columns).join(",")
+            columns.respond_to?(:map) ? quote_columns(columns).join(",") : columns
           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}"
@@ -93,7 +93,7 @@ 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
       return unless cache_versioning
 
@@ -101,13 +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)
-        end
-      else
-        if self.class.has_attribute?("updated_at")
-          raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"
+          timestamp.utc.to_fs(cache_timestamp_format)
         end
+      elsif self.class.has_attribute?("updated_at")
+        raise ActiveModel::MissingAttributeError, "missing attribute 'updated_at' for #{self.class}"
       end
     end
 
@@ -179,7 +178,10 @@ module ActiveRecord
       def can_use_fast_cache_version?(timestamp)
         timestamp.is_a?(String) &&
           cache_timestamp_format == :usec &&
-          default_timezone == :utc &&
+          # FIXME: checking out a connection for this is wasteful
+          # we should store/cache this information in the schema cache
+          # or similar.
+          self.class.with_connection(&:default_timezone) == :utc &&
           !updated_at_came_from_user?
       end
 

data/lib/active_record/internal_metadata.rb

@@ -6,48 +6,159 @@ 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.
-  class InternalMetadata < ActiveRecord::Base # :nodoc:
-    class << self
-      def _internal?
-        true
-      end
+  #
+  # This is enabled by default. To disable this functionality set
+  # `use_metadata_table` to false in your database configuration.
+  class InternalMetadata # :nodoc:
+    class NullInternalMetadata # :nodoc:
+    end
+
+    attr_reader :arel_table
+
+    def initialize(pool)
+      @pool = pool
+      @arel_table = Arel::Table.new(table_name)
+    end
+
+    def primary_key
+      "key"
+    end
+
+    def value_key
+      "value"
+    end
 
-      def primary_key
-        "key"
+    def table_name
+      "#{ActiveRecord::Base.table_name_prefix}#{ActiveRecord::Base.internal_metadata_table_name}#{ActiveRecord::Base.table_name_suffix}"
+    end
+
+    def enabled?
+      @pool.db_config.use_metadata_table?
+    end
+
+    def []=(key, value)
+      return unless enabled?
+
+      @pool.with_connection do |connection|
+        update_or_create_entry(connection, key, value)
       end
+    end
 
-      def table_name
-        "#{table_name_prefix}#{internal_metadata_table_name}#{table_name_suffix}"
+    def [](key)
+      return unless enabled?
+
+      @pool.with_connection do |connection|
+        if entry = select_entry(connection, key)
+          entry[value_key]
+        end
       end
+    end
 
-      def []=(key, value)
-        find_or_initialize_by(key: key).update!(value: value)
+    def delete_all_entries
+      dm = Arel::DeleteManager.new(arel_table)
+
+      @pool.with_connection do |connection|
+        connection.delete(dm, "#{self.class} Destroy")
       end
+    end
+
+    def count
+      sm = Arel::SelectManager.new(arel_table)
+      sm.project(*Arel::Nodes::Count.new([Arel.star]))
 
-      def [](key)
-        where(key: key).pluck(:value).first
+      @pool.with_connection do |connection|
+        connection.select_values(sm, "#{self.class} Count").first
       end
+    end
+
+    def create_table_and_set_flags(environment, schema_sha1 = nil)
+      return unless enabled?
 
-      def table_exists?
-        connection.table_exists?(table_name)
+      @pool.with_connection do |connection|
+        create_table
+        update_or_create_entry(connection, :environment, environment)
+        update_or_create_entry(connection, :schema_sha1, schema_sha1) if schema_sha1
       end
+    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
+    # Creates an internal metadata table with columns +key+ and +value+
+    def create_table
+      return unless enabled?
 
+      @pool.with_connection do |connection|
+        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
+    end
+
+    def drop_table
+      return unless enabled?
 
-      def drop_table
+      @pool.with_connection do |connection|
         connection.drop_table table_name, if_exists: true
       end
     end
+
+    def table_exists?
+      @pool.schema_cache.data_source_exists?(table_name)
+    end
+
+    private
+      def update_or_create_entry(connection, key, value)
+        entry = select_entry(connection, key)
+
+        if entry
+          if entry[value_key] != value
+            update_entry(connection, key, value)
+          else
+            entry[value_key]
+          end
+        else
+          create_entry(connection, key, value)
+        end
+      end
+
+      def current_time(connection)
+        connection.default_timezone == :utc ? Time.now.utc : Time.now
+      end
+
+      def create_entry(connection, 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(connection)],
+          [arel_table[:updated_at], current_time(connection)]
+        ]
+
+        connection.insert(im, "#{self.class} Create", primary_key, key)
+      end
+
+      def update_entry(connection, key, new_value)
+        um = Arel::UpdateManager.new(arel_table)
+        um.set [
+          [arel_table[value_key], new_value],
+          [arel_table[:updated_at], current_time(connection)]
+        ]
+
+        um.where(arel_table[primary_key].eq(key))
+
+        connection.update(um, "#{self.class} Update")
+      end
+
+      def select_entry(connection, key)
+        sm = Arel::SelectManager.new(arel_table)
+        sm.project(Arel::Nodes::SqlLiteral.new("*", retryable: true))
+        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

data/lib/active_record/legacy_yaml_adapter.rb

@@ -1,47 +1,14 @@
 # frozen_string_literal: true
 
 module ActiveRecord
-  module LegacyYamlAdapter
-    def self.convert(klass, coder)
+  module LegacyYamlAdapter # :nodoc:
+    def self.convert(coder)
       return coder unless coder.is_a?(Psych::Coder)
 
       case coder["active_record_yaml_version"]
       when 1, 2 then coder
       else
-        if coder["attributes"].is_a?(ActiveModel::AttributeSet)
-          Rails420.convert(klass, coder)
-        else
-          Rails41.convert(klass, coder)
-        end
-      end
-    end
-
-    module Rails420
-      def self.convert(klass, coder)
-        attribute_set = coder["attributes"]
-
-        klass.attribute_names.each do |attr_name|
-          attribute = attribute_set[attr_name]
-          if attribute.type.is_a?(Delegator)
-            type_from_klass = klass.type_for_attribute(attr_name)
-            attribute_set[attr_name] = attribute.with_type(type_from_klass)
-          end
-        end
-
-        coder
-      end
-    end
-
-    module Rails41
-      def self.convert(klass, coder)
-        attributes = klass.attributes_builder
-          .build_from_database(coder["attributes"])
-        new_record = coder["attributes"][klass.primary_key].blank?
-
-        {
-          "attributes" => attributes,
-          "new_record" => new_record,
-        }
+        raise("Active Record doesn't know how to load YAML with this format.")
       end
     end
   end