activerecord 4.2.9 → 6.1.4.1

data/lib/active_record/integration.rb

@@ -1,4 +1,6 @@
-require 'active_support/core_ext/string/filters'
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
 
 module ActiveRecord
   module Integration
@@ -7,17 +9,32 @@ module ActiveRecord
     included do
       ##
       # :singleton-method:
-      # Indicates the format used to generate the timestamp in the cache key.
-      # Accepts any of the symbols in <tt>Time::DATE_FORMATS</tt>.
+      # 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>.
+      #
+      # This is +:usec+, by default.
+      class_attribute :cache_timestamp_format, instance_writer: false, default: :usec
+
+      ##
+      # :singleton-method:
+      # 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.
+      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 +:nsec+, by default.
-      class_attribute :cache_timestamp_format, :instance_writer => false
-      self.cache_timestamp_format = :nsec
+      # 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 an URL to this
-    # object. The default implementation returns this record's id as a String,
-    # or nil if this record's unsaved.
+    # Returns a +String+, which Action Pack uses for constructing a URL to this
+    # object. The default implementation returns this record's id as a +String+,
+    # or +nil+ if this record's unsaved.
     #
     # For example, suppose that you have a User model, and that you have a
     # <tt>resources :users</tt> route. Normally, +user_path+ will
@@ -42,29 +59,62 @@ module ActiveRecord
       id && id.to_s # Be sure to stringify the id for routes
     end
 
-    # Returns a cache key that can be used to identify this record.
+    # Returns a stable cache key that can be used to identify this record.
     #
     #   Product.new.cache_key     # => "products/new"
-    #   Product.find(5).cache_key # => "products/5" (updated_at not available)
-    #   Person.find(5).cache_key  # => "people/5-20071224150000" (updated_at available)
+    #   Product.find(5).cache_key # => "products/5"
     #
-    # You can also pass a list of named timestamps, and the newest in the list will be
-    # used to generate the key:
+    # 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.
     #
-    #   Person.find(5).cache_key(:updated_at, :last_reviewed_at)
-    def cache_key(*timestamp_names)
-      case
-      when new_record?
+    #   Product.cache_versioning = false
+    #   Product.find(5).cache_key  # => "products/5-20071224150000" (updated_at available)
+    def cache_key
+      if new_record?
         "#{model_name.cache_key}/new"
-      when timestamp_names.any?
-        timestamp = max_updated_column_timestamp(timestamp_names)
-        timestamp = timestamp.utc.to_s(cache_timestamp_format)
-        "#{model_name.cache_key}/#{id}-#{timestamp}"
-      when timestamp = max_updated_column_timestamp
-        timestamp = timestamp.utc.to_s(cache_timestamp_format)
-        "#{model_name.cache_key}/#{id}-#{timestamp}"
       else
-        "#{model_name.cache_key}/#{id}"
+        if cache_version
+          "#{model_name.cache_key}/#{id}"
+        else
+          timestamp = max_updated_column_timestamp
+
+          if timestamp
+            timestamp = timestamp.utc.to_s(cache_timestamp_format)
+            "#{model_name.cache_key}/#{id}-#{timestamp}"
+          else
+            "#{model_name.cache_key}/#{id}"
+          end
+        end
+      end
+    end
+
+    # Returns a cache version that can be used together with the cache key to form
+    # a recyclable caching scheme. By default, the #updated_at column is used for the
+    # 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+.
+    def cache_version
+      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
+
+    # Returns a cache key along with the version.
+    def cache_key_with_version
+      if version = cache_version
+        "#{cache_key}-#{version}"
+      else
+        cache_key
       end
     end
 
@@ -84,9 +134,9 @@ module ActiveRecord
       # Values longer than 20 characters will be truncated. The value
       # is truncated word by word.
       #
-      #   user = User.find_by(name: 'David HeinemeierHansson')
+      #   user = User.find_by(name: 'David Heinemeier Hansson')
       #   user.id         # => 125
-      #   user_path(user) # => "/users/125-david"
+      #   user_path(user) # => "/users/125-david-heinemeier"
       #
       # Because the generated param begins with the record's +id+, it is
       # suitable for passing to +find+. In a controller, for example:
@@ -100,7 +150,7 @@ module ActiveRecord
           define_method :to_param do
             if (default = super()) &&
                  (result = send(method_name).to_s).present? &&
-                   (param = result.squish.truncate(20, separator: /\s/, omission: nil).parameterize).present?
+                   (param = result.squish.parameterize.truncate(20, separator: /-/, omission: "")).present?
               "#{default}-#{param}"
             else
               default
@@ -108,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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "active_record/scoping/default"
+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
+
+      def primary_key
+        "key"
+      end
+
+      def table_name
+        "#{table_name_prefix}#{internal_metadata_table_name}#{table_name_suffix}"
+      end
+
+      def []=(key, value)
+        return unless enabled?
+
+        find_or_initialize_by(key: key).update!(value: value)
+      end
+
+      def [](key)
+        return unless enabled?
+
+        where(key: key).pluck(:value).first
+      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
+    end
+  end
+end

data/lib/active_record/legacy_yaml_adapter.rb

@@ -1,20 +1,42 @@
+# 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 0 then coder
+      when 1, 2 then coder
       else
-        if coder["attributes"].is_a?(AttributeSet)
-          coder
+        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
           Rails41.convert(klass, coder)
         end
       end
     end
 
-    module Rails41
+    module Rails420 # :nodoc:
+      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 # :nodoc:
       def self.convert(klass, coder)
         attributes = klass.attributes_builder
           .build_from_database(coder["attributes"])

data/lib/active_record/locale/en.yml

@@ -7,6 +7,7 @@ en:
   # Default error messages
   errors:
     messages:
+      required: "must exist"
       taken: "has already been taken"
 
   # Active Record models configuration
@@ -15,8 +16,8 @@ en:
       messages:
         record_invalid: "Validation failed: %{errors}"
         restrict_dependent_destroy:
-          one: "Cannot delete record because a dependent %{record} exists"
-          many: "Cannot delete record because dependent %{record} exist"
+          has_one: "Cannot delete record because a dependent %{record} exists"
+          has_many: "Cannot delete record because dependent %{record} exist"
         # Append your own errors here or at the model/attributes scope.
 
       # You can define own errors for models or model attributes.

data/lib/active_record/locking/optimistic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Locking
     # == What is Optimistic Locking
@@ -11,7 +13,7 @@ module ActiveRecord
     #
     # == Usage
     #
-    # Active Records support optimistic locking if the field +lock_version+ is present. Each update to the
+    # Active Record supports optimistic locking if the +lock_version+ field is present. Each update to the
     # record increments the +lock_version+ column and the locking facilities ensure that records instantiated twice
     # will let the last one saved raise a +StaleObjectError+ if the first was also updated. Example:
     #
@@ -22,7 +24,7 @@ module ActiveRecord
     #   p1.save
     #
     #   p2.first_name = "should fail"
-    #   p2.save # Raises a ActiveRecord::StaleObjectError
+    #   p2.save # Raises an ActiveRecord::StaleObjectError
     #
     # Optimistic locking will also check for stale data when objects are destroyed. Example:
     #
@@ -32,7 +34,7 @@ module ActiveRecord
     #   p1.first_name = "Michael"
     #   p1.save
     #
-    #   p2.destroy # Raises a ActiveRecord::StaleObjectError
+    #   p2.destroy # Raises an ActiveRecord::StaleObjectError
     #
     # You're then responsible for dealing with the conflict by rescuing the exception and either rolling back, merging,
     # or otherwise apply the business logic needed to resolve the conflict.
@@ -51,22 +53,24 @@ module ActiveRecord
       extend ActiveSupport::Concern
 
       included do
-        class_attribute :lock_optimistically, instance_writer: false
-        self.lock_optimistically = true
+        class_attribute :lock_optimistically, instance_writer: false, default: true
       end
 
       def locking_enabled? #:nodoc:
         self.class.locking_enabled?
       end
 
