From 3792ba092bca666e12f24acc072ca4d205569569 Mon Sep 17 00:00:00 2001 From: Chao Sun Date: Tue, 1 Feb 2022 10:32:15 -0800 Subject: [PATCH 1/3] switch to use new approach --- .../expressions/objects/objects.scala | 51 +++++++++++++++++++ 1 file changed, 51 insertions(+) diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/objects/objects.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/objects/objects.scala index 68a55f7f11696..7c90265ffe2d0 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/objects/objects.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/objects/objects.scala @@ -254,6 +254,18 @@ case class StaticInvoke( returnNullable: Boolean = true, isDeterministic: Boolean = true) extends InvokeLike { + def this( + staticObject: Class[_], + dataType: DataType, + functionName: String, + arguments: Seq[Expression], + inputTypes: Seq[AbstractDataType], + propagateNull: Boolean, + returnNullable: Boolean) = { + this(staticObject, dataType, functionName, arguments, inputTypes, + propagateNull, returnNullable, true) + } + val objectName = staticObject.getName.stripSuffix("$") val cls = if (staticObject.getName == objectName) { staticObject @@ -321,6 +333,20 @@ case class StaticInvoke( copy(arguments = newChildren) } +object StaticInvoke { + def apply( + staticObject: Class[_], + dataType: DataType, + functionName: String, + arguments: Seq[Expression], + inputTypes: Seq[AbstractDataType], + propagateNull: Boolean, + returnNullable: Boolean): StaticInvoke = { + StaticInvoke(staticObject, dataType, functionName, arguments, inputTypes, propagateNull, + returnNullable, true) + } +} + /** * Calls the specified function on an object, optionally passing arguments. If the `targetObject` * expression evaluates to null then null will be returned. @@ -358,6 +384,18 @@ case class Invoke( returnNullable : Boolean = true, isDeterministic: Boolean = true) extends InvokeLike { + def this( + targetObject: Expression, + functionName: String, + dataType: DataType, + arguments: Seq[Expression], + methodInputTypes: Seq[AbstractDataType], + propagateNull: Boolean, + returnNullable : Boolean) = { + this(targetObject, functionName, dataType, arguments, methodInputTypes, propagateNull, + returnNullable, true) + } + lazy val argClasses = ScalaReflection.expressionJavaClasses(arguments) override def nullable: Boolean = targetObject.nullable || needNullCheck || returnNullable @@ -471,6 +509,19 @@ case class Invoke( copy(targetObject = newChildren.head, arguments = newChildren.tail) } +object Invoke { + def apply( + targetObject: Expression, + functionName: String, + dataType: DataType, + arguments: Seq[Expression], + methodInputTypes: Seq[AbstractDataType], + propagateNull: Boolean, + returnNullable : Boolean): Invoke = { + Invoke(targetObject, functionName, dataType, arguments, methodInputTypes, + propagateNull, returnNullable, true) + } +} object NewInstance { def apply( cls: Class[_], From bd4108928370ddf6c21a02606081bffa2c6764fb Mon Sep 17 00:00:00 2001 From: Nadav Samet Date: Tue, 1 Feb 2022 10:33:51 -0800 Subject: [PATCH 2/3] add co-author From 5df28973f4e79d491ae7b6d6f18f0e978f51ce2d Mon Sep 17 00:00:00 2001 From: Chao Sun Date: Tue, 1 Feb 2022 21:48:44 -0800 Subject: [PATCH 3/3] add more comments --- .../spark/sql/catalyst/expressions/objects/objects.scala | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/objects/objects.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/objects/objects.scala index 7c90265ffe2d0..a70599b5ccdc3 100644 --- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/objects/objects.scala +++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/objects/objects.scala @@ -254,6 +254,8 @@ case class StaticInvoke( returnNullable: Boolean = true, isDeterministic: Boolean = true) extends InvokeLike { + // This additional constructor is added to keep binary compatibility after the addition of the + // above `isDeterministic` parameter. See SPARK-38077 for more detail. def this( staticObject: Class[_], dataType: DataType, @@ -384,6 +386,8 @@ case class Invoke( returnNullable : Boolean = true, isDeterministic: Boolean = true) extends InvokeLike { + // This additional constructor is added to keep binary compatibility after the addition of the + // above `isDeterministic` parameter. See SPARK-38077 for more detail. def this( targetObject: Expression, functionName: String,