Don't recalculate HAVING in {update,delete}_all

These values are already calculated when building the SelectManager
arel, so we can use theminstead of recalculating/rebuilding them.

Author: skipkayhil

activerecord/lib/active_record/relation.rb

@@ -628,13 +628,12 @@ def update_all(updates)
         arel = eager_loading? ? apply_join_dependency.arel : build_arel(c)
         arel.source.left = table
 
-        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)
+        stmt = arel.compile_update(values, key)
         c.update(stmt, "#{model} Update All").tap { reset }
       end
     end
@@ -1044,13 +1043,12 @@ def delete_all
         arel = eager_loading? ? apply_join_dependency.arel : build_arel(c)
         arel.source.left = table
 
-        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)
+        stmt = arel.compile_delete(key)
 
         c.delete(stmt, "#{model} Delete All").tap { reset }
       end

activerecord/lib/arel/crud.rb

@@ -14,11 +14,7 @@ def create_insert
       InsertManager.new
     end
 
-    def compile_update(
-      values,
-      key = nil,
-      having_clause = nil
-    )
+    def compile_update(values, key = nil)
       um = UpdateManager.new(source)
       um.set(values)
       um.take(limit)
@@ -28,19 +24,19 @@ def compile_update(
       um.key = key
 
       um.ast.groups = @ctx.groups
-      um.having(having_clause) unless having_clause.nil?
+      @ctx.havings.each { |h| um.having(h) }
       um
     end
 
-    def compile_delete(key = nil, having_clause = nil)
+    def compile_delete(key = nil)
       dm = DeleteManager.new(source)
       dm.take(limit)
       dm.offset(offset)
       dm.order(*orders)
       dm.wheres = constraints
       dm.key = key
       dm.ast.groups = @ctx.groups
-      dm.having(having_clause) unless having_clause.nil?
+      @ctx.havings.each { |h| dm.having(h) }
       dm
     end
   end