fix

Author: xuanyuanking

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala

@@ -240,6 +240,7 @@ class Analyzer(
       ExtractWindowExpressions ::
       ResolveTimeZone(conf) ::
       GlobalAggregates ::
+      ResolveHaving ::
       ResolveAggregateFunctions ::
       TimeWindowing ::
       ResolveInlineTables(conf) ::
@@ -2029,16 +2030,24 @@ class Analyzer(
     }
   }
 
+  /**
+   * Replace [[AggregateWithHaving]]s with [[Filter]]s.
+   */
+  object ResolveHaving extends Rule[LogicalPlan] {
+    def apply(plan: LogicalPlan): LogicalPlan = plan.resolveOperatorsUp {
+      case AggregateWithHaving(cond, agg: Aggregate) if agg.resolved =>
+        Filter(cond, agg)
+    }
+  }
+
   /**
    * This rule finds aggregate expressions that are not in an aggregate operator.  For example,
    * those in a HAVING clause or ORDER BY clause.  These expressions are pushed down to the
    * underlying aggregate operator and then projected away after the original operator.
    */
   object ResolveAggregateFunctions extends Rule[LogicalPlan] {
     def apply(plan: LogicalPlan): LogicalPlan = plan.resolveOperatorsUp {
-      case AggregateWithHaving(
-          cond, agg @ Aggregate(grouping, originalAggExprs, child)) if agg.resolved =>
-        val having = Filter(cond, agg)
+      case f @ Filter(cond, agg @ Aggregate(grouping, originalAggExprs, child)) if agg.resolved =>
         // Try resolving the condition of the filter as though it is in the aggregate clause
         try {
           val aggregatedCondition =
@@ -2083,15 +2092,15 @@ class Analyzer(
                 Filter(transformedAggregateFilter,
                   agg.copy(aggregateExpressions = originalAggExprs ++ aggregateExpressions)))
             } else {
-              having
+              f
             }
           } else {
-            having
+            f
           }
         } catch {
           // Attempting to resolve in the aggregate can result in ambiguity.  When this happens,
           // just return the original plan.
-          case ae: AnalysisException => having
+          case ae: AnalysisException => f
         }
 
       case sort @ Sort(sortOrder, global, aggregate: Aggregate) if aggregate.resolved =>