From cb9a9617ba26eabca7e00f4d873239e2b7815647 Mon Sep 17 00:00:00 2001
From: chenyidao <979136761@qq.com>
Date: Tue, 1 Nov 2022 11:10:26 +0800
Subject: [PATCH 1/6] add upper

ut refactor
---
 .../boostkit/spark/expression/OmniExpressionAdaptor.scala    | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/omnioperator/omniop-spark-extension/java/src/main/scala/com/huawei/boostkit/spark/expression/OmniExpressionAdaptor.scala b/omnioperator/omniop-spark-extension/java/src/main/scala/com/huawei/boostkit/spark/expression/OmniExpressionAdaptor.scala
index 26555cc23..5a184d844 100644
--- a/omnioperator/omniop-spark-extension/java/src/main/scala/com/huawei/boostkit/spark/expression/OmniExpressionAdaptor.scala
+++ b/omnioperator/omniop-spark-extension/java/src/main/scala/com/huawei/boostkit/spark/expression/OmniExpressionAdaptor.scala
@@ -300,9 +300,10 @@ object OmniExpressionAdaptor extends Logging {
 
   private def unsupportedCastCheck(expr: Expression, cast: Cast): Unit = {
     def isDecimalOrStringType(dataType: DataType): Boolean = (dataType.isInstanceOf[DecimalType]) || (dataType.isInstanceOf[StringType])
-    // not support Cast(string as !(decimal/string)) and Cast(!(decimal/string) as string)
+    // not support Cast(string as !(decimal/string)) and Cast(!(decimal/string) as string) and (string as !(Date/string))
     if ((cast.dataType.isInstanceOf[StringType] && !isDecimalOrStringType(cast.child.dataType)) ||
-      (!isDecimalOrStringType(cast.dataType) && cast.child.dataType.isInstanceOf[StringType])) {
+      (!isDecimalOrStringType(cast.dataType) && !cast.dataType.isInstanceOf[DateType]
+        && cast.child.dataType.isInstanceOf[StringType])) {
       throw new UnsupportedOperationException(s"Unsupported expression: $expr")
     }
 
-- 
Gitee


From f0c0a2917c8abcc427e3e95ce2c2a64b7cec0a6e Mon Sep 17 00:00:00 2001
From: chenyidao <979136761@qq.com>
Date: Thu, 3 Nov 2022 15:16:51 +0800
Subject: [PATCH 2/6] add cast string to date ut

---
 .../forsql/ColumnarStringCastSuite.scala      | 90 +++++++++++++++++++
 1 file changed, 90 insertions(+)
 create mode 100644 omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala

diff --git a/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
new file mode 100644
index 000000000..60898f99a
--- /dev/null
+++ b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2022-2022. Huawei Technologies Co., Ltd. All rights reserved.
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.apache.spark.sql.execution.forsql
+
+import org.apache.spark.sql.{DataFrame, Row}
+import org.apache.spark.sql.execution.{ColumnarProjectExec, ColumnarSparkPlanTest, ProjectExec}
+
+class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
+  import testImplicits.{localSeqToDatasetHolder, newProductEncoder}
+
+  private var stringDateDf: DataFrame = _
+
+  protected override def beforeAll(): Unit = {
+    super.beforeAll()
+    stringDateDf = Seq[(String, String)](
+      ("2010-01-01", null),
+      ("2011-02-02", "  2022-09-02  "),
+      ("2012-03-03", ""),
+      ("2013-04-04", "40"),
+    ).toDF("string_normal", "string_null")
+
+    stringDateDf.createOrReplaceTempView("string_date")
+  }
+
+  // string to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast string to date") {
+    val sql = "select cast(string_normal as date) from string_date"
+    val expected = Seq(
+      Row("2010-01-01"),
+      Row("2011-02-02"),
+      Row("2012-03-03"),
+      Row("2013-04-04")
+    )
+    checkResult(sql, expected)
+  }
+
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast string to date with null") {
+    val sql = "select cast(string_null as date) from string_date"
+    val expected = Seq(
+      Row(null),
+      Row("2022-09-02"),
+      Row(null),
+      Row(null)
+    )
+    checkResult(sql, expected)
+  }
+
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast literal string to date") {
+    val sql = "select cast('1998-08-29' as date)"
+    val expected = Seq(
+      Row("1998-08-29")
+    )
+    checkResult(sql, expected)
+  }
+
+  def checkResult(sql: String, expected: Seq[Row], isUseOmni: Boolean = true): Unit = {
+    def assertOmniProjectHappen(res: DataFrame): Unit = {
+      val executedPlan = res.queryExecution.executedPlan
+      assert(executedPlan.find(_.isInstanceOf[ColumnarProjectExec]).isDefined, s"ColumnarProjectExec not happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(_.isInstanceOf[ProjectExec]).isEmpty, s"ProjectExec happened, executedPlan as follows： \n$executedPlan")
+    }
+    def assertOmniProjectNotHappen(res: DataFrame): Unit = {
+      val executedPlan = res.queryExecution.executedPlan
+      assert(executedPlan.find(_.isInstanceOf[ColumnarProjectExec]).isEmpty, s"ColumnarProjectExec happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(_.isInstanceOf[ProjectExec]).isDefined, s"ProjectExec not happened, executedPlan as follows： \n$executedPlan")
+    }
+    val res = spark.sql(sql)
+    if (isUseOmni) assertOmniProjectHappen(res) else assertOmniProjectNotHappen(res)
+    checkAnswer(res, expected)
+  }
+}
-- 
Gitee


From 709fabf4a4bcc0e6eaba7e6bd437eba75e0e8ab1 Mon Sep 17 00:00:00 2001
From: chenyidao <979136761@qq.com>
Date: Fri, 11 Nov 2022 11:31:22 +0800
Subject: [PATCH 3/6] add cast string to date ut with multi string format

---
 .../forsql/ColumnarStringCastSuite.scala      | 141 +++++++++++++++---
 1 file changed, 123 insertions(+), 18 deletions(-)

diff --git a/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
index 60898f99a..6cab6110b 100644
--- a/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
+++ b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
@@ -28,46 +28,151 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
 
   protected override def beforeAll(): Unit = {
     super.beforeAll()
-    stringDateDf = Seq[(String, String)](
-      ("2010-01-01", null),
-      ("2011-02-02", "  2022-09-02  "),
-      ("2012-03-03", ""),
-      ("2013-04-04", "40"),
-    ).toDF("string_normal", "string_null")
+    stringDateDf = Seq[(String, String, String, String, String, String)](
+      ("2010", "2010-1", "2010-01", "2010-02-4", "2010-02-04", "20 10"),
+      ("  2011 ", " 2011-1 ", " 2011-01 ", " 2011-03-4 ", " 2010-03-04 ", "abcd"),
+      (null, "2010-8", null, "2010-08-4", null, null),
+      ("2012", null, "2012-11", null, "2012-04-10", "2010-1 3")
+    ).toDF("yyyy", "yyyy_m", "yyyy_mm", "yyyy_mm_d", "yyyy_mm_dd", "invalid")
 
     stringDateDf.createOrReplaceTempView("string_date")
   }
 
   // string to date
+  // cast yyyy to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast string to date") {
-    val sql = "select cast(string_normal as date) from string_date"
+    val sql = "select cast(yyyy as date) from string_date"
     val expected = Seq(
       Row("2010-01-01"),
-      Row("2011-02-02"),
-      Row("2012-03-03"),
-      Row("2013-04-04")
+      Row("2011-01-01"),
+      Row("2012-01-01"),
+      Row(null)
     )
     checkResult(sql, expected)
   }
 
