use SQLTestUtils and If

Author: cloud-fan

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

@@ -497,10 +497,9 @@ trait HiveTypeCoercion {
     }
 
     private def transform(booleanExpr: Expression, numericExpr: Expression) = {
-      CaseWhen(Seq(
-        Or(IsNull(booleanExpr), IsNull(numericExpr)), Literal.create(null, BooleanType),
-        buildCaseKeyWhen(booleanExpr, numericExpr)
-      ))
+      If(Or(IsNull(booleanExpr), IsNull(numericExpr)),
+        Literal.create(null, BooleanType),
+        buildCaseKeyWhen(booleanExpr, numericExpr))
     }
 
     private def transformNullSafe(booleanExpr: Expression, numericExpr: Expression) = {

sql/core/src/test/scala/org/apache/spark/sql/SQLQuerySuite.scala

@@ -24,20 +24,20 @@ import org.apache.spark.sql.catalyst.errors.DialectException
 import org.apache.spark.sql.execution.GeneratedAggregate
 import org.apache.spark.sql.functions._
 import org.apache.spark.sql.TestData._
-import org.apache.spark.sql.test.TestSQLContext
+import org.apache.spark.sql.test.{SQLTestUtils, TestSQLContext}
 import org.apache.spark.sql.test.TestSQLContext.{udf => _, _}
 
 import org.apache.spark.sql.types._
 
 /** A SQL Dialect for testing purpose, and it can not be nested type */
 class MyDialect extends DefaultParserDialect
 
-class SQLQuerySuite extends QueryTest with BeforeAndAfterAll {
+class SQLQuerySuite extends QueryTest with BeforeAndAfterAll with SQLTestUtils {
   // Make sure the tables are loaded.
   TestData
 
-  import org.apache.spark.sql.test.TestSQLContext.implicits._
-  val sqlCtx = TestSQLContext
+  val sqlContext = TestSQLContext
+  import sqlContext.implicits._
 
   test("SPARK-6743: no columns from cache") {
     Seq(
@@ -915,7 +915,7 @@ class SQLQuerySuite extends QueryTest with BeforeAndAfterAll {
       Row(values(0).toInt, values(1), values(2).toBoolean, v4)
     }
 
-    val df1 = sqlCtx.createDataFrame(rowRDD1, schema1)
+    val df1 = createDataFrame(rowRDD1, schema1)
     df1.registerTempTable("applySchema1")
     checkAnswer(
       sql("SELECT * FROM applySchema1"),
@@ -945,7 +945,7 @@ class SQLQuerySuite extends QueryTest with BeforeAndAfterAll {
       Row(Row(values(0).toInt, values(2).toBoolean), Map(values(1) -> v4))
     }
 
-    val df2 = sqlCtx.createDataFrame(rowRDD2, schema2)
+    val df2 = createDataFrame(rowRDD2, schema2)
     df2.registerTempTable("applySchema2")
     checkAnswer(
       sql("SELECT * FROM applySchema2"),
@@ -970,7 +970,7 @@ class SQLQuerySuite extends QueryTest with BeforeAndAfterAll {
       Row(Row(values(0).toInt, values(2).toBoolean), scala.collection.mutable.Map(values(1) -> v4))
     }
 
-    val df3 = sqlCtx.createDataFrame(rowRDD3, schema2)
+    val df3 = createDataFrame(rowRDD3, schema2)
     df3.registerTempTable("applySchema3")
 
     checkAnswer(
@@ -1015,7 +1015,7 @@ class SQLQuerySuite extends QueryTest with BeforeAndAfterAll {
       .build()
     val schemaWithMeta = new StructType(Array(
       schema("id"), schema("name").copy(metadata = metadata), schema("age")))
-    val personWithMeta = sqlCtx.createDataFrame(person.rdd, schemaWithMeta)
+    val personWithMeta = createDataFrame(person.rdd, schemaWithMeta)
     def validateMetadata(rdd: DataFrame): Unit = {
       assert(rdd.schema("name").metadata.getString(docKey) == docValue)
     }
@@ -1333,23 +1333,25 @@ class SQLQuerySuite extends QueryTest with BeforeAndAfterAll {
   }
 
   test("SPARK-7952: fix the equality check between boolean and numeric types") {
-    val df = Seq(
-      (1, true),
-      (0, false),
-      (2, true),
-      (2, false),
-      (null, true),
-      (null, false),
-      (0, null),
-      (1, null),
-      (null, null)
-    ).map { case (i, b) =>
-      (i.asInstanceOf[Integer], b.asInstanceOf[java.lang.Boolean])
-    }.toDF("i", "b")
-
-    checkAnswer(df.select('i === 'b),
-      Seq(true, true, false, false, null, null, null, null, null).map(Row(_)))
-    checkAnswer(df.select('i <=> 'b),
-      Seq(true, true, false, false, false, false, false, false, true).map(Row(_)))
+    withTempTable("t") {
+      Seq(
+        (1, true),
+        (0, false),
+        (2, true),
+        (2, false),
+        (null, true),
+        (null, false),
+        (0, null),
+        (1, null),
+        (null, null)
+      ).map { case (i, b) =>
+        (i.asInstanceOf[Integer], b.asInstanceOf[java.lang.Boolean])
+      }.toDF("i", "b").registerTempTable("t")
+
+      checkAnswer(sql("select i = b from t"),
+        Seq(true, true, false, false, null, null, null, null, null).map(Row(_)))
+      checkAnswer(sql("select i <=> b from t"),
+        Seq(true, true, false, false, false, false, false, false, true).map(Row(_)))
+    }
   }
 }