activerecord 4.2.8 → 6.0.0

data/lib/active_record/no_touching.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 module ActiveRecord
   # = Active Record No Touching
   module NoTouching
     extend ActiveSupport::Concern
 
     module ClassMethods
-      # Lets you selectively disable calls to `touch` for the
+      # Lets you selectively disable calls to +touch+ for the
       # duration of a block.
       #
       # ==== Examples
@@ -41,10 +43,21 @@ module ActiveRecord
         end
     end
 
+    # Returns +true+ if the class has +no_touching+ set, +false+ otherwise.
+    #
+    #   Project.no_touching do
+    #     Project.first.no_touching? # true
+    #     Message.first.no_touching? # false
+    #   end
+    #
     def no_touching?
       NoTouching.applied_to?(self.class)
     end
 
+    def touch_later(*) # :nodoc:
+      super unless no_touching?
+    end
+
     def touch(*) # :nodoc:
       super unless no_touching?
     end

data/lib/active_record/null_relation.rb

@@ -1,20 +1,16 @@
-# -*- coding: utf-8 -*-
+# frozen_string_literal: true
 
 module ActiveRecord
   module NullRelation # :nodoc:
-    def exec_queries
-      @records = []
-    end
-
     def pluck(*column_names)
       []
     end
 
-    def delete_all(_conditions = nil)
+    def delete_all
       0
     end
 
-    def update_all(_updates, _conditions = nil, _options = {})
+    def update_all(_updates)
       0
     end
 
@@ -22,11 +18,11 @@ module ActiveRecord
       0
     end
 
-    def size
-      calculate :size, nil
+    def empty?
+      true
     end
 
-    def empty?
+    def none?
       true
     end
 
@@ -34,6 +30,10 @@ module ActiveRecord
       false
     end
 
+    def one?
+      false
+    end
+
     def many?
       false
     end
@@ -42,40 +42,27 @@ module ActiveRecord
       ""
     end
 
-    def count(*)
-      calculate :count, nil
-    end
-
-    def sum(*)
-      calculate :sum, nil
+    def calculate(operation, _column_name)
+      case operation
+      when :count, :sum
+        group_values.any? ? Hash.new : 0
+      when :average, :minimum, :maximum
+        group_values.any? ? Hash.new : nil
+      end
     end
 
-    def average(*)
-      calculate :average, nil
+    def exists?(_conditions = :none)
+      false
     end
 
-    def minimum(*)
-      calculate :minimum, nil
+    def or(other)
+      other.spawn
     end
 
-    def maximum(*)
-      calculate :maximum, nil
-    end
+    private
 
-    def calculate(operation, _column_name, _options = {})
-      # TODO: Remove _options argument as soon we remove support to
-      # activerecord-deprecated_finders.
-      if [:count, :sum, :size].include? operation
-        group_values.any? ? Hash.new : 0
-      elsif [:average, :minimum, :maximum].include?(operation) && group_values.any?
-        Hash.new
-      else
-        nil
+      def exec_queries
+        @records = [].freeze
       end
-    end
-
-    def exists?(_id = false)
-      false
-    end
   end
 end

data/lib/active_record/persistence.rb

@@ -1,5 +1,9 @@
+# frozen_string_literal: true
+
+require "active_record/insert_all"
+
 module ActiveRecord
-  # = Active Record Persistence
+  # = Active Record \Persistence
   module Persistence
     extend ActiveSupport::Concern
 
@@ -53,6 +57,192 @@ module ActiveRecord
         end
       end
 