+  // cast yyyy_m to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast string to date with null") {
-    val sql = "select cast(string_null as date) from string_date"
+    "when cast string to date") {
+    val sql = "select cast(yyyy_m as date) from string_date"
     val expected = Seq(
-      Row(null),
-      Row("2022-09-02"),
-      Row(null),
+      Row("2010-01-01"),
+      Row("2010-08-01"),
+      Row("2011-01-01"),
+      Row(null)
+    )
+    checkResult(sql, expected)
+  }
+
+  // cast yyyy_mm to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast string to date") {
+    val sql = "select cast(yyyy_mm as date) from string_date"
+    val expected = Seq(
+      Row("2010-01-01"),
+      Row("2011-01-01"),
+      Row("2012-11-01"),
+      Row(null)
+    )
+    checkResult(sql, expected)
+  }
+
+  // cast yyyy_mm_d to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast string to date") {
+    val sql = "select cast(yyyy_mm_d as date) from string_date"
+    val expected = Seq(
+      Row("2010-02-04"),
+      Row("2010-08-04"),
+      Row("2011-03-04"),
+      Row(null)
+    )
+    checkResult(sql, expected)
+  }
+
+  // cast yyyy_mm_dd to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast string to date") {
+    val sql = "select cast(yyyy_mm_dd as date) from string_date"
+    val expected = Seq(
+      Row("2010-02-04"),
+      Row("2011-03-04"),
+      Row("2012-04-10"),
       Row(null)
     )
     checkResult(sql, expected)
   }
 
