activerecord 7.0.8.7 → 7.1.0.beta1

data/lib/active_record/relation/batches.rb

@@ -3,8 +3,10 @@
 require "active_record/relation/batches/batch_enumerator"
 
 module ActiveRecord
+  # = Active Record \Batches
   module Batches
     ORDER_IGNORE_MESSAGE = "Scoped order is ignored, it's forced to be batch order."
+    DEFAULT_ORDER = :asc
 
     # Looping through a collection of records from the database
     # (using the Scoping::Named::ClassMethods.all method, for example)
@@ -37,7 +39,16 @@ module ActiveRecord
     # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
     # * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
     #   an order is present in the relation.
-    # * <tt>:order</tt> - Specifies the primary key order (can be +:asc+ or +:desc+). Defaults to +:asc+.
+    # * <tt>:order</tt> - Specifies the primary key order (can be +:asc+ or +:desc+ or an array consisting
+    #   of :asc or :desc). Defaults to +:asc+.
+    #
+    #     class Order < ActiveRecord::Base
+    #       self.primary_key = [:id_1, :id_2]
+    #     end
+    #
+    #     Order.find_each(order: [:asc, :desc])
+    #
+    #   In the above code, +id_1+ is sorted in ascending order and +id_2+ in descending order.
     #
     # Limits are honored, and if present there is no requirement for the batch
     # size: it can be less than, equal to, or greater than the limit.
@@ -65,7 +76,7 @@ module ActiveRecord
     #
     # NOTE: By its nature, batch processing is subject to race conditions if
     # other processes are modifying the database.
-    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc, &block)
+    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: DEFAULT_ORDER, &block)
       if block_given?
         find_in_batches(start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, order: order) do |records|
           records.each(&block)
@@ -73,7 +84,7 @@ module ActiveRecord
       else
         enum_for(:find_each, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, order: order) do
           relation = self
-          apply_limits(relation, start, finish, order).size
+          apply_limits(relation, start, finish, build_batch_orders(order)).size
         end
       end
     end
@@ -102,7 +113,16 @@ module ActiveRecord
     # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
     # * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
     #   an order is present in the relation.
-    # * <tt>:order</tt> - Specifies the primary key order (can be +:asc+ or +:desc+). Defaults to +:asc+.
+    # * <tt>:order</tt> - Specifies the primary key order (can be +:asc+ or +:desc+ or an array consisting
+    #   of :asc or :desc). Defaults to +:asc+.
+    #
+    #     class Order < ActiveRecord::Base
+    #       self.primary_key = [:id_1, :id_2]
+    #     end
+    #
+    #     Order.find_in_batches(order: [:asc, :desc])
+    #
+    #   In the above code, +id_1+ is sorted in ascending order and +id_2+ in descending order.
     #
     # Limits are honored, and if present there is no requirement for the batch
     # size: it can be less than, equal to, or greater than the limit.
@@ -125,11 +145,11 @@ module ActiveRecord
     #
     # NOTE: By its nature, batch processing is subject to race conditions if
     # other processes are modifying the database.
-    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: :asc)
+    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, order: DEFAULT_ORDER)
       relation = self
       unless block_given?
         return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, order: order) do
-          total = apply_limits(relation, start, finish, order).size
+          total = apply_limits(relation, start, finish, build_batch_orders(order)).size
           (total - 1).div(batch_size) + 1
         end
       end
@@ -167,7 +187,22 @@ module ActiveRecord
     # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
     # * <tt>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
     #   an order is present in the relation.
-    # * <tt>:order</tt> - Specifies the primary key order (can be +:asc+ or +:desc+). Defaults to +:asc+.
+    # * <tt>:order</tt> - Specifies the primary key order (can be +:asc+ or +:desc+ or an array consisting
+    #   of :asc or :desc). Defaults to +:asc+.
+    #
+    #     class Order < ActiveRecord::Base
+    #       self.primary_key = [:id_1, :id_2]
+    #     end
+    #
+    #     Order.in_batches(order: [:asc, :desc])
+    #
+    #   In the above code, +id_1+ is sorted in ascending order and +id_2+ in descending order.
+    #
+    # * <tt>:use_ranges</tt> - Specifies whether to use range iteration (id >= x AND id <= y).
+    #   It can make iterating over the whole or almost whole tables several times faster.
+    #   Only whole table iterations use this style of iteration by default. You can disable this behavior by passing +false+.
+    #   If you iterate over the table and the only condition is, e.g., <tt>archived_at: nil</tt> (and only a tiny fraction
+    #   of the records are archived), it makes sense to opt in to this approach.
     #
     # Limits are honored, and if present there is no requirement for the batch
     # size, it can be less than, equal, or greater than the limit.
