activerecord 5.0.7 → 5.1.7

data/lib/active_record/locking/optimistic.rb

@@ -60,13 +60,7 @@ module ActiveRecord
       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)
-        end
-
-        def _create_record(attribute_names = self.attribute_names, *) # :nodoc:
+        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,38 +69,37 @@ module ActiveRecord
           super
         end
 
-        def _update_record(attribute_names = self.attribute_names) #:nodoc:
+        def _touch_row(attribute_names, time)
+          super
+        ensure
+          clear_attribute_change(self.class.locking_column) if locking_enabled?
+        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
+            previous_lock_value = read_attribute_before_type_cast(locking_column)
+            attribute_names << locking_column
 
-          attribute_names += [lock_col]
-          attribute_names.uniq!
+            self[locking_column] += 1
 
-          begin
-            relation = self.class.unscoped
-
-            affected_rows = relation.where(
-              self.class.primary_key => id,
-              lock_col => previous_lock_value,
-            ).update_all(
-              attributes_for_update(attribute_names).map do |name|
-                [name, _read_attribute(name)]
-              end.to_h
+            affected_rows = self.class.unscoped._update_record(
+              arel_attributes_with_values(attribute_names),
+              self.class.primary_key => id_in_database,
+              locking_column => previous_lock_value
             )
 
-            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)
+            self[locking_column] = previous_lock_value.to_i
             raise
           end
         end
@@ -126,67 +119,69 @@ module ActiveRecord
 
           if locking_enabled?
             locking_column = self.class.locking_column
-            relation = relation.where(locking_column => _read_attribute(locking_column))
+            relation = relation.where(locking_column => read_attribute_before_type_cast(locking_column))
           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)
-          reload_schema_from_cache
-          @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
-          @locking_column = DEFAULT_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)
+          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
             end
-          end
-          super
         end
-      end
     end
 
+    # 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 deserialize(value)
-        # `nil` *should* be changed to 0
         super.to_i
       end
 
@@ -195,11 +190,11 @@ module ActiveRecord
       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

@@ -59,7 +59,16 @@ module ActiveRecord
       # 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?
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              Locking a record with unpersisted changes is deprecated and will raise an
+              exception in Rails 5.2. Use `save` to persist the changes, or `reload` to
+              discard them explicitly.
+            MSG
+          end
+          reload(lock: lock)
+        end
         self
       end
 

data/lib/active_record/log_subscriber.rb

@@ -15,11 +15,6 @@ module ActiveRecord
       rt
     end
 
-    def initialize
-      super
-      @odd = false
-    end
-
     def sql(event)
       self.class.runtime += event.duration
       return unless logger.debug?
@@ -29,6 +24,7 @@ module ActiveRecord
       return if IGNORE_PAYLOAD_NAMES.include?(payload[:name])
 
       name  = "#{payload[:name]} (#{event.duration.round(1)}ms)"
+      name  = "CACHE #{name}" if payload[:cached]
       sql   = payload[:sql]
       binds = nil
 
@@ -46,31 +42,30 @@ module ActiveRecord
     end
 
     private
+      def type_casted_binds(casted_binds)
+        casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
+      end
 
-    def type_casted_binds(casted_binds)
-      casted_binds.respond_to?(:call) ? casted_binds.call : casted_binds
-    end
+      def render_bind(attr, value)
+        if attr.is_a?(Array)
+          attr = attr.first
+        elsif attr.type.binary? && attr.value
+          value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        end
 
-    def render_bind(attr, value)
-      if attr.is_a?(Array)
-        attr = attr.first
-      elsif attr.type.binary? && attr.value
-        value = "<#{attr.value_for_database.to_s.bytesize} bytes of binary data>"
+        [attr && attr.name, value]
       end
 
-      [attr && attr.name, value]
-    end
-
-    def colorize_payload_name(name, payload_name)
-      if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
-        color(name, MAGENTA, true)
-      else
-        color(name, CYAN, true)
+      def colorize_payload_name(name, payload_name)
+        if payload_name.blank? || payload_name == "SQL" # SQL vs Model Load/Exists
+          color(name, MAGENTA, true)
+        else
+          color(name, CYAN, true)
+        end
       end
-    end
 
-    def sql_color(sql)
-      case sql
+      def sql_color(sql)
+        case sql
         when /\A\s*rollback/mi
           RED
         when /select .*for update/mi, /\A\s*lock/mi
@@ -87,12 +82,12 @@ module ActiveRecord
           CYAN
         else
           MAGENTA
+        end
       end
-    end
 
-    def logger
-      ActiveRecord::Base.logger
-    end
+      def logger
+        ActiveRecord::Base.logger
+      end
   end
 end
 

data/lib/active_record/migration/command_recorder.rb

@@ -92,7 +92,7 @@ module ActiveRecord
         send(method, args, &block)
       end
 
-      def respond_to?(*args) # :nodoc:
+      def respond_to_missing?(*args) # :nodoc:
         super || delegate.respond_to?(*args)
       end
 
@@ -112,127 +112,127 @@ module ActiveRecord
 
       private
 
