activerecord 4.2.11.3 → 5.0.0

data/lib/active_record/relation/batches.rb

@@ -1,8 +1,12 @@
+require "active_record/relation/batches/batch_enumerator"
+
 module ActiveRecord
   module Batches
+    ORDER_OR_LIMIT_IGNORED_MESSAGE = "Scoped order and limit are ignored, it's forced to be batch order and batch size."
+
     # Looping through a collection of records from the database
-    # (using the +all+ method, for example) is very inefficient
-    # since it will try to instantiate all the objects at once.
+    # (using the Scoping::Named::ClassMethods.all method, for example)
+    # is very inefficient since it will try to instantiate all the objects at once.
     #
     # In that case, batch processing methods allow you to work
     # with the records in batches, thereby greatly reducing memory consumption.
@@ -27,11 +31,15 @@ module ActiveRecord
     #
     # ==== Options
     # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
-    # * <tt>:start</tt> - Specifies the starting point for the batch processing.
+    # * <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>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
+    #                               the order and limit have to be ignored due to batching.
+    #
     # This is especially useful if you want multiple workers dealing with
     # the same processing queue. You can make worker 1 handle all the records
     # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
-    # (by setting the +:start+ option on that worker).
+    # (by setting the +:start+ and +:finish+ option on each worker).
     #
     #   # Let's process for a batch of 2000 records, skipping the first 2000 rows
     #   Person.find_each(start: 2000, batch_size: 2000) do |person|
@@ -40,24 +48,25 @@ module ActiveRecord
     #
     # NOTE: It's not possible to set the order. That is automatically set to
     # ascending on the primary key ("id ASC") to make the batch ordering
-    # work. This also means that this method only works with integer-based
-    # primary keys.
+    # work. This also means that this method only works when the primary key is
+    # orderable (e.g. an integer or string).
     #
     # NOTE: You can't set the limit either, that's used to control
     # the batch sizes.