+      # Inserts a single record into the database in a single SQL INSERT
+      # statement. It does not instantiate any models nor does it trigger
+      # Active Record callbacks or validations. Though passed values
+      # go through Active Record's type casting and serialization.
+      #
+      # See <tt>ActiveRecord::Persistence#insert_all</tt> for documentation.
+      def insert(attributes, returning: nil, unique_by: nil)
+        insert_all([ attributes ], returning: returning, unique_by: unique_by)
+      end
+
+      # Inserts multiple records into the database in a single SQL INSERT
+      # statement. It does not instantiate any models nor does it trigger
+      # Active Record callbacks or validations. Though passed values
+      # go through Active Record's type casting and serialization.
+      #
+      # The +attributes+ parameter is an Array of Hashes. Every Hash determines
+      # the attributes for a single row and must have the same keys.
+      #
+      # Rows are considered to be unique by every unique index on the table. Any
+      # duplicate rows are skipped.
+      # Override with <tt>:unique_by</tt> (see below).
+      #
+      # Returns an <tt>ActiveRecord::Result</tt> with its contents based on
+      # <tt>:returning</tt> (see below).
+      #
+      # ==== Options
+      #
+      # [:returning]
+      #   (PostgreSQL only) An array of attributes to return for all successfully
+      #   inserted records, which by default is the primary key.
+      #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
+      #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
+      #   clause entirely.
+      #
+      # [:unique_by]
+      #   (PostgreSQL and SQLite only) By default rows are considered to be unique
+      #   by every unique index on the table. Any duplicate rows are skipped.
+      #
+      #   To skip rows according to just one unique index pass <tt>:unique_by</tt>.
+      #
+      #   Consider a Book model where no duplicate ISBNs make sense, but if any
+      #   row has an existing id, or is not unique by another unique index,
+      #   <tt>ActiveRecord::RecordNotUnique</tt> is raised.
+      #
+      #   Unique indexes can be identified by columns or name:
+      #
+      #     unique_by: :isbn
+      #     unique_by: %i[ author_id name ]
+      #     unique_by: :index_books_on_isbn
+      #
+      # Because it relies on the index information from the database
+      # <tt>:unique_by</tt> is recommended to be paired with
+      # Active Record's schema_cache.
+      #
+      # ==== Example
+      #
+      #   # Insert records and skip inserting any duplicates.
+      #   # Here "Eloquent Ruby" is skipped because its id is not unique.
+      #
+      #   Book.insert_all([
+      #     { id: 1, title: "Rework", author: "David" },
+      #     { id: 1, title: "Eloquent Ruby", author: "Russ" }
+      #   ])
+      def insert_all(attributes, returning: nil, unique_by: nil)
+        InsertAll.new(self, attributes, on_duplicate: :skip, returning: returning, unique_by: unique_by).execute
+      end
+
+      # Inserts a single record into the database in a single SQL INSERT
+      # statement. It does not instantiate any models nor does it trigger
+      # Active Record callbacks or validations. Though passed values
+      # go through Active Record's type casting and serialization.
+      #
+      # See <tt>ActiveRecord::Persistence#insert_all!</tt> for more.
+      def insert!(attributes, returning: nil)
+        insert_all!([ attributes ], returning: returning)
+      end
+
+      # Inserts multiple records into the database in a single SQL INSERT
+      # statement. It does not instantiate any models nor does it trigger
+      # Active Record callbacks or validations. Though passed values
+      # go through Active Record's type casting and serialization.
+      #
+      # The +attributes+ parameter is an Array of Hashes. Every Hash determines
+      # the attributes for a single row and must have the same keys.
+      #
+      # Raises <tt>ActiveRecord::RecordNotUnique</tt> if any rows violate a
+      # unique index on the table. In that case, no rows are inserted.
+      #
+      # To skip duplicate rows, see <tt>ActiveRecord::Persistence#insert_all</tt>.
+      # To replace them, see <tt>ActiveRecord::Persistence#upsert_all</tt>.
+      #
+      # Returns an <tt>ActiveRecord::Result</tt> with its contents based on
+      # <tt>:returning</tt> (see below).
+      #
+      # ==== Options
+      #
+      # [:returning]
+      #   (PostgreSQL only) An array of attributes to return for all successfully
+      #   inserted records, which by default is the primary key.
+      #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
+      #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
+      #   clause entirely.
+      #
+      # ==== Examples
+      #
+      #   # Insert multiple records
+      #   Book.insert_all!([
+      #     { title: "Rework", author: "David" },
+      #     { title: "Eloquent Ruby", author: "Russ" }
+      #   ])
+      #
+      #   # Raises ActiveRecord::RecordNotUnique because "Eloquent Ruby"
+      #   # does not have a unique id.
+      #   Book.insert_all!([
+      #     { id: 1, title: "Rework", author: "David" },
+      #     { id: 1, title: "Eloquent Ruby", author: "Russ" }
+      #   ])
+      def insert_all!(attributes, returning: nil)
+        InsertAll.new(self, attributes, on_duplicate: :raise, returning: returning).execute
+      end
+
+      # Updates or inserts (upserts) a single record into the database in a
+      # single SQL INSERT statement. It does not instantiate any models nor does
+      # it trigger Active Record callbacks or validations. Though passed values
+      # go through Active Record's type casting and serialization.
+      #
+      # See <tt>ActiveRecord::Persistence#upsert_all</tt> for documentation.
+      def upsert(attributes, returning: nil, unique_by: nil)
+        upsert_all([ attributes ], returning: returning, unique_by: unique_by)
+      end
+
+      # Updates or inserts (upserts) multiple records into the database in a
+      # single SQL INSERT statement. It does not instantiate any models nor does
+      # it trigger Active Record callbacks or validations. Though passed values
+      # go through Active Record's type casting and serialization.
+      #
+      # The +attributes+ parameter is an Array of Hashes. Every Hash determines
+      # the attributes for a single row and must have the same keys.
+      #
+      # Returns an <tt>ActiveRecord::Result</tt> with its contents based on
+      # <tt>:returning</tt> (see below).
+      #
+      # ==== Options
+      #
+      # [:returning]
+      #   (PostgreSQL only) An array of attributes to return for all successfully
+      #   inserted records, which by default is the primary key.
+      #   Pass <tt>returning: %w[ id name ]</tt> for both id and name
+      #   or <tt>returning: false</tt> to omit the underlying <tt>RETURNING</tt> SQL
+      #   clause entirely.
+      #
+      # [:unique_by]
+      #   (PostgreSQL and SQLite only) By default rows are considered to be unique
+      #   by every unique index on the table. Any duplicate rows are skipped.
+      #
+      #   To skip rows according to just one unique index pass <tt>:unique_by</tt>.
+      #
+      #   Consider a Book model where no duplicate ISBNs make sense, but if any
+      #   row has an existing id, or is not unique by another unique index,
+      #   <tt>ActiveRecord::RecordNotUnique</tt> is raised.
+      #
+      #   Unique indexes can be identified by columns or name:
+      #
+      #     unique_by: :isbn
+      #     unique_by: %i[ author_id name ]
+      #     unique_by: :index_books_on_isbn
+      #
+      # Because it relies on the index information from the database
+      # <tt>:unique_by</tt> is recommended to be paired with
+      # Active Record's schema_cache.
+      #
+      # ==== Examples
+      #
+      #   # Inserts multiple records, performing an upsert when records have duplicate ISBNs.
+      #   # Here "Eloquent Ruby" overwrites "Rework" because its ISBN is duplicate.
+      #
+      #   Book.upsert_all([
+      #     { title: "Rework", author: "David", isbn: "1" },
+      #     { title: "Eloquent Ruby", author: "Russ", isbn: "1" }
+      #   ], unique_by: :isbn)
+      #
+      #   Book.find_by(isbn: "1").title # => "Eloquent Ruby"
+      def upsert_all(attributes, returning: nil, unique_by: nil)
+        InsertAll.new(self, attributes, on_duplicate: :update, returning: returning, unique_by: unique_by).execute
+      end
+
       # Given an attributes hash, +instantiate+ returns a new instance of
       # the appropriate class. Accepts only keys as strings.
       #