+  // cast literal string yyyy to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast literal string yyyy to date") {
+    val sql = "select cast('1998' as date)"
+    val expected = Seq(
+      Row("1998-01-01")
+    )
+    checkResult(sql, expected)
+  }
+
+  // cast literal string yyyy_m to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast literal string to date") {
-    val sql = "select cast('1998-08-29' as date)"
+    "when cast literal string yyyy_m to date") {
+    val sql = "select cast('1998-8' as date)"
     val expected = Seq(
-      Row("1998-08-29")
+      Row("1998-08-01")
+    )
+    checkResult(sql, expected)
+  }
+
+  // cast literal string yyyy_mm to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast literal string yyyy_mm to date") {
+    val sql = "select cast('1998-10' as date)"
+    val expected = Seq(
+      Row("1998-10-01")
+    )
+    checkResult(sql, expected)
+  }
+
+  // cast literal string yyyy_mm_d to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast literal string yyyy_mm_d to date") {
+    val sql = "select cast('1998_10_3' as date)"
+    val expected = Seq(
+      Row("1998-10-03")
+    )
+    checkResult(sql, expected)
+  }
+
+  // cast literal string yyyy_mm_dd to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast literal string yyyy_mm_dd to date") {
+    val sql = "select cast('1998_10_10' as date)"
+    val expected = Seq(
+      Row("1998-10-10")
+    )
+    checkResult(sql, expected)
+  }
+
+  // invalid cast literal string to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast invalid literal string to date") {
+    val sql = "select cast('1  998-10-1 0' as date)"
+    val expected = Seq(
+      Row(null)
+    )
+    checkResult(sql, expected)
+  }
+
+  // cast invalid string to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast invalid string to date") {
+    val sql = "select cast(invalid as date) from string_date"
+    val expected = Seq(
+      Row(null),
+      Row(null),
+      Row(null),
+      Row(null)
     )
     checkResult(sql, expected)
   }
-- 
Gitee


From ae80575a6abb51dac6c9d0a84bf1aa71b9701b65 Mon Sep 17 00:00:00 2001
From: chenyidao <979136761@qq.com>
Date: Mon, 28 Nov 2022 11:37:43 +0800
Subject: [PATCH 4/6] code review

---
 .../forsql/ColumnarStringCastSuite.scala      | 87 +++++++++++--------
 1 file changed, 50 insertions(+), 37 deletions(-)

