activerecord 7.2.4 → 8.1.4

data/lib/active_record/relation/batches.rb

@@ -5,7 +5,7 @@ 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."
+    ORDER_IGNORE_MESSAGE = "Scoped order is ignored, use :cursor with :order to configure custom order."
     DEFAULT_ORDER = :asc
 
     # Looping through a collection of records from the database
@@ -35,11 +35,13 @@ module ActiveRecord
     #
     # ==== Options
     # * <tt>:batch_size</tt> - Specifies the size of the batch. Defaults to 1000.
-    # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
-    # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
+    # * <tt>:start</tt> - Specifies the cursor column value to start from, inclusive of the value.
+    # * <tt>:finish</tt> - Specifies the cursor column 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+ or an array consisting
+    # * <tt>:cursor</tt> - Specifies the column to use for batching (can be a column name or an array
+    #   of column names). Defaults to primary key.
+    # * <tt>:order</tt> - Specifies the cursor column order (can be +:asc+ or +:desc+ or an array consisting
     #   of :asc or :desc). Defaults to +:asc+.
     #
     #     class Order < ActiveRecord::Base
@@ -71,20 +73,25 @@ module ActiveRecord
     #
     # NOTE: Order can be ascending (:asc) or descending (:desc). It is automatically set to
     # ascending on the primary key ("id ASC").
-    # This also means that this method only works when the primary key is
+    # This also means that this method only works when the cursor column is
     # orderable (e.g. an integer or string).
     #
+    # NOTE: When using custom columns for batching, they should include at least one unique column
+    # (e.g. primary key) as a tiebreaker. Also, to reduce the likelihood of race conditions,
+    # all columns should be static (unchangeable after it was set).
+    #
     # 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: DEFAULT_ORDER, &block)
+    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, cursor: primary_key, 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|
+        find_in_batches(start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, cursor: cursor, order: order) do |records|
           records.each(&block)
         end
       else
-        enum_for(:find_each, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, order: order) do
+        enum_for(:find_each, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, cursor: cursor, order: order) do
           relation = self
-          apply_limits(relation, start, finish, build_batch_orders(order)).size
+          cursor = Array(cursor)
+          apply_limits(relation, cursor, start, finish, build_batch_orders(cursor, order)).size
         end
       end
     end
@@ -109,11 +116,13 @@ module ActiveRecord
     #
     # ==== Options
     # * <tt>:batch_size</tt> - Specifies the size of the batch. Defaults to 1000.
-    # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
-    # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
+    # * <tt>:start</tt> - Specifies the cursor column value to start from, inclusive of the value.
+    # * <tt>:finish</tt> - Specifies the cursor column 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+ or an array consisting
+    # * <tt>:cursor</tt> - Specifies the column to use for batching (can be a column name or an array
+    #   of column names). Defaults to primary key.
+    # * <tt>:order</tt> - Specifies the cursor column order (can be +:asc+ or +:desc+ or an array consisting
     #   of :asc or :desc). Defaults to +:asc+.
     #
     #     class Order < ActiveRecord::Base
@@ -140,21 +149,26 @@ module ActiveRecord
     #
     # NOTE: Order can be ascending (:asc) or descending (:desc). It is automatically set to
     # ascending on the primary key ("id ASC").
-    # This also means that this method only works when the primary key is
+    # This also means that this method only works when the cursor column is
     # orderable (e.g. an integer or string).
     #
+    # NOTE: When using custom columns for batching, they should include at least one unique column
+    # (e.g. primary key) as a tiebreaker. Also, to reduce the likelihood of race conditions,
+    # all columns should be static (unchangeable after it was set).
+    #
     # 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: DEFAULT_ORDER)
+    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil, cursor: primary_key, 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, build_batch_orders(order)).size
+        return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore, cursor: cursor, order: order) do
+          cursor = Array(cursor)
+          total = apply_limits(relation, cursor, start, finish, build_batch_orders(cursor, order)).size
           (total - 1).div(batch_size) + 1
         end
       end
 
-      in_batches(of: batch_size, start: start, finish: finish, load: true, error_on_ignore: error_on_ignore, order: order) do |batch|
+      in_batches(of: batch_size, start: start, finish: finish, load: true, error_on_ignore: error_on_ignore, cursor: cursor, order: order) do |batch|
         yield batch.to_a
       end
     end
@@ -183,11 +197,13 @@ module ActiveRecord
     # ==== Options
     # * <tt>:of</tt> - Specifies the size of the batch. Defaults to 1000.
     # * <tt>:load</tt> - Specifies if the relation should be loaded. Defaults to false.