@@ -61,15 +251,158 @@ module ActiveRecord
       # +instantiate+ instead of +new+, finder methods ensure they get new
       # instances of the appropriate class for each record.
       #
-      # See +ActiveRecord::Inheritance#discriminate_class_for_record+ to see
+      # See <tt>ActiveRecord::Inheritance#discriminate_class_for_record</tt> to see
       # how this "single-table" inheritance mapping is implemented.
-      def instantiate(attributes, column_types = {})
+      def instantiate(attributes, column_types = {}, &block)
         klass = discriminate_class_for_record(attributes)
-        attributes = klass.attributes_builder.build_from_database(attributes, column_types)
-        klass.allocate.init_with('attributes' => attributes, 'new_record' => false)
+        instantiate_instance_of(klass, attributes, column_types, &block)
+      end
+
+      # Updates an object (or multiple objects) and saves it to the database, if validations pass.
+      # The resulting object is returned whether the object was saved successfully to the database or not.
+      #
+      # ==== Parameters
+      #
+      # * +id+ - This should be the id or an array of ids to be updated.
+      # * +attributes+ - This should be a hash of attributes or an array of hashes.
+      #
+      # ==== Examples
+      #
+      #   # Updates one record
+      #   Person.update(15, user_name: "Samuel", group: "expert")
+      #
+      #   # Updates multiple records
+      #   people = { 1 => { "first_name" => "David" }, 2 => { "first_name" => "Jeremy" } }
+      #   Person.update(people.keys, people.values)
+      #
+      #   # Updates multiple records from the result of a relation
+      #   people = Person.where(group: "expert")
+      #   people.update(group: "masters")
+      #
+      # Note: Updating a large number of records will run an UPDATE
+      # query for each record, which may cause a performance issue.
+      # When running callbacks is not needed for each record update,
+      # it is preferred to use {update_all}[rdoc-ref:Relation#update_all]
+      # for updating all records in a single query.
+      def update(id = :all, attributes)
+        if id.is_a?(Array)
+          id.map { |one_id| find(one_id) }.each_with_index { |object, idx|
+            object.update(attributes[idx])
+          }
+        elsif id == :all
+          all.each { |record| record.update(attributes) }
+        else
+          if ActiveRecord::Base === id
+            raise ArgumentError,
+              "You are passing an instance of ActiveRecord::Base to `update`. " \
+              "Please pass the id of the object by calling `.id`."
+          end
+          object = find(id)
+          object.update(attributes)
+          object
+        end
+      end
+
+      # Destroy an object (or multiple objects) that has the given id. The object is instantiated first,
+      # therefore all callbacks and filters are fired off before the object is deleted. This method is
+      # less efficient than #delete but allows cleanup methods and other actions to be run.
+      #
+      # This essentially finds the object (or multiple objects) with the given id, creates a new object
+      # from the attributes, and then calls destroy on it.
+      #
+      # ==== Parameters
+      #
+      # * +id+ - This should be the id or an array of ids to be destroyed.
+      #
+      # ==== Examples
+      #
+      #   # Destroy a single object
+      #   Todo.destroy(1)
+      #
+      #   # Destroy multiple objects
+      #   todos = [1,2,3]
+      #   Todo.destroy(todos)
+      def destroy(id)
+        if id.is_a?(Array)
+          find(id).each(&:destroy)
+        else
+          find(id).destroy
+        end
+      end
+
+      # Deletes the row with a primary key matching the +id+ argument, using an
+      # SQL +DELETE+ statement, and returns the number of rows deleted. Active
+      # Record objects are not instantiated, so the object's callbacks are not
+      # executed, including any <tt>:dependent</tt> association options.
+      #
+      # You can delete multiple rows at once by passing an Array of <tt>id</tt>s.
+      #
+      # Note: Although it is often much faster than the alternative, #destroy,
+      # skipping callbacks might bypass business logic in your application
+      # that ensures referential integrity or performs other essential jobs.
+      #
+      # ==== Examples
+      #
+      #   # Delete a single row
+      #   Todo.delete(1)
+      #
+      #   # Delete multiple rows
+      #   Todo.delete([2,3,4])
+      def delete(id_or_array)
+        delete_by(primary_key => id_or_array)
+      end
+
+      def _insert_record(values) # :nodoc:
+        primary_key = self.primary_key
+        primary_key_value = nil
+
+        if primary_key && Hash === values
+          primary_key_value = values[primary_key]
+
+          if !primary_key_value && prefetch_primary_key?
+            primary_key_value = next_sequence_value
+            values[primary_key] = primary_key_value
+          end
+        end
+
+        if values.empty?
+          im = arel_table.compile_insert(connection.empty_insert_statement_value(primary_key))
+          im.into arel_table
+        else
+          im = arel_table.compile_insert(_substitute_values(values))
+        end
+
+        connection.insert(im, "#{self} Create", primary_key || false, primary_key_value)
+      end
+
+      def _update_record(values, constraints) # :nodoc:
+        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
+        um = arel_table.where(
+          constraints.reduce(&:and)
+        ).compile_update(_substitute_values(values), primary_key)
+
+        connection.update(um, "#{self} Update")
+      end
+
+      def _delete_record(constraints) # :nodoc:
+        constraints = _substitute_values(constraints).map { |attr, bind| attr.eq(bind) }
+
+        dm = Arel::DeleteManager.new
+        dm.from(arel_table)
+        dm.wheres = constraints
+
+        connection.delete(dm, "#{self} Destroy")
       end
 
       private