diff --git a/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
index 6cab6110b..851ea01df 100644
--- a/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
+++ b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
@@ -24,25 +24,25 @@ import org.apache.spark.sql.execution.{ColumnarProjectExec, ColumnarSparkPlanTes
 class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   import testImplicits.{localSeqToDatasetHolder, newProductEncoder}
 
-  private var stringDateDf: DataFrame = _
+  private var stringDateDf: DataFrame = -
 
   protected override def beforeAll(): Unit = {
     super.beforeAll()
-    stringDateDf = Seq[(String, String, String, String, String, String)](
-      ("2010", "2010-1", "2010-01", "2010-02-4", "2010-02-04", "20 10"),
-      ("  2011 ", " 2011-1 ", " 2011-01 ", " 2011-03-4 ", " 2010-03-04 ", "abcd"),
-      (null, "2010-8", null, "2010-08-4", null, null),
-      ("2012", null, "2012-11", null, "2012-04-10", "2010-1 3")
-    ).toDF("yyyy", "yyyy_m", "yyyy_mm", "yyyy_mm_d", "yyyy_mm_dd", "invalid")
-
-    stringDateDf.createOrReplaceTempView("string_date")
+    stringDateDf = Seq[(String, String, String, String, String, String, String)](
+      ("2010", "2010-1", "2010-01", "2010-02-4", "2010-02-04", "2022-01-021234", "20 10"),
+      ("  2011 ", " 2011-1 ", " 2011-01 ", " 2011-03-4 ", " 2010-03-04 ", "2022-01-021  12", "abcd"),
+      (null, "2010-8", null, "2010-08-4", null, null, null),
+      ("2012", null, "2012-11", null, "2012-04-10", "2022-01-02abd", "2010-1 3")
+    ).toDF("yyyy", "yyyy-m", "yyyy-mm", "yyyy-mm-d", "yyyy-mm-dd", "yyyy-mm-dd-x", "invalid")
+
+    stringDateDf.createOrReplaceTempView("string-date")
   }
 
   // string to date
   // cast yyyy to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast string to date") {
-    val sql = "select cast(yyyy as date) from string_date"
+    val sql = "select cast(yyyy as date) from string-date"
     val expected = Seq(
       Row("2010-01-01"),
       Row("2011-01-01"),
@@ -52,10 +52,10 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
     checkResult(sql, expected)
   }
 
-  // cast yyyy_m to date
+  // cast yyyy-m to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast string to date") {
-    val sql = "select cast(yyyy_m as date) from string_date"
+    val sql = "select cast(yyyy-m as date) from string-date"
     val expected = Seq(
       Row("2010-01-01"),
       Row("2010-08-01"),
@@ -65,10 +65,10 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
     checkResult(sql, expected)
   }
 
-  // cast yyyy_mm to date
+  // cast yyyy-mm to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast string to date") {
-    val sql = "select cast(yyyy_mm as date) from string_date"
+    val sql = "select cast(yyyy-mm as date) from string-date"
     val expected = Seq(
       Row("2010-01-01"),
       Row("2011-01-01"),
@@ -78,10 +78,10 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
     checkResult(sql, expected)
   }
 
-  // cast yyyy_mm_d to date
+  // cast yyyy-mm-d to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast string to date") {
-    val sql = "select cast(yyyy_mm_d as date) from string_date"
+    val sql = "select cast(yyyy-mm-d as date) from string-date"
     val expected = Seq(
       Row("2010-02-04"),
       Row("2010-08-04"),
@@ -91,10 +91,10 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
     checkResult(sql, expected)
   }
 
-  // cast yyyy_mm_dd to date
+  // cast yyyy-mm-dd to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast string to date") {
-    val sql = "select cast(yyyy_mm_dd as date) from string_date"
+    val sql = "select cast(yyyy-mm-dd as date) from string-date"
     val expected = Seq(
       Row("2010-02-04"),
       Row("2011-03-04"),
@@ -104,6 +104,19 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
     checkResult(sql, expected)
   }
 
+  // cast yyyy-mm-dd* to date
+  test("Test ColumnarProjectExec happen and result is same as native " +
+    "when cast string to date") {
+    val sql = "select cast(yyyy-mm-dd-x as date) from string-date"
+    val expected = Seq(
+      Row("2022-01-02"),
+      Row("2022-01-02"),
+      Row("2022-01-02"),
+      Row(null)
+    )
+    checkResult(sql, expected)
+  }
+
   // cast literal string yyyy to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast literal string yyyy to date") {
@@ -114,9 +127,9 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
     checkResult(sql, expected)
   }
 