-    # * <tt>:start</tt> - Specifies the primary key value to start from, inclusive of the value.
-    # * <tt>:finish</tt> - Specifies the primary key value to end at, inclusive of the value.
+    # * <tt>:start</tt> - Specifies the cursor column value to start from, inclusive of the value.
+    # * <tt>:finish</tt> - Specifies the cursor column 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+ or an array consisting
+    # * <tt>:cursor</tt> - Specifies the column to use for batching (can be a column name or an array
+    #   of column names). Defaults to primary key.
+    # * <tt>:order</tt> - Specifies the cursor column order (can be +:asc+ or +:desc+ or an array consisting
     #   of :asc or :desc). Defaults to +:asc+.
     #
     #     class Order < ActiveRecord::Base
@@ -231,22 +247,25 @@ module ActiveRecord
     #
     # NOTE: Order can be ascending (:asc) or descending (:desc). It is automatically set to
     # ascending on the primary key ("id ASC").
-    # This also means that this method only works when the primary key is
+    # This also means that this method only works when the cursor column is
     # orderable (e.g. an integer or string).
     #
+    # NOTE: When using custom columns for batching, they should include at least one unique column
+    # (e.g. primary key) as a tiebreaker. Also, to reduce the likelihood of race conditions,
+    # all columns should be static (unchangeable after it was set).
+    #
     # 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: 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
+    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil, cursor: primary_key, order: DEFAULT_ORDER, use_ranges: nil, &block)
+      cursor = Array(cursor).map(&:to_s)
+      ensure_valid_options_for_batching!(cursor, start, finish, order)
 
       if arel.orders.present?
         act_on_ignored_order(error_on_ignore)
       end
 
       unless block
-        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self, order: order, use_ranges: use_ranges)
+        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self, cursor: cursor, order: order, use_ranges: use_ranges)
       end
 
       batch_limit = of
@@ -261,6 +280,7 @@ module ActiveRecord
           relation: self,
           start: start,
           finish: finish,
+          cursor: cursor,
           order: order,
           batch_limit: batch_limit,
           &block
@@ -271,6 +291,7 @@ module ActiveRecord
           start: start,
           finish: finish,
           load: load,
+          cursor: cursor,
           order: order,
           use_ranges: use_ranges,
           remaining: remaining,
@@ -281,28 +302,51 @@ module ActiveRecord
     end
 
     private
-      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
+      def ensure_valid_options_for_batching!(cursor, start, finish, order)
+        if start && Array(start).size != cursor.size
+          raise ArgumentError, ":start must contain one value per cursor column"
+        end
+
+        if finish && Array(finish).size != cursor.size
+          raise ArgumentError, ":finish must contain one value per cursor column"
+        end
+
+        if (Array(primary_key) - cursor).any?
+          indexes = model.schema_cache.indexes(table_name)
+          unique_index = indexes.find { |index| index.unique && index.where.nil? && (Array(index.columns) - cursor).empty? }
+
+          unless unique_index
+            raise ArgumentError, ":cursor must include a primary key or other unique column(s)"
+          end
+        end
+
+        if (Array(order) - [:asc, :desc]).any?
+          raise ArgumentError, ":order must be :asc or :desc or an array consisting of :asc or :desc, got #{order.inspect}"
+        end
+      end
+
+      def apply_limits(relation, cursor, start, finish, batch_orders)
+        relation = apply_start_limit(relation, cursor, start, batch_orders) if start
+        relation = apply_finish_limit(relation, cursor, finish, batch_orders) if finish
         relation
       end
 
-      def apply_start_limit(relation, start, batch_orders)
+      def apply_start_limit(relation, cursor, start, batch_orders)
         operators = batch_orders.map do |_column, order|
           order == :desc ? :lteq : :gteq
         end
-        batch_condition(relation, primary_key, start, operators)
+        batch_condition(relation, cursor, start, operators)
       end
 
-      def apply_finish_limit(relation, finish, batch_orders)
+      def apply_finish_limit(relation, cursor, finish, batch_orders)
         operators = batch_orders.map do |_column, order|
           order == :desc ? :gteq : :lteq
         end
-        batch_condition(relation, primary_key, finish, operators)
+        batch_condition(relation, cursor, finish, operators)
       end
 
-      def batch_condition(relation, columns, values, operators)
-        cursor_positions = Array(columns).zip(Array(values), operators)
+      def batch_condition(relation, cursor, values, operators)
+        cursor_positions = cursor.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]
@@ -316,9 +360,9 @@ module ActiveRecord
         relation.where(where_clause)
       end
 