@@ -201,14 +236,13 @@ module ActiveRecord
     #
     # NOTE: By its nature, batch processing is subject to race conditions if
     # other processes are modifying the database.
-    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: :asc)
-      relation = self
-      unless block_given?
-        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
+    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, order: DEFAULT_ORDER, use_ranges: nil, &block)
+      unless Array(order).all? { |ord| [:asc, :desc].include?(ord) }
+        raise ArgumentError, ":order must be :asc or :desc or an array consisting of :asc or :desc, got #{order.inspect}"
       end
 
-      unless [:asc, :desc].include?(order)
-        raise ArgumentError, ":order must be :asc or :desc, got #{order.inspect}"
+      unless block
+        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self, order: order, use_ranges: use_ranges)
       end
 
       if arel.orders.present?
@@ -216,71 +250,76 @@ module ActiveRecord
       end
 
       batch_limit = of
+
       if limit_value
         remaining   = limit_value
         batch_limit = remaining if remaining < batch_limit
       end
 
-      relation = relation.reorder(batch_order(order)).limit(batch_limit)
-      relation = apply_limits(relation, start, finish, order)
-      relation.skip_query_cache! # Retaining the results in the query cache would undermine the point of batching
-      batch_relation = relation
-
-      loop do
-        if load
-          records = batch_relation.records
-          ids = records.map(&:id)
-          yielded_relation = where(primary_key => ids)
-          yielded_relation.load_records(records)
-        else
-          ids = batch_relation.pluck(primary_key)
-          yielded_relation = where(primary_key => ids)
-        end
-
-        break if ids.empty?
-
-        primary_key_offset = ids.last
-        raise ArgumentError.new("Primary key not included in the custom select clause") unless primary_key_offset
-
-        yield yielded_relation
-
-        break if ids.length < batch_limit
-
-        if limit_value
-          remaining -= ids.length
-
-          if remaining == 0
-            # Saves a useless iteration when the limit is a multiple of the
-            # batch size.
-            break
-          elsif remaining < batch_limit
-            relation = relation.limit(remaining)
-          end
-        end
-
-        batch_relation = relation.where(
-          predicate_builder[primary_key, primary_key_offset, order == :desc ? :lt : :gt]
+      if self.loaded?
+        batch_on_loaded_relation(
+          relation: self,
+          start: start,
+          finish: finish,
+          order: order,
+          batch_limit: batch_limit,
+          &block
+        )
+      else
+        batch_on_unloaded_relation(
+          relation: self,
+          start: start,
+          finish: finish,
+          load: load,
+          order: order,
+          use_ranges: use_ranges,
+          remaining: remaining,
+          batch_limit: batch_limit,
+          &block
         )
       end
     end
 
     private
-      def apply_limits(relation, start, finish, order)
-        relation = apply_start_limit(relation, start, order) if start
-        relation = apply_finish_limit(relation, finish, order) if finish
+      def apply_limits(relation, start, finish, batch_orders)
+        relation = apply_start_limit(relation, start, batch_orders) if start
+        relation = apply_finish_limit(relation, finish, batch_orders) if finish
         relation
       end
 
-      def apply_start_limit(relation, start, order)
-        relation.where(predicate_builder[primary_key, start, order == :desc ? :lteq : :gteq])
+      def apply_start_limit(relation, start, batch_orders)
+        operators = batch_orders.map do |_column, order|
+          order == :desc ? :lteq : :gteq
+        end
+        batch_condition(relation, primary_key, start, operators)
+      end
+
+      def apply_finish_limit(relation, finish, batch_orders)
+        operators = batch_orders.map do |_column, order|
+          order == :desc ? :gteq : :lteq
+        end
+        batch_condition(relation, primary_key, finish, operators)
       end
 
-      def apply_finish_limit(relation, finish, order)
-        relation.where(predicate_builder[primary_key, finish, order == :desc ? :gteq : :lteq])
+      def batch_condition(relation, columns, values, operators)
+        cursor_positions = Array(columns).zip(Array(values), operators)
+
+        first_clause_column, first_clause_value, operator = cursor_positions.pop
+        where_clause = predicate_builder[first_clause_column, first_clause_value, operator]
+
+        cursor_positions.reverse_each do |column_name, value, operator|
+          where_clause = predicate_builder[column_name, value, operator == :lteq ? :lt : :gt].or(
+            predicate_builder[column_name, value, :eq].and(where_clause)
+          )
+        end
+
+        relation.where(where_clause)
       end
 
-      def batch_order(order)
-        table[primary_key].public_send(order)
+      def build_batch_orders(order)
+        get_the_order_of_primary_key(order).map do |column, ord|
+          [column, ord || DEFAULT_ORDER]
+        end
       end
 
       def act_on_ignored_order(error_on_ignore)
@@ -292,5 +331,95 @@ module ActiveRecord
           logger.warn(ORDER_IGNORE_MESSAGE)
         end
       end
+
+      def get_the_order_of_primary_key(order)
+        Array(primary_key).zip(Array(order))
+      end
+
+      def batch_on_loaded_relation(relation:, start:, finish:, order:, batch_limit:)
+        records = relation.to_a
+
+        if start || finish
+          records = records.filter do |record|
+            (start.nil? || record.id >= start) && (finish.nil? || record.id <= finish)
+          end
+        end
+
+        records = records.sort_by { |record| record.id }
+
+        if order == :desc
+          records.reverse!
+        end
+
+        (0...records.size).step(batch_limit).each do |start|
+          subrelation = relation.spawn
+          subrelation.load_records(records[start, batch_limit])
+
+          yield subrelation
+        end
+
+        nil
+      end
+
+      def batch_on_unloaded_relation(relation:, start:, finish:, load:, order:, use_ranges:, remaining:, batch_limit:)
+        batch_orders = build_batch_orders(order)
+        relation = relation.reorder(batch_orders.to_h).limit(batch_limit)
+        relation = apply_limits(relation, start, finish, batch_orders)
+        relation.skip_query_cache! # Retaining the results in the query cache would undermine the point of batching
+        batch_relation = relation
+        empty_scope = to_sql == klass.unscoped.all.to_sql
+
+        loop do
+          if load
+            records = batch_relation.records
+            ids = records.map(&:id)
+            yielded_relation = where(primary_key => ids)
+            yielded_relation.load_records(records)
+          elsif (empty_scope && use_ranges != false) || use_ranges
+            ids = batch_relation.ids
+            finish = ids.last
+            if finish
+              yielded_relation = apply_finish_limit(batch_relation, finish, batch_orders)
+              yielded_relation = yielded_relation.except(:limit, :order)
+              yielded_relation.skip_query_cache!(false)
+            end
+          else
+            ids = batch_relation.ids
+            yielded_relation = where(primary_key => ids)
+          end
+
+          break if ids.empty?
+
+          primary_key_offset = ids.last
+          raise ArgumentError.new("Primary key not included in the custom select clause") unless primary_key_offset
+
+          yield yielded_relation
+
+          break if ids.length < batch_limit
+
+          if limit_value
+            remaining -= ids.length
+
+            if remaining == 0
+              # Saves a useless iteration when the limit is a multiple of the
+              # batch size.
+              break
+            elsif remaining < batch_limit
+              relation = relation.limit(remaining)
+            end
+          end
+
+          batch_orders_copy = batch_orders.dup
+          _last_column, last_order = batch_orders_copy.pop
+          operators = batch_orders_copy.map do |_column, order|
+            order == :desc ? :lteq : :gteq
+          end
+          operators << (last_order == :desc ? :lt : :gt)
+
+          batch_relation = batch_condition(relation, primary_key, primary_key_offset, operators)
+        end
+
+        nil
+      end
   end
 end

data/lib/active_record/relation/calculations.rb

@@ -3,6 +3,7 @@
 require "active_support/core_ext/enumerable"
 
 module ActiveRecord
+  # = Active Record \Calculations
   module Calculations
     class ColumnAliasTracker # :nodoc:
       def initialize(connection)
@@ -71,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:
     #
@@ -93,6 +93,11 @@ module ActiveRecord
       end
     end
 
+    # Same as <tt>#count</tt> but perform 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.
     #
@@ -101,6 +106,11 @@ module ActiveRecord
       calculate(:average, column_name)
     end
 
+    # Same as <tt>#average</tt> but perform 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.
@@ -110,6 +120,11 @@ module ActiveRecord
       calculate(:minimum, column_name)
     end
 
+    # Same as <tt>#minimum</tt> but perform 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.
@@ -119,32 +134,29 @@ module ActiveRecord
       calculate(:maximum, column_name)
     end
 
+    # Same as <tt>#maximum</tt> but perform 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(identity_or_column = nil, &block)
+    def sum(initial_value_or_column = 0, &block)
       if block_given?
-        values = map(&block)
-        if identity_or_column.nil? && (values.first.is_a?(Numeric) || values.first(1) == [] || values.first.respond_to?(:coerce))
-          identity_or_column = 0
-        end
-
-        if identity_or_column.nil?
-          ActiveSupport::Deprecation.warn(<<-MSG.squish)
-            Rails 7.0 has deprecated Enumerable.sum in favor of Ruby's native implementation available since 2.4.
-            Sum of non-numeric elements requires an initial argument.
-          MSG
-          values.inject(:+) || 0
-        else
-          values.sum(identity_or_column)
-        end
+        map(&block).sum(initial_value_or_column)
       else
-        calculate(:sum, identity_or_column)
+        calculate(:sum, initial_value_or_column)
       end
     end
 
+    # Same as <tt>#sum</tt> but perform 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.
     #
@@ -177,10 +189,23 @@ 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] ]
@@ -229,31 +254,44 @@ module ActiveRecord
     #   # => ['0', '27761', '173']
     #
     # See also #ids.
