Reduce constructors

Author: amanomer

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/dsl/package.scala

@@ -173,8 +173,8 @@ package object dsl {
     def approxCountDistinct(e: Expression, rsd: Double = 0.05): Expression =
       HyperLogLogPlusPlus(e, rsd).toAggregateExpression()
     def avg(e: Expression): Expression = Average(e).toAggregateExpression()
-    def first(e: Expression): Expression = new First(e).toAggregateExpression()
-    def last(e: Expression): Expression = new Last(e).toAggregateExpression()
+    def first(e: Expression): Expression = First(e).toAggregateExpression()
+    def last(e: Expression): Expression = Last(e).toAggregateExpression()
     def min(e: Expression): Expression = Min(e).toAggregateExpression()
     def minDistinct(e: Expression): Expression = Min(e).toAggregateExpression(isDistinct = true)
     def max(e: Expression): Expression = Max(e).toAggregateExpression()

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/First.scala

@@ -47,10 +47,6 @@ import org.apache.spark.sql.types._
 case class First(funcName: String, child: Expression, ignoreNullsExpr: Expression)
   extends DeclarativeAggregate with ExpectsInputTypes {
 
-  def this(child: Expression, ignoreNullsExpr: Expression) = this("first", child, ignoreNullsExpr)
-
-  def this(child: Expression) = this(child, Literal.create(false, BooleanType))
-
   def this(funcName: String, child: Expression) =
     this(funcName, child, Literal.create(false, BooleanType))
 
@@ -122,3 +118,12 @@ case class First(funcName: String, child: Expression, ignoreNullsExpr: Expressio
 
   override def toString: String = s"$prettyName($child)${if (ignoreNulls) " ignore nulls"}"
 }
+
+object First {
+
+  def apply(child: Expression, ignoreNullsExpr: Expression): First =
+    First("first", child, ignoreNullsExpr)
+
+  def apply(child: Expression): First =
+    First("first", child)
+}

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregate/Last.scala

@@ -47,10 +47,6 @@ import org.apache.spark.sql.types._
 case class Last(funcName: String, child: Expression, ignoreNullsExpr: Expression)
   extends DeclarativeAggregate with ExpectsInputTypes {
 
-  def this(child: Expression, ignoreNullsExpr: Expression) = this("last", child, ignoreNullsExpr)
-
-  def this(child: Expression) = this(child, Literal.create(false, BooleanType))
-
   def this(funcName: String, child: Expression) =
     this(funcName, child, Literal.create(false, BooleanType))
 
@@ -118,3 +114,12 @@ case class Last(funcName: String, child: Expression, ignoreNullsExpr: Expression
 
   override def toString: String = s"$funcName($child)${if (ignoreNulls) " ignore nulls"}"
 }
+
+object Last {
+
+  def apply(child: Expression, ignoreNullsExpr: Expression): Last =
+    Last("last", child, ignoreNullsExpr)
+
+  def apply(child: Expression): Last =
+    Last("last", child)
+}

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/Optimizer.scala

@@ -1539,7 +1539,7 @@ object ReplaceDeduplicateWithAggregate extends Rule[LogicalPlan] {
         if (keyExprIds.contains(attr.exprId)) {
           attr
         } else {
-          Alias(new First(attr).toAggregateExpression(), attr.name)(attr.exprId)
+          Alias(First(attr).toAggregateExpression(), attr.name)(attr.exprId)
         }
       }
       // SPARK-22951: Physical aggregate operators distinguishes global aggregation and grouping

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/RewriteDistinctAggregates.scala

@@ -198,7 +198,7 @@ object RewriteDistinctAggregates extends Rule[LogicalPlan] {
 
         // Select the result of the first aggregate in the last aggregate.
         val result = AggregateExpression(
-          new aggregate.First(evalWithinGroup(regularGroupId, operator.toAttribute), Literal(true)),
+          aggregate.First(evalWithinGroup(regularGroupId, operator.toAttribute), Literal(true)),
           mode = Complete,
           isDistinct = false)
 

sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/parser/AstBuilder.scala

@@ -1510,15 +1510,15 @@ class AstBuilder(conf: SQLConf) extends SqlBaseBaseVisitor[AnyRef] with Logging
    */
   override def visitFirst(ctx: FirstContext): Expression = withOrigin(ctx) {
     val ignoreNullsExpr = ctx.IGNORE != null
-    new First(expression(ctx.expression), Literal(ignoreNullsExpr)).toAggregateExpression()
+    First(expression(ctx.expression), Literal(ignoreNullsExpr)).toAggregateExpression()
   }
 
   /**
    * Create a [[Last]] expression.
    */
   override def visitLast(ctx: LastContext): Expression = withOrigin(ctx) {
     val ignoreNullsExpr = ctx.IGNORE != null
-    new Last(expression(ctx.expression), Literal(ignoreNullsExpr)).toAggregateExpression()
+    Last(expression(ctx.expression), Literal(ignoreNullsExpr)).toAggregateExpression()
   }
 
   /**

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/aggregate/LastTestSuite.scala

@@ -23,9 +23,9 @@ import org.apache.spark.sql.types.IntegerType
 
 class LastTestSuite extends SparkFunSuite {
   val input = AttributeReference("input", IntegerType, nullable = true)()
-  val evaluator = DeclarativeAggregateEvaluator(new Last(input, Literal(false)), Seq(input))
+  val evaluator = DeclarativeAggregateEvaluator(Last(input, Literal(false)), Seq(input))
   val evaluatorIgnoreNulls = DeclarativeAggregateEvaluator(
-    new Last(input, Literal(true)), Seq(input))
+    Last(input, Literal(true)), Seq(input))
 
   test("empty buffer") {
     assert(evaluator.initialize() === InternalRow(null, false))

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/optimizer/ReplaceOperatorSuite.scala

@@ -203,7 +203,7 @@ class ReplaceOperatorSuite extends PlanTest {
         Seq(attrA),
         Seq(
           attrA,
-          Alias(new First(attrB).toAggregateExpression(), attrB.name)(attrB.exprId)
+          Alias(First(attrB).toAggregateExpression(), attrB.name)(attrB.exprId)
         ),
         input)
 

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/parser/ExpressionParserSuite.scala

@@ -787,25 +787,25 @@ class ExpressionParserSuite extends AnalysisTest {
   }
 
   test("SPARK-19526 Support ignore nulls keywords for first and last") {
-    assertEqual("first(a ignore nulls)", new First('a, Literal(true)).toAggregateExpression())
-    assertEqual("first(a)", new First('a, Literal(false)).toAggregateExpression())
-    assertEqual("last(a ignore nulls)", new Last('a, Literal(true)).toAggregateExpression())
-    assertEqual("last(a)", new Last('a, Literal(false)).toAggregateExpression())
+    assertEqual("first(a ignore nulls)", First('a, Literal(true)).toAggregateExpression())
+    assertEqual("first(a)", First('a, Literal(false)).toAggregateExpression())
+    assertEqual("last(a ignore nulls)", Last('a, Literal(true)).toAggregateExpression())
+    assertEqual("last(a)", Last('a, Literal(false)).toAggregateExpression())
   }
 
   test("Support respect nulls keywords for first_value and last_value") {
     assertEqual("first_value(a ignore nulls)",
-      new First('a, Literal(true)).toAggregateExpression())
+      First('a, Literal(true)).toAggregateExpression())
     assertEqual("first_value(a respect nulls)",
-      new First('a, Literal(false)).toAggregateExpression())
+      First('a, Literal(false)).toAggregateExpression())
     assertEqual("first_value(a)",
-      new First('a, Literal(false)).toAggregateExpression())
+      First('a, Literal(false)).toAggregateExpression())
     assertEqual("last_value(a ignore nulls)",
-      new Last('a, Literal(true)).toAggregateExpression())
+      Last('a, Literal(true)).toAggregateExpression())
     assertEqual("last_value(a respect nulls)",
-      new Last('a, Literal(false)).toAggregateExpression())
+      Last('a, Literal(false)).toAggregateExpression())
     assertEqual("last_value(a)",
-      new Last('a, Literal(false)).toAggregateExpression())
+      Last('a, Literal(false)).toAggregateExpression())
   }
 
   test("timestamp literals") {

sql/core/src/main/scala/org/apache/spark/sql/functions.scala

@@ -431,7 +431,7 @@ object functions {
    * @since 2.0.0
    */
   def first(e: Column, ignoreNulls: Boolean): Column = withAggregateFunction {
-    new First(e.expr, Literal(ignoreNulls))
+    First(e.expr, Literal(ignoreNulls))
   }
 
   /**
@@ -556,7 +556,7 @@ object functions {
    * @since 2.0.0
    */
   def last(e: Column, ignoreNulls: Boolean): Column = withAggregateFunction {
-    new Last(e.expr, Literal(ignoreNulls))
+    Last(e.expr, Literal(ignoreNulls))
   }
 
   /**