diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/SqlParser.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/SqlParser.scala
index b176f7e729a423717e3d7a80209d28cc16a17966..89f4a19add1c65597f0f94718cb961775f4c719f 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/SqlParser.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/SqlParser.scala
@@ -316,13 +316,13 @@ class SqlParser extends AbstractSparkSQLParser with DataTypeParser {
protected lazy val literal: Parser[Literal] =
( numericLiteral
| booleanLiteral
- | stringLit ^^ {case s => Literal(s, StringType) }
- | NULL ^^^ Literal(null, NullType)
+ | stringLit ^^ {case s => Literal.create(s, StringType) }
+ | NULL ^^^ Literal.create(null, NullType)
)
protected lazy val booleanLiteral: Parser[Literal] =
- ( TRUE ^^^ Literal(true, BooleanType)
- | FALSE ^^^ Literal(false, BooleanType)
+ ( TRUE ^^^ Literal.create(true, BooleanType)
+ | FALSE ^^^ Literal.create(false, BooleanType)
)
protected lazy val numericLiteral: Parser[Literal] =
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala
index c578d084a45b66e4c95ecf90367cc5ad174e2fb2..119cb9c3a4400a788fc7a4bc65daf7a067e9ba8f 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/Analyzer.scala
@@ -140,10 +140,10 @@ class Analyzer(
case x: Expression if nonSelectedGroupExprSet.contains(x) =>
// if the input attribute in the Invalid Grouping Expression set of for this group
// replace it with constant null
- Literal(null, expr.dataType)
+ Literal.create(null, expr.dataType)
case x if x == g.gid =>
// replace the groupingId with concrete value (the bit mask)
- Literal(bitmask, IntegerType)
+ Literal.create(bitmask, IntegerType)
})
result += GroupExpression(substitution)
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/HiveTypeCoercion.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/HiveTypeCoercion.scala
index 3c7b46e0702a2e6ce05f85059222ee1f64ebecce..9a33eb145273e76da4a2e953ae7917629997e291 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/HiveTypeCoercion.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/analysis/HiveTypeCoercion.scala
@@ -115,7 +115,7 @@ trait HiveTypeCoercion {
* the appropriate numeric equivalent.
*/
object ConvertNaNs extends Rule[LogicalPlan] {
- val stringNaN = Literal("NaN", StringType)
+ val stringNaN = Literal.create("NaN", StringType)
def apply(plan: LogicalPlan): LogicalPlan = plan transform {
case q: LogicalPlan => q transformExpressions {
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregates.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregates.scala
index 30da4faa3f1c68001533859e5163fc475aa20e21..406de38d1c48326cb7ef9c8e7a57d0642f29cd87 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregates.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/aggregates.scala
@@ -505,7 +505,8 @@ case class AverageFunction(expr: Expression, base: AggregateExpression)
private var count: Long = _
private val sum = MutableLiteral(zero.eval(null), calcType)
- private def addFunction(value: Any) = Add(sum, Cast(Literal(value, expr.dataType), calcType))
+ private def addFunction(value: Any) = Add(sum,
+ Cast(Literal.create(value, expr.dataType), calcType))
override def eval(input: Row): Any = {
if (count == 0L) {
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/literals.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/literals.scala
index 19f3fc9c2291a923ce120baa1bfc70ea41456290..0e2d593e94124b202b04fe3b80290c6c34d06ecb 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/literals.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/expressions/literals.scala
@@ -41,6 +41,8 @@ object Literal {
case _ =>
throw new RuntimeException("Unsupported literal type " + v.getClass + " " + v)
}
+
+ def create(v: Any, dataType: DataType): Literal = Literal(v, dataType)
}
/**
@@ -62,7 +64,10 @@ object IntegerLiteral {
}
}
-case class Literal(value: Any, dataType: DataType) extends LeafExpression {
+/**
+ * In order to do type checking, use Literal.create() instead of constructor
+ */
+case class Literal protected (value: Any, dataType: DataType) extends LeafExpression {
override def foldable: Boolean = true
override def nullable: Boolean = value == null
diff --git a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/Optimizer.scala b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/Optimizer.scala
index c23d3b61887c608e865b9e3c4a06c93162072542..93e69d409cb916d988c49efd3ea8bf7dbae7f375 100644
--- a/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/Optimizer.scala
+++ b/sql/catalyst/src/main/scala/org/apache/spark/sql/catalyst/optimizer/Optimizer.scala
@@ -218,12 +218,12 @@ object NullPropagation extends Rule[LogicalPlan] {
def apply(plan: LogicalPlan): LogicalPlan = plan transform {
case q: LogicalPlan => q transformExpressionsUp {
case e @ Count(Literal(null, _)) => Cast(Literal(0L), e.dataType)
- case e @ IsNull(c) if !c.nullable => Literal(false, BooleanType)
- case e @ IsNotNull(c) if !c.nullable => Literal(true, BooleanType)
- case e @ GetItem(Literal(null, _), _) => Literal(null, e.dataType)
- case e @ GetItem(_, Literal(null, _)) => Literal(null, e.dataType)
- case e @ StructGetField(Literal(null, _), _, _) => Literal(null, e.dataType)
- case e @ ArrayGetField(Literal(null, _), _, _, _) => Literal(null, e.dataType)
+ case e @ IsNull(c) if !c.nullable => Literal.create(false, BooleanType)
+ case e @ IsNotNull(c) if !c.nullable => Literal.create(true, BooleanType)
+ case e @ GetItem(Literal(null, _), _) => Literal.create(null, e.dataType)
+ case e @ GetItem(_, Literal(null, _)) => Literal.create(null, e.dataType)
+ case e @ StructGetField(Literal(null, _), _, _) => Literal.create(null, e.dataType)
+ case e @ ArrayGetField(Literal(null, _), _, _, _) => Literal.create(null, e.dataType)
case e @ EqualNullSafe(Literal(null, _), r) => IsNull(r)
case e @ EqualNullSafe(l, Literal(null, _)) => IsNull(l)
case e @ Count(expr) if !expr.nullable => Count(Literal(1))
@@ -235,36 +235,36 @@ object NullPropagation extends Rule[LogicalPlan] {
case _ => true
}
if (newChildren.length == 0) {
- Literal(null, e.dataType)
+ Literal.create(null, e.dataType)
} else if (newChildren.length == 1) {
newChildren(0)
} else {
Coalesce(newChildren)
}
- case e @ Substring(Literal(null, _), _, _) => Literal(null, e.dataType)
- case e @ Substring(_, Literal(null, _), _) => Literal(null, e.dataType)
- case e @ Substring(_, _, Literal(null, _)) => Literal(null, e.dataType)
+ case e @ Substring(Literal(null, _), _, _) => Literal.create(null, e.dataType)
+ case e @ Substring(_, Literal(null, _), _) => Literal.create(null, e.dataType)
+ case e @ Substring(_, _, Literal(null, _)) => Literal.create(null, e.dataType)
// Put exceptional cases above if any
case e: BinaryArithmetic => e.children match {
- case Literal(null, _) :: right :: Nil => Literal(null, e.dataType)
- case left :: Literal(null, _) :: Nil => Literal(null, e.dataType)
+ case Literal(null, _) :: right :: Nil => Literal.create(null, e.dataType)
+ case left :: Literal(null, _) :: Nil => Literal.create(null, e.dataType)
case _ => e
}
case e: BinaryComparison => e.children match {
- case Literal(null, _) :: right :: Nil => Literal(null, e.dataType)
- case left :: Literal(null, _) :: Nil => Literal(null, e.dataType)
+ case Literal(null, _) :: right :: Nil => Literal.create(null, e.dataType)
+ case left :: Literal(null, _) :: Nil => Literal.create(null, e.dataType)
case _ => e
}
case e: StringRegexExpression => e.children match {
- case Literal(null, _) :: right :: Nil => Literal(null, e.dataType)
- case left :: Literal(null, _) :: Nil => Literal(null, e.dataType)
+ case Literal(null, _) :: right :: Nil => Literal.create(null, e.dataType)
+ case left :: Literal(null, _) :: Nil => Literal.create(null, e.dataType)
case _ => e
}
case e: StringComparison => e.children match {
- case Literal(null, _) :: right :: Nil => Literal(null, e.dataType)
- case left :: Literal(null, _) :: Nil => Literal(null, e.dataType)
+ case Literal(null, _) :: right :: Nil => Literal.create(null, e.dataType)
+ case left :: Literal(null, _) :: Nil => Literal.create(null, e.dataType)
case _ => e
}
}
@@ -284,13 +284,13 @@ object ConstantFolding extends Rule[LogicalPlan] {
case l: Literal => l
// Fold expressions that are foldable.
- case e if e.foldable => Literal(e.eval(null), e.dataType)
+ case e if e.foldable => Literal.create(e.eval(null), e.dataType)
// Fold "literal in (item1, item2, ..., literal, ...)" into true directly.
case In(Literal(v, _), list) if list.exists {
case Literal(candidate, _) if candidate == v => true
case _ => false
- } => Literal(true, BooleanType)
+ } => Literal.create(true, BooleanType)
}
}
}
@@ -647,7 +647,7 @@ object DecimalAggregates extends Rule[LogicalPlan] {
case Average(e @ DecimalType.Expression(prec, scale)) if prec + 4 <= MAX_DOUBLE_DIGITS =>
Cast(
- Divide(Average(UnscaledValue(e)), Literal(math.pow(10.0, scale), DoubleType)),
+ Divide(Average(UnscaledValue(e)), Literal.create(math.pow(10.0, scale), DoubleType)),
DecimalType(prec + 4, scale + 4))
}
}
diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/analysis/HiveTypeCoercionSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/analysis/HiveTypeCoercionSuite.scala
index ecbb54218d457f0845d966237c2ea8a21054b6a5..70aef1cac421a74a418820982f93933845f3321f 100644
--- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/analysis/HiveTypeCoercionSuite.scala
+++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/analysis/HiveTypeCoercionSuite.scala
@@ -127,11 +127,11 @@ class HiveTypeCoercionSuite extends PlanTest {
ruleTest(
Coalesce(Literal(1.0)
:: Literal(1)
- :: Literal(1.0, FloatType)
+ :: Literal.create(1.0, FloatType)
:: Nil),
Coalesce(Cast(Literal(1.0), DoubleType)
:: Cast(Literal(1), DoubleType)
- :: Cast(Literal(1.0, FloatType), DoubleType)
+ :: Cast(Literal.create(1.0, FloatType), DoubleType)
:: Nil))
ruleTest(
Coalesce(Literal(1L)
diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/ExpressionEvaluationSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/ExpressionEvaluationSuite.scala
index 1183a0d899dda35f4b2db70981c1349d222c4f6a..3dbefa40d280897c7abd61b55ce413d1b9c2b75e 100644
--- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/ExpressionEvaluationSuite.scala
+++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/expressions/ExpressionEvaluationSuite.scala
@@ -111,7 +111,7 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
test("3VL Not") {
notTrueTable.foreach {
case (v, answer) =>
- checkEvaluation(!Literal(v, BooleanType), answer)
+ checkEvaluation(!Literal.create(v, BooleanType), answer)
}
}
@@ -155,7 +155,7 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
test(s"3VL $name") {
truthTable.foreach {
case (l,r,answer) =>
- val expr = op(Literal(l, BooleanType), Literal(r, BooleanType))
+ val expr = op(Literal.create(l, BooleanType), Literal.create(r, BooleanType))
checkEvaluation(expr, answer)
}
}
@@ -175,12 +175,12 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(Divide(Literal(1), Literal(0)), null)
checkEvaluation(Divide(Literal(1.0), Literal(0.0)), null)
checkEvaluation(Divide(Literal(0.0), Literal(0.0)), null)
- checkEvaluation(Divide(Literal(0), Literal(null, IntegerType)), null)
- checkEvaluation(Divide(Literal(1), Literal(null, IntegerType)), null)
- checkEvaluation(Divide(Literal(null, IntegerType), Literal(0)), null)
- checkEvaluation(Divide(Literal(null, DoubleType), Literal(0.0)), null)
- checkEvaluation(Divide(Literal(null, IntegerType), Literal(1)), null)
- checkEvaluation(Divide(Literal(null, IntegerType), Literal(null, IntegerType)), null)
+ checkEvaluation(Divide(Literal(0), Literal.create(null, IntegerType)), null)
+ checkEvaluation(Divide(Literal(1), Literal.create(null, IntegerType)), null)
+ checkEvaluation(Divide(Literal.create(null, IntegerType), Literal(0)), null)
+ checkEvaluation(Divide(Literal.create(null, DoubleType), Literal(0.0)), null)
+ checkEvaluation(Divide(Literal.create(null, IntegerType), Literal(1)), null)
+ checkEvaluation(Divide(Literal.create(null, IntegerType), Literal.create(null, IntegerType)), null)
}
test("Remainder") {
@@ -190,12 +190,12 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(Remainder(Literal(1), Literal(0)), null)
checkEvaluation(Remainder(Literal(1.0), Literal(0.0)), null)
checkEvaluation(Remainder(Literal(0.0), Literal(0.0)), null)
- checkEvaluation(Remainder(Literal(0), Literal(null, IntegerType)), null)
- checkEvaluation(Remainder(Literal(1), Literal(null, IntegerType)), null)
- checkEvaluation(Remainder(Literal(null, IntegerType), Literal(0)), null)
- checkEvaluation(Remainder(Literal(null, DoubleType), Literal(0.0)), null)
- checkEvaluation(Remainder(Literal(null, IntegerType), Literal(1)), null)
- checkEvaluation(Remainder(Literal(null, IntegerType), Literal(null, IntegerType)), null)
+ checkEvaluation(Remainder(Literal(0), Literal.create(null, IntegerType)), null)
+ checkEvaluation(Remainder(Literal(1), Literal.create(null, IntegerType)), null)
+ checkEvaluation(Remainder(Literal.create(null, IntegerType), Literal(0)), null)
+ checkEvaluation(Remainder(Literal.create(null, DoubleType), Literal(0.0)), null)
+ checkEvaluation(Remainder(Literal.create(null, IntegerType), Literal(1)), null)
+ checkEvaluation(Remainder(Literal.create(null, IntegerType), Literal.create(null, IntegerType)), null)
}
test("INSET") {
@@ -222,14 +222,14 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(MaxOf(1L, 2L), 2L)
checkEvaluation(MaxOf(2L, 1L), 2L)
- checkEvaluation(MaxOf(Literal(null, IntegerType), 2), 2)
- checkEvaluation(MaxOf(2, Literal(null, IntegerType)), 2)
+ checkEvaluation(MaxOf(Literal.create(null, IntegerType), 2), 2)
+ checkEvaluation(MaxOf(2, Literal.create(null, IntegerType)), 2)
}
test("LIKE literal Regular Expression") {
- checkEvaluation(Literal(null, StringType).like("a"), null)
- checkEvaluation(Literal("a", StringType).like(Literal(null, StringType)), null)
- checkEvaluation(Literal(null, StringType).like(Literal(null, StringType)), null)
+ checkEvaluation(Literal.create(null, StringType).like("a"), null)
+ checkEvaluation(Literal.create("a", StringType).like(Literal.create(null, StringType)), null)
+ checkEvaluation(Literal.create(null, StringType).like(Literal.create(null, StringType)), null)
checkEvaluation("abdef" like "abdef", true)
checkEvaluation("a_%b" like "a\\__b", true)
checkEvaluation("addb" like "a_%b", true)
@@ -264,13 +264,13 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation("ab" like regEx, true, new GenericRow(Array[Any]("a%b")))
checkEvaluation("a\nb" like regEx, true, new GenericRow(Array[Any]("a%b")))
- checkEvaluation(Literal(null, StringType) like regEx, null, new GenericRow(Array[Any]("bc%")))
+ checkEvaluation(Literal.create(null, StringType) like regEx, null, new GenericRow(Array[Any]("bc%")))
}
test("RLIKE literal Regular Expression") {
- checkEvaluation(Literal(null, StringType) rlike "abdef", null)
- checkEvaluation("abdef" rlike Literal(null, StringType), null)
- checkEvaluation(Literal(null, StringType) rlike Literal(null, StringType), null)
+ checkEvaluation(Literal.create(null, StringType) rlike "abdef", null)
+ checkEvaluation("abdef" rlike Literal.create(null, StringType), null)
+ checkEvaluation(Literal.create(null, StringType) rlike Literal.create(null, StringType), null)
checkEvaluation("abdef" rlike "abdef", true)
checkEvaluation("abbbbc" rlike "a.*c", true)
@@ -381,7 +381,7 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
assert(("abcdef" cast DoubleType).nullable === true)
assert(("abcdef" cast FloatType).nullable === true)
- checkEvaluation(Cast(Literal(null, IntegerType), ShortType), null)
+ checkEvaluation(Cast(Literal.create(null, IntegerType), ShortType), null)
}
test("date") {
@@ -507,8 +507,8 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
}
test("array casting") {
- val array = Literal(Seq("123", "abc", "", null), ArrayType(StringType, containsNull = true))
- val array_notNull = Literal(Seq("123", "abc", ""), ArrayType(StringType, containsNull = false))
+ val array = Literal.create(Seq("123", "abc", "", null), ArrayType(StringType, containsNull = true))
+ val array_notNull = Literal.create(Seq("123", "abc", ""), ArrayType(StringType, containsNull = false))
{
val cast = Cast(array, ArrayType(IntegerType, containsNull = true))
@@ -556,10 +556,10 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
}
test("map casting") {
- val map = Literal(
+ val map = Literal.create(
Map("a" -> "123", "b" -> "abc", "c" -> "", "d" -> null),
MapType(StringType, StringType, valueContainsNull = true))
- val map_notNull = Literal(
+ val map_notNull = Literal.create(
Map("a" -> "123", "b" -> "abc", "c" -> ""),
MapType(StringType, StringType, valueContainsNull = false))
@@ -617,14 +617,14 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
}
test("struct casting") {
- val struct = Literal(
+ val struct = Literal.create(
Row("123", "abc", "", null),
StructType(Seq(
StructField("a", StringType, nullable = true),
StructField("b", StringType, nullable = true),
StructField("c", StringType, nullable = true),
StructField("d", StringType, nullable = true))))
- val struct_notNull = Literal(
+ val struct_notNull = Literal.create(
Row("123", "abc", ""),
StructType(Seq(
StructField("a", StringType, nullable = false),
@@ -712,7 +712,7 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
}
test("complex casting") {
- val complex = Literal(
+ val complex = Literal.create(
Row(
Seq("123", "abc", ""),
Map("a" -> "123", "b" -> "abc", "c" -> ""),
@@ -755,30 +755,30 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(c2.isNull, true, row)
checkEvaluation(c2.isNotNull, false, row)
- checkEvaluation(Literal(1, ShortType).isNull, false)
- checkEvaluation(Literal(1, ShortType).isNotNull, true)
+ checkEvaluation(Literal.create(1, ShortType).isNull, false)
+ checkEvaluation(Literal.create(1, ShortType).isNotNull, true)
- checkEvaluation(Literal(null, ShortType).isNull, true)
- checkEvaluation(Literal(null, ShortType).isNotNull, false)
+ checkEvaluation(Literal.create(null, ShortType).isNull, true)
+ checkEvaluation(Literal.create(null, ShortType).isNotNull, false)
checkEvaluation(Coalesce(c1 :: c2 :: Nil), "^Ba*n", row)
- checkEvaluation(Coalesce(Literal(null, StringType) :: Nil), null, row)
- checkEvaluation(Coalesce(Literal(null, StringType) :: c1 :: c2 :: Nil), "^Ba*n", row)
+ checkEvaluation(Coalesce(Literal.create(null, StringType) :: Nil), null, row)
+ checkEvaluation(Coalesce(Literal.create(null, StringType) :: c1 :: c2 :: Nil), "^Ba*n", row)
- checkEvaluation(If(c3, Literal("a", StringType), Literal("b", StringType)), "a", row)
+ checkEvaluation(If(c3, Literal.create("a", StringType), Literal.create("b", StringType)), "a", row)
checkEvaluation(If(c3, c1, c2), "^Ba*n", row)
checkEvaluation(If(c4, c2, c1), "^Ba*n", row)
- checkEvaluation(If(Literal(null, BooleanType), c2, c1), "^Ba*n", row)
- checkEvaluation(If(Literal(true, BooleanType), c1, c2), "^Ba*n", row)
- checkEvaluation(If(Literal(false, BooleanType), c2, c1), "^Ba*n", row)
- checkEvaluation(If(Literal(false, BooleanType),
- Literal("a", StringType), Literal("b", StringType)), "b", row)
+ checkEvaluation(If(Literal.create(null, BooleanType), c2, c1), "^Ba*n", row)
+ checkEvaluation(If(Literal.create(true, BooleanType), c1, c2), "^Ba*n", row)
+ checkEvaluation(If(Literal.create(false, BooleanType), c2, c1), "^Ba*n", row)
+ checkEvaluation(If(Literal.create(false, BooleanType),
+ Literal.create("a", StringType), Literal.create("b", StringType)), "b", row)
checkEvaluation(c1 in (c1, c2), true, row)
checkEvaluation(
- Literal("^Ba*n", StringType) in (Literal("^Ba*n", StringType)), true, row)
+ Literal.create("^Ba*n", StringType) in (Literal.create("^Ba*n", StringType)), true, row)
checkEvaluation(
- Literal("^Ba*n", StringType) in (Literal("^Ba*n", StringType), c2), true, row)
+ Literal.create("^Ba*n", StringType) in (Literal.create("^Ba*n", StringType), c2), true, row)
}
test("case when") {
@@ -793,9 +793,9 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(CaseWhen(Seq(c1, c4, c6)), "c", row)
checkEvaluation(CaseWhen(Seq(c2, c4, c6)), "c", row)
checkEvaluation(CaseWhen(Seq(c3, c4, c6)), "a", row)
- checkEvaluation(CaseWhen(Seq(Literal(null, BooleanType), c4, c6)), "c", row)
- checkEvaluation(CaseWhen(Seq(Literal(false, BooleanType), c4, c6)), "c", row)
- checkEvaluation(CaseWhen(Seq(Literal(true, BooleanType), c4, c6)), "a", row)
+ checkEvaluation(CaseWhen(Seq(Literal.create(null, BooleanType), c4, c6)), "c", row)
+ checkEvaluation(CaseWhen(Seq(Literal.create(false, BooleanType), c4, c6)), "c", row)
+ checkEvaluation(CaseWhen(Seq(Literal.create(true, BooleanType), c4, c6)), "a", row)
checkEvaluation(CaseWhen(Seq(c3, c4, c2, c5, c6)), "a", row)
checkEvaluation(CaseWhen(Seq(c2, c4, c3, c5, c6)), "b", row)
@@ -841,17 +841,17 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(GetItem(BoundReference(3, typeMap, true),
Literal("aa")), "bb", row)
- checkEvaluation(GetItem(Literal(null, typeMap), Literal("aa")), null, row)
- checkEvaluation(GetItem(Literal(null, typeMap), Literal(null, StringType)), null, row)
+ checkEvaluation(GetItem(Literal.create(null, typeMap), Literal("aa")), null, row)
+ checkEvaluation(GetItem(Literal.create(null, typeMap), Literal.create(null, StringType)), null, row)
checkEvaluation(GetItem(BoundReference(3, typeMap, true),
- Literal(null, StringType)), null, row)
+ Literal.create(null, StringType)), null, row)
checkEvaluation(GetItem(BoundReference(4, typeArray, true),
Literal(1)), "bb", row)
- checkEvaluation(GetItem(Literal(null, typeArray), Literal(1)), null, row)
- checkEvaluation(GetItem(Literal(null, typeArray), Literal(null, IntegerType)), null, row)
+ checkEvaluation(GetItem(Literal.create(null, typeArray), Literal(1)), null, row)
+ checkEvaluation(GetItem(Literal.create(null, typeArray), Literal.create(null, IntegerType)), null, row)
checkEvaluation(GetItem(BoundReference(4, typeArray, true),
- Literal(null, IntegerType)), null, row)
+ Literal.create(null, IntegerType)), null, row)
def quickBuildGetField(expr: Expression, fieldName: String) = {
expr.dataType match {
@@ -864,7 +864,7 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
def quickResolve(u: UnresolvedGetField) = quickBuildGetField(u.child, u.fieldName)
checkEvaluation(quickBuildGetField(BoundReference(2, typeS, nullable = true), "a"), "aa", row)
- checkEvaluation(quickBuildGetField(Literal(null, typeS), "a"), null, row)
+ checkEvaluation(quickBuildGetField(Literal.create(null, typeS), "a"), null, row)
val typeS_notNullable = StructType(
StructField("a", StringType, nullable = false)
@@ -874,8 +874,8 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
assert(quickBuildGetField(BoundReference(2,typeS, nullable = true), "a").nullable === true)
assert(quickBuildGetField(BoundReference(2, typeS_notNullable, nullable = false), "a").nullable === false)
- assert(quickBuildGetField(Literal(null, typeS), "a").nullable === true)
- assert(quickBuildGetField(Literal(null, typeS_notNullable), "a").nullable === true)
+ assert(quickBuildGetField(Literal.create(null, typeS), "a").nullable === true)
+ assert(quickBuildGetField(Literal.create(null, typeS_notNullable), "a").nullable === true)
checkEvaluation('c.map(typeMap).at(3).getItem("aa"), "bb", row)
checkEvaluation('c.array(typeArray.elementType).at(4).getItem(1), "bb", row)
@@ -890,13 +890,13 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
val c4 = 'a.int.at(3)
checkEvaluation(UnaryMinus(c1), -1, row)
- checkEvaluation(UnaryMinus(Literal(100, IntegerType)), -100)
+ checkEvaluation(UnaryMinus(Literal.create(100, IntegerType)), -100)
checkEvaluation(Add(c1, c4), null, row)
checkEvaluation(Add(c1, c2), 3, row)
- checkEvaluation(Add(c1, Literal(null, IntegerType)), null, row)
- checkEvaluation(Add(Literal(null, IntegerType), c2), null, row)
- checkEvaluation(Add(Literal(null, IntegerType), Literal(null, IntegerType)), null, row)
+ checkEvaluation(Add(c1, Literal.create(null, IntegerType)), null, row)
+ checkEvaluation(Add(Literal.create(null, IntegerType), c2), null, row)
+ checkEvaluation(Add(Literal.create(null, IntegerType), Literal.create(null, IntegerType)), null, row)
checkEvaluation(-c1, -1, row)
checkEvaluation(c1 + c2, 3, row)
@@ -914,12 +914,12 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
val c4 = 'a.double.at(3)
checkEvaluation(UnaryMinus(c1), -1.1, row)
- checkEvaluation(UnaryMinus(Literal(100.0, DoubleType)), -100.0)
+ checkEvaluation(UnaryMinus(Literal.create(100.0, DoubleType)), -100.0)
checkEvaluation(Add(c1, c4), null, row)
checkEvaluation(Add(c1, c2), 3.1, row)
- checkEvaluation(Add(c1, Literal(null, DoubleType)), null, row)
- checkEvaluation(Add(Literal(null, DoubleType), c2), null, row)
- checkEvaluation(Add(Literal(null, DoubleType), Literal(null, DoubleType)), null, row)
+ checkEvaluation(Add(c1, Literal.create(null, DoubleType)), null, row)
+ checkEvaluation(Add(Literal.create(null, DoubleType), c2), null, row)
+ checkEvaluation(Add(Literal.create(null, DoubleType), Literal.create(null, DoubleType)), null, row)
checkEvaluation(-c1, -1.1, row)
checkEvaluation(c1 + c2, 3.1, row)
@@ -940,9 +940,9 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(LessThan(c1, c4), null, row)
checkEvaluation(LessThan(c1, c2), true, row)
- checkEvaluation(LessThan(c1, Literal(null, IntegerType)), null, row)
- checkEvaluation(LessThan(Literal(null, IntegerType), c2), null, row)
- checkEvaluation(LessThan(Literal(null, IntegerType), Literal(null, IntegerType)), null, row)
+ checkEvaluation(LessThan(c1, Literal.create(null, IntegerType)), null, row)
+ checkEvaluation(LessThan(Literal.create(null, IntegerType), c2), null, row)
+ checkEvaluation(LessThan(Literal.create(null, IntegerType), Literal.create(null, IntegerType)), null, row)
checkEvaluation(c1 < c2, true, row)
checkEvaluation(c1 <= c2, true, row)
@@ -954,8 +954,8 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(c1 <=> c4, false, row)
checkEvaluation(c4 <=> c6, true, row)
checkEvaluation(c3 <=> c5, true, row)
- checkEvaluation(Literal(true) <=> Literal(null, BooleanType), false, row)
- checkEvaluation(Literal(null, BooleanType) <=> Literal(true), false, row)
+ checkEvaluation(Literal(true) <=> Literal.create(null, BooleanType), false, row)
+ checkEvaluation(Literal.create(null, BooleanType) <=> Literal(true), false, row)
}
test("StringComparison") {
@@ -966,17 +966,17 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(c1 contains "b", true, row)
checkEvaluation(c1 contains "x", false, row)
checkEvaluation(c2 contains "b", null, row)
- checkEvaluation(c1 contains Literal(null, StringType), null, row)
+ checkEvaluation(c1 contains Literal.create(null, StringType), null, row)
checkEvaluation(c1 startsWith "a", true, row)
checkEvaluation(c1 startsWith "b", false, row)
checkEvaluation(c2 startsWith "a", null, row)
- checkEvaluation(c1 startsWith Literal(null, StringType), null, row)
+ checkEvaluation(c1 startsWith Literal.create(null, StringType), null, row)
checkEvaluation(c1 endsWith "c", true, row)
checkEvaluation(c1 endsWith "b", false, row)
checkEvaluation(c2 endsWith "b", null, row)
- checkEvaluation(c1 endsWith Literal(null, StringType), null, row)
+ checkEvaluation(c1 endsWith Literal.create(null, StringType), null, row)
}
test("Substring") {
@@ -985,54 +985,54 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
val s = 'a.string.at(0)
// substring from zero position with less-than-full length
- checkEvaluation(Substring(s, Literal(0, IntegerType), Literal(2, IntegerType)), "ex", row)
- checkEvaluation(Substring(s, Literal(1, IntegerType), Literal(2, IntegerType)), "ex", row)
+ checkEvaluation(Substring(s, Literal.create(0, IntegerType), Literal.create(2, IntegerType)), "ex", row)
+ checkEvaluation(Substring(s, Literal.create(1, IntegerType), Literal.create(2, IntegerType)), "ex", row)
// substring from zero position with full length
- checkEvaluation(Substring(s, Literal(0, IntegerType), Literal(7, IntegerType)), "example", row)
- checkEvaluation(Substring(s, Literal(1, IntegerType), Literal(7, IntegerType)), "example", row)
+ checkEvaluation(Substring(s, Literal.create(0, IntegerType), Literal.create(7, IntegerType)), "example", row)
+ checkEvaluation(Substring(s, Literal.create(1, IntegerType), Literal.create(7, IntegerType)), "example", row)
// substring from zero position with greater-than-full length
- checkEvaluation(Substring(s, Literal(0, IntegerType), Literal(100, IntegerType)), "example", row)
- checkEvaluation(Substring(s, Literal(1, IntegerType), Literal(100, IntegerType)), "example", row)
+ checkEvaluation(Substring(s, Literal.create(0, IntegerType), Literal.create(100, IntegerType)), "example", row)
+ checkEvaluation(Substring(s, Literal.create(1, IntegerType), Literal.create(100, IntegerType)), "example", row)
// substring from nonzero position with less-than-full length
- checkEvaluation(Substring(s, Literal(2, IntegerType), Literal(2, IntegerType)), "xa", row)
+ checkEvaluation(Substring(s, Literal.create(2, IntegerType), Literal.create(2, IntegerType)), "xa", row)
// substring from nonzero position with full length
- checkEvaluation(Substring(s, Literal(2, IntegerType), Literal(6, IntegerType)), "xample", row)
+ checkEvaluation(Substring(s, Literal.create(2, IntegerType), Literal.create(6, IntegerType)), "xample", row)
// substring from nonzero position with greater-than-full length
- checkEvaluation(Substring(s, Literal(2, IntegerType), Literal(100, IntegerType)), "xample", row)
+ checkEvaluation(Substring(s, Literal.create(2, IntegerType), Literal.create(100, IntegerType)), "xample", row)
// zero-length substring (within string bounds)
- checkEvaluation(Substring(s, Literal(0, IntegerType), Literal(0, IntegerType)), "", row)
+ checkEvaluation(Substring(s, Literal.create(0, IntegerType), Literal.create(0, IntegerType)), "", row)
// zero-length substring (beyond string bounds)
- checkEvaluation(Substring(s, Literal(100, IntegerType), Literal(4, IntegerType)), "", row)
+ checkEvaluation(Substring(s, Literal.create(100, IntegerType), Literal.create(4, IntegerType)), "", row)
// substring(null, _, _) -> null
- checkEvaluation(Substring(s, Literal(100, IntegerType), Literal(4, IntegerType)), null, new GenericRow(Array[Any](null)))
+ checkEvaluation(Substring(s, Literal.create(100, IntegerType), Literal.create(4, IntegerType)), null, new GenericRow(Array[Any](null)))
// substring(_, null, _) -> null
- checkEvaluation(Substring(s, Literal(null, IntegerType), Literal(4, IntegerType)), null, row)
+ checkEvaluation(Substring(s, Literal.create(null, IntegerType), Literal.create(4, IntegerType)), null, row)
// substring(_, _, null) -> null
- checkEvaluation(Substring(s, Literal(100, IntegerType), Literal(null, IntegerType)), null, row)
+ checkEvaluation(Substring(s, Literal.create(100, IntegerType), Literal.create(null, IntegerType)), null, row)
// 2-arg substring from zero position
- checkEvaluation(Substring(s, Literal(0, IntegerType), Literal(Integer.MAX_VALUE, IntegerType)), "example", row)
- checkEvaluation(Substring(s, Literal(1, IntegerType), Literal(Integer.MAX_VALUE, IntegerType)), "example", row)
+ checkEvaluation(Substring(s, Literal.create(0, IntegerType), Literal.create(Integer.MAX_VALUE, IntegerType)), "example", row)
+ checkEvaluation(Substring(s, Literal.create(1, IntegerType), Literal.create(Integer.MAX_VALUE, IntegerType)), "example", row)
// 2-arg substring from nonzero position
- checkEvaluation(Substring(s, Literal(2, IntegerType), Literal(Integer.MAX_VALUE, IntegerType)), "xample", row)
+ checkEvaluation(Substring(s, Literal.create(2, IntegerType), Literal.create(Integer.MAX_VALUE, IntegerType)), "xample", row)
val s_notNull = 'a.string.notNull.at(0)
- assert(Substring(s, Literal(0, IntegerType), Literal(2, IntegerType)).nullable === true)
- assert(Substring(s_notNull, Literal(0, IntegerType), Literal(2, IntegerType)).nullable === false)
- assert(Substring(s_notNull, Literal(null, IntegerType), Literal(2, IntegerType)).nullable === true)
- assert(Substring(s_notNull, Literal(0, IntegerType), Literal(null, IntegerType)).nullable === true)
+ assert(Substring(s, Literal.create(0, IntegerType), Literal.create(2, IntegerType)).nullable === true)
+ assert(Substring(s_notNull, Literal.create(0, IntegerType), Literal.create(2, IntegerType)).nullable === false)
+ assert(Substring(s_notNull, Literal.create(null, IntegerType), Literal.create(2, IntegerType)).nullable === true)
+ assert(Substring(s_notNull, Literal.create(0, IntegerType), Literal.create(null, IntegerType)).nullable === true)
checkEvaluation(s.substr(0, 2), "ex", row)
checkEvaluation(s.substr(0), "example", row)
@@ -1050,7 +1050,7 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(Sqrt(d), expected, row)
}
- checkEvaluation(Sqrt(Literal(null, DoubleType)), null, new GenericRow(Array[Any](null)))
+ checkEvaluation(Sqrt(Literal.create(null, DoubleType)), null, new GenericRow(Array[Any](null)))
checkEvaluation(Sqrt(-1), null, EmptyRow)
checkEvaluation(Sqrt(-1.5), null, EmptyRow)
}
@@ -1064,22 +1064,22 @@ class ExpressionEvaluationSuite extends ExpressionEvaluationBaseSuite {
checkEvaluation(BitwiseAnd(c1, c4), null, row)
checkEvaluation(BitwiseAnd(c1, c2), 0, row)
- checkEvaluation(BitwiseAnd(c1, Literal(null, IntegerType)), null, row)
- checkEvaluation(BitwiseAnd(Literal(null, IntegerType), Literal(null, IntegerType)), null, row)
+ checkEvaluation(BitwiseAnd(c1, Literal.create(null, IntegerType)), null, row)
+ checkEvaluation(BitwiseAnd(Literal.create(null, IntegerType), Literal.create(null, IntegerType)), null, row)
checkEvaluation(BitwiseOr(c1, c4), null, row)
checkEvaluation(BitwiseOr(c1, c2), 3, row)
- checkEvaluation(BitwiseOr(c1, Literal(null, IntegerType)), null, row)
- checkEvaluation(BitwiseOr(Literal(null, IntegerType), Literal(null, IntegerType)), null, row)
+ checkEvaluation(BitwiseOr(c1, Literal.create(null, IntegerType)), null, row)
+ checkEvaluation(BitwiseOr(Literal.create(null, IntegerType), Literal.create(null, IntegerType)), null, row)
checkEvaluation(BitwiseXor(c1, c4), null, row)
checkEvaluation(BitwiseXor(c1, c2), 3, row)
- checkEvaluation(BitwiseXor(c1, Literal(null, IntegerType)), null, row)
- checkEvaluation(BitwiseXor(Literal(null, IntegerType), Literal(null, IntegerType)), null, row)
+ checkEvaluation(BitwiseXor(c1, Literal.create(null, IntegerType)), null, row)
+ checkEvaluation(BitwiseXor(Literal.create(null, IntegerType), Literal.create(null, IntegerType)), null, row)
checkEvaluation(BitwiseNot(c4), null, row)
checkEvaluation(BitwiseNot(c1), -2, row)
- checkEvaluation(BitwiseNot(Literal(null, IntegerType)), null, row)
+ checkEvaluation(BitwiseNot(Literal.create(null, IntegerType)), null, row)
checkEvaluation(c1 & c2, 0, row)
checkEvaluation(c1 | c2, 3, row)
diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/optimizer/ConstantFoldingSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/optimizer/ConstantFoldingSuite.scala
index ef10c0aece71639e9b125a3a2be2606218e6cb0f..a0efe9e2e7f6b0347edd286d1b39eb822cb15807 100644
--- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/optimizer/ConstantFoldingSuite.scala
+++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/optimizer/ConstantFoldingSuite.scala
@@ -182,33 +182,33 @@ class ConstantFoldingSuite extends PlanTest {
IsNull(Literal(null)) as 'c1,
IsNotNull(Literal(null)) as 'c2,
- GetItem(Literal(null, ArrayType(IntegerType)), 1) as 'c3,
- GetItem(Literal(Seq(1), ArrayType(IntegerType)), Literal(null, IntegerType)) as 'c4,
+ GetItem(Literal.create(null, ArrayType(IntegerType)), 1) as 'c3,
+ GetItem(Literal.create(Seq(1), ArrayType(IntegerType)), Literal.create(null, IntegerType)) as 'c4,
UnresolvedGetField(
- Literal(null, StructType(Seq(StructField("a", IntegerType, true)))),
+ Literal.create(null, StructType(Seq(StructField("a", IntegerType, true)))),
"a") as 'c5,
- UnaryMinus(Literal(null, IntegerType)) as 'c6,
+ UnaryMinus(Literal.create(null, IntegerType)) as 'c6,
Cast(Literal(null), IntegerType) as 'c7,
- Not(Literal(null, BooleanType)) as 'c8,
+ Not(Literal.create(null, BooleanType)) as 'c8,
- Add(Literal(null, IntegerType), 1) as 'c9,
- Add(1, Literal(null, IntegerType)) as 'c10,
+ Add(Literal.create(null, IntegerType), 1) as 'c9,
+ Add(1, Literal.create(null, IntegerType)) as 'c10,
- EqualTo(Literal(null, IntegerType), 1) as 'c11,
- EqualTo(1, Literal(null, IntegerType)) as 'c12,
+ EqualTo(Literal.create(null, IntegerType), 1) as 'c11,
+ EqualTo(1, Literal.create(null, IntegerType)) as 'c12,
- Like(Literal(null, StringType), "abc") as 'c13,
- Like("abc", Literal(null, StringType)) as 'c14,
+ Like(Literal.create(null, StringType), "abc") as 'c13,
+ Like("abc", Literal.create(null, StringType)) as 'c14,
- Upper(Literal(null, StringType)) as 'c15,
+ Upper(Literal.create(null, StringType)) as 'c15,
- Substring(Literal(null, StringType), 0, 1) as 'c16,
- Substring("abc", Literal(null, IntegerType), 1) as 'c17,
- Substring("abc", 0, Literal(null, IntegerType)) as 'c18,
+ Substring(Literal.create(null, StringType), 0, 1) as 'c16,
+ Substring("abc", Literal.create(null, IntegerType), 1) as 'c17,
+ Substring("abc", 0, Literal.create(null, IntegerType)) as 'c18,
- Contains(Literal(null, StringType), "abc") as 'c19,
- Contains("abc", Literal(null, StringType)) as 'c20
+ Contains(Literal.create(null, StringType), "abc") as 'c19,
+ Contains("abc", Literal.create(null, StringType)) as 'c20
)
val optimized = Optimize(originalQuery.analyze)
@@ -219,31 +219,31 @@ class ConstantFoldingSuite extends PlanTest {
Literal(true) as 'c1,
Literal(false) as 'c2,
- Literal(null, IntegerType) as 'c3,
- Literal(null, IntegerType) as 'c4,
- Literal(null, IntegerType) as 'c5,
+ Literal.create(null, IntegerType) as 'c3,
+ Literal.create(null, IntegerType) as 'c4,
+ Literal.create(null, IntegerType) as 'c5,
- Literal(null, IntegerType) as 'c6,
- Literal(null, IntegerType) as 'c7,
- Literal(null, BooleanType) as 'c8,
+ Literal.create(null, IntegerType) as 'c6,
+ Literal.create(null, IntegerType) as 'c7,
+ Literal.create(null, BooleanType) as 'c8,
- Literal(null, IntegerType) as 'c9,
- Literal(null, IntegerType) as 'c10,
+ Literal.create(null, IntegerType) as 'c9,
+ Literal.create(null, IntegerType) as 'c10,
- Literal(null, BooleanType) as 'c11,
- Literal(null, BooleanType) as 'c12,
+ Literal.create(null, BooleanType) as 'c11,
+ Literal.create(null, BooleanType) as 'c12,
- Literal(null, BooleanType) as 'c13,
- Literal(null, BooleanType) as 'c14,
+ Literal.create(null, BooleanType) as 'c13,
+ Literal.create(null, BooleanType) as 'c14,
- Literal(null, StringType) as 'c15,
+ Literal.create(null, StringType) as 'c15,
- Literal(null, StringType) as 'c16,
- Literal(null, StringType) as 'c17,
- Literal(null, StringType) as 'c18,
+ Literal.create(null, StringType) as 'c16,
+ Literal.create(null, StringType) as 'c17,
+ Literal.create(null, StringType) as 'c18,
- Literal(null, BooleanType) as 'c19,
- Literal(null, BooleanType) as 'c20
+ Literal.create(null, BooleanType) as 'c19,
+ Literal.create(null, BooleanType) as 'c20
).analyze
comparePlans(optimized, correctAnswer)
diff --git a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/trees/TreeNodeSuite.scala b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/trees/TreeNodeSuite.scala
index e7ce92a2160b6bcf6d97c73d9d7343937504b0fc..274f3ede0045c9bb25ce5649d91844aac6bca944 100644
--- a/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/trees/TreeNodeSuite.scala
+++ b/sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/trees/TreeNodeSuite.scala
@@ -90,7 +90,7 @@ class TreeNodeSuite extends FunSuite {
}
test("transform works on nodes with Option children") {
- val dummy1 = Dummy(Some(Literal("1", StringType)))
+ val dummy1 = Dummy(Some(Literal.create("1", StringType)))
val dummy2 = Dummy(None)
val toZero: PartialFunction[Expression, Expression] = { case Literal(_, _) => Literal(0) }
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/execution/GeneratedAggregate.scala b/sql/core/src/main/scala/org/apache/spark/sql/execution/GeneratedAggregate.scala
index 89682d25ca7dcad1e5a27d48e46ad9280aa804e8..a8018b9213f2bad1c6aff14492ce42c519b6aeb2 100644
--- a/sql/core/src/main/scala/org/apache/spark/sql/execution/GeneratedAggregate.scala
+++ b/sql/core/src/main/scala/org/apache/spark/sql/execution/GeneratedAggregate.scala
@@ -93,7 +93,7 @@ case class GeneratedAggregate(
}
val currentSum = AttributeReference("currentSum", calcType, nullable = true)()
- val initialValue = Literal(null, calcType)
+ val initialValue = Literal.create(null, calcType)
// Coalasce avoids double calculation...
// but really, common sub expression elimination would be better....
@@ -137,13 +137,13 @@ case class GeneratedAggregate(
expr.dataType match {
case DecimalType.Fixed(_, _) =>
If(EqualTo(currentCount, Literal(0L)),
- Literal(null, a.dataType),
+ Literal.create(null, a.dataType),
Cast(Divide(
Cast(currentSum, DecimalType.Unlimited),
Cast(currentCount, DecimalType.Unlimited)), a.dataType))
case _ =>
If(EqualTo(currentCount, Literal(0L)),
- Literal(null, a.dataType),
+ Literal.create(null, a.dataType),
Divide(Cast(currentSum, a.dataType), Cast(currentCount, a.dataType)))
}
@@ -156,7 +156,7 @@ case class GeneratedAggregate(
case m @ Max(expr) =>
val currentMax = AttributeReference("currentMax", expr.dataType, nullable = true)()
- val initialValue = Literal(null, expr.dataType)
+ val initialValue = Literal.create(null, expr.dataType)
val updateMax = MaxOf(currentMax, expr)
AggregateEvaluation(
diff --git a/sql/core/src/main/scala/org/apache/spark/sql/parquet/newParquet.scala b/sql/core/src/main/scala/org/apache/spark/sql/parquet/newParquet.scala
index 19800ad88c0317da3683961cb3f4dcf180bbd8a3..43f260d3ef8d3bbcdfc2977f89eae26600289ddb 100644
--- a/sql/core/src/main/scala/org/apache/spark/sql/parquet/newParquet.scala
+++ b/sql/core/src/main/scala/org/apache/spark/sql/parquet/newParquet.scala
@@ -872,9 +872,9 @@ private[sql] object ParquetRelation2 extends Logging {
* PartitionValues(
* Seq("a", "b", "c"),
* Seq(
- * Literal(42, IntegerType),
- * Literal("hello", StringType),
- * Literal(3.14, FloatType)))
+ * Literal.create(42, IntegerType),
+ * Literal.create("hello", StringType),
+ * Literal.create(3.14, FloatType)))
* }}}
*/
private[parquet] def parsePartition(
@@ -953,15 +953,16 @@ private[sql] object ParquetRelation2 extends Logging {
raw: String,
defaultPartitionName: String): Literal = {
// First tries integral types
- Try(Literal(Integer.parseInt(raw), IntegerType))
- .orElse(Try(Literal(JLong.parseLong(raw), LongType)))
+ Try(Literal.create(Integer.parseInt(raw), IntegerType))
+ .orElse(Try(Literal.create(JLong.parseLong(raw), LongType)))
// Then falls back to fractional types
- .orElse(Try(Literal(JFloat.parseFloat(raw), FloatType)))
- .orElse(Try(Literal(JDouble.parseDouble(raw), DoubleType)))
- .orElse(Try(Literal(new JBigDecimal(raw), DecimalType.Unlimited)))
+ .orElse(Try(Literal.create(JFloat.parseFloat(raw), FloatType)))
+ .orElse(Try(Literal.create(JDouble.parseDouble(raw), DoubleType)))
+ .orElse(Try(Literal.create(new JBigDecimal(raw), DecimalType.Unlimited)))
// Then falls back to string
.getOrElse {
- if (raw == defaultPartitionName) Literal(null, NullType) else Literal(raw, StringType)
+ if (raw == defaultPartitionName) Literal.create(null, NullType)
+ else Literal.create(raw, StringType)
}
}
@@ -980,7 +981,7 @@ private[sql] object ParquetRelation2 extends Logging {
}
literals.map { case l @ Literal(_, dataType) =>
- Literal(Cast(l, desiredType).eval(), desiredType)
+ Literal.create(Cast(l, desiredType).eval(), desiredType)
}
}
}
diff --git a/sql/core/src/test/scala/org/apache/spark/sql/parquet/ParquetPartitionDiscoverySuite.scala b/sql/core/src/test/scala/org/apache/spark/sql/parquet/ParquetPartitionDiscoverySuite.scala
index adb3c9391f6c25559d523bd8daf724240a7ae82a..b7561ce7298cbd075018f68cb3d25903bd6e7ceb 100644
--- a/sql/core/src/test/scala/org/apache/spark/sql/parquet/ParquetPartitionDiscoverySuite.scala
+++ b/sql/core/src/test/scala/org/apache/spark/sql/parquet/ParquetPartitionDiscoverySuite.scala
@@ -45,11 +45,11 @@ class ParquetPartitionDiscoverySuite extends QueryTest with ParquetTest {
assert(inferPartitionColumnValue(raw, defaultPartitionName) === literal)
}
- check("10", Literal(10, IntegerType))
- check("1000000000000000", Literal(1000000000000000L, LongType))
- check("1.5", Literal(1.5, FloatType))
- check("hello", Literal("hello", StringType))
- check(defaultPartitionName, Literal(null, NullType))
+ check("10", Literal.create(10, IntegerType))
+ check("1000000000000000", Literal.create(1000000000000000L, LongType))
+ check("1.5", Literal.create(1.5, FloatType))
+ check("hello", Literal.create("hello", StringType))
+ check(defaultPartitionName, Literal.create(null, NullType))
}
test("parse partition") {
@@ -75,22 +75,22 @@ class ParquetPartitionDiscoverySuite extends QueryTest with ParquetTest {
"file://path/a=10",
PartitionValues(
ArrayBuffer("a"),
- ArrayBuffer(Literal(10, IntegerType))))
+ ArrayBuffer(Literal.create(10, IntegerType))))
check(
"file://path/a=10/b=hello/c=1.5",
PartitionValues(
ArrayBuffer("a", "b", "c"),
ArrayBuffer(
- Literal(10, IntegerType),
- Literal("hello", StringType),
- Literal(1.5, FloatType))))
+ Literal.create(10, IntegerType),
+ Literal.create("hello", StringType),
+ Literal.create(1.5, FloatType))))
check(
"file://path/a=10/b_hello/c=1.5",
PartitionValues(
ArrayBuffer("c"),
- ArrayBuffer(Literal(1.5, FloatType))))
+ ArrayBuffer(Literal.create(1.5, FloatType))))
checkThrows[AssertionError]("file://path/=10", "Empty partition column name")
checkThrows[AssertionError]("file://path/a=", "Empty partition column value")
diff --git a/sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveInspectors.scala b/sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveInspectors.scala
index 4afa2e71d77cc96da89d8471c81d049f87402da0..921c6194c7b7665940bb81dfdda8effc2561abe2 100644
--- a/sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveInspectors.scala
+++ b/sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveInspectors.scala
@@ -593,7 +593,7 @@ private[hive] trait HiveInspectors {
case Literal(_, dt) => sys.error(s"Hive doesn't support the constant type [$dt].")
// ideally, we don't test the foldable here(but in optimizer), however, some of the
// Hive UDF / UDAF requires its argument to be constant objectinspector, we do it eagerly.
- case _ if expr.foldable => toInspector(Literal(expr.eval(), expr.dataType))
+ case _ if expr.foldable => toInspector(Literal.create(expr.eval(), expr.dataType))
// For those non constant expression, map to object inspector according to its data type
case _ => toInspector(expr.dataType)
}
diff --git a/sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveQl.scala b/sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveQl.scala
index cd8e7c09eea5babe556ad36d68c0b318332c2d9e..5be09a11ad6417a9b7db049773a1c5207521cab6 100644
--- a/sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveQl.scala
+++ b/sql/hive/src/main/scala/org/apache/spark/sql/hive/HiveQl.scala
@@ -1201,7 +1201,7 @@ https://cwiki.apache.org/confluence/display/Hive/Enhanced+Aggregation%2C+Cube%2C
CreateArray(children.map(nodeToExpr))
case Token("TOK_FUNCTION", Token(RAND(), Nil) :: Nil) => Rand
case Token("TOK_FUNCTION", Token(SUBSTR(), Nil) :: string :: pos :: Nil) =>
- Substring(nodeToExpr(string), nodeToExpr(pos), Literal(Integer.MAX_VALUE, IntegerType))
+ Substring(nodeToExpr(string), nodeToExpr(pos), Literal.create(Integer.MAX_VALUE, IntegerType))
case Token("TOK_FUNCTION", Token(SUBSTR(), Nil) :: string :: pos :: length :: Nil) =>
Substring(nodeToExpr(string), nodeToExpr(pos), nodeToExpr(length))
case Token("TOK_FUNCTION", Token(COALESCE(), Nil) :: list) => Coalesce(list.map(nodeToExpr))
@@ -1213,9 +1213,9 @@ https://cwiki.apache.org/confluence/display/Hive/Enhanced+Aggregation%2C+Cube%2C
UnresolvedFunction(name, UnresolvedStar(None) :: Nil)
/* Literals */
- case Token("TOK_NULL", Nil) => Literal(null, NullType)
- case Token(TRUE(), Nil) => Literal(true, BooleanType)
- case Token(FALSE(), Nil) => Literal(false, BooleanType)
+ case Token("TOK_NULL", Nil) => Literal.create(null, NullType)
+ case Token(TRUE(), Nil) => Literal.create(true, BooleanType)
+ case Token(FALSE(), Nil) => Literal.create(false, BooleanType)
case Token("TOK_STRINGLITERALSEQUENCE", strings) =>
Literal(strings.map(s => BaseSemanticAnalyzer.unescapeSQLString(s.getText)).mkString)
@@ -1226,21 +1226,21 @@ https://cwiki.apache.org/confluence/display/Hive/Enhanced+Aggregation%2C+Cube%2C
try {
if (ast.getText.endsWith("L")) {
// Literal bigint.
- v = Literal(ast.getText.substring(0, ast.getText.length() - 1).toLong, LongType)
+ v = Literal.create(ast.getText.substring(0, ast.getText.length() - 1).toLong, LongType)
} else if (ast.getText.endsWith("S")) {
// Literal smallint.
- v = Literal(ast.getText.substring(0, ast.getText.length() - 1).toShort, ShortType)
+ v = Literal.create(ast.getText.substring(0, ast.getText.length() - 1).toShort, ShortType)
} else if (ast.getText.endsWith("Y")) {
// Literal tinyint.
- v = Literal(ast.getText.substring(0, ast.getText.length() - 1).toByte, ByteType)
+ v = Literal.create(ast.getText.substring(0, ast.getText.length() - 1).toByte, ByteType)
} else if (ast.getText.endsWith("BD") || ast.getText.endsWith("D")) {
// Literal decimal
val strVal = ast.getText.stripSuffix("D").stripSuffix("B")
v = Literal(Decimal(strVal))
} else {
- v = Literal(ast.getText.toDouble, DoubleType)
- v = Literal(ast.getText.toLong, LongType)
- v = Literal(ast.getText.toInt, IntegerType)
+ v = Literal.create(ast.getText.toDouble, DoubleType)
+ v = Literal.create(ast.getText.toLong, LongType)
+ v = Literal.create(ast.getText.toInt, IntegerType)
}
} catch {
case nfe: NumberFormatException => // Do nothing
diff --git a/sql/hive/src/test/scala/org/apache/spark/sql/hive/HiveInspectorSuite.scala b/sql/hive/src/test/scala/org/apache/spark/sql/hive/HiveInspectorSuite.scala
index 3181cfe40016c792e3a82b0faa37b54e3e886848..c482c6de8a736b8f7a3fe3212d661547642cf26c 100644
--- a/sql/hive/src/test/scala/org/apache/spark/sql/hive/HiveInspectorSuite.scala
+++ b/sql/hive/src/test/scala/org/apache/spark/sql/hive/HiveInspectorSuite.scala
@@ -79,9 +79,9 @@ class HiveInspectorSuite extends FunSuite with HiveInspectors {
Literal(Decimal(BigDecimal(123.123))) ::
Literal(new java.sql.Timestamp(123123)) ::
Literal(Array[Byte](1,2,3)) ::
- Literal(Seq[Int](1,2,3), ArrayType(IntegerType)) ::
- Literal(Map[Int, Int](1->2, 2->1), MapType(IntegerType, IntegerType)) ::
- Literal(Row(1,2.0d,3.0f),
+ Literal.create(Seq[Int](1,2,3), ArrayType(IntegerType)) ::
+ Literal.create(Map[Int, Int](1->2, 2->1), MapType(IntegerType, IntegerType)) ::
+ Literal.create(Row(1,2.0d,3.0f),
StructType(StructField("c1", IntegerType) ::
StructField("c2", DoubleType) ::
StructField("c3", FloatType) :: Nil)) ::
@@ -166,7 +166,7 @@ class HiveInspectorSuite extends FunSuite with HiveInspectors {
val constantData = constantExprs.map(_.eval())
val constantNullData = constantData.map(_ => null)
val constantWritableOIs = constantExprs.map(e => toWritableInspector(e.dataType))
- val constantNullWritableOIs = constantExprs.map(e => toInspector(Literal(null, e.dataType)))
+ val constantNullWritableOIs = constantExprs.map(e => toInspector(Literal.create(null, e.dataType)))
checkValues(constantData, constantData.zip(constantWritableOIs).map {
case (d, oi) => unwrap(wrap(d, oi), oi)
@@ -212,8 +212,8 @@ class HiveInspectorSuite extends FunSuite with HiveInspectors {
val d = row(0) :: row(0) :: Nil
checkValue(d, unwrap(wrap(d, toInspector(dt)), toInspector(dt)))
checkValue(null, unwrap(wrap(null, toInspector(dt)), toInspector(dt)))
- checkValue(d, unwrap(wrap(d, toInspector(Literal(d, dt))), toInspector(Literal(d, dt))))
- checkValue(d, unwrap(wrap(null, toInspector(Literal(d, dt))), toInspector(Literal(d, dt))))
+ checkValue(d, unwrap(wrap(d, toInspector(Literal.create(d, dt))), toInspector(Literal.create(d, dt))))
+ checkValue(d, unwrap(wrap(null, toInspector(Literal.create(d, dt))), toInspector(Literal.create(d, dt))))
}
test("wrap / unwrap Map Type") {
@@ -222,7 +222,7 @@ class HiveInspectorSuite extends FunSuite with HiveInspectors {
val d = Map(row(0) -> row(1))
checkValue(d, unwrap(wrap(d, toInspector(dt)), toInspector(dt)))
checkValue(null, unwrap(wrap(null, toInspector(dt)), toInspector(dt)))
- checkValue(d, unwrap(wrap(d, toInspector(Literal(d, dt))), toInspector(Literal(d, dt))))
- checkValue(d, unwrap(wrap(null, toInspector(Literal(d, dt))), toInspector(Literal(d, dt))))
+ checkValue(d, unwrap(wrap(d, toInspector(Literal.create(d, dt))), toInspector(Literal.create(d, dt))))
+ checkValue(d, unwrap(wrap(null, toInspector(Literal.create(d, dt))), toInspector(Literal.create(d, dt))))
}
}