-    #
     def pluck(*column_names)
+      return [] if @none
+
       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!(column_names.flatten)
         columns = arel_columns(column_names)
         relation = spawn
         relation.select_values = columns
         result = skip_query_cache_if_necessary do
           if where_clause.contradiction?
-            ActiveRecord::Result.empty
+            ActiveRecord::Result.empty(async: @async)
           else
-            klass.connection.select_all(relation.arel, "#{klass.name} Pluck")
+            klass.connection.select_all(relation.arel, "#{klass.name} Pluck", async: @async)
           end
         end
-        type_cast_pluck_values(result, columns)
+        result.then do |result|
+          type_cast_pluck_values(result, columns)
+        end
       end
     end
 
+    # Same as <tt>#pluck</tt> but perform 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.
@@ -270,18 +308,59 @@ 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
 
-    # Pluck all the ID's for the relation using the table's primary key
+    # Same as <tt>#pick</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    def async_pick(*column_names)
+      async.pick(*column_names)
+    end
+
+    # 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(:companies).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.connection.select_all(relation, "#{klass.name} Ids", async: @async)
+        end
+      end
+
+      result.then { |result| type_cast_pluck_values(result, columns) }
+    end
+
+    # Same as <tt>#ids</tt> but perform the query asynchronously and returns an ActiveRecord::Promise
+    def async_ids
+      async.ids
     end
 
     private
