Apply reviews

sql/catalyst/src/test/scala/org/apache/spark/sql/util/SchemaUtilsSuite.scala

@@ -24,82 +24,60 @@ import org.apache.spark.sql.types.StructType
 
 class SchemaUtilsSuite extends SparkFunSuite {
 
-  test("Check column name duplication in case-sensitive cases") {
-    def checkCaseSensitiveExceptionCases(schemaStr: String, duplicatedColumns: String): Unit = {
-      val expectedErrorMsg = s"Found duplicate column(s) in SchemaUtilsSuite: $duplicatedColumns"
-      val schema = StructType.fromDDL(schemaStr)
-      var msg = intercept[AnalysisException] {
-        SchemaUtils.checkSchemaColumnNameDuplication(
-          schema, "in SchemaUtilsSuite", caseSensitiveAnalysis = true)
-      }.getMessage
-      assert(msg.contains(expectedErrorMsg))
-      msg = intercept[AnalysisException] {
-        SchemaUtils.checkColumnNameDuplication(
-          schema.map(_.name), "in SchemaUtilsSuite", caseSensitiveResolution)
-      }.getMessage
-      assert(msg.contains(expectedErrorMsg))
-      msg = intercept[AnalysisException] {
-        SchemaUtils.checkColumnNameDuplication(
-          schema.map(_.name), "in SchemaUtilsSuite", caseSensitiveAnalysis = true)
-      }.getMessage
-      assert(msg.contains(expectedErrorMsg))
+  private def resolver(caseSensitiveAnalysis: Boolean): Resolver = {
+    if (caseSensitiveAnalysis) {
+      caseSensitiveResolution
+    } else {
+      caseInsensitiveResolution
     }
+  }
 
-    checkCaseSensitiveExceptionCases("a INT, b INT, a INT", "`a`")
-    checkCaseSensitiveExceptionCases("a INT, b INT, a INT, a INT", "`a`")
-    checkCaseSensitiveExceptionCases("a INT, b INT, a INT, b INT", "`b`, `a`")
-    checkCaseSensitiveExceptionCases("a INT, c INT, b INT, a INT, b INT, c INT", "`b`, `a`, `c`")
+  Seq((true, ("a", "a"), ("b", "b")), (false, ("a", "A"), ("b", "B"))).foreach {
+      case (caseSensitive, (a0, a1), (b0, b1)) =>
 
-    // Check no exception thrown
-    def checkCaseSensitiveNoExceptionCases(schemaStr: String): Unit = {
-      val schema = StructType.fromDDL(schemaStr)
-      SchemaUtils.checkSchemaColumnNameDuplication(
-        schema, "in SchemaUtilsSuite", caseSensitiveAnalysis = true)
-      SchemaUtils.checkColumnNameDuplication(
-        schema.map(_.name), "in SchemaUtilsSuite", caseSensitiveResolution)
-      SchemaUtils.checkColumnNameDuplication(
-        schema.map(_.name), "in SchemaUtilsSuite", caseSensitiveAnalysis = true)
-    }
+    val testType = if (caseSensitive) "case-sensitive" else "case-insensitive"
+    test(s"Check column name duplication in $testType cases") {
+      def checkExceptionCases(schemaStr: String, duplicatedColumns: Seq[String]): Unit = {
+        val expectedErrorMsg = "Found duplicate column(s) in SchemaUtilsSuite: " +
+          duplicatedColumns.map(c => s"`${c.toLowerCase}`").mkString(", ")
+        val schema = StructType.fromDDL(schemaStr)
+        var msg = intercept[AnalysisException] {
+          SchemaUtils.checkSchemaColumnNameDuplication(
+            schema, "in SchemaUtilsSuite", caseSensitiveAnalysis = caseSensitive)
+        }.getMessage
+        assert(msg.contains(expectedErrorMsg))
+        msg = intercept[AnalysisException] {
+          SchemaUtils.checkColumnNameDuplication(
+            schema.map(_.name), "in SchemaUtilsSuite", resolver(caseSensitive))
+        }.getMessage
+        assert(msg.contains(expectedErrorMsg))
+        msg = intercept[AnalysisException] {
+          SchemaUtils.checkColumnNameDuplication(
+            schema.map(_.name), "in SchemaUtilsSuite", caseSensitiveAnalysis = caseSensitive)
+        }.getMessage
+        assert(msg.contains(expectedErrorMsg))
+      }
 
-    checkCaseSensitiveNoExceptionCases("a INT, b INT, c INT")
-    checkCaseSensitiveNoExceptionCases("Aa INT, b INT, aA INT")
+      checkExceptionCases(s"$a0 INT, b INT, $a1 INT", a0 :: Nil)
+      checkExceptionCases(s"$a0 INT, b INT, $a1 INT, $a0 INT", a0 :: Nil)
+      checkExceptionCases(s"$a0 INT, $b0 INT, $a1 INT, $a0 INT, $b1 INT", b0 :: a0 :: Nil)
+    }
   }
 
-  test("Check column name duplication in case-insensitive cases") {
-     def checkCaseInsensitiveExceptionCases(schemaStr: String, duplicatedColumns: String): Unit = {
-      val expectedErrorMsg = s"Found duplicate column(s) in SchemaUtilsSuite: $duplicatedColumns"
+  test("Check no exception thrown for valid schemas") {
+    def checkNoExceptionCases(schemaStr: String, caseSensitive: Boolean): Unit = {
       val schema = StructType.fromDDL(schemaStr)
-      var msg = intercept[AnalysisException] {
-        SchemaUtils.checkSchemaColumnNameDuplication(
-          schema, "in SchemaUtilsSuite", caseSensitiveAnalysis = false)
-      }.getMessage
-      assert(msg.contains(expectedErrorMsg))
-      msg = intercept[AnalysisException] {
-        SchemaUtils.checkColumnNameDuplication(
-          schema.map(_.name), "in SchemaUtilsSuite", caseInsensitiveResolution)
-      }.getMessage
-      assert(msg.contains(expectedErrorMsg))
-      msg = intercept[AnalysisException] {
-        SchemaUtils.checkColumnNameDuplication(
-          schema.map(_.name), "in SchemaUtilsSuite", caseSensitiveAnalysis = false)
-      }.getMessage
-      assert(msg.contains(expectedErrorMsg))
+      SchemaUtils.checkSchemaColumnNameDuplication(
+        schema, "in SchemaUtilsSuite", caseSensitiveAnalysis = caseSensitive)
+      SchemaUtils.checkColumnNameDuplication(
+        schema.map(_.name), "in SchemaUtilsSuite", resolver(caseSensitive))
+      SchemaUtils.checkColumnNameDuplication(
+        schema.map(_.name), "in SchemaUtilsSuite", caseSensitiveAnalysis = caseSensitive)
     }
 
-    checkCaseInsensitiveExceptionCases("Aa INT, b INT, Aa INT", "`aa`")
-    checkCaseInsensitiveExceptionCases("a INT, bB INT, Bb INT", "`bb`")
-    checkCaseInsensitiveExceptionCases("Aa INT, b INT, Aa INT, c INT, aa INT", "`aa`")
-    checkCaseInsensitiveExceptionCases("Aa INT, bB INT, Bb INT, aa INT", "`bb`, `aa`")
-    checkCaseInsensitiveExceptionCases(
-      "Aa INT, cc INT, bB INT, cC INT, Bb INT, aa INT", "`bb`, `cc`, `aa`")
+    checkNoExceptionCases("a INT, b INT, c INT", caseSensitive = true)
+    checkNoExceptionCases("Aa INT, b INT, aA INT", caseSensitive = true)
 
-    // Check no exception thrown
-    val schema = StructType.fromDDL("a INT, b INT, c INT")
-    SchemaUtils.checkSchemaColumnNameDuplication(
-      schema, "in SchemaUtilsSuite", caseSensitiveAnalysis = false)
-    SchemaUtils.checkColumnNameDuplication(
-      schema.map(_.name), "in SchemaUtilsSuite", caseInsensitiveResolution)
-    SchemaUtils.checkColumnNameDuplication(
-      schema.map(_.name), "in SchemaUtilsSuite", caseSensitiveAnalysis = false)
+    checkNoExceptionCases("a INT, b INT, c INT", caseSensitive = false)
   }
 }

sql/core/src/test/resources/sql-tests/results/create.sql.out

@@ -16,7 +16,7 @@ CREATE TABLE t (c0 STRING, c1 INT, c1 DOUBLE, c0 INT) USING parquet
 struct<>
 -- !query 1 output
 org.apache.spark.sql.AnalysisException
-Found duplicate column(s) in the table definition of `t`: `c0`, `c1`;
+Found duplicate column(s) in the table definition of `t`: `c1`, `c0`;
 
 
 -- !query 2
@@ -33,7 +33,7 @@ CREATE TABLE t (c0 STRING, c1 INT, c1 DOUBLE, c0 INT) USING parquet
 struct<>
 -- !query 3 output
 org.apache.spark.sql.AnalysisException
-Found duplicate column(s) in the table definition of `t`: `c0`, `c1`;
+Found duplicate column(s) in the table definition of `t`: `c1`, `c0`;
 
 
 -- !query 4

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

@@ -716,7 +716,6 @@ class DataFrameReaderWriterSuite extends QueryTest with SharedSQLContext with Be
       df.toDF().write.mode("overwrite").text(testDir.getAbsolutePath)
       val e = intercept[AnalysisException] {
         spark.read.format(format).option("inferSchema", true).load(testDir.getAbsolutePath)
-
       }
       assert(e.getMessage.contains("Found duplicate column(s) in the data schema:"))
     }