activerecord 7.0.8.7 → 7.1.0.beta1

data/lib/active_record/persistence.rb

@@ -57,6 +57,36 @@ module ActiveRecord
         end
       end
 
+      # Builds an object (or multiple objects) and returns either the built object or a list of built
+      # objects.
+      #
+      # The +attributes+ parameter can be either a Hash or an Array of Hashes. These Hashes describe the
+      # attributes on the objects that are to be built.
+      #
+      # ==== Examples
+      #   # Build a single new object
+      #   User.build(first_name: 'Jamie')
+      #
+      #   # Build an Array of new objects
+      #   User.build([{ first_name: 'Jamie' }, { first_name: 'Jeremy' }])
+      #
+      #   # Build a single object and pass it into a block to set other attributes.
+      #   User.build(first_name: 'Jamie') do |u|
+      #     u.is_admin = false
+      #   end
+      #
+      #   # Building an Array of new objects using a block, where the block is executed for each object:
+      #   User.build([{ first_name: 'Jamie' }, { first_name: 'Jeremy' }]) do |u|
+      #     u.is_admin = false
+      #   end
+      def build(attributes = nil, &block)
+        if attributes.is_a?(Array)
+          attributes.collect { |attr| build(attr, &block) }
+        else
+          new(attributes, &block)
+        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
@@ -92,7 +122,7 @@ module ActiveRecord
       #   clause entirely.
       #
       #   You can also pass an SQL string if you need more control on the return values
-      #   (for example, <tt>returning: "id, name as new_name"</tt>).
+      #   (for example, <tt>returning: Arel.sql("id, name as new_name")</tt>).
       #
       # [:unique_by]
       #   (PostgreSQL and SQLite only) By default rows are considered to be unique
@@ -102,7 +132,7 @@ module ActiveRecord
       #
       #   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.
+      #   ActiveRecord::RecordNotUnique is raised.
       #
       #   Unique indexes can be identified by columns or name:
       #
@@ -164,7 +194,7 @@ module ActiveRecord
       # 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
+      # Raises ActiveRecord::RecordNotUnique if any rows violate a
       # unique index on the table. In that case, no rows are inserted.
       #
       # To skip duplicate rows, see #insert_all. To replace them, see #upsert_all.
@@ -182,7 +212,7 @@ module ActiveRecord
       #   clause entirely.
       #
       #   You can also pass an SQL string if you need more control on the return values
-      #   (for example, <tt>returning: "id, name as new_name"</tt>).
+      #   (for example, <tt>returning: Arel.sql("id, name as new_name")</tt>).
       #
       # [:record_timestamps]
       #   By default, automatic setting of timestamp columns is controlled by
@@ -219,8 +249,8 @@ module ActiveRecord
       # go through Active Record's type casting and serialization.
       #
       # See #upsert_all for documentation.
-      def upsert(attributes, on_duplicate: :update, returning: nil, unique_by: nil, record_timestamps: nil)
-        upsert_all([ attributes ], on_duplicate: on_duplicate, returning: returning, unique_by: unique_by, record_timestamps: record_timestamps)
+      def upsert(attributes, **kwargs)
+        upsert_all([ attributes ], **kwargs)
       end
 
       # Updates or inserts (upserts) multiple records into the database in a
@@ -248,7 +278,7 @@ module ActiveRecord
       #   clause entirely.
       #
       #   You can also pass an SQL string if you need more control on the return values
-      #   (for example, <tt>returning: "id, name as new_name"</tt>).
+      #   (for example, <tt>returning: Arel.sql("id, name as new_name")</tt>).
       #
       # [:unique_by]
       #   (PostgreSQL and SQLite only) By default rows are considered to be unique
@@ -258,7 +288,7 @@ module ActiveRecord
       #
       #   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.
+      #   ActiveRecord::RecordNotUnique is raised.
       #
       #   Unique indexes can be identified by columns or name:
       #
@@ -425,6 +455,62 @@ module ActiveRecord
         end
       end
 