+        # Given a class, an attributes hash, +instantiate_instance_of+ returns a
+        # new instance of the class. Accepts only keys as strings.
+        def instantiate_instance_of(klass, attributes, column_types = {}, &block)
+          attributes = klass.attributes_builder.build_from_database(attributes, column_types)
+          klass.allocate.init_with_attributes(attributes, &block)
+        end
+
         # Called by +instantiate+ to decide which class to use for a new
         # record instance.
         #
@@ -78,68 +411,96 @@ module ActiveRecord
         def discriminate_class_for_record(record)
           self
         end
+
+        def _substitute_values(values)
+          values.map do |name, value|
+            attr = arel_attribute(name)
+            bind = predicate_builder.build_bind_attribute(name, value)
+            [attr, bind]
+          end
+        end
     end
 
     # Returns true if this object hasn't been saved yet -- that is, a record
     # for the object doesn't exist in the database yet; otherwise, returns false.
     def new_record?
-      sync_with_transaction_state
+      sync_with_transaction_state if @transaction_state&.finalized?
       @new_record
     end
 
     # Returns true if this object has been destroyed, otherwise returns false.
     def destroyed?
-      sync_with_transaction_state
+      sync_with_transaction_state if @transaction_state&.finalized?
       @destroyed
     end
 
     # Returns true if the record is persisted, i.e. it's not a new record and it was
     # not destroyed, otherwise returns false.
     def persisted?
-      !(new_record? || destroyed?)
+      sync_with_transaction_state if @transaction_state&.finalized?
+      !(@new_record || @destroyed)
     end
 
+    ##
+    # :call-seq:
+    #   save(*args)
+    #
     # Saves the model.
     #
-    # If the model is new a record gets created in the database, otherwise
+    # If the model is new, a record gets created in the database, otherwise
     # the existing record gets updated.
     #
-    # By default, save always run validations. If any of them fail the action
-    # is cancelled and +save+ returns +false+. However, if you supply
-    # validate: false, validations are bypassed altogether. See
+    # By default, save always runs validations. If any of them fail the action
+    # is cancelled and #save returns +false+, and the record won't be saved. However, if you supply
+    # <tt>validate: false</tt>, validations are bypassed altogether. See
     # ActiveRecord::Validations for more information.
     #
-    # There's a series of callbacks associated with +save+. If any of the
-    # <tt>before_*</tt> callbacks return +false+ the action is cancelled and
-    # +save+ returns +false+. See ActiveRecord::Callbacks for further
+    # By default, #save also sets the +updated_at+/+updated_on+ attributes to
+    # the current time. However, if you supply <tt>touch: false</tt>, these
+    # timestamps will not be updated.
+    #
+    # There's a series of callbacks associated with #save. If any of the
+    # <tt>before_*</tt> callbacks throws +:abort+ the action is cancelled and
+    # #save returns +false+. See ActiveRecord::Callbacks for further
     # details.
     #
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
-    def save(*)
-      create_or_update
+    def save(*args, &block)
+      create_or_update(*args, &block)
     rescue ActiveRecord::RecordInvalid
       false
     end
 
