activerecord 6.1.7 → 7.2.0

data/lib/active_record/relation/calculations.rb

@@ -3,7 +3,49 @@
 require "active_support/core_ext/enumerable"
 
 module ActiveRecord
+  # = Active Record \Calculations
   module Calculations
+    class ColumnAliasTracker # :nodoc:
+      def initialize(connection)
+        @connection = connection
+        @aliases = Hash.new(0)
+      end
+
+      def alias_for(field)
+        aliased_name = column_alias_for(field)
+
+        if @aliases[aliased_name] == 0
+          @aliases[aliased_name] = 1
+          aliased_name
+        else
+          # Update the count
+          count = @aliases[aliased_name] += 1
+          "#{truncate(aliased_name)}_#{count}"
+        end
+      end
+
+      private
+        # Converts the given field to the value that the database adapter returns as
+        # a usable column name:
+        #
+        #   column_alias_for("users.id")                 # => "users_id"
+        #   column_alias_for("sum(id)")                  # => "sum_id"
+        #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
+        #   column_alias_for("count(*)")                 # => "count_all"
+        def column_alias_for(field)
+          column_alias = +field
+          column_alias.gsub!(/\*/, "all")
+          column_alias.gsub!(/\W+/, " ")
+          column_alias.strip!
+          column_alias.gsub!(/ +/, "_")
+          @connection.table_alias_for(column_alias)
+        end
+
+        def truncate(name)
+          name.slice(0, @connection.table_alias_length - 2)
+        end
+    end
+
     # Count the records.
     #
     #   Person.count
@@ -30,8 +72,7 @@ module ActiveRecord
     # of each key would be the #count.
     #
     #   Article.group(:status, :category).count
-    #   # =>  {["draft", "business"]=>10, ["draft", "technology"]=>4,
-    #          ["published", "business"]=>0, ["published", "technology"]=>2}
+    #   # =>  {["draft", "business"]=>10, ["draft", "technology"]=>4, ["published", "technology"]=>2}
     #
     # If #count is used with {Relation#select}[rdoc-ref:QueryMethods#select], it will count the selected columns:
     #
@@ -40,6 +81,16 @@ module ActiveRecord
     #
     # Note: not all valid {Relation#select}[rdoc-ref:QueryMethods#select] expressions are valid #count expressions. The specifics differ
     # between databases. In invalid cases, an error from the database is thrown.
+    #
+    # When given a block, loads all records in the relation, if the relation
+    # hasn't been loaded yet. Calls the block with each record in the relation.
+    # Returns the number of records for which the block returns a truthy value.
+    #
+    #   Person.count { |person| person.age > 21 }
+    #   # => counts the number of people older that 21
+    #
+    # Note: If there are a lot of records in the relation, loading all records
+    # could result in performance issues.
     def count(column_name = nil)
       if block_given?
         unless column_name.nil?
@@ -52,6 +103,12 @@ module ActiveRecord
       end
     end
 
+    # Same as #count, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_count(column_name = nil)
+      async.count(column_name)
+    end
+
     # Calculates the average value on a given column. Returns +nil+ if there's
     # no row. See #calculate for examples with options.
     #
@@ -60,6 +117,12 @@ module ActiveRecord
       calculate(:average, column_name)
     end
 
+    # Same as #average, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_average(column_name)
+      async.average(column_name)
+    end
+
     # Calculates the minimum value on a given column. The value is returned
     # with the same data type of the column, or +nil+ if there's no row. See
     # #calculate for examples with options.
@@ -69,6 +132,12 @@ module ActiveRecord
       calculate(:minimum, column_name)
     end
 
+    # Same as #minimum, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_minimum(column_name)
+      async.minimum(column_name)
+    end
+
     # Calculates the maximum value on a given column. The value is returned
     # with the same data type of the column, or +nil+ if there's no row. See
     # #calculate for examples with options.
@@ -78,23 +147,42 @@ module ActiveRecord
       calculate(:maximum, column_name)
     end
 
+    # Same as #maximum, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_maximum(column_name)
+      async.maximum(column_name)
+    end
+
     # Calculates the sum of values on a given column. The value is returned
     # with the same data type of the column, +0+ if there's no row. See
     # #calculate for examples with options.
     #
     #   Person.sum(:age) # => 4562