-  // cast literal string yyyy_m to date
+  // cast literal string yyyy-m to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast literal string yyyy_m to date") {
+    "when cast literal string yyyy-m to date") {
     val sql = "select cast('1998-8' as date)"
     val expected = Seq(
       Row("1998-08-01")
@@ -124,9 +137,9 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
     checkResult(sql, expected)
   }
 
-  // cast literal string yyyy_mm to date
+  // cast literal string yyyy-mm to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast literal string yyyy_mm to date") {
+    "when cast literal string yyyy-mm to date") {
     val sql = "select cast('1998-10' as date)"
     val expected = Seq(
       Row("1998-10-01")
@@ -134,32 +147,32 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
     checkResult(sql, expected)
   }
 
-  // cast literal string yyyy_mm_d to date
+  // cast literal string yyyy-mm-d to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast literal string yyyy_mm_d to date") {
-    val sql = "select cast('1998_10_3' as date)"
+    "when cast literal string yyyy-mm-d to date") {
+    val sql = "select cast('1998-10-3' as date)"
     val expected = Seq(
       Row("1998-10-03")
     )
     checkResult(sql, expected)
   }
 
-  // cast literal string yyyy_mm_dd to date
+  // cast literal string yyyy-mm-dd to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast literal string yyyy_mm_dd to date") {
-    val sql = "select cast('1998_10_10' as date)"
+    "when cast literal string yyyy-mm-dd to date") {
+    val sql = "select cast('1998-10-10' as date)"
     val expected = Seq(
       Row("1998-10-10")
     )
     checkResult(sql, expected)
   }
 
-  // invalid cast literal string to date
+  // cast literal string yyyy-mm-dd* to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast invalid literal string to date") {
-    val sql = "select cast('1  998-10-1 0' as date)"
+    "when cast yyyy-mm-dd* literal string to date") {
+    val sql = "select cast('1998-10-101234' as date)"
     val expected = Seq(
-      Row(null)
+      Row("1998-10-10")
     )
     checkResult(sql, expected)
   }