-    def find_each(options = {})
+    def find_each(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
       if block_given?
-        find_in_batches(options) do |records|
+        find_in_batches(start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do |records|
           records.each { |record| yield record }
         end
       else
-        enum_for :find_each, options do
-          options[:start] ? where(table[primary_key].gteq(options[:start])).size : size
+        enum_for(:find_each, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do
+          relation = self
+          apply_limits(relation, start, finish).size
         end
       end
     end
 
-    # Yields each batch of records that was found by the find +options+ as
+    # Yields each batch of records that was found by the find options as
     # an array.
     #
     #   Person.where("age > 21").find_in_batches do |group|
@@ -77,11 +86,15 @@ module ActiveRecord
     #
     # ==== Options
     # * <tt>:batch_size</tt> - Specifies the size of the batch. Default to 1000.
-    # * <tt>:start</tt> - Specifies the starting point for the batch processing.
+    # * <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>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
+    #                               the order and limit have to be ignored due to batching.
+    #
     # This is especially useful if you want multiple workers dealing with
     # the same processing queue. You can make worker 1 handle all the records
     # between id 0 and 10,000 and worker 2 handle from 10,000 and beyond
-    # (by setting the +:start+ option on that worker).
+    # (by setting the +:start+ and +:finish+ option on each worker).
     #
     #   # Let's process the next 2000 records
     #   Person.find_in_batches(start: 2000, batch_size: 2000) do |group|
@@ -90,49 +103,141 @@ module ActiveRecord
     #
     # NOTE: It's not possible to set the order. That is automatically set to
     # ascending on the primary key ("id ASC") to make the batch ordering
-    # work. This also means that this method only works with integer-based
-    # primary keys.
+    # work. This also means that this method only works when the primary key is
+    # orderable (e.g. an integer or string).
     #
     # NOTE: You can't set the limit either, that's used to control
     # the batch sizes.
-    def find_in_batches(options = {})
-      options.assert_valid_keys(:start, :batch_size)
-
+    def find_in_batches(start: nil, finish: nil, batch_size: 1000, error_on_ignore: nil)
       relation = self
-      start = options[:start]
-      batch_size = options[:batch_size] || 1000
-
       unless block_given?
-        return to_enum(:find_in_batches, options) do
-          total = start ? where(table[primary_key].gteq(start)).size : size
+        return to_enum(:find_in_batches, start: start, finish: finish, batch_size: batch_size, error_on_ignore: error_on_ignore) do
+          total = apply_limits(relation, start, finish).size
           (total - 1).div(batch_size) + 1
         end
       end
 
-      if logger && (arel.orders.present? || arel.taken.present?)
-        logger.warn("Scoped order and limit are ignored, it's forced to be batch order and batch size")
+      in_batches(of: batch_size, start: start, finish: finish, load: true, error_on_ignore: error_on_ignore) do |batch|
+        yield batch.to_a
       end
+    end
 
-      relation = relation.reorder(batch_order).limit(batch_size)
-      records = start ? relation.where(table[primary_key].gteq(start)).to_a : relation.to_a
+    # Yields ActiveRecord::Relation objects to work with a batch of records.
+    #
+    #   Person.where("age > 21").in_batches do |relation|
+    #     relation.delete_all
+    #     sleep(10) # Throttle the delete queries
+    #   end
+    #
+    # If you do not provide a block to #in_batches, it will return a
+    # BatchEnumerator which is enumerable.
+    #
+    #   Person.in_batches.with_index do |relation, batch_index|
+    #     puts "Processing relation ##{batch_index}"
+    #     relation.each { |relation| relation.delete_all }
+    #   end
+    #
+    # Examples of calling methods on the returned BatchEnumerator object:
+    #
+    #   Person.in_batches.delete_all
+    #   Person.in_batches.update_all(awesome: true)
+    #   Person.in_batches.each_record(&:party_all_night!)
+    #
+    # ==== Options
+    # * <tt>:of</tt> - Specifies the size of the batch. Default to 1000.
+    # * <tt>:load</tt> - Specifies if the relation should be loaded. Default 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>:error_on_ignore</tt> - Overrides the application config to specify if an error should be raised when
+    #                               the order and limit have to be ignored due to batching.
+    #
+    # This is especially useful if you want to work with the
+    # ActiveRecord::Relation object instead of the array of records, or if
+    # you want multiple workers dealing with the same processing queue. You can
+    # make worker 1 handle all the records between id 0 and 10,000 and worker 2
+    # handle from 10,000 and beyond (by setting the +:start+ and +:finish+
+    # option on each worker).
+    #
+    #   # Let's process the next 2000 records
+    #   Person.in_batches(of: 2000, start: 2000).update_all(awesome: true)
+    #
+    # An example of calling where query method on the relation:
+    #
+    #   Person.in_batches.each do |relation|
+    #     relation.update_all('age = age + 1')
+    #     relation.where('age > 21').update_all(should_party: true)
+    #     relation.where('age <= 21').delete_all
+    #   end
+    #
+    # NOTE: If you are going to iterate through each record, you should call
+    # #each_record on the yielded BatchEnumerator:
+    #
+    #   Person.in_batches.each_record(&:party_all_night!)
+    #
+    # NOTE: It's not possible to set the order. That is automatically set to
+    # ascending on the primary key ("id ASC") to make the batch ordering
+    # consistent. Therefore the primary key must be orderable, e.g an integer
+    # or a string.
+    #
+    # NOTE: You can't set the limit either, that's used to control the batch
+    # sizes.
+    def in_batches(of: 1000, start: nil, finish: nil, load: false, error_on_ignore: nil)
+      relation = self
+      unless block_given?
+        return BatchEnumerator.new(of: of, start: start, finish: finish, relation: self)
+      end
+
+      if arel.orders.present? || arel.taken.present?
+        act_on_order_or_limit_ignored(error_on_ignore)
+      end
+
+      relation = relation.reorder(batch_order).limit(of)
+      relation = apply_limits(relation, start, finish)
+      batch_relation = relation
 
-      while records.any?
-        records_size = records.size
-        primary_key_offset = records.last.id
-        raise "Primary key not included in the custom select clause" unless primary_key_offset
+      loop do
+        if load
+          records = batch_relation.records
+          ids = records.map(&:id)
+          yielded_relation = self.where(primary_key => ids)
+          yielded_relation.load_records(records)
+        else
+          ids = batch_relation.pluck(primary_key)
+          yielded_relation = self.where(primary_key => ids)
+        end
 
-        yield records
+        break if ids.empty?
 
-        break if records_size < batch_size
+        primary_key_offset = ids.last
+        raise ArgumentError.new("Primary key not included in the custom select clause") unless primary_key_offset
 
-        records = relation.where(table[primary_key].gt(primary_key_offset)).to_a
+        yield yielded_relation
+
+        break if ids.length < of
+        batch_relation = relation.where(arel_attribute(primary_key).gt(primary_key_offset))
       end
     end
 
     private
 
+    def apply_limits(relation, start, finish)
+      relation = relation.where(arel_attribute(primary_key).gteq(start)) if start
+      relation = relation.where(arel_attribute(primary_key).lteq(finish)) if finish
+      relation
+    end
+
     def batch_order
       "#{quoted_table_name}.#{quoted_primary_key} ASC"
     end
+
+    def act_on_order_or_limit_ignored(error_on_ignore)
+      raise_error = (error_on_ignore.nil? ? self.klass.error_on_ignored_order_or_limit : error_on_ignore)
+
+      if raise_error
+        raise ArgumentError.new(ORDER_OR_LIMIT_IGNORED_MESSAGE)
+      elsif logger
+        logger.warn(ORDER_OR_LIMIT_IGNORED_MESSAGE)
+      end
+    end
   end
 end

data/lib/active_record/relation/calculations.rb

@@ -14,127 +14,112 @@ module ActiveRecord
     #   Person.distinct.count(:age)
     #   # => counts the number of different age values
     #
-    # If +count+ is used with +group+, it returns a Hash whose keys represent the aggregated column,
+    # If #count is used with {Relation#group}[rdoc-ref:QueryMethods#group],
+    # it returns a Hash whose keys represent the aggregated column,
     # and the values are the respective amounts:
     #
     #   Person.group(:city).count
     #   # => { 'Rome' => 5, 'Paris' => 3 }
     #
-    # If +count+ is used with +group+ for multiple columns, it returns a Hash whose
+    # If #count is used with {Relation#group}[rdoc-ref:QueryMethods#group] for multiple columns, it returns a Hash whose
     # keys are an array containing the individual values of each column and the value
-    # of each key would be the +count+.
+    # of each key would be the #count.
     #
     #   Article.group(:status, :category).count
     #   # =>  {["draft", "business"]=>10, ["draft", "technology"]=>4,
     #          ["published", "business"]=>0, ["published", "technology"]=>2}
     #
-    # If +count+ is used with +select+, it will count the selected columns:
+    # If #count is used with {Relation#select}[rdoc-ref:QueryMethods#select], it will count the selected columns:
     #
     #   Person.select(:age).count
     #   # => counts the number of different age values
     #
-    # Note: not all valid +select+ expressions are valid +count+ expressions. The specifics differ
+    # 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.
-    def count(column_name = nil, options = {})
-      if options.present? && !ActiveRecord.const_defined?(:DeprecatedFinders)
-        raise ArgumentError, "Relation#count does not support finder options anymore. " \
-                             "Please build a scope and then call count on it or use the " \
-                             "activerecord-deprecated_finders gem to enable this functionality."
-
-      end
-
-      # TODO: Remove options argument as soon we remove support to
-      # activerecord-deprecated_finders.
-      calculate(:count, column_name, options)
+    def count(column_name = nil)
+      calculate(: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.
+    # no row. See #calculate for examples with options.
     #
     #   Person.average(:age) # => 35.8
-    def average(column_name, options = {})
-      # TODO: Remove options argument as soon we remove support to
-      # activerecord-deprecated_finders.
-      calculate(:average, column_name, options)
+    def average(column_name)
+      calculate(: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.
+    # #calculate for examples with options.
     #
     #   Person.minimum(:age) # => 7
-    def minimum(column_name, options = {})
-      # TODO: Remove options argument as soon we remove support to
-      # activerecord-deprecated_finders.
-      calculate(:minimum, column_name, options)
+    def minimum(column_name)
+      calculate(: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.
+    # #calculate for examples with options.
     #
     #   Person.maximum(:age) # => 93
-    def maximum(column_name, options = {})
-      # TODO: Remove options argument as soon we remove support to
-      # activerecord-deprecated_finders.
-      calculate(:maximum, column_name, options)
+    def maximum(column_name)
+      calculate(: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.
+    # 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(*args)
-      calculate(:sum, *args)
+    def sum(column_name = nil, &block)
+      return super(&block) if block_given?
+      calculate(:sum, column_name)
     end
 
-    # This calculates aggregate values in the given column. Methods for count, sum, average,
-    # minimum, and maximum have been added as shortcuts.
+    # This calculates aggregate values in the given column. Methods for #count, #sum, #average,
+    # #minimum, and #maximum have been added as shortcuts.
     #
-    # There are two basic forms of output:
+    #   Person.calculate(:count, :all) # The same as Person.count
+    #   Person.average(:age) # SELECT AVG(age) FROM people...
     #
-    #   * Single aggregate value: The single value is type cast to Integer for COUNT, Float
-    #     for AVG, and the given column's type for everything else.
+    #   # Selects the minimum age for any family without any minors
+    #   Person.group(:last_name).having("min(age) > 17").minimum(:age)
     #
-    #   * Grouped values: This returns an ordered hash of the values and groups them. It
-    #     takes either a column name, or the name of a belongs_to association.
+    #   Person.sum("2 * age")
     #
-    #       values = Person.group('last_name').maximum(:age)
-    #       puts values["Drake"]
-    #       # => 43
+    # There are two basic forms of output:
     #
-    #       drake  = Family.find_by(last_name: 'Drake')
-    #       values = Person.group(:family).maximum(:age) # Person belongs_to :family
-    #       puts values[drake]
-    #       # => 43
+    # * Single aggregate value: The single value is type cast to Integer for COUNT, Float
+    #   for AVG, and the given column's type for everything else.
     #
-    #       values.each do |family, max_age|
-    #       ...
-    #       end
+    # * Grouped values: This returns an ordered hash of the values and groups them. It
+    #   takes either a column name, or the name of a belongs_to association.
     #
-    #   Person.calculate(:count, :all) # The same as Person.count
-    #   Person.average(:age) # SELECT AVG(age) FROM people...
+    #      values = Person.group('last_name').maximum(:age)
+    #      puts values["Drake"]
+    #      # => 43
     #
-    #   # Selects the minimum age for any family without any minors
-    #   Person.group(:last_name).having("min(age) > 17").minimum(:age)
+    #      drake  = Family.find_by(last_name: 'Drake')
+    #      values = Person.group(:family).maximum(:age) # Person belongs_to :family
+    #      puts values[drake]
+    #      # => 43
     #
-    #   Person.sum("2 * age")
-    def calculate(operation, column_name, options = {})
-      # TODO: Remove options argument as soon we remove support to
-      # activerecord-deprecated_finders.
+    #      values.each do |family, max_age|
+    #        ...
+    #      end
+    def calculate(operation, column_name)
       if column_name.is_a?(Symbol) && attribute_alias?(column_name)
         column_name = attribute_alias(column_name)
       end
 
       if has_include?(column_name)
-        construct_relation_for_association_calculations.calculate(operation, column_name, options)
+        construct_relation_for_association_calculations.calculate(operation, column_name)
       else
-        perform_calculation(operation, column_name, options)
+        perform_calculation(operation, column_name)
       end
     end
 
-    # Use <tt>pluck</tt> as a shortcut to select one or more attributes without
+    # Use #pluck as a shortcut to select one or more attributes without
     # loading a bunch of records just to grab the attributes you want.
     #
     #   Person.pluck(:name)
@@ -143,19 +128,19 @@ module ActiveRecord
     #
     #   Person.all.map(&:name)
     #
-    # Pluck returns an <tt>Array</tt> of attribute values type-casted to match
+    # Pluck returns an Array of attribute values type-casted to match
     # the plucked column names, if they can be deduced. Plucking an SQL fragment
     # returns String values by default.
     #
-    #   Person.pluck(:id)
-    #   # SELECT people.id FROM people
-    #   # => [1, 2, 3]
+    #   Person.pluck(:name)
+    #   # SELECT people.name FROM people
+    #   # => ['David', 'Jeremy', 'Jose']
     #
     #   Person.pluck(:id, :name)
     #   # SELECT people.id, people.name FROM people
     #   # => [[1, 'David'], [2, 'Jeremy'], [3, 'Jose']]
     #
-    #   Person.pluck('DISTINCT role')
+    #   Person.distinct.pluck(:role)
     #   # SELECT DISTINCT role FROM people
     #   # => ['admin', 'member', 'guest']
     #
@@ -167,13 +152,11 @@ module ActiveRecord
     #   # SELECT DATEDIFF(updated_at, created_at) FROM people
     #   # => ['0', '27761', '173']
     #
+    # See also #ids.
+    #
     def pluck(*column_names)
-      column_names.map! do |column_name|
-        if column_name.is_a?(Symbol) && attribute_alias?(column_name)
-          attribute_alias(column_name)
-        else
-          column_name.to_s
-        end
+      if loaded? && (column_names.map(&:to_s) - @klass.attribute_names - @klass.attribute_aliases.keys).empty?
+        return @records.pluck(*column_names)
       end
 
       if has_include?(column_names.first)
@@ -181,10 +164,10 @@ module ActiveRecord
       else
         relation = spawn
         relation.select_values = column_names.map { |cn|
-          columns_hash.key?(cn) ? arel_table[cn] : cn
+          @klass.has_attribute?(cn) || @klass.attribute_alias?(cn) ? arel_attribute(cn) : cn
         }
-        result = klass.connection.select_all(relation.arel, nil, relation.arel.bind_values + bind_values)
-        result.cast_values(klass.column_types)
+        result = klass.connection.select_all(relation.arel, nil, bound_attributes)
+        result.cast_values(klass.attribute_types)
       end
     end
 
@@ -199,15 +182,14 @@ module ActiveRecord
     private
 
     def has_include?(column_name)
-      eager_loading? || (includes_values.present? && ((column_name && column_name != :all) || references_eager_loaded_tables?))
+      eager_loading? || (includes_values.present? && column_name && column_name != :all)
     end
 
-    def perform_calculation(operation, column_name, options = {})
-      # TODO: Remove options argument as soon we remove support to
-      # activerecord-deprecated_finders.
+    def perform_calculation(operation, column_name)
       operation = operation.to_s.downcase
 
-      # If #count is used with #distinct / #uniq it is considered distinct. (eg. relation.distinct.count)
+      # If #count is used with #distinct (i.e. `relation.distinct.count`) it is
+      # considered distinct.
       distinct = self.distinct_value
 
       if operation == "count"
@@ -229,6 +211,8 @@ module ActiveRecord
     end
 
     def aggregate_column(column_name)
+      return column_name if Arel::Expressions === column_name
+
       if @klass.column_names.include?(column_name.to_s)
         Arel::Attribute.new(@klass.unscoped.table, column_name)
       else
@@ -241,19 +225,16 @@ module ActiveRecord
     end
 
     def execute_simple_calculation(operation, column_name, distinct) #:nodoc:
-      # Postgresql doesn't like ORDER BY when there are no GROUP BY
+      # PostgreSQL doesn't like ORDER BY when there are no GROUP BY
       relation = unscope(:order)
 
       column_alias = column_name
 
-      bind_values = nil
-
       if operation == "count" && (relation.limit_value || relation.offset_value)
         # Shortcut when limit is zero.
         return 0 if relation.limit_value == 0
 
         query_builder = build_count_subquery(relation, column_name, distinct)
-        bind_values = query_builder.bind_values + relation.bind_values
       else
         column = aggregate_column(column_name)
 
@@ -264,10 +245,9 @@ module ActiveRecord
         relation.select_values = [select_value]
 
         query_builder = relation.arel
-        bind_values = query_builder.bind_values + relation.bind_values
       end
 
-      result = @klass.connection.select_all(query_builder, nil, bind_values)
+      result = @klass.connection.select_all(query_builder, nil, bound_attributes)
       row    = result.first
       value  = row && row.values.first
       column = result.column_types.fetch(column_alias) do
@@ -289,14 +269,8 @@ module ActiveRecord
       end
       group_fields = arel_columns(group_fields)
 
-      group_aliases = group_fields.map { |field|
-        column_alias_for(field)
-      }
-      group_columns = group_aliases.zip(group_fields).map { |aliaz,field|
-        [aliaz, field]
-      }
-
-      group = group_fields
+      group_aliases = group_fields.map { |field| column_alias_for(field) }
+      group_columns = group_aliases.zip(group_fields)
 
       if operation == 'count' && column_name == :all
         aggregate_alias = 'count_all'
@@ -310,9 +284,9 @@ module ActiveRecord
           operation,
           distinct).as(aggregate_alias)
       ]
-      select_values += self.select_values unless having_values.empty?
+      select_values += select_values unless having_clause.empty?
 
-      select_values.concat group_fields.zip(group_aliases).map { |field,aliaz|
+      select_values.concat group_columns.map { |aliaz, field|
         if field.respond_to?(:as)
           field.as(aliaz)
         else
@@ -321,14 +295,14 @@ module ActiveRecord
       }
 
       relation = except(:group)
-      relation.group_values  = group
+      relation.group_values  = group_fields
       relation.select_values = select_values
 
-      calculated_data = @klass.connection.select_all(relation, nil, relation.arel.bind_values + bind_values)
+      calculated_data = @klass.connection.select_all(relation, nil, relation.bound_attributes)
 
       if association
         key_ids     = calculated_data.collect { |row| row[group_aliases.first] }
-        key_records = association.klass.base_class.find(key_ids)
+        key_records = association.klass.base_class.where(association.klass.base_class.primary_key => key_ids)
         key_records = Hash[key_records.map { |r| [r.id, r] }]
       end
 
@@ -354,7 +328,6 @@ module ActiveRecord
     #   column_alias_for("sum(id)")                  # => "sum_id"
     #   column_alias_for("count(distinct users.id)") # => "count_distinct_users_id"
     #   column_alias_for("count(*)")                 # => "count_all"
-    #   column_alias_for("count", "id")              # => "count_id"
     def column_alias_for(keys)
       if keys.respond_to? :name
         keys = "#{keys.relation.name}.#{keys.name}"
@@ -377,15 +350,15 @@ module ActiveRecord
     def type_cast_calculated_value(value, type, operation = nil)
       case operation
         when 'count'   then value.to_i
-        when 'sum'     then type.type_cast_from_database(value || 0)
+        when 'sum'     then type.deserialize(value || 0)
         when 'average' then value.respond_to?(:to_d) ? value.to_d : value
-        else type.type_cast_from_database(value)
+        else type.deserialize(value)
       end
     end
 
-    # TODO: refactor to allow non-string `select_values` (eg. Arel nodes).
     def select_for_count
       if select_values.present?
+        return select_values.first if select_values.one?
         select_values.join(", ")
       else
         :all
@@ -398,11 +371,9 @@ module ActiveRecord
 
       aliased_column = aggregate_column(column_name == :all ? 1 : column_name).as(column_alias)
       relation.select_values = [aliased_column]
-      arel = relation.arel
-      subquery = arel.as(subquery_alias)
+      subquery = relation.arel.as(subquery_alias)
 
       sm = Arel::SelectManager.new relation.engine
-      sm.bind_values = arel.bind_values
       select_value = operation_over_aggregate_column(column_alias, 'count', distinct)
       sm.project(select_value).from(subquery)
     end