-      def build_batch_orders(order)
-        get_the_order_of_primary_key(order).map do |column, ord|
-          [column, ord || DEFAULT_ORDER]
+      def build_batch_orders(cursor, order)
+        cursor.zip(Array(order)).map do |column, order_|
+          [column, order_ || DEFAULT_ORDER]
         end
       end
 
@@ -327,34 +371,28 @@ module ActiveRecord
 
         if raise_error
           raise ArgumentError.new(ORDER_IGNORE_MESSAGE)
-        elsif logger
-          logger.warn(ORDER_IGNORE_MESSAGE)
+        elsif model.logger
+          model.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:)
+      def batch_on_loaded_relation(relation:, start:, finish:, cursor:, order:, batch_limit:)
         records = relation.to_a
+        order = build_batch_orders(cursor, order).map(&:second)
 
         if start || finish
           records = records.filter do |record|
-            id = record.id
+            values = record_cursor_values(record, cursor)
 
-            if order == :asc
-              (start.nil? || id >= start) && (finish.nil? || id <= finish)
-            else
-              (start.nil? || id <= start) && (finish.nil? || id >= finish)
-            end
+            (start.nil? || compare_values_for_order(values, Array(start), order) >= 0) &&
+              (finish.nil? || compare_values_for_order(values, Array(finish), order) <= 0)
           end
         end
 
-        records.sort_by!(&:id)
-
-        if order == :desc
-          records.reverse!
+        records.sort! do |record1, record2|
+          values1 = record_cursor_values(record1, cursor)
+          values2 = record_cursor_values(record2, cursor)
+          compare_values_for_order(values1, values2, order)
         end
 
         records.each_slice(batch_limit) do |subrecords|
@@ -367,44 +405,79 @@ module ActiveRecord
         nil
       end
 
-      def batch_on_unloaded_relation(relation:, start:, finish:, load:, order:, use_ranges:, remaining:, batch_limit:)
-        batch_orders = build_batch_orders(order)
+      def record_cursor_values(record, cursor)
+        record.attributes.slice(*cursor).values
+      end
+
+      # This is a custom implementation of `<=>` operator,
+      # which also takes into account how the collection will be ordered.
+      def compare_values_for_order(values1, values2, order)
+        values1.each_with_index do |element1, index|
+          element2 = values2[index]
+          direction = order[index]
+          comparison = element1 <=> element2
+          comparison = -comparison if direction == :desc
+          return comparison if comparison != 0
+        end
+
+        0
+      end
+
+      def batch_on_unloaded_relation(relation:, start:, finish:, load:, cursor:, order:, use_ranges:, remaining:, batch_limit:)
+        batch_orders = build_batch_orders(cursor, order)
         relation = relation.reorder(batch_orders.to_h).limit(batch_limit)
-        relation = apply_limits(relation, start, finish, batch_orders)
+        relation = apply_limits(relation, cursor, 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
+        empty_scope = to_sql == model.unscoped.all.to_sql
 
         loop do
           if load
             records = batch_relation.records
-            ids = records.map(&:id)
-            yielded_relation = where(primary_key => ids)
+            values = records.pluck(*cursor)
+            values_size = values.size
+            values_last = values.last
+            yielded_relation = rewhere(cursor => values)
             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)
+            # Efficiently peak at the last value for the next batch using offset and limit.
+            values_size = remaining ? [batch_limit, remaining].min : batch_limit
+            values_last = batch_relation.offset(values_size - 1).pick(*cursor)
+
+            # If the last value is not found using offset, there is at most one more batch of size < batch_limit.
+            # Retry by getting the whole list of remaining values so that we have the exact size and last value.
+            unless values_last
+              values = batch_relation.pluck(*cursor)
+              values_size = values.size
+              values_last = values.last
+            end
+
+            # Finally, build the yielded relation if at least one value found.
+            if values_last
+              yielded_relation = apply_finish_limit(batch_relation, cursor, values_last, 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)
+            values = batch_relation.pluck(*cursor)
+            values_size = values.size
+            values_last = values.last
+            yielded_relation = rewhere(cursor => values)
           end
 
-          break if ids.empty?
+          break if values_size == 0
 
-          primary_key_offset = ids.last
-          raise ArgumentError.new("Primary key not included in the custom select clause") unless primary_key_offset
+          if [values_last].flatten.any?(nil)
+            raise ArgumentError, "Not all of the batch cursor columns were included in the custom select clause "\
+                                  "or some columns contain nil."
+          end
 
           yield yielded_relation
 
