activerecord 6.0.4.8 → 6.1.0.rc1

data/lib/active_record/insert_all.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_support/core_ext/enumerable"
+
 module ActiveRecord
   class InsertAll # :nodoc:
     attr_reader :model, :connection, :inserts, :keys
@@ -8,13 +10,19 @@ module ActiveRecord
     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).to_set
+      @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) if 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!
@@ -32,7 +40,7 @@ module ActiveRecord
     end
 
     def primary_keys
-      Array(model.primary_key)
+      Array(connection.schema_cache.primary_keys(model.table_name))
     end
 
 
@@ -47,6 +55,8 @@ module ActiveRecord
     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|
@@ -56,13 +66,18 @@ module ActiveRecord
     end
 
     private
+      attr_reader :scope_attributes
+
       def find_unique_index_for(unique_by)
-        match = Array(unique_by).map(&:to_s)
+        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 #{unique_by}"
+          raise ArgumentError, "No unique index found for #{name_or_columns}"
         end
       end
 
@@ -151,9 +166,21 @@ module ActiveRecord
           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

data/lib/active_record/integration.rb

@@ -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
 
@@ -104,10 +104,8 @@ module ActiveRecord
         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"
-        end
+      elsif self.class.has_attribute?("updated_at")
+        raise ActiveModel::MissingAttributeError, "missing attribute: updated_at"
       end
     end
 

data/lib/active_record/internal_metadata.rb

@@ -6,8 +6,15 @@ 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:
     class << self
+      def enabled?
+        ActiveRecord::Base.connection.use_metadata_table?
+      end
+
       def _internal?
         true
       end