+      # Accepts a list of attribute names to be used in the WHERE clause
+      # of SELECT / UPDATE / DELETE queries and in the ORDER BY clause for `#first` and `#last` finder methods.
+      #
+      #   class Developer < ActiveRecord::Base
+      #     query_constraints :company_id, :id
+      #   end
+      #
+      #   developer = Developer.first
+      #   # SELECT "developers".* FROM "developers" ORDER BY "developers"."company_id" ASC, "developers"."id" ASC LIMIT 1
+      #   developer.inspect # => #<Developer id: 1, company_id: 1, ...>
+      #
+      #   developer.update!(name: "Nikita")
+      #   # UPDATE "developers" SET "name" = 'Nikita' WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   It is possible to update attribute used in the query_by clause:
+      #   developer.update!(company_id: 2)
+      #   # UPDATE "developers" SET "company_id" = 2 WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   developer.name = "Bob"
+      #   developer.save!
+      #   # UPDATE "developers" SET "name" = 'Bob' WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   developer.destroy!
+      #   # DELETE FROM "developers" WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   developer.delete
+      #   # DELETE FROM "developers" WHERE "developers"."company_id" = 1 AND "developers"."id" = 1
+      #
+      #   developer.reload
+      #   # SELECT "developers".* FROM "developers" WHERE "developers"."company_id" = 1 AND "developers"."id" = 1 LIMIT 1
+      def query_constraints(*columns_list)
+        raise ArgumentError, "You must specify at least one column to be used in querying" if columns_list.empty?
+
+        @query_constraints_list = columns_list.map(&:to_s)
+        @has_query_constraints = @query_constraints_list
+      end
+
+      def has_query_constraints? # :nodoc:
+        @has_query_constraints
+      end
+
+      def query_constraints_list # :nodoc:
+        @query_constraints_list ||= if base_class? || primary_key != base_class.primary_key
+          primary_key if primary_key.is_a?(Array)
+        else
+          base_class.query_constraints_list
+        end
+      end
+
+      # Returns an array of column names to be used in queries. The source of column
+      # names is derived from +query_constraints_list+ or +primary_key+. This method
+      # is for internal use when the primary key is to be treated as an array.
+      def composite_query_constraints_list # :nodoc:
+        @composite_query_constraints_list ||= query_constraints_list || Array(primary_key)
+      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.
@@ -445,7 +531,13 @@ module ActiveRecord
       #   todos = [1,2,3]
       #   Todo.destroy(todos)
       def destroy(id)
-        if id.is_a?(Array)
+        multiple_ids = if composite_primary_key?
+          id.first.is_a?(Array)
+        else
+          id.is_a?(Array)
+        end
+
+        if multiple_ids
           find(id).each(&:destroy)
         else
           find(id).destroy
@@ -474,7 +566,7 @@ module ActiveRecord
         delete_by(primary_key => id_or_array)
       end
 
-      def _insert_record(values) # :nodoc:
+      def _insert_record(values, returning) # :nodoc:
         primary_key = self.primary_key
         primary_key_value = nil
 
@@ -493,7 +585,10 @@ module ActiveRecord
           im.insert(values.transform_keys { |name| arel_table[name] })
         end
 
-        connection.insert(im, "#{self} Create", primary_key || false, primary_key_value)
+        connection.insert(
+          im, "#{self} Create", primary_key || false, primary_key_value,
+          returning: returning
+        )
       end
 
       def _update_record(values, constraints) # :nodoc:
@@ -530,6 +625,14 @@ module ActiveRecord
       end
 
       private
+        def inherited(subclass)
+          super
+          subclass.class_eval do
+            @_query_constraints_list = nil
+            @has_query_constraints = false
+          end
+        end
+
         # 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)
@@ -677,11 +780,7 @@ module ActiveRecord
     def destroy
       _raise_readonly_record_error if readonly?
       destroy_associations
-      @_trigger_destroy_callback = if persisted?
-        destroy_row > 0
-      else
-        true
-      end
+      @_trigger_destroy_callback ||= persisted? && destroy_row > 0
       @destroyed = true
       @previously_new_record = false
       freeze
@@ -709,11 +808,14 @@ module ActiveRecord
     # Note: The new instance will share a link to the same attributes as the original class.
     # Therefore the STI column value will still be the same.
     # Any change to the attributes on either instance will affect both instances.