-    def sum(column_name = nil)
+    #
+    # When given a block, loads all records in the relation, if the relation
+    # hasn't been loaded yet. Calls the block with each record in the relation.
+    # Returns the sum of +initial_value_or_column+ and the block return
+    # values:
+    #
+    #   Person.sum { |person| person.age } # => 4562
+    #   Person.sum(1000) { |person| person.age } # => 5562
+    #
+    # Note: If there are a lot of records in the relation, loading all records
+    # could result in performance issues.
+    def sum(initial_value_or_column = 0, &block)
       if block_given?
-        unless column_name.nil?
-          raise ArgumentError, "Column name argument is not supported when a block is passed."
-        end
-
-        super()
+        map(&block).sum(initial_value_or_column)
       else
-        calculate(:sum, column_name)
+        calculate(:sum, initial_value_or_column)
       end
     end
 
+    # Same as #sum, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_sum(identity_or_column = nil)
+      async.sum(identity_or_column)
+    end
+
     # This calculates aggregate values in the given column. Methods for #count, #sum, #average,
     # #minimum, and #maximum have been added as shortcuts.
     #
@@ -127,13 +215,26 @@ module ActiveRecord
     #        ...
     #      end
     def calculate(operation, column_name)
+      operation = operation.to_s.downcase
+
+      if @none
+        case operation
+        when "count", "sum"
+          result = group_values.any? ? Hash.new : 0
+          return @async ? Promise::Complete.new(result) : result
+        when "average", "minimum", "maximum"
+          result = group_values.any? ? Hash.new : nil
+          return @async ? Promise::Complete.new(result) : result
+        end
+      end
+
       if has_include?(column_name)
         relation = apply_join_dependency
 
-        if operation.to_s.downcase == "count"
+        if operation == "count"
           unless distinct_value || distinct_select?(column_name || select_for_count)
             relation.distinct!
-            relation.select_values = [ klass.primary_key || table[Arel.star] ]
+            relation.select_values = Array(klass.primary_key || table[Arel.star])
           end
           # PostgreSQL: ORDER BY expressions must appear in SELECT list when using DISTINCT
           relation.order_values = [] if group_values.empty?
@@ -146,7 +247,7 @@ module ActiveRecord
     end
 
     # Use #pluck as a shortcut to select one or more attributes without
-    # loading a bunch of records just to grab the attributes you want.
+    # loading an entire record object per row.
     #
     #   Person.pluck(:name)
     #
@@ -174,36 +275,62 @@ module ActiveRecord
     #   # SELECT people.id FROM people WHERE people.age = 21 LIMIT 5
     #   # => [2, 3]
     #
+    #   Comment.joins(:person).pluck(:id, person: [:id])
+    #   # SELECT comments.id, people.id FROM comments INNER JOIN people on comments.person_id = people.id
+    #   # => [[1, 2], [2, 2]]
+    #
     #   Person.pluck(Arel.sql('DATEDIFF(updated_at, created_at)'))
     #   # SELECT DATEDIFF(updated_at, created_at) FROM people
     #   # => ['0', '27761', '173']
     #
     # See also #ids.
-    #
     def pluck(*column_names)
+      if @none
+        if @async
+          return Promise::Complete.new([])
+        else
+          return []
+        end
+      end
+
       if loaded? && all_attributes?(column_names)
-        return records.pluck(*column_names)
+        result = records.pluck(*column_names)
+        if @async
+          return Promise::Complete.new(result)
+        else
+          return result
+        end
       end
 
       if has_include?(column_names.first)
         relation = apply_join_dependency
         relation.pluck(*column_names)
       else
-        klass.disallow_raw_sql!(column_names)
+        klass.disallow_raw_sql!(flattened_args(column_names))
         columns = arel_columns(column_names)
         relation = spawn
         relation.select_values = columns
         result = skip_query_cache_if_necessary do
           if where_clause.contradiction?
-            ActiveRecord::Result.new([], [])
+            ActiveRecord::Result.empty(async: @async)
           else
-            klass.connection.select_all(relation.arel, nil)
+            klass.with_connection do |c|
+              c.select_all(relation.arel, "#{klass.name} Pluck", async: @async)
+            end
           end
         end
-        type_cast_pluck_values(result, columns)
+        result.then do |result|
+          type_cast_pluck_values(result, columns)
+        end
       end
     end
 