-      private
-        def increment_lock
-          lock_col = self.class.locking_column
-          previous_lock_value = send(lock_col).to_i
-          send(lock_col + '=', previous_lock_value + 1)
+      def increment!(*, **) #:nodoc:
+        super.tap do
+          if locking_enabled?
+            self[self.class.locking_column] += 1
+            clear_attribute_change(self.class.locking_column)
+          end
         end
+      end
 
-        def _create_record(attribute_names = self.attribute_names, *) # :nodoc:
+      private
+        def _create_record(attribute_names = self.attribute_names)
           if locking_enabled?
             # We always want to persist the locking version, even if we don't detect
             # a change from the default, since the database might have no default
@@ -75,131 +79,133 @@ module ActiveRecord
           super
         end
 
-        def _update_record(attribute_names = self.attribute_names) #:nodoc:
+        def _touch_row(attribute_names, time)
+          @_touch_attr_names << self.class.locking_column if locking_enabled?
+          super
+        end
+
+        def _update_row(attribute_names, attempted_action = "update")
           return super unless locking_enabled?
-          return 0 if attribute_names.empty?
 
-          lock_col = self.class.locking_column
-          previous_lock_value = send(lock_col).to_i
-          increment_lock
+          begin
+            locking_column = self.class.locking_column
+            lock_attribute_was = @attributes[locking_column]
+            lock_value_for_database = _lock_value_for_database(locking_column)
 
-          attribute_names += [lock_col]
-          attribute_names.uniq!
+            attribute_names = attribute_names.dup if attribute_names.frozen?
+            attribute_names << locking_column
 
-          begin
-            relation = self.class.unscoped
-
-            affected_rows = relation.where(
-              self.class.primary_key => id,
-              lock_col => previous_lock_value,
-            ).update_all(
-              Hash[attributes_for_update(attribute_names).map do |name|
-                [name, _read_attribute(name)]
-              end]
+            self[locking_column] += 1
+
+            affected_rows = self.class._update_record(
+              attributes_with_values(attribute_names),
+              @primary_key => id_in_database,
+              locking_column => lock_value_for_database
             )
 
-            unless affected_rows == 1
-              raise ActiveRecord::StaleObjectError.new(self, "update")
+            if affected_rows != 1
+              raise ActiveRecord::StaleObjectError.new(self, attempted_action)
             end
 
             affected_rows
 
-          # If something went wrong, revert the version.
+          # If something went wrong, revert the locking_column value.
           rescue Exception
-            send(lock_col + '=', previous_lock_value)
+            @attributes[locking_column] = lock_attribute_was
             raise
           end
         end
 
         def destroy_row
-          affected_rows = super
+          return super unless locking_enabled?
+
+          locking_column = self.class.locking_column
+
+          affected_rows = self.class._delete_record(
+            @primary_key => id_in_database,
+            locking_column => _lock_value_for_database(locking_column)
+          )
 
-          if locking_enabled? && affected_rows != 1
+          if affected_rows != 1
             raise ActiveRecord::StaleObjectError.new(self, "destroy")
           end
 
           affected_rows
         end
 
-        def relation_for_destroy
-          relation = super
-
-          if locking_enabled?
-            column_name = self.class.locking_column
-            column      = self.class.columns_hash[column_name]
-            substitute  = self.class.connection.substitute_at(column)
-
-            relation = relation.where(self.class.arel_table[column_name].eq(substitute))
-            relation.bind_values << [column, self[column_name].to_i]
+        def _lock_value_for_database(locking_column)
+          if will_save_change_to_attribute?(locking_column)
+            @attributes[locking_column].value_for_database
+          else
+            @attributes[locking_column].original_value_for_database
           end
-
-          relation
         end
 
-      module ClassMethods
-        DEFAULT_LOCKING_COLUMN = 'lock_version'
+        module ClassMethods
+          DEFAULT_LOCKING_COLUMN = "lock_version"
 
-        # Returns true if the +lock_optimistically+ flag is set to true
-        # (which it is, by default) and the table includes the
-        # +locking_column+ column (defaults to +lock_version+).
-        def locking_enabled?
-          lock_optimistically && columns_hash[locking_column]
-        end
+          # Returns true if the +lock_optimistically+ flag is set to true
+          # (which it is, by default) and the table includes the
+          # +locking_column+ column (defaults to +lock_version+).
+          def locking_enabled?
+            lock_optimistically && columns_hash[locking_column]
+          end
 
-        # Set the column to use for optimistic locking. Defaults to +lock_version+.
-        def locking_column=(value)
-          clear_caches_calculated_from_columns
-          @locking_column = value.to_s
-        end
+          # Set the column to use for optimistic locking. Defaults to +lock_version+.
+          def locking_column=(value)
+            reload_schema_from_cache
+            @locking_column = value.to_s
+          end
 
-        # The version column used for optimistic locking. Defaults to +lock_version+.
-        def locking_column
-          reset_locking_column unless defined?(@locking_column)
-          @locking_column
-        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
 
-        # Reset the column used for optimistic locking back to the +lock_version+ default.
-        def reset_locking_column
-          self.locking_column = DEFAULT_LOCKING_COLUMN
-        end
+          # Reset the column used for optimistic locking back to the +lock_version+ default.
+          def reset_locking_column
+            self.locking_column = DEFAULT_LOCKING_COLUMN
+          end
 
-        # Make sure the lock version column gets updated when counters are
-        # updated.
-        def update_counters(id, counters)
-          counters = counters.merge(locking_column => 1) if locking_enabled?
-          super
-        end
+          # Make sure the lock version column gets updated when counters are
+          # updated.
+          def update_counters(id, counters)
+            counters = counters.merge(locking_column => 1) if locking_enabled?
+            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)
+          def define_attribute(name, cast_type, **) # :nodoc:
+            if lock_optimistically && name == locking_column
+              cast_type = LockingType.new(cast_type)
             end