+    ##
+    # :call-seq:
+    #   save!(*args)
+    #
     # Saves the model.
     #
-    # If the model is new a record gets created in the database, otherwise
+    # If the model is new, a record gets created in the database, otherwise
     # the existing record gets updated.
     #
-    # With <tt>save!</tt> validations always run. If any of them fail
-    # ActiveRecord::RecordInvalid gets raised. See ActiveRecord::Validations
-    # for more information.
+    # By default, #save! always runs validations. If any of them fail
+    # ActiveRecord::RecordInvalid gets raised, and the record won't be saved. However, if you supply
+    # <tt>validate: false</tt>, validations are bypassed altogether. See
+    # ActiveRecord::Validations for more information.
     #
-    # There's a series of callbacks associated with <tt>save!</tt>. If any of
-    # the <tt>before_*</tt> callbacks return +false+ the action is cancelled
-    # and <tt>save!</tt> raises ActiveRecord::RecordNotSaved. See
+    # By default, #save! also sets the +updated_at+/+updated_on+ attributes to
+    # the current time. However, if you supply <tt>touch: false</tt>, these
+    # timestamps will not be updated.
+    #
+    # There's a series of callbacks associated with #save!. If any of
+    # the <tt>before_*</tt> callbacks throws +:abort+ the action is cancelled
+    # and #save! raises ActiveRecord::RecordNotSaved. See
     # ActiveRecord::Callbacks for further details.
     #
     # Attributes marked as readonly are silently ignored if the record is
     # being updated.
-    def save!(*)
-      create_or_update || raise(RecordNotSaved.new("Failed to save the record", self))
+    #
+    # Unless an error is raised, returns true.
+    def save!(*args, &block)
+      create_or_update(*args, &block) || raise(RecordNotSaved.new("Failed to save the record", self))
     end
 
     # Deletes the record in the database and freezes this instance to
@@ -149,11 +510,13 @@ module ActiveRecord
     # The row is simply removed with an SQL +DELETE+ statement on the
     # record's primary key, and no callbacks are executed.
     #
+    # Note that this will also delete records marked as {#readonly?}[rdoc-ref:Core#readonly?].
+    #
     # To enforce the object's +before_destroy+ and +after_destroy+
     # callbacks or any <tt>:dependent</tt> association
     # options, use <tt>#destroy</tt>.
     def delete
-      self.class.delete(id) if persisted?
+      _delete_row if persisted?
       @destroyed = true
       freeze
     end
@@ -161,15 +524,18 @@ module ActiveRecord
     # Deletes the record in the database and freezes this instance to reflect
     # that no changes should be made (since they can't be persisted).
     #
-    # There's a series of callbacks associated with <tt>destroy</tt>. If
-    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
-    # and <tt>destroy</tt> returns +false+. See
-    # ActiveRecord::Callbacks for further details.
+    # There's a series of callbacks associated with #destroy. If the
+    # <tt>before_destroy</tt> callback throws +:abort+ the action is cancelled
+    # and #destroy returns +false+.
+    # See ActiveRecord::Callbacks for further details.
     def destroy
-      raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
+      _raise_readonly_record_error if readonly?
       destroy_associations
-      self.class.connection.add_transaction_record(self)
-      destroy_row if persisted?
+      @_trigger_destroy_callback = if persisted?
+        destroy_row > 0
+      else
+        true
+      end
       @destroyed = true
       freeze
     end
@@ -177,12 +543,12 @@ module ActiveRecord
     # Deletes the record in the database and freezes this instance to reflect
     # that no changes should be made (since they can't be persisted).
     #
-    # There's a series of callbacks associated with <tt>destroy!</tt>. If
-    # the <tt>before_destroy</tt> callback return +false+ the action is cancelled
-    # and <tt>destroy!</tt> raises ActiveRecord::RecordNotDestroyed. See
-    # ActiveRecord::Callbacks for further details.
+    # There's a series of callbacks associated with #destroy!. If the
+    # <tt>before_destroy</tt> callback throws +:abort+ the action is cancelled
+    # and #destroy! raises ActiveRecord::RecordNotDestroyed.
+    # See ActiveRecord::Callbacks for further details.
     def destroy!
-      destroy || raise(RecordNotDestroyed.new("Failed to destroy the record", self))
+      destroy || _raise_record_not_destroyed
     end
 
     # Returns an instance of the specified +klass+ with the attributes of the
@@ -194,19 +560,21 @@ module ActiveRecord
     # instance using the companies/company partial instead of clients/client.
     #
     # Note: The new instance will share a link to the same attributes as the original class.