-      module StraightReversions
-        private
-        { transaction:       :transaction,
-          execute_block:     :execute_block,
-          create_table:      :drop_table,
-          create_join_table: :drop_join_table,
-          add_column:        :remove_column,
-          add_timestamps:    :remove_timestamps,
-          add_reference:     :remove_reference,
-          enable_extension:  :disable_extension
-        }.each do |cmd, inv|
-          [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
-            class_eval <<-EOV, __FILE__, __LINE__ + 1
-              def invert_#{method}(args, &block)    # def invert_create_table(args, &block)
-                [:#{inverse}, args, block]          #   [:drop_table, args, block]
-              end                                   # end
-            EOV
-          end
+        module StraightReversions
+          private
+            { transaction:       :transaction,
+              execute_block:     :execute_block,
+              create_table:      :drop_table,
+              create_join_table: :drop_join_table,
+              add_column:        :remove_column,
+              add_timestamps:    :remove_timestamps,
+              add_reference:     :remove_reference,
+              enable_extension:  :disable_extension
+            }.each do |cmd, inv|
+              [[inv, cmd], [cmd, inv]].uniq.each do |method, inverse|
+                class_eval <<-EOV, __FILE__, __LINE__ + 1
+                  def invert_#{method}(args, &block)    # def invert_create_table(args, &block)
+                    [:#{inverse}, args, block]          #   [:drop_table, args, block]
+                  end                                   # end
+                EOV
+              end
+            end
         end
-      end
 
-      include StraightReversions
+        include StraightReversions
 
-      def invert_drop_table(args, &block)
-        if args.size == 1 && block == nil
-          raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty)."
+        def invert_drop_table(args, &block)
+          if args.size == 1 && block == nil
+            raise ActiveRecord::IrreversibleMigration, "To avoid mistakes, drop_table is only reversible if given options or a block (can be empty)."
+          end
+          super
         end
-        super
-      end
 
-      def invert_rename_table(args)
-        [:rename_table, args.reverse]
-      end
+        def invert_rename_table(args)
+          [:rename_table, args.reverse]
+        end
 
-      def invert_remove_column(args)
-        raise ActiveRecord::IrreversibleMigration, "remove_column is only reversible if given a type." if args.size <= 2
-        super
-      end
+        def invert_remove_column(args)
+          raise ActiveRecord::IrreversibleMigration, "remove_column is only reversible if given a type." if args.size <= 2
+          super
+        end
 
-      def invert_rename_index(args)
-        [:rename_index, [args.first] + args.last(2).reverse]
-      end
+        def invert_rename_index(args)
+          [:rename_index, [args.first] + args.last(2).reverse]
+        end
 
-      def invert_rename_column(args)
-        [:rename_column, [args.first] + args.last(2).reverse]
-      end
+        def invert_rename_column(args)
+          [:rename_column, [args.first] + args.last(2).reverse]
+        end
 
-      def invert_add_index(args)
-        table, columns, options = *args
-        options ||= {}
+        def invert_add_index(args)
+          table, columns, options = *args
+          options ||= {}
 
-        index_name = options[:name]
-        options_hash = index_name ? { name: index_name } : { column: columns }
+          index_name = options[:name]
+          options_hash = index_name ? { name: index_name } : { column: columns }
 
-        [:remove_index, [table, options_hash]]
-      end
+          [:remove_index, [table, options_hash]]
+        end
 
-      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."
+        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]]
           end
-          options = options.dup
-          [:add_index, [table, options.delete(:column), options]]
-        elsif (column = options_or_column).present?
-          [:add_index, [table, column]]
         end
-      end
 
-      alias :invert_add_belongs_to :invert_add_reference
-      alias :invert_remove_belongs_to :invert_remove_reference
+        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
 
-      def invert_change_column_default(args)
-        table, column, options = *args
+          unless options && 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
 
-        unless options && 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."
+          [:change_column_default, [table, column, from: options[:to], to: options[:from]]]
         end
 
-        [:change_column_default, [table, column, from: options[:to], to: options[:from]]]
-      end
+        def invert_change_column_null(args)
+          args[2] = !args[2]
+          [:change_column_null, args]
+        end
 
-      def invert_change_column_null(args)
-        args[2] = !args[2]
-        [:change_column_null, args]
-      end
+        def invert_add_foreign_key(args)
+          from_table, to_table, add_options = args
+          add_options ||= {}
 
-      def invert_add_foreign_key(args)
-        from_table, to_table, add_options = args
-        add_options ||= {}
+          if add_options[:name]
+            options = { name: add_options[:name] }
+          elsif add_options[:column]
+            options = { column: add_options[:column] }
+          else
+            options = to_table
+          end
 
-        if add_options[:name]
-          options = { name: add_options[:name] }
-        elsif add_options[:column]
-          options = { column: add_options[:column] }
-        else
-          options = to_table
+          [:remove_foreign_key, [from_table, options]]
         end
 
-        [:remove_foreign_key, [from_table, options]]
-      end
-
-      def invert_remove_foreign_key(args)
-        from_table, to_table, remove_options = args
-        raise ActiveRecord::IrreversibleMigration, "remove_foreign_key is only reversible if given a second table" if to_table.nil? || to_table.is_a?(Hash)
+        def invert_remove_foreign_key(args)
+          from_table, to_table, remove_options = args
+          raise ActiveRecord::IrreversibleMigration, "remove_foreign_key is only reversible if given a second table" if to_table.nil? || to_table.is_a?(Hash)
 
-        reversed_args = [from_table, to_table]
-        reversed_args << remove_options if remove_options
+          reversed_args = [from_table, to_table]
+          reversed_args << remove_options if remove_options
 
-        [:add_foreign_key, reversed_args]
-      end
+          [:add_foreign_key, reversed_args]
+        end
 
-      # Forwards any missing method call to the \target.
-      def method_missing(method, *args, &block)
-        if @delegate.respond_to?(method)
-          @delegate.send(method, *args, &block)
-        else
-          super
+        # Forwards any missing method call to the \target.
+        def method_missing(method, *args, &block)
+          if @delegate.respond_to?(method)
+            @delegate.send(method, *args, &block)
+          else
+            super
+          end
         end
-      end
     end
   end
 end