+    # This includes any attribute initialization done by the new instance.
+    #
     # If you want to change the STI column as well, use #becomes! instead.
     def becomes(klass)
       became = klass.allocate
 
       became.send(:initialize) do |becoming|
+        @attributes.reverse_merge!(becoming.instance_variable_get(:@attributes))
         becoming.instance_variable_set(:@attributes, @attributes)
         becoming.instance_variable_set(:@mutations_from_database, @mutations_from_database ||= nil)
         becoming.instance_variable_set(:@new_record, new_record?)
@@ -748,7 +850,7 @@ module ActiveRecord
     # * 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.
     #
     # Also see #update_column.
@@ -760,6 +862,28 @@ module ActiveRecord
       save(validate: false)
     end
 
+    # Updates a single attribute and saves the record.
+    # This is especially useful for boolean flags on existing records. Also note that
+    #
+    # * Validation is skipped.
+    # * \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
+    # attribute is marked as readonly.
+    #
+    # If any of the <tt>before_*</tt> callbacks throws +:abort+ the action is cancelled
+    # and #update_attribute! raises ActiveRecord::RecordNotSaved. See
+    # ActiveRecord::Callbacks for further details.
+    def update_attribute!(name, value)
+      name = name.to_s
+      verify_readonly_attribute(name)
+      public_send("#{name}=", value)
+
+      save!(validate: false)
+    end
+
     # Updates the attributes of the model from the passed-in hash and saves the
     # record, all wrapped in a transaction. If the object is invalid, the saving
     # will fail and false will be returned.
@@ -946,7 +1070,7 @@ module ActiveRecord
       self.class.connection.clear_query_cache
 
       fresh_object = if apply_scoping?(options)
-        _find_record(options)
+        _find_record((options || {}).merge(all_queries: true))
       else
         self.class.unscoped { _find_record(options) }
       end
@@ -997,10 +1121,12 @@ module ActiveRecord
       _raise_readonly_record_error if readonly?
 
       attribute_names = timestamp_attributes_for_update_in_model
-      attribute_names |= names.map! do |name|
+      attribute_names = (attribute_names | names).map! do |name|
         name = name.to_s
-        self.class.attribute_aliases[name] || name
-      end unless names.empty?
+        name = self.class.attribute_aliases[name] || name
+        verify_readonly_attribute(name)
+        name
+      end
 
       unless attribute_names.empty?
         affected_rows = _touch_row(attribute_names, time)
@@ -1011,6 +1137,12 @@ module ActiveRecord
     end
 
   private
+    def init_internals
+      super
+      @_trigger_destroy_callback = @_trigger_update_callback = nil
+      @previously_new_record = false
+    end
+
     def strict_loaded_associations
       @association_cache.find_all do |_, assoc|
         assoc.owner.strict_loading? && !assoc.owner.strict_loading_n_plus_one_only?
@@ -1018,10 +1150,23 @@ module ActiveRecord
     end
 
     def _find_record(options)
+      all_queries = options ? options[:all_queries] : nil
+      base = self.class.all(all_queries: all_queries).preload(strict_loaded_associations)
+
       if options && options[:lock]
-        self.class.preload(strict_loaded_associations).lock(options[:lock]).find(id)
+        base.lock(options[:lock]).find_by!(_in_memory_query_constraints_hash)
+      else
+        base.find_by!(_in_memory_query_constraints_hash)
+      end
+    end
+
+    def _in_memory_query_constraints_hash
+      if self.class.query_constraints_list.nil?
+        { @primary_key => id }
       else
-        self.class.preload(strict_loaded_associations).find(id)
+        self.class.query_constraints_list.index_with do |column_name|
+          attribute(column_name)
+        end
       end
     end
 
@@ -1031,7 +1176,13 @@ module ActiveRecord
     end
 
     def _query_constraints_hash
-      { @primary_key => id_in_database }
+      if self.class.query_constraints_list.nil?
+        { @primary_key => id_in_database }
+      else
+        self.class.query_constraints_list.index_with do |column_name|
+          attribute_in_database(column_name)
+        end
+      end
     end
 
     # A hook to be overridden by association modules.