-    # So any change to the attributes in either instance will affect the other.
+    # Therefore the sti column value will still be the same.
+    # Any change to the attributes on either instance will affect both instances.
+    # If you want to change the sti column as well, use #becomes! instead.
     def becomes(klass)
-      became = klass.new
+      became = klass.allocate
+      became.send(:initialize)
       became.instance_variable_set("@attributes", @attributes)
-      changed_attributes = @changed_attributes if defined?(@changed_attributes)
-      became.instance_variable_set("@changed_attributes", changed_attributes || {})
+      became.instance_variable_set("@mutations_from_database", @mutations_from_database ||= nil)
       became.instance_variable_set("@new_record", new_record?)
       became.instance_variable_set("@destroyed", destroyed?)
-      became.instance_variable_set("@errors", errors)
+      became.errors.copy!(errors)
       became
     end
 
-    # Wrapper around +becomes+ that also changes the instance's sti column value.
+    # Wrapper around #becomes that also changes the instance's sti column value.
     # This is especially useful if you want to persist the changed class in your
     # database.
     #
@@ -226,18 +594,19 @@ module ActiveRecord
     # This is especially useful for boolean flags on existing records. Also note that
     #
     # * Validation is skipped.
-    # * Callbacks are invoked.
+    # * \Callbacks are invoked.
     # * updated_at/updated_on column is updated if that column is available.
     # * Updates all the attributes that are dirty in this object.
     #
-    # This method raises an +ActiveRecord::ActiveRecordError+  if the
+    # This method raises an ActiveRecord::ActiveRecordError  if the
     # attribute is marked as readonly.
     #
-    # See also +update_column+.
+    # Also see #update_column.
     def update_attribute(name, value)
       name = name.to_s
       verify_readonly_attribute(name)
-      send("#{name}=", value)
+      public_send("#{name}=", value)
+
       save(validate: false)
     end
 
@@ -254,9 +623,10 @@ module ActiveRecord
     end
 
     alias update_attributes update
+    deprecate update_attributes: "please, use update instead"
 
-    # Updates its receiver just like +update+ but calls <tt>save!</tt> instead
-    # of +save+, so an exception is raised if the record is invalid.
+    # Updates its receiver just like #update but calls #save! instead
+    # of +save+, so an exception is raised if the record is invalid and saving will fail.
     def update!(attributes)
       # The following transaction covers any possible database side-effects of the
       # attributes assignment. For example, setting the IDs of a child collection.
@@ -267,6 +637,7 @@ module ActiveRecord
     end
 
     alias update_attributes! update!
+    deprecate update_attributes!: "please, use update! instead"
 
     # Equivalent to <code>update_columns(name => value)</code>.
     def update_column(name, value)
@@ -282,27 +653,37 @@ module ActiveRecord
     # the database, but take into account that in consequence the regular update
     # procedures are totally bypassed. In particular:
     #
-    # * Validations are skipped.
-    # * Callbacks are skipped.
+    # * \Validations are skipped.
+    # * \Callbacks are skipped.
     # * +updated_at+/+updated_on+ are not updated.
+    # * However, attributes are serialized with the same rules as ActiveRecord::Relation#update_all
     #
-    # This method raises an +ActiveRecord::ActiveRecordError+ when called on new
+    # This method raises an ActiveRecord::ActiveRecordError when called on new
     # objects, or when at least one of the attributes is marked as readonly.
     def update_columns(attributes)
       raise ActiveRecordError, "cannot update a new record" if new_record?
       raise ActiveRecordError, "cannot update a destroyed record" if destroyed?
 
-      attributes.each_key do |key|
-        verify_readonly_attribute(key.to_s)
+      attributes = attributes.transform_keys do |key|
+        name = key.to_s
+        self.class.attribute_aliases[name] || name
       end
 
-      updated_count = self.class.unscoped.where(self.class.primary_key => id).update_all(attributes)
+      attributes.each_key do |key|
+        verify_readonly_attribute(key)
+      end
 
+      id_in_database = self.id_in_database
       attributes.each do |k, v|
-        raw_write_attribute(k, v)
+        write_attribute_without_type_cast(k, v)
       end
 
-      updated_count == 1
+      affected_rows = self.class._update_record(
+        attributes,
+        @primary_key => id_in_database
+      )
+
+      affected_rows == 1
     end
 
     # Initializes +attribute+ to zero if +nil+ and adds the value passed as +by+ (default is 1).
@@ -314,42 +695,56 @@ module ActiveRecord
       self
     end
 
-    # Wrapper around +increment+ that saves the record. This method differs from
-    # its non-bang version in that it passes through the attribute setter.
-    # Saving is not subjected to validation checks. Returns +true+ if the
-    # record could be saved.
-    def increment!(attribute, by = 1)
-      increment(attribute, by).update_attribute(attribute, self[attribute])
+    # Wrapper around #increment that writes the update to the database.
+    # Only +attribute+ is updated; the record itself is not saved.
+    # This means that any other modified attributes will still be dirty.
+    # Validations and callbacks are skipped. Supports the +touch+ option from
+    # +update_counters+, see that for more.
+    # Returns +self+.
+    def increment!(attribute, by = 1, touch: nil)
+      increment(attribute, by)
+      change = public_send(attribute) - (attribute_in_database(attribute.to_s) || 0)
+      self.class.update_counters(id, attribute => change, touch: touch)
+      clear_attribute_change(attribute) # eww
+      self
     end
 
     # Initializes +attribute+ to zero if +nil+ and subtracts the value passed as +by+ (default is 1).
     # The decrement is performed directly on the underlying attribute, no setter is invoked.
     # Only makes sense for number-based attributes. Returns +self+.
     def decrement(attribute, by = 1)