+    # Same as #pluck, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_pluck(*column_names)
+      async.pluck(*column_names)
+    end
+
     # Pick the value(s) from the named column(s) in the current relation.
     # This is short-hand for <tt>relation.limit(1).pluck(*column_names).first</tt>, and is primarily useful
     # when you have a relation that's already narrowed down to a single row.
@@ -220,18 +347,63 @@ module ActiveRecord
     #   # => [ 'David', 'david@loudthinking.com' ]
     def pick(*column_names)
       if loaded? && all_attributes?(column_names)
-        return records.pick(*column_names)
+        result = records.pick(*column_names)
+        return @async ? Promise::Complete.new(result) : result
       end
 
-      limit(1).pluck(*column_names).first
+      limit(1).pluck(*column_names).then(&:first)
+    end
+
+    # Same as #pick, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_pick(*column_names)
+      async.pick(*column_names)
     end
 
-    # Pluck all the ID's for the relation using the table's primary key
+    # Returns the base model's ID's for the relation using the table's primary key
     #
     #   Person.ids # SELECT people.id FROM people
-    #   Person.joins(:companies).ids # SELECT people.id FROM people INNER JOIN companies ON companies.person_id = people.id
+    #   Person.joins(:company).ids # SELECT people.id FROM people INNER JOIN companies ON companies.id = people.company_id
     def ids
-      pluck primary_key
+      primary_key_array = Array(primary_key)
+
+      if loaded?
+        result = records.map do |record|
+          if primary_key_array.one?
+            record._read_attribute(primary_key_array.first)
+          else
+            primary_key_array.map { |column| record._read_attribute(column) }
+          end
+        end
+        return @async ? Promise::Complete.new(result) : result
+      end
+
+      if has_include?(primary_key)
+        relation = apply_join_dependency.group(*primary_key_array)
+        return relation.ids
+      end
+
+      columns = arel_columns(primary_key_array)
+      relation = spawn
+      relation.select_values = columns
+
+      result = if relation.where_clause.contradiction?
+        ActiveRecord::Result.empty
+      else
+        skip_query_cache_if_necessary do
+          klass.with_connection do |c|
+            c.select_all(relation, "#{klass.name} Ids", async: @async)
+          end
+        end
+      end
+
+      result.then { |result| type_cast_pluck_values(result, columns) }
+    end
+
+    # Same as #ids, but performs the query asynchronously and returns an
+    # ActiveRecord::Promise.
+    def async_ids
+      async.ids
     end
 
     private
@@ -278,7 +450,7 @@ module ActiveRecord
         return column_name if Arel::Expressions === column_name
 
         arel_column(column_name.to_s) do |name|
-          Arel.sql(column_name == :all ? "*" : name)
+          column_name == :all ? Arel.sql("*", retryable: true) : Arel.sql(name)
         end
       end
 
@@ -286,11 +458,12 @@ module ActiveRecord
         operation == "count" ? column.count(distinct) : column.public_send(operation)
       end
 
-      def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-        if operation == "count" && (column_name == :all && distinct || has_limit_or_offset?)
+      def execute_simple_calculation(operation, column_name, distinct) # :nodoc:
+        if build_count_subquery?(operation, column_name, distinct)
           # Shortcut when limit is zero.
           return 0 if limit_value == 0
 
+          relation = self
           query_builder = build_count_subquery(spawn, column_name, distinct)
         else
           # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
@@ -305,29 +478,31 @@ module ActiveRecord
           query_builder = relation.arel
         end
 
-        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder) }
+        query_result = if relation.where_clause.contradiction?
+          ActiveRecord::Result.empty
+        else
+          skip_query_cache_if_necessary do
+            @klass.with_connection do |c|
+              c.select_all(query_builder, "#{@klass.name} #{operation.capitalize}", async: @async)
+            end
+          end
+        end
 
-        type_cast_calculated_value(result.cast_values.first, operation) do |value|
-          type = column.try(:type_caster) ||
-            lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
-          type = type.subtype if Enum::EnumType === type
-          type.deserialize(value)
+        query_result.then do |result|
+          if operation != "count"
+            type = column.try(:type_caster) ||
+              lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
+            type = type.subtype if Enum::EnumType === type
+          end
+
+          type_cast_calculated_value(result.cast_values.first, operation, type)
         end
       end
 
