Don't recalculate GROUP BY in {update,delete}_all

These values are already calculated when building the SelectManager
arel, so we can use them instead of recalculating/rebuilding them.
Specifically, this prevents calling `arel_columns` after building the
relation, which opens up the possibility to cache the built Arel ast. It
couldn't be cached before because `arel_columns` may modify the
relation.

Going through the {Update,Delete}Manager's ast in `Crud` is necessary to
prevent `Group(Group(SQL))` because `#group` will wrap its arguments in
`Group` nodes.

Author: skipkayhil

activerecord/lib/active_record/relation.rb

@@ -628,14 +628,13 @@ def update_all(updates)
         arel = eager_loading? ? apply_join_dependency.arel : build_arel(c)
         arel.source.left = table
 
-        group_values_arel_columns = arel_columns(group_values.uniq)
         having_clause_ast = having_clause.ast unless having_clause.empty?
         key = if model.composite_primary_key?
           primary_key.map { |pk| table[pk] }
         else
           table[primary_key]
         end
-        stmt = arel.compile_update(values, key, having_clause_ast, group_values_arel_columns)
+        stmt = arel.compile_update(values, key, having_clause_ast)
         c.update(stmt, "#{model} Update All").tap { reset }
       end
     end
@@ -1045,14 +1044,13 @@ def delete_all
         arel = eager_loading? ? apply_join_dependency.arel : build_arel(c)
         arel.source.left = table
 
-        group_values_arel_columns = arel_columns(group_values.uniq)
         having_clause_ast = having_clause.ast unless having_clause.empty?
         key = if model.composite_primary_key?
           primary_key.map { |pk| table[pk] }
         else
           table[primary_key]
         end
-        stmt = arel.compile_delete(key, having_clause_ast, group_values_arel_columns)
+        stmt = arel.compile_delete(key, having_clause_ast)
 
         c.delete(stmt, "#{model} Delete All").tap { reset }
       end

activerecord/lib/arel/crud.rb

@@ -17,8 +17,7 @@ def create_insert
     def compile_update(
       values,
       key = nil,
-      having_clause = nil,
-      group_values_columns = []
+      having_clause = nil
     )
       um = UpdateManager.new(source)
       um.set(values)
@@ -28,19 +27,19 @@ def compile_update(
       um.wheres = constraints
       um.key = key
 
-      um.group(group_values_columns) unless group_values_columns.empty?
+      um.ast.groups = @ctx.groups
       um.having(having_clause) unless having_clause.nil?
       um
     end
 
-    def compile_delete(key = nil, having_clause = nil, group_values_columns = [])
+    def compile_delete(key = nil, having_clause = nil)
       dm = DeleteManager.new(source)
       dm.take(limit)
       dm.offset(offset)
       dm.order(*orders)
       dm.wheres = constraints
       dm.key = key
-      dm.group(group_values_columns) unless group_values_columns.empty?
+      dm.ast.groups = @ctx.groups
       dm.having(having_clause) unless having_clause.nil?
       dm
     end