-      self[attribute] ||= 0
-      self[attribute] -= by
-      self
+      increment(attribute, -by)
     end
 
-    # Wrapper around +decrement+ that saves the record. This method differs from
-    # its non-bang version in that it passes through the attribute setter.
-    # Saving is not subjected to validation checks. Returns +true+ if the
-    # record could be saved.
-    def decrement!(attribute, by = 1)
-      decrement(attribute, by).update_attribute(attribute, self[attribute])
+    # Wrapper around #decrement that writes the update to the database.
+    # Only +attribute+ is updated; the record itself is not saved.
+    # This means that any other modified attributes will still be dirty.
+    # Validations and callbacks are skipped. Supports the +touch+ option from
+    # +update_counters+, see that for more.
+    # Returns +self+.
+    def decrement!(attribute, by = 1, touch: nil)
+      increment!(attribute, -by, touch: touch)
     end
 
     # Assigns to +attribute+ the boolean opposite of <tt>attribute?</tt>. So
     # if the predicate returns +true+ the attribute will become +false+. This
     # method toggles directly the underlying value without calling any setter.
     # Returns +self+.
+    #
+    # Example:
+    #
+    #   user = User.first
+    #   user.banned? # => false
+    #   user.toggle(:banned)
+    #   user.banned? # => true
+    #
     def toggle(attribute)
-      self[attribute] = !send("#{attribute}?")
+      self[attribute] = !public_send("#{attribute}?")
       self
     end
 
-    # Wrapper around +toggle+ that saves the record. This method differs from
-    # its non-bang version in that it passes through the attribute setter.
+    # Wrapper around #toggle that saves the record. This method differs from
+    # its non-bang version in the sense that it passes through the attribute setter.
     # Saving is not subjected to validation checks. Returns +true+ if the
     # record could be saved.
     def toggle!(attribute)
@@ -358,8 +753,8 @@ module ActiveRecord
 
     # Reloads the record from the database.
     #
-    # This method finds record by its primary key (which could be assigned manually) and
-    # modifies the receiver in-place:
+    # This method finds the record by its primary key (which could be assigned
+    # manually) and modifies the receiver in-place:
     #
     #   account = Account.new
     #   # => #<Account id: nil, email: nil>
@@ -371,7 +766,7 @@ module ActiveRecord
     # Attributes are reloaded from the database, and caches busted, in
     # particular the associations cache and the QueryCache.
     #
-    # If the record no longer exists in the database <tt>ActiveRecord::RecordNotFound</tt>
+    # If the record no longer exists in the database ActiveRecord::RecordNotFound
     # is raised. Otherwise, in addition to the in-place modification the method
     # returns +self+ for convenience.
     #
@@ -405,8 +800,6 @@ module ActiveRecord
     #   end
     #
     def reload(options = nil)
-      clear_aggregation_cache
-      clear_association_cache
       self.class.connection.clear_query_cache
 
       fresh_object =
@@ -416,24 +809,27 @@ module ActiveRecord
           self.class.unscoped { self.class.find(id) }
         end
 
-      @attributes = fresh_object.instance_variable_get('@attributes')
+      @attributes = fresh_object.instance_variable_get("@attributes")
       @new_record = false
       self
     end
 
-    # Saves the record with the updated_at/on attributes set to the current time.
+    # Saves the record with the updated_at/on attributes set to the current time
+    # or the time specified.
     # Please note that no validation is performed and only the +after_touch+,
     # +after_commit+ and +after_rollback+ callbacks are executed.
     #
+    # This method can be passed attribute names and an optional time argument.
     # If attribute names are passed, they are updated along with updated_at/on
-    # attributes.
+    # attributes. If no time argument is passed, the current time is used as default.
     #
-    #   product.touch                         # updates updated_at/on
+    #   product.touch                         # updates updated_at/on with current time
+    #   product.touch(time: Time.new(2015, 2, 16, 0, 0, 0)) # updates updated_at/on with specified time
     #   product.touch(:designed_at)           # updates the designed_at attribute and updated_at/on
     #   product.touch(:started_at, :ended_at) # updates started_at, ended_at and updated_at/on attributes
     #
-    # If used along with +belongs_to+ then +touch+ will invoke +touch+ method on
-    # associated object.
+    # If used along with {belongs_to}[rdoc-ref:Associations::ClassMethods#belongs_to]
+    # then +touch+ will invoke +touch+ method on associated object.
     #
     #   class Brake < ActiveRecord::Base
     #     belongs_to :car, touch: true