-      def execute_grouped_calculation(operation, column_name, distinct) #:nodoc:
+      def execute_grouped_calculation(operation, column_name, distinct) # :nodoc:
         group_fields = group_values
         group_fields = group_fields.uniq if group_fields.size > 1
 
-        unless group_fields == group_values
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            `#{operation}` with group by duplicated fields does no longer affect to result in Rails 7.0.
-            To migrate to Rails 7.0's behavior, use `uniq!(:group)` to deduplicate group fields
-            (`#{klass.name&.tableize || klass.table_name}.uniq!(:group).#{operation}(#{column_name.inspect})`).
-          MSG
-          group_fields = group_values
-        end
-
         if group_fields.size == 1 && group_fields.first.respond_to?(:to_sym)
           association  = klass._reflect_on_association(group_fields.first)
           associated   = association && association.belongs_to? # only count belongs_to associations
@@ -335,86 +510,77 @@ module ActiveRecord
         end
         group_fields = arel_columns(group_fields)
 
-        group_aliases = group_fields.map { |field|
-          field = connection.visitor.compile(field) if Arel.arel_node?(field)
-          column_alias_for(field.to_s.downcase)
-        }
-        group_columns = group_aliases.zip(group_fields)
-
-        column = aggregate_column(column_name)
-        column_alias = column_alias_for("#{operation} #{column_name.to_s.downcase}")
-        select_value = operation_over_aggregate_column(column, operation, distinct)
-        select_value.as(column_alias)
+        @klass.with_connection do |connection|
+          column_alias_tracker = ColumnAliasTracker.new(connection)
 
-        select_values = [select_value]
-        select_values += self.select_values unless having_clause.empty?
+          group_aliases = group_fields.map { |field|
+            field = connection.visitor.compile(field) if Arel.arel_node?(field)
+            column_alias_tracker.alias_for(field.to_s.downcase)
+          }
+          group_columns = group_aliases.zip(group_fields)
 
-        select_values.concat group_columns.map { |aliaz, field|
-          if field.respond_to?(:as)
-            field.as(aliaz)
-          else
-            "#{field} AS #{aliaz}"
-          end
-        }
+          column = aggregate_column(column_name)
+          column_alias = column_alias_tracker.alias_for("#{operation} #{column_name.to_s.downcase}")
+          select_value = operation_over_aggregate_column(column, operation, distinct)
+          select_value.as(adapter_class.quote_column_name(column_alias))
 
-        relation = except(:group).distinct!(false)
-        relation.group_values  = group_fields
-        relation.select_values = select_values
+          select_values = [select_value]
+          select_values += self.select_values unless having_clause.empty?
 
-        calculated_data = skip_query_cache_if_necessary { @klass.connection.select_all(relation.arel, nil) }
+          select_values.concat group_columns.map { |aliaz, field|
+            aliaz = adapter_class.quote_column_name(aliaz)
+            if field.respond_to?(:as)
+              field.as(aliaz)
+            else
+              "#{field} AS #{aliaz}"
+            end
+          }
 
-        if association
-          key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
-          key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
-          key_records = key_records.index_by(&:id)
-        end
+          relation = except(:group).distinct!(false)
+          relation.group_values  = group_fields
+          relation.select_values = select_values
 
-        key_types = group_columns.each_with_object({}) do |(aliaz, col_name), types|
-          types[aliaz] = type_for(col_name) do
-            calculated_data.column_types.fetch(aliaz, Type.default_value)
+          result = skip_query_cache_if_necessary do
+            connection.select_all(relation.arel, "#{@klass.name} #{operation.capitalize}", async: @async)
           end
-        end
 
-        hash_rows = calculated_data.cast_values(key_types).map! do |row|
-          calculated_data.columns.each_with_object({}).with_index do |(col_name, hash), i|
-            hash[col_name] = row[i]
-          end
-        end
+          result.then do |calculated_data|
+            if association
+              key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
+              key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
+              key_records = key_records.index_by(&:id)
+            end
 