+            super
           end
-          super
         end
-      end
     end
 
-    class LockingType < SimpleDelegator # :nodoc:
-      def type_cast_from_database(value)
-        # `nil` *should* be changed to 0
+    # In de/serialize we change `nil` to 0, so that we can allow passing
+    # `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
+
+      def serialize(value)
         super.to_i
       end
 
       def init_with(coder)
-        __setobj__(coder['subtype'])
+        __setobj__(coder["subtype"])
       end
 
       def encode_with(coder)
-        coder['subtype'] = __getobj__
+        coder["subtype"] = __getobj__
       end
     end
   end

data/lib/active_record/locking/pessimistic.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   module Locking
     # Locking::Pessimistic provides support for row-level locking using
@@ -12,9 +14,9 @@ module ActiveRecord
     # of your own such as 'LOCK IN SHARE MODE' or 'FOR UPDATE NOWAIT'. Example:
     #
     #   Account.transaction do
-    #     # select * from accounts where name = 'shugo' limit 1 for update
-    #     shugo = Account.where("name = 'shugo'").lock(true).first
-    #     yuko = Account.where("name = 'yuko'").lock(true).first
+    #     # select * from accounts where name = 'shugo' limit 1 for update nowait
+    #     shugo = Account.lock("FOR UPDATE NOWAIT").find_by(name: "shugo")
+    #     yuko = Account.lock("FOR UPDATE NOWAIT").find_by(name: "yuko")
     #     shugo.balance -= 100
     #     shugo.save!
     #     yuko.balance += 100
@@ -51,15 +53,29 @@ module ActiveRecord
     #   end
     #
     # Database-specific information on row locking:
-    #   MySQL: http://dev.mysql.com/doc/refman/5.1/en/innodb-locking-reads.html
-    #   PostgreSQL: http://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
       # or pass true for "FOR UPDATE" (the default, an exclusive row lock). Returns
       # the locked record.
       def lock!(lock = true)
-        reload(:lock => lock) if persisted?
+        if persisted?
+          if has_changes_to_save?
+            raise(<<-MSG.squish)
+              Locking a record with unpersisted changes is not supported. Use
+              `save` to persist the changes, or `reload` to discard them
+              explicitly.
+            MSG
+          end
+
+          reload(lock: lock)
+        end
         self
       end