@@ -452,26 +848,22 @@ module ActiveRecord
     #   ball = Ball.new
     #   ball.touch(:updated_at)   # => raises ActiveRecordError
     #
-    def touch(*names)
-      raise ActiveRecordError, "cannot touch on a new record object" unless persisted?
-
-      attributes = timestamp_attributes_for_update_in_model
-      attributes.concat(names)
-
-      unless attributes.empty?
-        current_time = current_time_from_proper_timezone
-        changes = {}
-
-        attributes.each do |column|
-          column = column.to_s
-          changes[column] = write_attribute(column, current_time)
-        end
+    def touch(*names, time: nil)
+      unless persisted?
+        raise ActiveRecordError, <<-MSG.squish
+          cannot touch on a new or destroyed record object. Consider using
+          persisted?, new_record?, or destroyed? before touching
+        MSG
+      end
 
-        changes[self.class.locking_column] = increment_lock if locking_enabled?
+      attribute_names = timestamp_attributes_for_update_in_model
+      attribute_names |= names.map!(&:to_s).map! { |name|
+        self.class.attribute_aliases[name] || name
+      }
 
-        clear_attribute_changes(changes.keys)
-        primary_key = self.class.primary_key
-        self.class.unscoped.where(primary_key => self[primary_key]).update_all(changes) == 1
+      unless attribute_names.empty?
+        affected_rows = _touch_row(attribute_names, time)
+        @_trigger_update_callback = affected_rows == 1
       else
         true
       end
@@ -484,52 +876,92 @@ module ActiveRecord
     end
 
     def destroy_row
-      relation_for_destroy.delete_all
+      _delete_row
+    end
+
+    def _delete_row
+      self.class._delete_record(@primary_key => id_in_database)
     end
 
-    def relation_for_destroy
-      pk         = self.class.primary_key
-      column     = self.class.columns_hash[pk]
-      substitute = self.class.connection.substitute_at(column)
+    def _touch_row(attribute_names, time)
+      time ||= current_time_from_proper_timezone
 
-      relation = self.class.unscoped.where(
-        self.class.arel_table[pk].eq(substitute))
+      attribute_names.each do |attr_name|
+        _write_attribute(attr_name, time)
+      end
+
+      _update_row(attribute_names, "touch")
+    end
 
-      relation.bind_values = [[column, id]]
-      relation
+    def _update_row(attribute_names, attempted_action = "update")
+      self.class._update_record(
+        attributes_with_values(attribute_names),
+        @primary_key => id_in_database
+      )
     end
 
-    def create_or_update
-      raise ReadOnlyRecord, "#{self.class} is marked as readonly" if readonly?
-      result = new_record? ? _create_record : _update_record
+    def create_or_update(**, &block)
+      _raise_readonly_record_error if readonly?
+      return false if destroyed?
+      result = new_record? ? _create_record(&block) : _update_record(&block)
       result != false
     end
 
     # Updates the associated record with values matching those of the instance attributes.
     # Returns the number of affected rows.
     def _update_record(attribute_names = self.attribute_names)
-      attributes_values = arel_attributes_with_values_for_update(attribute_names)
-      if attributes_values.empty?
-        0
+      attribute_names = attributes_for_update(attribute_names)
+
+      if attribute_names.empty?
+        affected_rows = 0
+        @_trigger_update_callback = true
       else
-        self.class.unscoped._update_record attributes_values, id, id_was
+        affected_rows = _update_row(attribute_names)
+        @_trigger_update_callback = affected_rows == 1
       end
+
+      yield(self) if block_given?
+
+      affected_rows
     end
 
     # Creates a record with values matching those of the instance attributes
     # and returns its id.
     def _create_record(attribute_names = self.attribute_names)
-      attributes_values = arel_attributes_with_values_for_create(attribute_names)
+      attribute_names = attributes_for_create(attribute_names)
+
+      new_id = self.class._insert_record(
+        attributes_with_values(attribute_names)
+      )
 
-      new_id = self.class.unscoped.insert attributes_values
-      self.id ||= new_id if self.class.primary_key
+      self.id ||= new_id if @primary_key
 
       @new_record = false
+
+      yield(self) if block_given?
+
       id
     end
 
     def verify_readonly_attribute(name)
       raise ActiveRecordError, "#{name} is marked as readonly" if self.class.readonly_attributes.include?(name)
     end
+
+    def _raise_record_not_destroyed
+      @_association_destroy_exception ||= nil
+      raise @_association_destroy_exception || RecordNotDestroyed.new("Failed to destroy the record", self)
+    ensure
+      @_association_destroy_exception = nil
+    end
+
+    # The name of the method used to touch a +belongs_to+ association when the
+    # +:touch+ option is used.
+    def belongs_to_touch_method
+      :touch
+    end
+
+    def _raise_readonly_record_error
+      raise ReadOnlyRecord, "#{self.class} is marked as readonly"
+    end
   end
 end