@@ -1095,11 +1246,16 @@ module ActiveRecord
     def _create_record(attribute_names = self.attribute_names)
       attribute_names = attributes_for_create(attribute_names)
 
-      new_id = self.class._insert_record(
-        attributes_with_values(attribute_names)
+      returning_columns = self.class._returning_columns_for_insert
+
+      returning_values = self.class._insert_record(
+        attributes_with_values(attribute_names),
+        returning_columns
       )
 
-      self.id ||= new_id if @primary_key
+      returning_columns.zip(returning_values).each do |column, value|
+        _write_attribute(column, value) if !_read_attribute(column)
+      end if returning_values
 
       @new_record = false
       @previously_new_record = true
@@ -1131,11 +1287,5 @@ module ActiveRecord
         persisted?, new_record?, or destroyed? before touching.
       MSG
     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
   end
 end

data/lib/active_record/promise.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  class Promise < BasicObject
+    undef_method :==, :!, :!=
+
+    def initialize(future_result, block) # :nodoc:
+      @future_result = future_result
+      @block = block
+    end
+
+    # Returns whether the associated query is still being executed or not.
+    def pending?
+      @future_result.pending?
+    end
+
+    # Returns the query result.
+    # If the query wasn't completed yet, accessing +#value+ will block until the query completes.
+    # If the query failed, +#value+ will raise the corresponding error.
+    def value
+      return @value if defined? @value
+
+      result = @future_result.result
+      @value = if @block
+        @block.call(result)
+      else
+        result
+      end
+    end
+
+    # Returns a new +ActiveRecord::Promise+ that will apply the passed block
+    # when the value is accessed:
+    #
+    #   Post.async_pluck(:title).then { |title| title.upcase }.value
+    #   # => "POST TITLE"
+    def then(&block)
+      Promise.new(@future_result, @block ? @block >> block : block)
+    end
+
+    [:class, :respond_to?, :is_a?].each do |method|
+      define_method(method, ::Object.instance_method(method))
+    end
+
+    def inspect # :nodoc:
+      "#<ActiveRecord::Promise status=#{status}>"
+    end
+
+    def pretty_print(q) # :nodoc:
+      q.text(inspect)
+    end
+
+    private
+      def status
+        if @future_result.pending?
+          :pending
+        elsif @future_result.canceled?
+          :canceled
+        else
+          :complete
+        end
+      end
+
+      class Complete < self # :nodoc:
+        attr_reader :value
+
+        def initialize(value)
+          @value = value
+        end
+
+        def then
+          Complete.new(yield @value)
+        end
+
+        def pending?
+          false
+        end
+
+        private
+          def status
+            :complete
+          end
+      end
+  end
+end

data/lib/active_record/query_cache.rb

@@ -26,32 +26,14 @@ module ActiveRecord
     end
 
     def self.run
-      pools = []
-
-      if ActiveRecord.legacy_connection_handling
-        ActiveRecord::Base.connection_handlers.each do |key, handler|
-          pools.concat(handler.connection_pool_list.reject { |p| p.query_cache_enabled }.each { |p| p.enable_query_cache! })
-        end
-      else
-        pools.concat(ActiveRecord::Base.connection_handler.all_connection_pools.reject { |p| p.query_cache_enabled }.each { |p| p.enable_query_cache! })
-      end
-
-      pools
+      ActiveRecord::Base.connection_handler.each_connection_pool.reject { |p| p.query_cache_enabled }.each { |p| p.enable_query_cache! }
     end
 
     def self.complete(pools)
       pools.each { |pool| pool.disable_query_cache! }
 
-      if ActiveRecord.legacy_connection_handling
-        ActiveRecord::Base.connection_handlers.each do |_, handler|
-          handler.connection_pool_list.each do |pool|
-            pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
-          end
-        end
-      else
-        ActiveRecord::Base.connection_handler.all_connection_pools.each do |pool|
-          pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
-        end
+      ActiveRecord::Base.connection_handler.each_connection_pool do |pool|
+        pool.release_connection if pool.active_connection? && !pool.connection.transaction_open?
       end
     end