-        type = nil
-        hash_rows.each_with_object({}) do |row, result|
-          key = group_aliases.map { |aliaz| row[aliaz] }
-          key = key.first if key.size == 1
-          key = key_records[key] if associated
+            key_types = group_columns.each_with_object({}) do |(aliaz, col_name), types|
+              types[aliaz] = col_name.try(:type_caster) ||
+                type_for(col_name) do
+                  calculated_data.column_types.fetch(aliaz, Type.default_value)
+                end
+            end
+
+            hash_rows = calculated_data.cast_values(key_types).map! do |row|
+              calculated_data.columns.each_with_object({}).with_index do |(col_name, hash), i|
+                hash[col_name] = row[i]
+              end
+            end
 
-          result[key] = type_cast_calculated_value(row[column_alias], operation) do |value|
-            unless type
+            if operation != "count"
               type = column.try(:type_caster) ||
                 lookup_cast_type_from_join_dependencies(column_name.to_s) || Type.default_value
               type = type.subtype if Enum::EnumType === type
             end
-            type.deserialize(value)
+
+            hash_rows.each_with_object({}) do |row, result|
+              key = group_aliases.map { |aliaz| row[aliaz] }
+              key = key.first if key.size == 1
+              key = key_records[key] if associated
+
+              result[key] = type_cast_calculated_value(row[column_alias], operation, type)
+            end
           end
         end
       end
 
-      # Converts the given field to the value that the database adapter returns as
-      # a usable column name:
-      #
-      #   column_alias_for("users.id")                 # => "users_id"
-      #   column_alias_for("sum(id)")                  # => "sum_id"
-      #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
-      #   column_alias_for("count(*)")                 # => "count_all"
-      def column_alias_for(field)
-        column_alias = +field
-        column_alias.gsub!(/\*/, "all")
-        column_alias.gsub!(/\W+/, " ")
-        column_alias.strip!
-        column_alias.gsub!(/ +/, "_")
-
-        connection.table_alias_for(column_alias)
-      end
-
       def type_for(field, &block)
         field_name = field.respond_to?(:name) ? field.name.to_s : field.to_s.split(".").last
         @klass.type_for_attribute(field_name, &block)
@@ -438,35 +604,58 @@ module ActiveRecord
               klass.attribute_types.fetch(name = result.columns[i]) do
                 join_dependencies ||= build_join_dependencies
                 lookup_cast_type_from_join_dependencies(name, join_dependencies) ||
-                  result.column_types[name] || Type.default_value
+                  result.column_types[i] || Type.default_value
               end
           end
         end
         result.cast_values(cast_types)
       end
 
-      def type_cast_calculated_value(value, operation)
+      def type_cast_calculated_value(value, operation, type)
         case operation
         when "count"
           value.to_i
         when "sum"
-          yield value || 0
+          type.deserialize(value || 0)
         when "average"
-          value&.respond_to?(:to_d) ? value.to_d : value
+          case type.type
+          when :integer, :decimal
+            value&.to_d
+          else
+            type.deserialize(value)
+          end
         else # "minimum", "maximum"
-          yield value
+          type.deserialize(value)
         end
       end
 
       def select_for_count
         if select_values.present?
           return select_values.first if select_values.one?
-          select_values.join(", ")
+
+          select_values.map do |field|
+            column = arel_column(field.to_s) do |attr_name|
+              Arel.sql(attr_name)
+            end
+
+            if column.is_a?(Arel::Nodes::SqlLiteral)
+              column
+            else
+              "#{adapter_class.quote_table_name(column.relation.name)}.#{adapter_class.quote_column_name(column.name)}"
+            end
+          end.join(", ")
         else
           :all
         end
       end
 
+      def build_count_subquery?(operation, column_name, distinct)
+        # SQLite and older MySQL does not support `COUNT DISTINCT` with `*` or
+        # multiple columns, so we need to use subquery for this.
+        operation == "count" &&
+          (((column_name == :all || select_values.many?) && distinct) || has_limit_or_offset?)
+      end
+
       def build_count_subquery(relation, column_name, distinct)
         if column_name == :all
           column_alias = Arel.star
@@ -476,7 +665,7 @@ module ActiveRecord
           relation.select_values = [ aggregate_column(column_name).as(column_alias) ]
         end
 
-        subquery_alias = Arel.sql("subquery_for_count")
+        subquery_alias = Arel.sql("subquery_for_count", retryable: true)
         select_value = operation_over_aggregate_column(column_alias, "count", false)
 
         relation.build_subquery(subquery_alias, select_value)