@@ -167,7 +180,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   // cast invalid string to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast invalid string to date") {
-    val sql = "select cast(invalid as date) from string_date"
+    val sql = "select cast(invalid as date) from string-date"
     val expected = Seq(
       Row(null),
       Row(null),
@@ -180,13 +193,13 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   def checkResult(sql: String, expected: Seq[Row], isUseOmni: Boolean = true): Unit = {
     def assertOmniProjectHappen(res: DataFrame): Unit = {
       val executedPlan = res.queryExecution.executedPlan
-      assert(executedPlan.find(_.isInstanceOf[ColumnarProjectExec]).isDefined, s"ColumnarProjectExec not happened, executedPlan as follows： \n$executedPlan")
-      assert(executedPlan.find(_.isInstanceOf[ProjectExec]).isEmpty, s"ProjectExec happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(-.isInstanceOf[ColumnarProjectExec]).isDefined, s"ColumnarProjectExec not happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(-.isInstanceOf[ProjectExec]).isEmpty, s"ProjectExec happened, executedPlan as follows： \n$executedPlan")
     }
     def assertOmniProjectNotHappen(res: DataFrame): Unit = {
       val executedPlan = res.queryExecution.executedPlan
-      assert(executedPlan.find(_.isInstanceOf[ColumnarProjectExec]).isEmpty, s"ColumnarProjectExec happened, executedPlan as follows： \n$executedPlan")
-      assert(executedPlan.find(_.isInstanceOf[ProjectExec]).isDefined, s"ProjectExec not happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(-.isInstanceOf[ColumnarProjectExec]).isEmpty, s"ColumnarProjectExec happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(-.isInstanceOf[ProjectExec]).isDefined, s"ProjectExec not happened, executedPlan as follows： \n$executedPlan")
     }
     val res = spark.sql(sql)
     if (isUseOmni) assertOmniProjectHappen(res) else assertOmniProjectNotHappen(res)
-- 
Gitee


From 0d84852f0a7acc44164661923fc8e52c7be66efe Mon Sep 17 00:00:00 2001
From: chenyidao <979136761@qq.com>
Date: Mon, 28 Nov 2022 11:54:36 +0800
Subject: [PATCH 5/6] fix bug

---
 .../forsql/ColumnarStringCastSuite.scala      | 24 +++++++++----------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
index 851ea01df..7f78d4413 100644
--- a/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
+++ b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
@@ -24,7 +24,7 @@ import org.apache.spark.sql.execution.{ColumnarProjectExec, ColumnarSparkPlanTes
 class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   import testImplicits.{localSeqToDatasetHolder, newProductEncoder}
 
-  private var stringDateDf: DataFrame = -
+  private var stringDateDf: DataFrame = _
 
   protected override def beforeAll(): Unit = {
     super.beforeAll()
@@ -41,7 +41,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   // string to date
   // cast yyyy to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast string to date") {
+    "when cast yyyy to date") {
     val sql = "select cast(yyyy as date) from string-date"
     val expected = Seq(
       Row("2010-01-01"),
@@ -54,7 +54,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
 
   // cast yyyy-m to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast string to date") {
+    "when cast yyyy-m to date") {
     val sql = "select cast(yyyy-m as date) from string-date"
     val expected = Seq(
       Row("2010-01-01"),
@@ -67,7 +67,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
 
   // cast yyyy-mm to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast string to date") {
+    "when cast yyyy-mm to date") {
     val sql = "select cast(yyyy-mm as date) from string-date"
     val expected = Seq(
       Row("2010-01-01"),
@@ -80,7 +80,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
 
   // cast yyyy-mm-d to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast string to date") {
+    "when cast yyyy-mm-d to date") {
     val sql = "select cast(yyyy-mm-d as date) from string-date"
     val expected = Seq(
       Row("2010-02-04"),
@@ -93,7 +93,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
 
   // cast yyyy-mm-dd to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast string to date") {
+    "when cast yyyy-mm-dd to date") {
     val sql = "select cast(yyyy-mm-dd as date) from string-date"
     val expected = Seq(
       Row("2010-02-04"),
@@ -106,7 +106,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
 
   // cast yyyy-mm-dd* to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast string to date") {
+    "when cast yyyy-mm-dd* to date") {
     val sql = "select cast(yyyy-mm-dd-x as date) from string-date"
     val expected = Seq(
       Row("2022-01-02"),
@@ -169,7 +169,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
 
   // cast literal string yyyy-mm-dd* to date
   test("Test ColumnarProjectExec happen and result is same as native " +
-    "when cast yyyy-mm-dd* literal string to date") {
+    "when cast literal string yyyy-mm-dd* to date") {
     val sql = "select cast('1998-10-101234' as date)"
     val expected = Seq(
       Row("1998-10-10")
@@ -193,13 +193,13 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   def checkResult(sql: String, expected: Seq[Row], isUseOmni: Boolean = true): Unit = {
     def assertOmniProjectHappen(res: DataFrame): Unit = {
       val executedPlan = res.queryExecution.executedPlan
-      assert(executedPlan.find(-.isInstanceOf[ColumnarProjectExec]).isDefined, s"ColumnarProjectExec not happened, executedPlan as follows： \n$executedPlan")
-      assert(executedPlan.find(-.isInstanceOf[ProjectExec]).isEmpty, s"ProjectExec happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(_.isInstanceOf[ColumnarProjectExec]).isDefined, s"ColumnarProjectExec not happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(_.isInstanceOf[ProjectExec]).isEmpty, s"ProjectExec happened, executedPlan as follows： \n$executedPlan")
     }
     def assertOmniProjectNotHappen(res: DataFrame): Unit = {
       val executedPlan = res.queryExecution.executedPlan
-      assert(executedPlan.find(-.isInstanceOf[ColumnarProjectExec]).isEmpty, s"ColumnarProjectExec happened, executedPlan as follows： \n$executedPlan")
-      assert(executedPlan.find(-.isInstanceOf[ProjectExec]).isDefined, s"ProjectExec not happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(_.isInstanceOf[ColumnarProjectExec]).isEmpty, s"ColumnarProjectExec happened, executedPlan as follows： \n$executedPlan")
+      assert(executedPlan.find(_.isInstanceOf[ProjectExec]).isDefined, s"ProjectExec not happened, executedPlan as follows： \n$executedPlan")
     }
     val res = spark.sql(sql)
     if (isUseOmni) assertOmniProjectHappen(res) else assertOmniProjectNotHappen(res)
-- 
Gitee


From fb90a2790c9c635a37cb9fefb765262ae79d5ae9 Mon Sep 17 00:00:00 2001
From: chenyidao <979136761@qq.com>
Date: Mon, 28 Nov 2022 11:57:20 +0800
Subject: [PATCH 6/6] bug fix

---
 .../forsql/ColumnarStringCastSuite.scala         | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
index 7f78d4413..dd189d73e 100644
--- a/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
+++ b/omnioperator/omniop-spark-extension/java/src/test/scala/org/apache/spark/sql/execution/forsql/ColumnarStringCastSuite.scala
@@ -35,14 +35,14 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
       ("2012", null, "2012-11", null, "2012-04-10", "2022-01-02abd", "2010-1 3")
     ).toDF("yyyy", "yyyy-m", "yyyy-mm", "yyyy-mm-d", "yyyy-mm-dd", "yyyy-mm-dd-x", "invalid")
 
-    stringDateDf.createOrReplaceTempView("string-date")
+    stringDateDf.createOrReplaceTempView("string_date")
   }
 
   // string to date
   // cast yyyy to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast yyyy to date") {
-    val sql = "select cast(yyyy as date) from string-date"
+    val sql = "select cast(yyyy as date) from string_date"
     val expected = Seq(
       Row("2010-01-01"),
       Row("2011-01-01"),
@@ -55,7 +55,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   // cast yyyy-m to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast yyyy-m to date") {
-    val sql = "select cast(yyyy-m as date) from string-date"
+    val sql = "select cast(yyyy-m as date) from string_date"
     val expected = Seq(
       Row("2010-01-01"),
       Row("2010-08-01"),
@@ -68,7 +68,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   // cast yyyy-mm to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast yyyy-mm to date") {
-    val sql = "select cast(yyyy-mm as date) from string-date"
+    val sql = "select cast(yyyy-mm as date) from string_date"
     val expected = Seq(
       Row("2010-01-01"),
       Row("2011-01-01"),
@@ -81,7 +81,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   // cast yyyy-mm-d to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast yyyy-mm-d to date") {
-    val sql = "select cast(yyyy-mm-d as date) from string-date"
+    val sql = "select cast(yyyy-mm-d as date) from string_date"
     val expected = Seq(
       Row("2010-02-04"),
       Row("2010-08-04"),
@@ -94,7 +94,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   // cast yyyy-mm-dd to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast yyyy-mm-dd to date") {
-    val sql = "select cast(yyyy-mm-dd as date) from string-date"
+    val sql = "select cast(yyyy-mm-dd as date) from string_date"
     val expected = Seq(
       Row("2010-02-04"),
       Row("2011-03-04"),
@@ -107,7 +107,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   // cast yyyy-mm-dd* to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast yyyy-mm-dd* to date") {
-    val sql = "select cast(yyyy-mm-dd-x as date) from string-date"
+    val sql = "select cast(yyyy-mm-dd-x as date) from string_date"
     val expected = Seq(
       Row("2022-01-02"),
       Row("2022-01-02"),
@@ -180,7 +180,7 @@ class ColumnarStringCastSuite extends ColumnarSparkPlanTest{
   // cast invalid string to date
   test("Test ColumnarProjectExec happen and result is same as native " +
     "when cast invalid string to date") {
-    val sql = "select cast(invalid as date) from string-date"
+    val sql = "select cast(invalid as date) from string_date"
     val expected = Seq(
       Row(null),
       Row(null),
-- 
Gitee