-          break if ids.length < batch_limit
+          break if values_size < batch_limit
 
           if limit_value
-            remaining -= ids.length
+            remaining -= values_size
 
             if remaining == 0
               # Saves a useless iteration when the limit is a multiple of the
@@ -422,7 +495,8 @@ module ActiveRecord
           end
           operators << (last_order == :desc ? :lt : :gt)
 
-          batch_relation = batch_condition(relation, primary_key, primary_key_offset, operators)
+          cursor_value = values_last
+          batch_relation = batch_condition(relation, cursor, cursor_value, operators)
         end
 
         nil

data/lib/active_record/relation/calculations.rb

@@ -233,7 +233,7 @@ module ActiveRecord
         if operation == "count"
           unless distinct_value || distinct_select?(column_name || select_for_count)
             relation.distinct!
-            relation.select_values = Array(klass.primary_key || table[Arel.star])
+            relation.select_values = Array(model.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?
@@ -274,14 +274,23 @@ 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
+    #   Comment.joins(:person).pluck(:id, person: :id)
+    #   # SELECT comments.id, person.id FROM comments INNER JOIN people person ON person.id = comments.person_id
     #   # => [[1, 2], [2, 2]]
     #
+    #   Comment.joins(:person).pluck(:id, person: [:id, :name])
+    #   # SELECT comments.id, person.id, person.name FROM comments INNER JOIN people person ON person.id = comments.person_id
+    #   # => [[1, 2, 'David'], [2, 2, 'David']]
+    #
     #   Person.pluck(Arel.sql('DATEDIFF(updated_at, created_at)'))
     #   # SELECT DATEDIFF(updated_at, created_at) FROM people
     #   # => ['0', '27761', '173']
     #
+    # Be aware that #pluck ignores any previous select clauses
+    #
+    #   Person.select(:name).pluck(:id)
+    #   # SELECT people.id FROM people
+    #
     # See also #ids.
     def pluck(*column_names)
       if @none
@@ -305,16 +314,16 @@ module ActiveRecord
         relation = apply_join_dependency
         relation.pluck(*column_names)
       else
-        klass.disallow_raw_sql!(flattened_args(column_names))
+        model.disallow_raw_sql!(flattened_args(column_names))
         relation = spawn
         columns = relation.arel_columns(column_names)
         relation.select_values = columns
         result = skip_query_cache_if_necessary do
-          if where_clause.contradiction?
+          if where_clause.contradiction? && !possible_aggregation?(column_names)
             ActiveRecord::Result.empty(async: @async)
           else
-            klass.with_connection do |c|
-              c.select_all(relation.arel, "#{klass.name} Pluck", async: @async)
+            model.with_connection do |c|
+              c.select_all(relation.arel, "#{model.name} Pluck", async: @async)
             end
           end
         end
@@ -387,11 +396,11 @@ module ActiveRecord
       relation.select_values = columns
 
       result = if relation.where_clause.contradiction?
-        ActiveRecord::Result.empty
+        ActiveRecord::Result.empty(async: @async)
       else
         skip_query_cache_if_necessary do
-          klass.with_connection do |c|
-            c.select_all(relation, "#{klass.name} Ids", async: @async)
+          model.with_connection do |c|
+            c.select_all(relation, "#{model.name} Ids", async: @async)
           end
         end
       end
@@ -407,16 +416,19 @@ module ActiveRecord
 
     protected
       def aggregate_column(column_name)
-        return column_name if Arel::Expressions === column_name
-
-        arel_column(column_name.to_s) do |name|
-          column_name == :all ? Arel.sql("*", retryable: true) : Arel.sql(name)
+        case column_name
+        when Arel::Expressions
+          column_name
+        when :all
+          Arel.star
+        else
+          arel_column(column_name.to_s)
         end
       end
 
     private
       def all_attributes?(column_names)
-        (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
+        (column_names.map(&:to_s) - model.attribute_names - model.attribute_aliases.keys).empty?
       end
 
       def has_include?(column_name)
@@ -454,6 +466,16 @@ module ActiveRecord
         column_name.is_a?(::String) && /\bDISTINCT[\s(]/i.match?(column_name)
       end
 
+      def possible_aggregation?(column_names)
+        column_names.all? do |column_name|
+          if column_name.is_a?(String)
+            column_name.include?("(")
+          else
+            Arel.arel_node?(column_name)
+          end
+        end
+      end
+
       def operation_over_aggregate_column(column, operation, distinct)
         operation == "count" ? column.count(distinct) : column.public_send(operation)
       end
@@ -471,7 +493,7 @@ module ActiveRecord
 
           column = relation.aggregate_column(column_name)
           select_value = operation_over_aggregate_column(column, operation, distinct)
-          select_value.distinct = true if operation == "sum" && distinct
+          select_value.distinct = true if distinct && (operation == "sum" || operation == "average")
 
           relation.select_values = [select_value]
 
@@ -486,8 +508,8 @@ module ActiveRecord
           end
         else
           skip_query_cache_if_necessary do
-            @klass.with_connection do |c|
-              c.select_all(query_builder, "#{@klass.name} #{operation.capitalize}", async: @async)
+            model.with_connection do |c|
+              c.select_all(query_builder, "#{model.name} #{operation.capitalize}", async: @async)
             end
           end
         end
@@ -505,10 +527,9 @@ module ActiveRecord
 
       def execute_grouped_calculation(operation, column_name, distinct) # :nodoc:
         group_fields = group_values
-        group_fields = group_fields.uniq if group_fields.size > 1
 
         if group_fields.size == 1 && group_fields.first.respond_to?(:to_sym)
-          association  = klass._reflect_on_association(group_fields.first)
+          association  = model._reflect_on_association(group_fields.first)
           associated   = association && association.belongs_to? # only count belongs_to associations
           group_fields = Array(association.foreign_key) if associated
         end
@@ -516,7 +537,7 @@ module ActiveRecord
         relation = except(:group).distinct!(false)
         group_fields = relation.arel_columns(group_fields)
 
-        @klass.with_connection do |connection|
+        model.with_connection do |connection|
           column_alias_tracker = ColumnAliasTracker.new(connection)
 
           group_aliases = group_fields.map { |field|
@@ -528,13 +549,14 @@ module ActiveRecord
           column = relation.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))
+          select_value.distinct = true if distinct && (operation == "sum" || operation == "average")
+          select_value = select_value.as(model.adapter_class.quote_column_name(column_alias))
 
           select_values = [select_value]
           select_values += self.select_values unless having_clause.empty?
 
           select_values.concat group_columns.map { |aliaz, field|
-            aliaz = adapter_class.quote_column_name(aliaz)
+            aliaz = model.adapter_class.quote_column_name(aliaz)
             if field.respond_to?(:as)
               field.as(aliaz)
             else
@@ -546,12 +568,16 @@ module ActiveRecord
           relation.select_values = select_values
 
           result = skip_query_cache_if_necessary do
-            connection.select_all(relation.arel, "#{@klass.name} #{operation.capitalize}", async: @async)
+            connection.select_all(relation.arel, "#{model.name} #{operation.capitalize}", async: @async)
           end
 
           result.then do |calculated_data|
             if association
-              key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
+              key_ids = if association.klass.base_class.composite_primary_key?
+                calculated_data.collect { |row| group_aliases.map { |group_alias| row[group_alias] } }
+              else
+                calculated_data.collect { |row| row[group_aliases.first] }
+              end
               key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
               key_records = key_records.index_by(&:id)
             end
@@ -588,7 +614,7 @@ module ActiveRecord
 
       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)
+        model.type_for_attribute(field_name, &block)
       end
 
       def lookup_cast_type_from_join_dependencies(name, join_dependencies = build_join_dependencies)
@@ -601,12 +627,12 @@ module ActiveRecord
 
       def type_cast_pluck_values(result, columns)
         cast_types = if result.columns.size != columns.size
-          klass.attribute_types
+          model.attribute_types
         else
           join_dependencies = nil
           columns.map.with_index do |column, i|
             column.try(:type_caster) ||
-              klass.attribute_types.fetch(name = result.columns[i]) do
+              model.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[i] || Type.default_value
@@ -635,22 +661,12 @@ module ActiveRecord
       end
 
       def select_for_count
-        if select_values.present?
-          return select_values.first if select_values.one?
-
-          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
+        if select_values.empty?
           :all
+        else
+          with_connection do |conn|
+            arel_columns(select_values).map { |column| conn.visitor.compile(column) }.join(", ")
+          end
         end
       end
 
@@ -665,6 +681,7 @@ module ActiveRecord
         if column_name == :all
           column_alias = Arel.star
           relation.select_values = [ Arel.sql(FinderMethods::ONE_AS_ONE) ] unless distinct
+          relation.unscope!(:order)
         else
           column_alias = Arel.sql("count_column")
           relation.select_values = [ relation.aggregate_column(column_name).as(column_alias) ]