@@ -21,19 +28,21 @@ module ActiveRecord
       end
 
       def []=(key, 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
+        return unless enabled?
+
         unless table_exists?
           key_options = connection.internal_string_options_for_primary_key
 
@@ -46,6 +55,8 @@ module ActiveRecord
       end
 
       def drop_table
+        return unless enabled?
+
         connection.drop_table table_name, if_exists: true
       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 6.2.
+        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"])

data/lib/active_record/locking/optimistic.rb

@@ -89,7 +89,8 @@ module ActiveRecord
 
           begin
             locking_column = self.class.locking_column
-            previous_lock_value = read_attribute_before_type_cast(locking_column)
+            previous_lock_value = attribute_before_type_cast(locking_column)
+            attribute_names = attribute_names.dup if attribute_names.frozen?
             attribute_names << locking_column
 
             self[locking_column] += 1
@@ -97,7 +98,7 @@ module ActiveRecord
             affected_rows = self.class._update_record(
               attributes_with_values(attribute_names),
               @primary_key => id_in_database,
-              locking_column => previous_lock_value
+              locking_column => @attributes[locking_column].original_value_for_database
             )
 
             if affected_rows != 1
@@ -120,7 +121,7 @@ module ActiveRecord
 
           affected_rows = self.class._delete_record(
             @primary_key => id_in_database,
-            locking_column => read_attribute_before_type_cast(locking_column)
+            locking_column => attribute_before_type_cast(locking_column)
           )
 
           if affected_rows != 1
@@ -164,20 +165,12 @@ module ActiveRecord
             super
           end
 
-          private
-            # We need to apply this decorator here, rather than on module inclusion. The closure
-            # created by the matcher would otherwise evaluate for `ActiveRecord::Base`, not the
-            # sub class being decorated. As such, changes to `lock_optimistically`, or
-            # `locking_column` would not be picked up.
-            def inherited(subclass)
-              subclass.class_eval do
-                is_lock_column = ->(name, _) { lock_optimistically && name == locking_column }
-                decorate_matching_attribute_types(is_lock_column, "_optimistic_locking") do |type|
-                  LockingType.new(type)
-                end
-              end
-              super
+          def define_attribute(name, cast_type, **) # :nodoc:
+            if lock_optimistically && name == locking_column
+              cast_type = LockingType.new(cast_type)
             end
+            super
+          end
         end
     end
 
@@ -185,6 +178,10 @@ module ActiveRecord
     # `nil` values to `lock_version`, and not result in `ActiveRecord::StaleObjectError`
     # during update record.
     class LockingType < DelegateClass(Type::Value) # :nodoc:
+      def self.new(subtype)
+        self === subtype ? subtype : super
+      end
+
       def deserialize(value)
         super.to_i
       end

data/lib/active_record/locking/pessimistic.rb

@@ -53,8 +53,12 @@ module ActiveRecord
     #   end
     #
     # Database-specific information on row locking:
-    #   MySQL: https://dev.mysql.com/doc/refman/5.7/en/innodb-locking-reads.html
-    #   PostgreSQL: https://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
+    #
+    # [MySQL]
+    #   https://dev.mysql.com/doc/refman/en/innodb-locking-reads.html
+    #
+    # [PostgreSQL]
+    #   https://www.postgresql.org/docs/current/interactive/sql-select.html#SQL-FOR-UPDATE-SHARE
     module Pessimistic
       # Obtain a row lock on this record. Reloads the record to obtain the requested
       # lock. Pass an SQL locking clause to append the end of the SELECT statement

data/lib/active_record/log_subscriber.rb

@@ -19,6 +19,15 @@ module ActiveRecord
       rt
     end
 
+    def strict_loading_violation(event)
+      debug do
+        owner = event.payload[:owner]
+        association = event.payload[:association]
+
+        color("Strict loading violation: #{association} lazily loaded on #{owner}.", RED)
+      end
+    end
+
     def sql(event)
       self.class.runtime += event.duration
       return unless logger.debug?
@@ -32,11 +41,15 @@ module ActiveRecord
       sql   = payload[:sql]
       binds = nil
 
-      unless (payload[:binds] || []).empty?
+      if payload[:binds]&.any?
         casted_params = type_casted_binds(payload[:type_casted_binds])
-        binds = "  " + payload[:binds].zip(casted_params).map { |attr, value|
-          render_bind(attr, value)
-        }.inspect
+
+        binds = []
+        payload[:binds].each_with_index do |attr, i|
+          binds << render_bind(attr, casted_params[i])
+        end
+        binds = binds.inspect
+        binds.prepend("  ")
       end
 
       name = colorize_payload_name(name, payload[:name])
@@ -51,13 +64,18 @@ module ActiveRecord
       end
 
       def render_bind(attr, value)
-        if attr.is_a?(Array)
+        case attr
+        when ActiveModel::Attribute
+          if attr.type.binary? && attr.value
+            value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+          end
+        when Array
           attr = attr.first
-        elsif attr.type.binary? && attr.value
-          value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        else
+          attr = nil
         end
 
-        [attr && attr.name, value]
+        [attr&.name, value]
       end
 
       def colorize_payload_name(name, payload_name)

data/lib/active_record/middleware/database_selector/resolver/session.rb

@@ -38,6 +38,9 @@ module ActiveRecord
           def update_last_write_timestamp
             session[:last_write] = self.class.convert_time_to_timestamp(Time.now)
           end
+
+          def save(response)
+          end
         end
       end
     end

data/lib/active_record/middleware/database_selector/resolver.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "active_record/middleware/database_selector/resolver/session"
+require "active_support/core_ext/numeric/time"
 
 module ActiveRecord
   module Middleware
@@ -43,6 +44,10 @@ module ActiveRecord
           write_to_primary(&blk)
         end
 
+        def update_context(response)
+          context.save(response)
+        end
+
         private
           def read_from_primary(&blk)
             ActiveRecord::Base.connected_to(role: ActiveRecord::Base.writing_role, prevent_writes: true) do

data/lib/active_record/middleware/database_selector.rb

@@ -59,11 +59,14 @@ module ActiveRecord
           context = context_klass.call(request)
           resolver = resolver_klass.call(context, options)
 
-          if reading_request?(request)
+          response = if reading_request?(request)
             resolver.read(&blk)
           else
             resolver.write(&blk)
           end
+
+          resolver.update_context(response)
+          response
         end
 
         def reading_request?(request)

data/lib/active_record/migration/command_recorder.rb

@@ -8,6 +8,7 @@ module ActiveRecord
     #
     # * add_column
     # * add_foreign_key
+    # * add_check_constraint
     # * add_index
     # * add_reference
     # * add_timestamps
@@ -25,6 +26,7 @@ module ActiveRecord
     # * remove_column (must supply a type)
     # * remove_columns (must specify at least one column name or more)
     # * remove_foreign_key (must supply a second table)
+    # * remove_check_constraint
     # * remove_index
     # * remove_reference
     # * remove_timestamps
@@ -39,7 +41,8 @@ module ActiveRecord
         :drop_join_table, :drop_table, :execute_block, :enable_extension, :disable_extension,
         :change_column, :execute, :remove_columns, :change_column_null,
         :add_foreign_key, :remove_foreign_key,
-        :change_column_comment, :change_table_comment
+        :change_column_comment, :change_table_comment,
+        :add_check_constraint, :remove_check_constraint
       ]
       include JoinTable
 