@@ -341,6 +420,7 @@ module ActiveRecord
           # 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
@@ -355,15 +435,23 @@ module ActiveRecord
           query_builder = relation.arel
         end
 
-        result = skip_query_cache_if_necessary { @klass.connection.select_all(query_builder, "#{@klass.name} #{operation.capitalize}") }
-
-        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
+        query_result = if relation.where_clause.contradiction?
+          ActiveRecord::Result.empty
+        else
+          skip_query_cache_if_necessary do
+            @klass.connection.select_all(query_builder, "#{@klass.name} #{operation.capitalize}", async: @async)
+          end
         end
 
-        type_cast_calculated_value(result.cast_values.first, operation, type)
+        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:
@@ -406,39 +494,40 @@ module ActiveRecord
         relation.group_values  = group_fields
         relation.select_values = select_values
 
-        calculated_data = skip_query_cache_if_necessary { @klass.connection.select_all(relation.arel, "#{@klass.name} #{operation.capitalize}") }
+        result = skip_query_cache_if_necessary { @klass.connection.select_all(relation.arel, "#{@klass.name} #{operation.capitalize}", async: @async) }
+        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
 
-        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
+          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
 
-        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)
+          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
-
-        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
 
-        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
+          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
 
-        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
+          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)
+            result[key] = type_cast_calculated_value(row[column_alias], operation, type)
+          end
         end
       end