@@ -85,6 +88,11 @@ module ActiveRecord
       #   recorder.inverse_of(:rename_table, [:old, :new])
       #   # => [:rename_table, [:new, :old]]
       #
+      # If the inverse of a command requires several commands, returns array of commands.
+      #
+      #   recorder.inverse_of(:remove_columns, [:some_table, :foo, :bar, type: :string])
+      #   # => [[:add_column, :some_table, :foo, :string], [:add_column, :some_table, :bar, :string]]
+      #
       # This method will raise an +IrreversibleMigration+ exception if it cannot
       # invert the +command+.
       def inverse_of(command, args, &block)
@@ -127,9 +135,11 @@ module ActiveRecord
               create_table:      :drop_table,
               create_join_table: :drop_join_table,
               add_column:        :remove_column,
+              add_index:         :remove_index,
               add_timestamps:    :remove_timestamps,
               add_reference:     :remove_reference,
               add_foreign_key:   :remove_foreign_key,
+              add_check_constraint: :remove_check_constraint,
               enable_extension:  :disable_extension
             }.each do |cmd, inv|
               [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
@@ -171,44 +181,49 @@ module ActiveRecord
           super
         end
 
+        def invert_remove_columns(args)
+          unless args[-1].is_a?(Hash) && args[-1].has_key?(:type)
+            raise ActiveRecord::IrreversibleMigration, "remove_columns is only reversible if given a type."
+          end
+
+          [:add_columns, args]
+        end
+
         def invert_rename_index(args)
-          [:rename_index, [args.first] + args.last(2).reverse]
+          table_name, old_name, new_name = args
+          [:rename_index, [table_name, new_name, old_name]]
         end
 
         def invert_rename_column(args)
-          [:rename_column, [args.first] + args.last(2).reverse]
+          table_name, old_name, new_name = args
+          [:rename_column, [table_name, new_name, old_name]]
         end
 
-        def invert_add_index(args)
-          table, columns, options = *args
-          options ||= {}
-
-          options_hash = options.slice(:name, :algorithm)
-          options_hash[:column] = columns if !options_hash[:name]
+        def invert_remove_index(args)
+          options = args.extract_options!
+          table, columns = args
 
-          [:remove_index, [table, options_hash]]
-        end
+          columns ||= options.delete(:column)
 
-        def invert_remove_index(args)
-          table, options_or_column = *args
-          if (options = options_or_column).is_a?(Hash)
-            unless options[:column]
-              raise ActiveRecord::IrreversibleMigration, "remove_index is only reversible if given a :column option."
-            end
-            options = options.dup
-            [:add_index, [table, options.delete(:column), options]]
-          elsif (column = options_or_column).present?
-            [:add_index, [table, column]]
+          unless columns
+            raise ActiveRecord::IrreversibleMigration, "remove_index is only reversible if given a :column option."
           end
+
+          options.delete(:if_exists)
+
+          args = [table, columns]
+          args << options unless options.empty?
+
+          [:add_index, args]
         end
 
         alias :invert_add_belongs_to :invert_add_reference
         alias :invert_remove_belongs_to :invert_remove_reference
 
         def invert_change_column_default(args)
-          table, column, options = *args
+          table, column, options = args
 
-          unless options && options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
+          unless options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
             raise ActiveRecord::IrreversibleMigration, "change_column_default is only reversible if given a :from and :to option."
           end
 
@@ -235,9 +250,9 @@ module ActiveRecord
         end
 
         def invert_change_column_comment(args)
-          table, column, options = *args
+          table, column, options = args
 
-          unless options && options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
+          unless options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
             raise ActiveRecord::IrreversibleMigration, "change_column_comment is only reversible if given a :from and :to option."
           end
 
@@ -245,15 +260,20 @@ module ActiveRecord
         end
 
         def invert_change_table_comment(args)
-          table, options = *args
+          table, options = args
 
-          unless options && options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
+          unless options.is_a?(Hash) && options.has_key?(:from) && options.has_key?(:to)
             raise ActiveRecord::IrreversibleMigration, "change_table_comment is only reversible if given a :from and :to option."
           end
 
           [:change_table_comment, [table, from: options[:to], to: options[:from]]]
         end
 
+        def invert_remove_check_constraint(args)
+          raise ActiveRecord::IrreversibleMigration, "remove_check_constraint is only reversible if given an expression." if args.size < 2
+          super
+        end
+
         def respond_to_missing?(method, _)
           super || delegate.respond_to?(method)
         end

data/lib/active_record/migration/compatibility.rb

@@ -13,7 +13,61 @@ module ActiveRecord
         const_get(name)
       end
 
-      V6_0 = Current
+      V6_1 = Current
+
+      class V6_0 < V6_1
+        class ReferenceDefinition < ConnectionAdapters::ReferenceDefinition
+          def index_options(table_name)
+            as_options(index)
+          end
+        end
+
+        module TableDefinition
+          def references(*args, **options)
+            args.each do |ref_name|
+              ReferenceDefinition.new(ref_name, **options).add_to(self)
+            end
+          end
+          alias :belongs_to :references
+        end
+
+        def create_table(table_name, **options)
+          if block_given?
+            super { |t| yield compatible_table_definition(t) }
+          else
+            super
+          end
+        end
+
+        def change_table(table_name, **options)
+          if block_given?
+            super { |t| yield compatible_table_definition(t) }
+          else
+            super
+          end
+        end
+
+        def create_join_table(table_1, table_2, **options)
+          if block_given?
+            super { |t| yield compatible_table_definition(t) }
+          else
+            super
+          end
+        end
+
+        def add_reference(table_name, ref_name, **options)
+          ReferenceDefinition.new(ref_name, **options).add_to(update_table_definition(table_name, self))
+        end
+        alias :add_belongs_to :add_reference
+
+        private
+          def compatible_table_definition(t)
+            class << t
+              prepend TableDefinition
+            end
+            t
+          end
+      end
 
       class V5_2 < V6_0
         module TableDefinition
@@ -29,13 +83,11 @@ module ActiveRecord
           end
 
           def invert_change_column_comment(args)
-            table_name, column_name, comment = args
-            [:change_column_comment, [table_name, column_name, from: comment, to: comment]]
+            [:change_column_comment, args]
           end
 
           def invert_change_table_comment(args)
-            table_name, comment = args
-            [:change_table_comment, [table_name, from: comment, to: comment]]
+            [:change_table_comment, args]
           end
         end
 
@@ -86,9 +138,9 @@ module ActiveRecord
       end
 
       class V5_1 < V5_2
-        def change_column(table_name, column_name, type, options = {})
+        def change_column(table_name, column_name, type, **options)
           if connection.adapter_name == "PostgreSQL"
-            super(table_name, column_name, type, options.except(:default, :null, :comment))
+            super(table_name, column_name, type, **options.except(:default, :null, :comment))
             connection.change_column_default(table_name, column_name, options[:default]) if options.key?(:default)
             connection.change_column_null(table_name, column_name, options[:null], options[:default]) if options.key?(:null)
             connection.change_column_comment(table_name, column_name, options[:comment]) if options.key?(:comment)
@@ -194,7 +246,7 @@ module ActiveRecord
           super
         end
 
-        def index_exists?(table_name, column_name, options = {})
+        def index_exists?(table_name, column_name, **options)
           column_names = Array(column_name).map(&:to_s)
           options[:name] =
             if options[:name].present?
@@ -205,10 +257,9 @@ module ActiveRecord
           super
         end
 
-        def remove_index(table_name, options = {})
-          options = { column: options } unless options.is_a?(Hash)
-          options[:name] = index_name_for_remove(table_name, options)
-          super(table_name, options)
+        def remove_index(table_name, column_name = nil, **options)
+          options[:name] = index_name_for_remove(table_name, column_name, options)
+          super
         end
 
         private
@@ -219,13 +270,12 @@ module ActiveRecord
             super
           end
 
-          def index_name_for_remove(table_name, options = {})
-            index_name = connection.index_name(table_name, options)
+          def index_name_for_remove(table_name, column_name, options)
+            index_name = connection.index_name(table_name, column_name || options)
 
             unless connection.index_name_exists?(table_name, index_name)
-              if options.is_a?(Hash) && options.has_key?(:name)
-                options_without_column = options.dup
-                options_without_column.delete :column
+              if options.key?(:name)
+                options_without_column = options.except(:column)
                 index_name_without_column = connection.index_name(table_name, options_without_column)
 
                 if connection.index_name_exists?(table_name, index_name_without_column)