You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@gluten.apache.org by ma...@apache.org on 2025/02/21 16:15:14 UTC
(incubator-gluten) branch main updated: [GLUTEN-8738][VL] Update GlutenSQLQueryTestSuite to exclude or overwrite failed queries for Spark3.5 (#8739)
This is an automated email from the ASF dual-hosted git repository.
marong pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/incubator-gluten.git
The following commit(s) were added to refs/heads/main by this push:
new 6975c0823c [GLUTEN-8738][VL] Update GlutenSQLQueryTestSuite to exclude or overwrite failed queries for Spark3.5 (#8739)
6975c0823c is described below
commit 6975c0823c7550fcf407c80cff01692db9e2cf02
Author: Rong Ma <ma...@apache.org>
AuthorDate: Fri Feb 21 16:15:10 2025 +0000
[GLUTEN-8738][VL] Update GlutenSQLQueryTestSuite to exclude or overwrite failed queries for Spark3.5 (#8739)
---
cpp/velox/substrait/SubstraitToVeloxExpr.cc | 15 +-
.../apache/gluten/utils/SQLQueryTestSettings.scala | 2 +
.../ClickHouseSQLQueryTestSettings.scala | 3 +
.../utils/velox/VeloxSQLQueryTestSettings.scala | 3 +
.../ClickHouseSQLQueryTestSettings.scala | 3 +
.../utils/velox/VeloxSQLQueryTestSettings.scala | 3 +
.../ClickHouseSQLQueryTestSettings.scala | 3 +
.../utils/velox/VeloxSQLQueryTestSettings.scala | 3 +
.../sql-tests/inputs/group-by-ordinal.sql | 0
.../sql-tests/inputs/group-by.sql | 0
.../sql-tests/inputs/linear-regression.sql | 0
.../sql-tests/inputs/misc-functions.sql | 0
.../sql-tests/inputs/random.sql | 0
.../sql-tests/inputs/table-valued-functions.sql | 0
.../sql-tests/inputs/udf/udf-group-by.sql | 0
.../sql-tests/results/group-by-ordinal.sql.out | 0
.../sql-tests/results/group-by.sql.out | 0
.../sql-tests/results/linear-regression.sql.out | 0
.../sql-tests/results/misc-functions.sql.out | 0
.../sql-tests/results/random.sql.out | 0
.../results/table-valued-functions.sql.out | 0
.../sql-tests/results/udf/udf-group-by.sql.out | 0
.../backends-velox/sql-tests/inputs/array.sql | 183 +
.../backends-velox/sql-tests/inputs/bitwise.sql | 77 +
.../sql-tests/inputs/charvarchar.sql | 130 +
.../backends-velox/sql-tests/inputs/count.sql | 57 +
.../backends-velox/sql-tests/inputs/cte.sql | 181 +
.../backends-velox/sql-tests/inputs/date.sql | 168 +
.../sql-tests/inputs/datetime-legacy.sql | 3 +
.../sql-tests/inputs/datetime-parsing-invalid.sql | 28 +
.../sql-tests/inputs/datetime-parsing-legacy.sql | 2 +
.../sql-tests/inputs/datetime-parsing.sql | 29 +
.../sql-tests/inputs/group-by-ordinal.sql | 0
.../sql-tests/inputs/group-by.sql | 15 +
.../backends-velox/sql-tests/inputs/hll.sql | 76 +
.../backends-velox/sql-tests/inputs/interval.sql | 387 +++
.../sql-tests/inputs/linear-regression.sql | 0
.../sql-tests/inputs/misc-functions.sql | 3 +
.../sql-tests/inputs/percentiles.sql | 389 +++
.../sql-tests/inputs/postgreSQL/window_part1.sql | 365 ++
.../sql-tests/inputs/postgreSQL/window_part3.sql | 463 +++
.../sql-tests/inputs/postgreSQL/window_part4.sql | 408 +++
.../sql-tests/inputs/random.sql | 0
.../sql-tests/inputs/regexp-functions.sql | 79 +
.../sql-tests/inputs/string-functions.sql | 255 ++
.../subquery/in-subquery/in-null-semantics.sql | 62 +
.../sql-tests/inputs/table-valued-functions.sql | 0
.../backends-velox/sql-tests/inputs/timestamp.sql | 145 +
.../sql-tests/inputs/try_arithmetic.sql | 88 +
.../backends-velox/sql-tests/inputs/try_cast.sql | 50 +
.../sql-tests/inputs/try_datetime_functions.sql | 4 +
.../sql-tests/inputs/try_element_at.sql | 11 +
.../native/stringCastAndExpressions.sql | 54 +
.../sql-tests/inputs/udf/udf-group-by.sql | 0
.../sql-tests/inputs/url-functions.sql | 20 +
.../backends-velox/sql-tests/inputs/window.sql | 477 +++
.../backends-velox/sql-tests/results/array.sql.out | 794 +++++
.../sql-tests/results/bitwise.sql.out | 306 ++
.../sql-tests/results/charvarchar.sql.out | 1243 +++++++
.../backends-velox/sql-tests/results/count.sql.out | 214 ++
.../backends-velox/sql-tests/results/cte.sql.out | 595 ++++
.../sql-tests/results/datetime-legacy.sql.out | 2154 ++++++++++++
.../results/datetime-parsing-invalid.sql.out | 137 +
.../results/datetime-parsing-legacy.sql.out | 79 +
.../sql-tests/results/datetime-parsing.sql.out | 79 +
.../sql-tests/results/group-by-ordinal.sql.out | 0
.../sql-tests/results/group-by.sql.out | 62 +-
.../backends-velox/sql-tests/results/hll.sql.out | 247 ++
.../sql-tests/results/interval.sql.out | 3665 ++++++++++++++++++++
.../sql-tests/results/linear-regression.sql.out | 0
.../sql-tests/results/misc-functions.sql.out | 16 +
.../sql-tests/results/percentiles.sql.out | 907 +++++
.../results/postgreSQL/window_part1.sql.out | 754 ++++
.../results/postgreSQL/window_part3.sql.out | 556 +++
.../results/postgreSQL/window_part4.sql.out | 529 +++
.../sql-tests/results/random.sql.out | 0
.../sql-tests/results/regexp-functions.sql.out | 600 ++++
.../sql-tests/results/string-functions.sql.out | 1738 ++++++++++
.../subquery/in-subquery/in-null-semantics.sql.out | 271 ++
.../results/table-valued-functions.sql.out | 0
.../sql-tests/results/try_arithmetic.sql.out | 553 +++
.../sql-tests/results/try_cast.sql.out | 199 ++
.../results/try_datetime_functions.sql.out | 32 +
.../sql-tests/results/try_element_at.sql.out | 64 +
.../native/stringCastAndExpressions.sql.out | 279 ++
.../sql-tests/results/udf/udf-group-by.sql.out | 0
.../sql-tests/results/url-functions.sql.out | 120 +
.../sql-tests/results/window.sql.out | 1416 ++++++++
.../ClickHouseSQLQueryTestSettings.scala | 10 +-
.../utils/velox/VeloxSQLQueryTestSettings.scala | 173 +-
.../apache/spark/sql/GlutenSQLQueryTestSuite.scala | 32 +-
91 files changed, 21965 insertions(+), 103 deletions(-)
diff --git a/cpp/velox/substrait/SubstraitToVeloxExpr.cc b/cpp/velox/substrait/SubstraitToVeloxExpr.cc
index fb4861e4fe..eb75306ff6 100755
--- a/cpp/velox/substrait/SubstraitToVeloxExpr.cc
+++ b/cpp/velox/substrait/SubstraitToVeloxExpr.cc
@@ -298,13 +298,14 @@ core::TypedExprPtr SubstraitVeloxExprConverter::toVeloxExpr(
if (veloxFunction == "lambdafunction") {
return toLambdaExpr(substraitFunc, inputType);
- } else if (veloxFunction == "namedlambdavariable") {
+ }
+ if (veloxFunction == "namedlambdavariable") {
return makeFieldAccessExpr(substraitFunc.arguments(0).value().literal().string(), outputType, nullptr);
- } else if (veloxFunction == "extract") {
+ }
+ if (veloxFunction == "extract") {
return toExtractExpr(std::move(params), outputType);
- } else {
- return std::make_shared<const core::CallTypedExpr>(outputType, std::move(params), veloxFunction);
}
+ return std::make_shared<const core::CallTypedExpr>(outputType, std::move(params), veloxFunction);
}
std::shared_ptr<const core::ConstantTypedExpr> SubstraitVeloxExprConverter::literalsToConstantExpr(
@@ -379,11 +380,11 @@ std::shared_ptr<const core::ConstantTypedExpr> SubstraitVeloxExprConverter::toVe
auto veloxType = SubstraitParser::parseType(substraitLit.null());
if (veloxType->isShortDecimal()) {
return std::make_shared<core::ConstantTypedExpr>(veloxType, variant::null(TypeKind::BIGINT));
- } else if (veloxType->isLongDecimal()) {
+ }
+ if (veloxType->isLongDecimal()) {
return std::make_shared<core::ConstantTypedExpr>(veloxType, variant::null(TypeKind::HUGEINT));
- } else {
- return std::make_shared<core::ConstantTypedExpr>(veloxType, variant::null(veloxType->kind()));
}
+ return std::make_shared<core::ConstantTypedExpr>(veloxType, variant::null(veloxType->kind()));
}
default:
auto veloxType = getScalarType(substraitLit);
diff --git a/gluten-ut/common/src/test/scala/org/apache/gluten/utils/SQLQueryTestSettings.scala b/gluten-ut/common/src/test/scala/org/apache/gluten/utils/SQLQueryTestSettings.scala
index 3c2da2b1f8..fa88192e23 100644
--- a/gluten-ut/common/src/test/scala/org/apache/gluten/utils/SQLQueryTestSettings.scala
+++ b/gluten-ut/common/src/test/scala/org/apache/gluten/utils/SQLQueryTestSettings.scala
@@ -17,6 +17,8 @@
package org.apache.gluten.utils
trait SQLQueryTestSettings {
+ def getResourceFilePath: String
+
def getSupportedSQLQueryTests: Set[String]
def getOverwriteSQLQueryTests: Set[String]
diff --git a/gluten-ut/spark32/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala b/gluten-ut/spark32/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala
index 5d420ff19f..d3c65f9480 100644
--- a/gluten-ut/spark32/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala
+++ b/gluten-ut/spark32/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala
@@ -19,6 +19,9 @@ package org.apache.gluten.utils.clickhouse
import org.apache.gluten.utils.SQLQueryTestSettings
object ClickHouseSQLQueryTestSettings extends SQLQueryTestSettings {
+ override def getResourceFilePath: String =
+ getClass.getResource("/").getPath + "../../../src/test/resources/sql-tests"
+
override def getSupportedSQLQueryTests: Set[String] = Set()
override def getOverwriteSQLQueryTests: Set[String] = Set()
diff --git a/gluten-ut/spark32/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala b/gluten-ut/spark32/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala
index 739cb44e3b..0d16d72e1f 100644
--- a/gluten-ut/spark32/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala
+++ b/gluten-ut/spark32/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala
@@ -19,6 +19,9 @@ package org.apache.gluten.utils.velox
import org.apache.gluten.utils.SQLQueryTestSettings
object VeloxSQLQueryTestSettings extends SQLQueryTestSettings {
+ override def getResourceFilePath: String =
+ getClass.getResource("/").getPath + "../../../src/test/resources/sql-tests"
+
override def getSupportedSQLQueryTests: Set[String] = SUPPORTED_SQL_QUERY_LIST
override def getOverwriteSQLQueryTests: Set[String] = OVERWRITE_SQL_QUERY_LIST
diff --git a/gluten-ut/spark33/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala b/gluten-ut/spark33/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala
index 5d420ff19f..d3c65f9480 100644
--- a/gluten-ut/spark33/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala
+++ b/gluten-ut/spark33/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala
@@ -19,6 +19,9 @@ package org.apache.gluten.utils.clickhouse
import org.apache.gluten.utils.SQLQueryTestSettings
object ClickHouseSQLQueryTestSettings extends SQLQueryTestSettings {
+ override def getResourceFilePath: String =
+ getClass.getResource("/").getPath + "../../../src/test/resources/sql-tests"
+
override def getSupportedSQLQueryTests: Set[String] = Set()
override def getOverwriteSQLQueryTests: Set[String] = Set()
diff --git a/gluten-ut/spark33/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala b/gluten-ut/spark33/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala
index d4004b6424..182005437d 100644
--- a/gluten-ut/spark33/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala
+++ b/gluten-ut/spark33/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala
@@ -19,6 +19,9 @@ package org.apache.gluten.utils.velox
import org.apache.gluten.utils.SQLQueryTestSettings
object VeloxSQLQueryTestSettings extends SQLQueryTestSettings {
+ override def getResourceFilePath: String =
+ getClass.getResource("/").getPath + "../../../src/test/resources/sql-tests"
+
override def getSupportedSQLQueryTests: Set[String] = SUPPORTED_SQL_QUERY_LIST
override def getOverwriteSQLQueryTests: Set[String] = OVERWRITE_SQL_QUERY_LIST
diff --git a/gluten-ut/spark34/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala b/gluten-ut/spark34/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala
index 5d420ff19f..d3c65f9480 100644
--- a/gluten-ut/spark34/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala
+++ b/gluten-ut/spark34/src/test/scala/org/apache/gluten/utils/clickhouse/ClickHouseSQLQueryTestSettings.scala
@@ -19,6 +19,9 @@ package org.apache.gluten.utils.clickhouse
import org.apache.gluten.utils.SQLQueryTestSettings
object ClickHouseSQLQueryTestSettings extends SQLQueryTestSettings {
+ override def getResourceFilePath: String =
+ getClass.getResource("/").getPath + "../../../src/test/resources/sql-tests"
+
override def getSupportedSQLQueryTests: Set[String] = Set()
override def getOverwriteSQLQueryTests: Set[String] = Set()
diff --git a/gluten-ut/spark34/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala b/gluten-ut/spark34/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala
index d49e9ccc66..c9dc0020ca 100644
--- a/gluten-ut/spark34/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala
+++ b/gluten-ut/spark34/src/test/scala/org/apache/gluten/utils/velox/VeloxSQLQueryTestSettings.scala
@@ -19,6 +19,9 @@ package org.apache.gluten.utils.velox
import org.apache.gluten.utils.SQLQueryTestSettings
object VeloxSQLQueryTestSettings extends SQLQueryTestSettings {
+ override def getResourceFilePath: String =
+ getClass.getResource("/").getPath + "../../../src/test/resources/sql-tests"
+
override def getSupportedSQLQueryTests: Set[String] = SUPPORTED_SQL_QUERY_LIST
override def getOverwriteSQLQueryTests: Set[String] = OVERWRITE_SQL_QUERY_LIST
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/group-by-ordinal.sql b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by-ordinal.sql
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/inputs/group-by-ordinal.sql
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by-ordinal.sql
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/group-by.sql b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by.sql
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/inputs/group-by.sql
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by.sql
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/linear-regression.sql b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/linear-regression.sql
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/inputs/linear-regression.sql
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/linear-regression.sql
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/misc-functions.sql b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/misc-functions.sql
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/inputs/misc-functions.sql
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/misc-functions.sql
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/random.sql b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/random.sql
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/inputs/random.sql
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/random.sql
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/table-valued-functions.sql b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/table-valued-functions.sql
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/inputs/table-valued-functions.sql
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/table-valued-functions.sql
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/udf/udf-group-by.sql b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/udf/udf-group-by.sql
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/inputs/udf/udf-group-by.sql
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/inputs/udf/udf-group-by.sql
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/results/group-by-ordinal.sql.out b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/group-by-ordinal.sql.out
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/results/group-by-ordinal.sql.out
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/group-by-ordinal.sql.out
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/results/group-by.sql.out b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/group-by.sql.out
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/results/group-by.sql.out
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/group-by.sql.out
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/results/linear-regression.sql.out b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/linear-regression.sql.out
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/results/linear-regression.sql.out
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/linear-regression.sql.out
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/results/misc-functions.sql.out b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/misc-functions.sql.out
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/results/misc-functions.sql.out
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/misc-functions.sql.out
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/results/random.sql.out b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/random.sql.out
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/results/random.sql.out
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/random.sql.out
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/results/table-valued-functions.sql.out b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/table-valued-functions.sql.out
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/results/table-valued-functions.sql.out
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/table-valued-functions.sql.out
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/results/udf/udf-group-by.sql.out b/gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/udf/udf-group-by.sql.out
similarity index 100%
copy from gluten-ut/spark35/src/test/resources/sql-tests/results/udf/udf-group-by.sql.out
copy to gluten-ut/spark35/src/test/resources/backends-clickhouse/sql-tests/results/udf/udf-group-by.sql.out
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/array.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/array.sql
new file mode 100644
index 0000000000..865dc8bac4
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/array.sql
@@ -0,0 +1,183 @@
+-- test cases for array functions
+
+create temporary view data as select * from values
+ ("one", array(11, 12, 13), array(array(111, 112, 113), array(121, 122, 123))),
+ ("two", array(21, 22, 23), array(array(211, 212, 213), array(221, 222, 223)))
+ as data(a, b, c);
+
+select * from data;
+
+-- index into array
+select a, b[0], b[0] + b[1] from data;
+
+-- index into array of arrays
+select a, c[0][0] + c[0][0 + 1] from data;
+
+
+create temporary view primitive_arrays as select * from values (
+ array(true),
+ array(2Y, 1Y),
+ array(2S, 1S),
+ array(2, 1),
+ array(2L, 1L),
+ array(9223372036854775809, 9223372036854775808),
+ array(2.0D, 1.0D),
+ array(float(2.0), float(1.0)),
+ array(date '2016-03-14', date '2016-03-13'),
+ array(timestamp '2016-11-15 20:54:00.000', timestamp '2016-11-12 20:54:00.000')
+) as primitive_arrays(
+ boolean_array,
+ tinyint_array,
+ smallint_array,
+ int_array,
+ bigint_array,
+ decimal_array,
+ double_array,
+ float_array,
+ date_array,
+ timestamp_array
+);
+
+select * from primitive_arrays;
+
+-- array_contains on all primitive types: result should alternate between true and false
+select
+ array_contains(boolean_array, true), array_contains(boolean_array, false),
+ array_contains(tinyint_array, 2Y), array_contains(tinyint_array, 0Y),
+ array_contains(smallint_array, 2S), array_contains(smallint_array, 0S),
+ array_contains(int_array, 2), array_contains(int_array, 0),
+ array_contains(bigint_array, 2L), array_contains(bigint_array, 0L),
+ array_contains(decimal_array, 9223372036854775809), array_contains(decimal_array, 1),
+ array_contains(double_array, 2.0D), array_contains(double_array, 0.0D),
+ array_contains(float_array, float(2.0)), array_contains(float_array, float(0.0)),
+ array_contains(date_array, date '2016-03-14'), array_contains(date_array, date '2016-01-01'),
+ array_contains(timestamp_array, timestamp '2016-11-15 20:54:00.000'), array_contains(timestamp_array, timestamp '2016-01-01 20:54:00.000')
+from primitive_arrays;
+
+-- array_contains on nested arrays
+select array_contains(b, 11), array_contains(c, array(111, 112, 113)) from data;
+
+-- sort_array
+select
+ sort_array(boolean_array),
+ sort_array(tinyint_array),
+ sort_array(smallint_array),
+ sort_array(int_array),
+ sort_array(bigint_array),
+ sort_array(decimal_array),
+ sort_array(double_array),
+ sort_array(float_array),
+ sort_array(date_array),
+ sort_array(timestamp_array)
+from primitive_arrays;
+
+-- sort_array with an invalid string literal for the argument of sort order.
+select sort_array(array('b', 'd'), '1');
+
+-- sort_array with an invalid null literal casted as boolean for the argument of sort order.
+select sort_array(array('b', 'd'), cast(NULL as boolean));
+
+-- size
+select
+ size(boolean_array),
+ size(tinyint_array),
+ size(smallint_array),
+ size(int_array),
+ size(bigint_array),
+ size(decimal_array),
+ size(double_array),
+ size(float_array),
+ size(date_array),
+ size(timestamp_array)
+from primitive_arrays;
+
+-- index out of range for array elements
+select element_at(array(1, 2, 3), 5);
+select element_at(array(1, 2, 3), -5);
+select element_at(array(1, 2, 3), 0);
+
+select elt(4, '123', '456');
+select elt(0, '123', '456');
+select elt(-1, '123', '456');
+select elt(null, '123', '456');
+select elt(null, '123', null);
+select elt(1, '123', null);
+select elt(2, '123', null);
+
+select array(1, 2, 3)[5];
+select array(1, 2, 3)[-1];
+
+-- array_size
+select array_size(array());
+select array_size(array(true));
+select array_size(array(2, 1));
+select array_size(NULL);
+select array_size(map('a', 1, 'b', 2));
+
+-- size(arrays_zip)
+select size(arrays_zip(array(1, 2, 3), array(4), array(7, 8, 9, 10)));
+select size(arrays_zip(array(), array(1, 2, 3), array(4), array(7, 8, 9, 10)));
+select size(arrays_zip(array(1, 2, 3), array(4), null, array(7, 8, 9, 10)));
+
+-- isnotnull(arrays_zip)
+select isnotnull(arrays_zip(array(), array(4), array(7, 8, 9, 10)));
+select isnotnull(arrays_zip(array(1, 2, 3), array(4), array(7, 8, 9, 10)));
+select isnotnull(arrays_zip(array(1, 2, 3), NULL, array(4), array(7, 8, 9, 10)));
+
+-- function get()
+select get(array(1, 2, 3), 0);
+select get(array(1, 2, 3), 3);
+select get(array(1, 2, 3), null);
+select get(array(1, 2, 3), -1);
+
+-- function array_insert()
+select array_insert(array(1, 2, 3), 3, 4);
+select array_insert(array(2, 3, 4), 0, 1);
+select array_insert(array(2, 3, 4), 1, 1);
+select array_insert(array(1, 3, 4), -2, 2);
+select array_insert(array(1, 2, 3), 3, "4");
+select array_insert(cast(NULL as ARRAY<INT>), 1, 1);
+select array_insert(array(1, 2, 3, NULL), cast(NULL as INT), 4);
+select array_insert(array(1, 2, 3, NULL), 4, cast(NULL as INT));
+select array_insert(array(2, 3, NULL, 4), 5, 5);
+select array_insert(array(2, 3, NULL, 4), -5, 1);
+select array_insert(array(1), 2, cast(2 as tinyint));
+
+set spark.sql.legacy.negativeIndexInArrayInsert=true;
+select array_insert(array(1, 3, 4), -2, 2);
+select array_insert(array(2, 3, NULL, 4), -5, 1);
+set spark.sql.legacy.negativeIndexInArrayInsert=false;
+
+-- function array_compact
+select array_compact(id) from values (1) as t(id);
+select array_compact(array("1", null, "2", null));
+select array_compact(array("a", "b", "c"));
+select array_compact(array(1D, null, 2D, null));
+select array_compact(array(array(1, 2, 3, null), null, array(4, null, 6)));
+select array_compact(array(null));
+
+-- function array_append
+select array_append(array(1, 2, 3), 4);
+select array_append(array('a', 'b', 'c'), 'd');
+select array_append(array(1, 2, 3, NULL), NULL);
+select array_append(array('a', 'b', 'c', NULL), NULL);
+select array_append(CAST(null AS ARRAY<String>), 'a');
+select array_append(CAST(null AS ARRAY<String>), CAST(null as String));
+select array_append(array(), 1);
+select array_append(CAST(array() AS ARRAY<String>), CAST(NULL AS String));
+select array_append(array(CAST(NULL AS String)), CAST(NULL AS String));
+
+-- function array_prepend
+select array_prepend(array(1, 2, 3), 4);
+select array_prepend(array('a', 'b', 'c'), 'd');
+select array_prepend(array(1, 2, 3, NULL), NULL);
+select array_prepend(array('a', 'b', 'c', NULL), NULL);
+select array_prepend(CAST(null AS ARRAY<String>), 'a');
+select array_prepend(CAST(null AS ARRAY<String>), CAST(null as String));
+select array_prepend(array(), 1);
+select array_prepend(CAST(array() AS ARRAY<String>), CAST(NULL AS String));
+select array_prepend(array(CAST(NULL AS String)), CAST(NULL AS String));
+
+-- SPARK-45599: Confirm 0.0, -0.0, and NaN are handled appropriately.
+select array_union(array(0.0, -0.0, DOUBLE("NaN")), array(0.0, -0.0, DOUBLE("NaN")));
+select array_distinct(array(0.0, -0.0, -0.0, DOUBLE("NaN"), DOUBLE("NaN")));
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/bitwise.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/bitwise.sql
new file mode 100644
index 0000000000..f9dfd161d0
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/bitwise.sql
@@ -0,0 +1,77 @@
+-- test cases for bitwise functions
+
+-- null
+select bit_count(null);
+
+-- boolean
+select bit_count(true);
+select bit_count(false);
+
+-- byte/tinyint
+select bit_count(cast(1 as tinyint));
+select bit_count(cast(2 as tinyint));
+select bit_count(cast(3 as tinyint));
+
+-- short/smallint
+select bit_count(1S);
+select bit_count(2S);
+select bit_count(3S);
+
+-- int
+select bit_count(1);
+select bit_count(2);
+select bit_count(3);
+
+-- long/bigint
+select bit_count(1L);
+select bit_count(2L);
+select bit_count(3L);
+
+-- negative num
+select bit_count(-1L);
+
+-- edge value
+select bit_count(9223372036854775807L);
+select bit_count(-9223372036854775808L);
+
+-- other illegal arguments
+select bit_count("bit count");
+select bit_count('a');
+
+-- test for bit_xor
+--
+CREATE OR REPLACE TEMPORARY VIEW bitwise_test AS SELECT * FROM VALUES
+ (1, 1, 1, 1L),
+ (2, 3, 4, null),
+ (7, 7, 7, 3L) AS bitwise_test(b1, b2, b3, b4);
+
+-- empty case
+SELECT BIT_XOR(b3) AS n1 FROM bitwise_test where 1 = 0;
+
+-- null case
+SELECT BIT_XOR(b4) AS n1 FROM bitwise_test where b4 is null;
+
+-- the suffix numbers show the expected answer
+SELECT
+ BIT_XOR(cast(b1 as tinyint)) AS a4,
+ BIT_XOR(cast(b2 as smallint)) AS b5,
+ BIT_XOR(b3) AS c2,
+ BIT_XOR(b4) AS d2,
+ BIT_XOR(distinct b4) AS e2
+FROM bitwise_test;
+
+-- group by
+SELECT bit_xor(b3) FROM bitwise_test GROUP BY b1 & 1;
+
+--having
+SELECT b1, bit_xor(b2) FROM bitwise_test GROUP BY b1 HAVING bit_and(b2) < 7;
+
+-- window
+SELECT b1, b2, bit_xor(b2) OVER (PARTITION BY b1 ORDER BY b2) FROM bitwise_test;
+
+-- getbit
+select getbit(11L, 3), getbit(11L, 2), getbit(11L, 1), getbit(11L, 0);
+select getbit(11L, 2 + 1), getbit(11L, 3 - 1), getbit(10L + 1, 1 * 1), getbit(cast(11L / 1 AS long), 1 - 1);
+select getbit(11L, 63);
+select getbit(11L, -1);
+select getbit(11L, 64);
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/charvarchar.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/charvarchar.sql
new file mode 100644
index 0000000000..3b8ffcff18
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/charvarchar.sql
@@ -0,0 +1,130 @@
+create table char_tbl(c char(5), v varchar(6)) using parquet;
+desc formatted char_tbl;
+desc formatted char_tbl c;
+show create table char_tbl;
+
+create table char_tbl2 using parquet as select * from char_tbl;
+show create table char_tbl2;
+desc formatted char_tbl2;
+desc formatted char_tbl2 c;
+
+create table char_tbl3 like char_tbl;
+desc formatted char_tbl3;
+desc formatted char_tbl3 c;
+show create table char_tbl3;
+
+create view char_view as select * from char_tbl;
+desc formatted char_view;
+desc formatted char_view c;
+show create table char_view;
+
+alter table char_tbl rename to char_tbl1;
+desc formatted char_tbl1;
+
+alter table char_tbl1 change column c type char(6);
+alter table char_tbl1 change column c type char(5);
+desc formatted char_tbl1;
+
+alter table char_tbl1 add columns (d char(5));
+desc formatted char_tbl1;
+
+alter view char_view as select * from char_tbl2;
+desc formatted char_view;
+
+alter table char_tbl1 SET TBLPROPERTIES('yes'='no');
+desc formatted char_tbl1;
+
+alter view char_view SET TBLPROPERTIES('yes'='no');
+desc formatted char_view;
+
+alter table char_tbl1 UNSET TBLPROPERTIES('yes');
+desc formatted char_tbl1;
+
+alter view char_view UNSET TBLPROPERTIES('yes');
+desc formatted char_view;
+
+alter table char_tbl1 SET SERDEPROPERTIES('yes'='no');
+desc formatted char_tbl1;
+
+create table char_part(c1 char(5), c2 char(2), v1 varchar(6), v2 varchar(2)) using parquet partitioned by (v2, c2);
+desc formatted char_part;
+
+alter table char_part add partition (v2='ke', c2='nt') location 'loc1';
+desc formatted char_part;
+
+alter table char_part partition (v2='ke') rename to partition (v2='nt');
+desc formatted char_part;
+
+alter table char_part partition (v2='ke', c2='nt') set location 'loc2';
+desc formatted char_part;
+
+MSCK REPAIR TABLE char_part;
+desc formatted char_part;
+
+create temporary view str_view as select c, v from values
+ (null, null),
+ (null, 'S'),
+ ('N', 'N '),
+ ('Ne', 'Sp'),
+ ('Net ', 'Spa '),
+ ('NetE', 'Spar'),
+ ('NetEa ', 'Spark '),
+ ('NetEas ', 'Spark'),
+ ('NetEase', 'Spark-') t(c, v);
+
+create table char_tbl4(c7 char(7), c8 char(8), v varchar(6), s string) using parquet;
+insert into char_tbl4 select c, c, v, c from str_view;
+
+select c7, c8, v, s from char_tbl4;
+select c7, c8, v, s from char_tbl4 where c7 = c8;
+select c7, c8, v, s from char_tbl4 where c7 = v;
+select c7, c8, v, s from char_tbl4 where c7 = s;
+select c7, c8, v, s from char_tbl4 where c7 = 'NetEase ';
+select c7, c8, v, s from char_tbl4 where v = 'Spark ';
+select c7, c8, v, s from char_tbl4 order by c7;
+select c7, c8, v, s from char_tbl4 order by v;
+
+select ascii(c7), ascii(c8), ascii(v), ascii(s) from char_tbl4;
+select base64(c7), base64(c8), base64(v), ascii(s) from char_tbl4;
+select bit_length(c7), bit_length(c8), bit_length(v), bit_length(s) from char_tbl4;
+select char_length(c7), char_length(c8), char_length(v), char_length(s) from char_tbl4;
+select octet_length(c7), octet_length(c8), octet_length(v), octet_length(s) from char_tbl4;
+select concat_ws('|', c7, c8), concat_ws('|', c7, v), concat_ws('|', c7, s), concat_ws('|', v, s) from char_tbl4;
+select concat(c7, c8), concat(c7, v), concat(c7, s), concat(v, s) from char_tbl4;
+select like(c7, 'Ne _'), like(c8, 'Ne _') from char_tbl4;
+select like(v, 'Spark_') from char_tbl4;
+select c7 = c8, upper(c7) = upper(c8), lower(c7) = lower(c8) from char_tbl4 where s = 'NetEase';
+select c7 = s, upper(c7) = upper(s), lower(c7) = lower(s) from char_tbl4 where s = 'NetEase';
+select c7 = 'NetEase', upper(c7) = upper('NetEase'), lower(c7) = lower('NetEase') from char_tbl4 where s = 'NetEase';
+select printf('Hey, %s%s%s%s', c7, c8, v, s) from char_tbl4;
+select repeat(c7, 2), repeat(c8, 2), repeat(v, 2), repeat(s, 2) from char_tbl4;
+select replace(c7, 'Net', 'Apache'), replace(c8, 'Net', 'Apache'), replace(v, 'Spark', 'Kyuubi'), replace(s, 'Net', 'Apache') from char_tbl4;
+select rpad(c7, 10), rpad(c8, 5), rpad(v, 5), rpad(s, 5) from char_tbl4;
+select rtrim(c7), rtrim(c8), rtrim(v), rtrim(s) from char_tbl4;
+select split(c7, 'e'), split(c8, 'e'), split(v, 'a'), split(s, 'e') from char_tbl4;
+select substring(c7, 2), substring(c8, 2), substring(v, 3), substring(s, 2) from char_tbl4;
+select left(c7, 2), left(c8, 2), left(v, 3), left(s, 2) from char_tbl4;
+select right(c7, 2), right(c8, 2), right(v, 3), right(s, 2) from char_tbl4;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+select typeof(c7), typeof(c8), typeof(v), typeof(s) from char_tbl4 limit 1;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+select cast(c7 as char(1)), cast(c8 as char(10)), cast(v as char(1)), cast(v as varchar(1)), cast(s as char(5)) from char_tbl4;
+
+-- char_tbl has renamed to char_tbl1
+drop table char_tbl1;
+drop table char_tbl2;
+drop table char_tbl3;
+drop table char_tbl4;
+
+-- ascii value for Latin-1 Supplement characters
+select ascii('§'), ascii('÷'), ascii('×10');
+select chr(167), chr(247), chr(215);
+
+-- to_varchar is an alias for to_char
+SELECT to_varchar(78.12, '$99.99');
+SELECT to_varchar(111.11, '99.9');
+SELECT to_varchar(12454.8, '99,999.9S');
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/count.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/count.sql
new file mode 100644
index 0000000000..3e673f9581
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/count.sql
@@ -0,0 +1,57 @@
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (1, 1), (null, 2), (1, null), (null, null)
+AS testData(a, b);
+
+-- count with single expression
+SELECT
+ count(*), count(1), count(null), count(a), count(b), count(a + b), count((a, b))
+FROM testData;
+
+-- distinct count with single expression
+SELECT
+ count(DISTINCT 1),
+ count(DISTINCT null),
+ count(DISTINCT a),
+ count(DISTINCT b),
+ count(DISTINCT (a + b)),
+ count(DISTINCT (a, b))
+FROM testData;
+
+-- count with multiple expressions
+SELECT count(a, b), count(b, a), count(testData.*, testData.*) FROM testData;
+
+-- distinct count with multiple expressions
+SELECT
+ count(DISTINCT a, b), count(DISTINCT b, a), count(DISTINCT *), count(DISTINCT testData.*, testData.*)
+FROM testData;
+
+-- distinct count with multiple literals
+SELECT count(DISTINCT 3,2);
+SELECT count(DISTINCT 2), count(DISTINCT 2,3);
+SELECT count(DISTINCT 2), count(DISTINCT 3,2);
+SELECT count(DISTINCT a), count(DISTINCT 2,3) FROM testData;
+SELECT count(DISTINCT a), count(DISTINCT 3,2) FROM testData;
+SELECT count(DISTINCT a), count(DISTINCT 2), count(DISTINCT 2,3) FROM testData;
+SELECT count(DISTINCT a), count(DISTINCT 2), count(DISTINCT 3,2) FROM testData;
+SELECT count(distinct 0.8), percentile_approx(distinct a, 0.8) FROM testData;
+
+-- legacy behavior: allow calling function count without parameters
+set spark.sql.legacy.allowParameterlessCount=true;
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding;
+
+SELECT count() FROM testData;
+
+-- count without expressions
+set spark.sql.legacy.allowParameterlessCount=false;
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+SELECT count() FROM testData;
+
+-- legacy behavior: allow count(testData.*)
+set spark.sql.legacy.allowStarWithSingleTableIdentifierInCount=true;
+SELECT count(testData.*) FROM testData;
+
+-- count with a single tblName.* as parameter
+set spark.sql.legacy.allowStarWithSingleTableIdentifierInCount=false;
+SELECT count(testData.*) FROM testData;
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/cte.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/cte.sql
new file mode 100644
index 0000000000..ca88bbd42f
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/cte.sql
@@ -0,0 +1,181 @@
+create temporary view t as select * from values 0, 1, 2 as t(id);
+create temporary view t2 as select * from values 0, 1 as t(id);
+
+-- WITH clause should not fall into infinite loop by referencing self
+WITH s AS (SELECT 1 FROM s) SELECT * FROM s;
+
+WITH r AS (SELECT (SELECT * FROM r))
+SELECT * FROM r;
+
+-- WITH clause should reference the base table
+WITH t AS (SELECT 1 FROM t) SELECT * FROM t;
+
+-- WITH clause should not allow cross reference
+WITH s1 AS (SELECT 1 FROM s2), s2 AS (SELECT 1 FROM s1) SELECT * FROM s1, s2;
+
+-- WITH clause should reference the previous CTE
+WITH t1 AS (SELECT * FROM t2), t2 AS (SELECT 2 FROM t1) SELECT * FROM t1 cross join t2;
+
+-- SPARK-18609 CTE with self-join
+WITH CTE1 AS (
+ SELECT b.id AS id
+ FROM T2 a
+ CROSS JOIN (SELECT id AS id FROM T2) b
+)
+SELECT t1.id AS c1,
+ t2.id AS c2
+FROM CTE1 t1
+ CROSS JOIN CTE1 t2;
+
+-- CTE with column alias
+WITH t(x) AS (SELECT 1)
+SELECT * FROM t WHERE x = 1;
+
+-- CTE with multiple column aliases
+WITH t(x, y) AS (SELECT 1, 2)
+SELECT * FROM t WHERE x = 1 AND y = 2;
+
+-- CTE with duplicate column aliases
+WITH t(x, x) AS (SELECT 1, 2)
+SELECT * FROM t;
+
+-- CTE with empty column alias list is not allowed
+WITH t() AS (SELECT 1)
+SELECT * FROM t;
+
+-- CTEs with duplicate names are not allowed
+WITH
+ t(x) AS (SELECT 1),
+ t(x) AS (SELECT 2)
+SELECT * FROM t;
+
+-- invalid CTE relation should fail the query even if it's not referenced
+WITH t AS (SELECT 1 FROM non_existing_table)
+SELECT 2;
+
+-- The following tests are ported from Postgres
+-- Multiple uses are evaluated only once
+SELECT count(*) FROM (
+ WITH q1(x) AS (SELECT random() FROM range(1, 5))
+ SELECT * FROM q1
+ UNION
+ SELECT * FROM q1
+) ss;
+
+-- Deeply nested
+WITH w1(c1) AS
+ (WITH w2(c2) AS
+ (WITH w3(c3) AS
+ (WITH w4(c4) AS
+ (WITH w5(c5) AS
+ (WITH w6(c6) AS
+ (WITH w7(c7) AS
+ (WITH w8(c8) AS
+ (SELECT 1)
+ SELECT * FROM w8)
+ SELECT * FROM w7)
+ SELECT * FROM w6)
+ SELECT * FROM w5)
+ SELECT * FROM w4)
+ SELECT * FROM w3)
+ SELECT * FROM w2)
+SELECT * FROM w1;
+
+-- CTE referencing an outer-level variable, should fail
+SELECT ( WITH cte(foo) AS ( VALUES(id) )
+ SELECT (SELECT foo FROM cte) )
+FROM t;
+
+-- CTE name collision with subquery name
+WITH same_name AS (SELECT 42)
+SELECT * FROM same_name, (SELECT 10) AS same_name;
+
+-- CTE name collision with subquery name, should fail
+WITH same_name(x) AS (SELECT 42)
+SELECT same_name.x FROM (SELECT 10) AS same_name(x), same_name;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+-- Test behavior with an unknown-type literal in the WITH
+WITH q AS (SELECT 'foo' AS x)
+SELECT x, typeof(x) FROM q;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+-- The following tests are ported from ZetaSQL
+-- Alias inside the with hides the underlying column name, should fail
+with cte as (select id as id_alias from t)
+select id from cte;
+
+-- Reference of later WITH, should fail.
+with r1 as (select * from r2),
+ r2 as (select 1)
+select 2;
+
+-- WITH in a table subquery
+SELECT * FROM
+ (WITH q AS (select 1 x) SELECT x+1 AS y FROM q);
+
+-- WITH in an expression subquery
+select (with q as (select 1 x) select * from q);
+
+-- WITH in an IN subquery
+select 1 in (with q as (select 1) select * from q);
+
+-- WITH alias referenced outside its scope, should fail
+SELECT * FROM
+ (WITH q AS (select 1 x) SELECT x+1 AS y FROM q),
+ q;
+
+-- References to CTEs of the same name should be resolved properly
+WITH T1 as (select 1 a)
+select *
+from
+ T1 x,
+ (WITH T1 as (select 2 b) select * from T1) y,
+ T1 z;
+
+-- References to CTEs of the same name should be resolved properly
+WITH TTtt as (select 1 a),
+ `tTTt_2` as (select 2 a)
+select *
+from
+ (WITH TtTt as (select 3 c) select * from ttTT, `tttT_2`);
+
+-- Correlated CTE subquery
+select
+ (WITH q AS (select T.x) select * from q)
+from (select 1 x, 2 y) T;
+
+-- The main query inside WITH can be correlated.
+select
+ (WITH q AS (select 3 z) select x + t.y + z from q)
+from (select 1 x, 2 y) T;
+
+-- A WITH subquery alias is visible inside a WITH clause subquery.
+WITH q1 as (select 1 x)
+select * from
+ (with q2 as (select * from q1) select * from q2);
+
+-- A WITH subquery alias is visible inside a WITH clause subquery, and they have the same name.
+WITH q1 as (select 1 x)
+select * from
+ (with q1 as (select x+1 from q1) select * from q1);
+
+-- The following tests are ported from DuckDB
+-- Duplicate CTE alias, should fail
+with cte1 as (select 42), cte1 as (select 42) select * FROM cte1;
+
+-- Refer to CTE in subquery
+with cte1 as (Select id as j from t)
+select * from cte1 where j = (select max(j) from cte1 as cte2);
+
+-- Nested CTE views that re-use CTE aliases
+with cte AS (SELECT * FROM va) SELECT * FROM cte;
+
+-- Self-refer to non-existent cte, should fail.
+with cte as (select * from cte) select * from cte;
+
+-- Clean up
+DROP VIEW IF EXISTS t;
+DROP VIEW IF EXISTS t2;
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/date.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/date.sql
new file mode 100644
index 0000000000..c1ae432d63
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/date.sql
@@ -0,0 +1,168 @@
+-- date literals, functions and operations
+
+create temporary view date_view as select '2011-11-11' date_str, '1' int_str;
+
+select date '2019-01-01\t';
+select date '2020-01-01中文';
+
+select make_date(2019, 1, 1), make_date(12, 12, 12);
+-- invalid month
+select make_date(2000, 13, 1);
+-- invalid day
+select make_date(2000, 1, 33);
+
+-- invalid: year field must have at least 4 digits
+select date'015';
+-- invalid: month field can have at most 2 digits
+select date'2021-4294967297-11';
+
+select current_date = current_date;
+-- under ANSI mode, `current_date` can't be a function name.
+select current_date() = current_date();
+select curdate(1);
+
+-- conversions between date and unix_date (number of days from epoch)
+select DATE_FROM_UNIX_DATE(0), DATE_FROM_UNIX_DATE(1000), DATE_FROM_UNIX_DATE(null);
+select UNIX_DATE(DATE('1970-01-01')), UNIX_DATE(DATE('2020-12-04')), UNIX_DATE(null);
+
+select to_date(null), to_date('2016-12-31'), to_date('2016-12-31', 'yyyy-MM-dd');
+
+-- `dayofweek` accepts both date and timestamp ltz/ntz inputs.
+select dayofweek('2007-02-03'), dayofweek('2009-07-30'), dayofweek('2017-05-27'), dayofweek(null),
+ dayofweek('1582-10-15 13:10:15'), dayofweek(timestamp_ltz'1582-10-15 13:10:15'), dayofweek(timestamp_ntz'1582-10-15 13:10:15');
+
+-- `weekday` accepts both date and timestamp ltz/ntz inputs.
+select weekday('2007-02-03'), weekday('2009-07-30'), weekday('2017-05-27'), weekday(null),
+ weekday('1582-10-15 13:10:15'), weekday(timestamp_ltz'1582-10-15 13:10:15'), weekday(timestamp_ntz'1582-10-15 13:10:15');
+
+-- `year` accepts both date and timestamp ltz/ntz inputs.
+select year('1500-01-01'), year('1582-10-15 13:10:15'), year(timestamp_ltz'1582-10-15 13:10:15'), year(timestamp_ntz'1582-10-15 13:10:15');
+
+-- `month` accepts both date and timestamp ltz/ntz inputs.
+select month('1500-01-01'), month('1582-10-15 13:10:15'), month(timestamp_ltz'1582-10-15 13:10:15'), month(timestamp_ntz'1582-10-15 13:10:15');
+
+-- `dayOfYear` accepts both date and timestamp ltz/ntz inputs.
+select dayOfYear('1500-01-01'), dayOfYear('1582-10-15 13:10:15'), dayOfYear(timestamp_ltz'1582-10-15 13:10:15'), dayOfYear(timestamp_ntz'1582-10-15 13:10:15');
+
+-- next_day
+select next_day("2015-07-23", "Mon");
+select next_day("2015-07-23", "xx");
+select next_day("2015-07-23 12:12:12", "Mon");
+-- next_date does not accept timestamp lzt/ntz input
+select next_day(timestamp_ltz"2015-07-23 12:12:12", "Mon");
+select next_day(timestamp_ntz"2015-07-23 12:12:12", "Mon");
+select next_day("xx", "Mon");
+select next_day(null, "Mon");
+select next_day(null, "xx");
+
+-- date add
+select date_add(date'2011-11-11', 1);
+select date_add('2011-11-11', 1);
+select date_add('2011-11-11', 1Y);
+select date_add('2011-11-11', 1S);
+-- invalid cases: the second parameter can only be byte/short/int
+select date_add('2011-11-11', 1L);
+select date_add('2011-11-11', 1.0);
+select date_add('2011-11-11', 1E1);
+-- the second parameter can be a string literal if it can be parsed to int
+select date_add('2011-11-11', '1');
+select date_add('2011-11-11', '1.2');
+-- null input leads to null result.
+select date_add(null, 1);
+select date_add(date'2011-11-11', null);
+-- `date_add` accepts both date and timestamp ltz/ntz inputs (non-ANSI mode).
+select date_add(timestamp_ltz'2011-11-11 12:12:12', 1);
+select date_add(timestamp_ntz'2011-11-11 12:12:12', 1);
+
+-- date sub
+select date_sub(date'2011-11-11', 1);
+select date_sub('2011-11-11', 1);
+select date_sub('2011-11-11', 1Y);
+select date_sub('2011-11-11', 1S);
+-- invalid cases: the second parameter can only be byte/short/int
+select date_sub('2011-11-11', 1L);
+select date_sub('2011-11-11', 1.0);
+select date_sub('2011-11-11', 1E1);
+-- the second parameter can be a string literal if it can be parsed to int
+select date_sub(date'2011-11-11', '1');
+select date_sub(date'2011-11-11', '1.2');
+-- null input leads to null result.
+select date_sub(null, 1);
+select date_sub(date'2011-11-11', null);
+-- `date_sub` accepts both date and timestamp ltz/ntz inputs (non-ANSI mode).
+select date_sub(timestamp_ltz'2011-11-11 12:12:12', 1);
+select date_sub(timestamp_ntz'2011-11-11 12:12:12', 1);
+
+-- date add/sub with non-literal string column
+select date_add('2011-11-11', int_str) from date_view;
+select date_sub('2011-11-11', int_str) from date_view;
+select date_add(date_str, 1) from date_view;
+select date_sub(date_str, 1) from date_view;
+
+-- date +/- number
+select date '2011-11-11' + 1E1;
+select date '2001-09-28' + 7Y;
+select 7S + date '2001-09-28';
+select date '2001-10-01' - 7;
+
+-- date - date
+select date '2001-10-01' - date '2001-09-28';
+-- if one side is string/null literal, promote it to date type.
+select date '2001-10-01' - '2001-09-28';
+select '2001-10-01' - date '2001-09-28';
+select date '2001-09-28' - null;
+select null - date '2019-10-06';
+-- invalid: non-literal string column
+select date_str - date '2001-09-28' from date_view;
+select date '2001-09-28' - date_str from date_view;
+
+-- invalid: date + string literal
+select date'2011-11-11' + '1';
+select '1' + date'2011-11-11';
+
+-- null result: date + null
+select date'2011-11-11' + null;
+select null + date'2011-11-11';
+
+-- date +/- interval and interval + date
+select date '2012-01-01' - interval '2-2' year to month,
+ date '2011-11-11' - interval '2' day,
+ date '2012-01-01' + interval '-2-2' year to month,
+ date '2011-11-11' + interval '-2' month,
+ - interval '2-2' year to month + date '2012-01-01',
+ interval '-2' day + date '2011-11-11';
+
+-- Unsupported narrow text style
+select to_date('26/October/2015', 'dd/MMMMM/yyyy');
+select from_json('{"d":"26/October/2015"}', 'd Date', map('dateFormat', 'dd/MMMMM/yyyy'));
+select from_csv('26/October/2015', 'd Date', map('dateFormat', 'dd/MMMMM/yyyy'));
+
+-- Add a number of units to a timestamp or a date
+select dateadd(MICROSECOND, 1001, timestamp'2022-02-25 01:02:03.123');
+select date_add(MILLISECOND, -1, timestamp'2022-02-25 01:02:03.456');
+select dateadd(SECOND, 58, timestamp'2022-02-25 01:02:03');
+select date_add(MINUTE, -100, date'2022-02-25');
+select dateadd(HOUR, -1, timestamp'2022-02-25 01:02:03');
+select date_add(DAY, 367, date'2022-02-25');
+select dateadd(WEEK, -4, timestamp'2022-02-25 01:02:03');
+select date_add(MONTH, -1, timestamp'2022-02-25 01:02:03');
+select dateadd(QUARTER, 5, date'2022-02-25');
+select date_add(YEAR, 1, date'2022-02-25');
+
+select dateadd('MICROSECOND', 1001, timestamp'2022-02-25 01:02:03.123');
+select date_add('QUARTER', 5, date'2022-02-25');
+
+-- Get the difference between timestamps or dates in the specified units
+select datediff(MICROSECOND, timestamp'2022-02-25 01:02:03.123', timestamp'2022-02-25 01:02:03.124001');
+select date_diff(MILLISECOND, timestamp'2022-02-25 01:02:03.456', timestamp'2022-02-25 01:02:03.455');
+select datediff(SECOND, timestamp'2022-02-25 01:02:03', timestamp'2022-02-25 01:03:01');
+select date_diff(MINUTE, date'2022-02-25', timestamp'2022-02-24 22:20:00');
+select datediff(HOUR, timestamp'2022-02-25 01:02:03', timestamp'2022-02-25 00:02:03');
+select date_diff(DAY, date'2022-02-25', timestamp'2023-02-27 00:00:00');
+select datediff(WEEK, timestamp'2022-02-25 01:02:03', timestamp'2022-01-28 01:02:03');
+select date_diff(MONTH, timestamp'2022-02-25 01:02:03', timestamp'2022-01-25 01:02:03');
+select datediff(QUARTER, date'2022-02-25', date'2023-05-25');
+select date_diff(YEAR, date'2022-02-25', date'2023-02-25');
+
+select date_diff('MILLISECOND', timestamp'2022-02-25 01:02:03.456', timestamp'2022-02-25 01:02:03.455');
+select datediff('YEAR', date'2022-02-25', date'2023-02-25');
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-legacy.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-legacy.sql
new file mode 100644
index 0000000000..22b29f3451
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-legacy.sql
@@ -0,0 +1,3 @@
+--SET spark.sql.legacy.timeParserPolicy=LEGACY
+--IMPORT date.sql
+--IMPORT timestamp.sql
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-invalid.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-invalid.sql
new file mode 100644
index 0000000000..730e5eac1f
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-invalid.sql
@@ -0,0 +1,28 @@
+--- TESTS FOR DATETIME PARSING FUNCTIONS WITH INVALID VALUES ---
+
+-- parsing invalid value with pattern 'y'
+select to_timestamp('294248', 'y'); -- out of year value range [0, 294247]
+
+select to_timestamp('1234567', 'yyyyyyy'); -- the length of 'y' pattern must be less than 7
+
+-- in java 8 this case is invalid, but valid in java 11, disabled for jenkins
+-- select to_timestamp('100', 'DD');
+-- The error message is changed since Java 11+
+-- select to_timestamp('366', 'DD');
+select to_timestamp('2019-366', 'yyyy-DDD');
+select to_timestamp('2020-11-31-366', 'yyyy-MM-dd-DDD');
+-- add a special case to test csv, because the legacy formatter it uses is lenient then Spark should
+-- throw SparkUpgradeException
+select from_csv('2018-366', 'date Date', map('dateFormat', 'yyyy-DDD'));
+
+-- Datetime types parse error
+select to_date("2020-01-27T20:06:11.847", "yyyy-MM-dd HH:mm:ss.SSS");
+select to_date("Unparseable", "yyyy-MM-dd HH:mm:ss.SSS");
+select to_timestamp("2020-01-27T20:06:11.847", "yyyy-MM-dd HH:mm:ss.SSS");
+select to_timestamp("Unparseable", "yyyy-MM-dd HH:mm:ss.SSS");
+select unix_timestamp("2020-01-27T20:06:11.847", "yyyy-MM-dd HH:mm:ss.SSS");
+select unix_timestamp("Unparseable", "yyyy-MM-dd HH:mm:ss.SSS");
+select to_unix_timestamp("2020-01-27T20:06:11.847", "yyyy-MM-dd HH:mm:ss.SSS");
+select to_unix_timestamp("Unparseable", "yyyy-MM-dd HH:mm:ss.SSS");
+select cast("Unparseable" as timestamp);
+select cast("Unparseable" as date);
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-legacy.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-legacy.sql
new file mode 100644
index 0000000000..ee1afe502a
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-legacy.sql
@@ -0,0 +1,2 @@
+--SET spark.sql.legacy.timeParserPolicy=LEGACY
+--IMPORT datetime-parsing.sql
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing.sql
new file mode 100644
index 0000000000..b412e463fc
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing.sql
@@ -0,0 +1,29 @@
+--- TESTS FOR DATETIME PARSING FUNCTIONS ---
+
+-- parsing with pattern 'y'.
+-- the range of valid year is [-290307, 294247],
+-- but particularly, some thrift client use java.sql.Timestamp to parse timestamp, which allows
+-- only positive year values less or equal than 9999. So the cases bellow only use [1, 9999] to pass
+-- ThriftServerQueryTestSuite
+select to_timestamp('1', 'y');
+
+-- reduced two digit form is used, the range of valid year is 20-[01, 99]
+select to_timestamp('00', 'yy');
+
+-- the range of valid year is [-290307, 294247], the number of digits must be in [3, 6] for 'yyy'
+select to_timestamp('001', 'yyy');
+
+-- the range of valid year is [-9999, 9999], the number of digits must be 4 for 'yyyy'.
+select to_timestamp('0001', 'yyyy');
+
+-- the range of valid year is [-99999, 99999], the number of digits must be 5 for 'yyyyy'.
+select to_timestamp('00001', 'yyyyy');
+
+-- the range of valid year is [-290307, 294247], the number of digits must be 6 for 'yyyyyy'.
+select to_timestamp('000001', 'yyyyyy');
+
+-- parsing with pattern 'D'
+select to_timestamp('2020-365', 'yyyy-DDD');
+select to_timestamp('2020-30-365', 'yyyy-dd-DDD');
+select to_timestamp('2020-12-350', 'yyyy-MM-DDD');
+select to_timestamp('2020-12-31-366', 'yyyy-MM-dd-DDD');
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/group-by-ordinal.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/group-by-ordinal.sql
similarity index 100%
rename from gluten-ut/spark35/src/test/resources/sql-tests/inputs/group-by-ordinal.sql
rename to gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/group-by-ordinal.sql
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/group-by.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/group-by.sql
similarity index 97%
rename from gluten-ut/spark35/src/test/resources/sql-tests/inputs/group-by.sql
rename to gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/group-by.sql
index c35cdb0de2..ce1b422de3 100644
--- a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/group-by.sql
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/group-by.sql
@@ -264,3 +264,18 @@ FROM (
GROUP BY b
) t3
GROUP BY c;
+
+-- SPARK-45599: Check that "weird" doubles group and sort as desired.
+SELECT col1, count(*) AS cnt
+FROM VALUES
+ (0.0),
+ (-0.0),
+ (double('NaN')),
+ (double('NaN')),
+ (double('Infinity')),
+ (double('Infinity')),
+ (-double('Infinity')),
+ (-double('Infinity'))
+GROUP BY col1
+ORDER BY col1
+;
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/hll.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/hll.sql
new file mode 100644
index 0000000000..a0c29cb25a
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/hll.sql
@@ -0,0 +1,76 @@
+-- Positive test cases
+-- Create a table with some testing data.
+DROP TABLE IF EXISTS t1;
+CREATE TABLE t1 USING JSON AS VALUES (0), (1), (2), (2), (2), (3), (4) as tab(col);
+
+SELECT hll_sketch_estimate(hll_sketch_agg(col)) AS result FROM t1;
+
+SELECT hll_sketch_estimate(hll_sketch_agg(col, 12))
+FROM VALUES (50), (60), (60), (60), (75), (100) tab(col);
+
+SELECT hll_sketch_estimate(hll_sketch_agg(col))
+FROM VALUES ('abc'), ('def'), ('abc'), ('ghi'), ('abc') tab(col);
+
+SELECT hll_sketch_estimate(
+ hll_union(
+ hll_sketch_agg(col1),
+ hll_sketch_agg(col2)))
+ FROM VALUES
+ (1, 4),
+ (1, 4),
+ (2, 5),
+ (2, 5),
+ (3, 6) AS tab(col1, col2);
+
+SELECT hll_sketch_estimate(hll_union_agg(sketch, true))
+ FROM (SELECT hll_sketch_agg(col) as sketch
+ FROM VALUES (1) AS tab(col)
+ UNION ALL
+ SELECT hll_sketch_agg(col, 20) as sketch
+ FROM VALUES (1) AS tab(col));
+
+-- Negative test cases
+SELECT hll_sketch_agg(col)
+FROM VALUES (ARRAY(1, 2)), (ARRAY(3, 4)) tab(col);
+
+SELECT hll_sketch_agg(col, 2)
+FROM VALUES (50), (60), (60) tab(col);
+
+SELECT hll_sketch_agg(col, 40)
+FROM VALUES (50), (60), (60) tab(col);
+
+SELECT hll_union(
+ hll_sketch_agg(col1, 12),
+ hll_sketch_agg(col2, 13))
+ FROM VALUES
+ (1, 4),
+ (1, 4),
+ (2, 5),
+ (2, 5),
+ (3, 6) AS tab(col1, col2);
+
+SELECT hll_union_agg(sketch, false)
+FROM (SELECT hll_sketch_agg(col, 12) as sketch
+ FROM VALUES (1) AS tab(col)
+ UNION ALL
+ SELECT hll_sketch_agg(col, 20) as sketch
+ FROM VALUES (1) AS tab(col));
+
+SELECT hll_union(1, 2)
+ FROM VALUES
+ (1, 4),
+ (1, 4),
+ (2, 5),
+ (2, 5),
+ (3, 6) AS tab(col1, col2);
+
+-- The HLL functions receive invalid buffers as inputs.
+SELECT hll_sketch_estimate(CAST ('abc' AS BINARY));
+
+SELECT hll_union(CAST ('abc' AS BINARY), CAST ('def' AS BINARY));
+
+SELECT hll_union_agg(buffer, false)
+FROM (SELECT CAST('abc' AS BINARY) AS buffer);
+
+-- Clean up
+DROP TABLE IF EXISTS t1;
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/interval.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/interval.sql
new file mode 100644
index 0000000000..e4da28c2e7
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/interval.sql
@@ -0,0 +1,387 @@
+-- test for intervals
+
+-- multiply and divide an interval by a number
+select 3 * (timestamp'2019-10-15 10:11:12.001002' - date'2019-10-15');
+select interval 4 month 2 weeks 3 microseconds * 1.5;
+select interval 2 years 4 months;
+select interval 2 weeks 3 microseconds * 1.5;
+select (timestamp'2019-10-15' - timestamp'2019-10-14') / 1.5;
+select interval 2147483647 month * 2;
+select interval 2147483647 month / 0.5;
+select interval 2147483647 day * 2;
+select interval 2147483647 day / 0.5;
+
+-- multiply and divide an interval by a string literal
+select interval 2 second * '2';
+select interval 2 second / '2';
+select interval 2 year * '2';
+select interval 2 year / '2';
+select interval 2 second * 'a';
+select interval 2 second / 'a';
+select interval 2 year * 'a';
+select interval 2 year / 'a';
+
+select '2' * interval 2 second;
+select '2' * interval 2 year;
+select 'a' * interval 2 second;
+select 'a' * interval 2 year;
+
+-- invalid: string literal / interval
+select '2' / interval 2 second;
+select '2' / interval 2 year;
+
+-- interval operation with null and zero case
+select interval '2 seconds' / 0;
+select interval '2 seconds' / null;
+select interval '2 seconds' * null;
+select null * interval '2 seconds';
+select interval '2' year / 0;
+select interval '2' year / null;
+select interval '2' year * null;
+select null * interval '2' year;
+
+-- invalid: divide by interval
+select 2 / interval '2' year;
+select 2 / interval '2' hour;
+select null / interval '2' year;
+select null / interval '2' hour;
+
+-- interval with a positive/negative sign
+select -interval '-1 month 1 day -1 second';
+select -interval '-1 year 1 month';
+select -interval '-1 day 1 hour -1 minute 1 second';
+select -interval -1 month 1 day -1 second;
+select -interval -1 year 1 month;
+select -interval -1 day 1 hour -1 minute 1 second;
+select +interval '-1 month 1 day -1 second';
+select +interval '-1 year 1 month';
+select +interval '-1 day 1 hour -1 minute 1 second';
+select +interval -1 month 1 day -1 second;
+select +interval -1 year 1 month;
+select +interval -1 day 1 hour -1 minute 1 second;
+select interval -'1-1' year to month;
+select interval -'-1-1' year to month;
+select interval +'-1-1' year to month;
+select interval - '1 2:3:4.001' day to second;
+select interval +'1 2:3:4.001' day to second;
+select interval -'-1 2:3:4.001' day to second;
+select interval -'1' year;
+select interval -'-1' year;
+select interval -'11' month;
+select interval -'-11' month;
+select interval -'1' day;
+select interval -'-1' day;
+select interval -'23' hour;
+select interval -'-23' hour;
+select interval -'59' minute;
+select interval -'-59' minute;
+select interval -'59' second;
+select interval -'-59' second;
+
+-- make intervals
+select make_interval(1);
+select make_interval(1, 2);
+select make_interval(1, 2, 3);
+select make_interval(1, 2, 3, 4);
+select make_interval(1, 2, 3, 4, 5);
+select make_interval(1, 2, 3, 4, 5, 6);
+select make_interval(1, 2, 3, 4, 5, 6, 7.008009);
+select make_interval(1, 2, 3, 4, 0, 0, 123456789012.123456);
+select make_interval(0, 0, 0, 0, 0, 0, 1234567890123456789);
+
+-- make_dt_interval
+select make_dt_interval(1);
+select make_dt_interval(1, 2);
+select make_dt_interval(1, 2, 3);
+select make_dt_interval(1, 2, 3, 4.005006);
+select make_dt_interval(1, 0, 0, 123456789012.123456);
+select make_dt_interval(2147483647);
+
+-- make_ym_interval
+select make_ym_interval(1);
+select make_ym_interval(1, 2);
+select make_ym_interval(0, 1);
+select make_ym_interval(178956970, 7);
+select make_ym_interval(178956970, 8);
+select make_ym_interval(-178956970, -8);
+select make_ym_interval(-178956970, -9);
+
+-- cast string to intervals
+select cast('1 second' as interval);
+select cast('+1 second' as interval);
+select cast('-1 second' as interval);
+select cast('+ 1 second' as interval);
+select cast('- 1 second' as interval);
+select cast('- -1 second' as interval);
+select cast('- +1 second' as interval);
+
+-- interval literal
+select interval 13.123456789 seconds, interval -13.123456789 second;
+select interval 1 year 2 month 3 week 4 day 5 hour 6 minute 7 seconds 8 millisecond 9 microsecond;
+select interval 1 year 2 month;
+select interval 4 day 5 hour 6 minute 7 seconds;
+select interval 3 week 8 millisecond 9 microsecond;
+select interval '30' year '25' month '-100' day '40' hour '80' minute '299.889987299' second;
+select interval '30' year '25' month;
+select interval '-100' day '40' hour '80' minute '299.889987299' second;
+select interval '0-0' year to month;
+select interval '0 0:0:0' day to second;
+select interval '0 0:0:0.1' day to second;
+select interval '10-9' year to month;
+select interval '20 15' day to hour;
+select interval '20 15:40' day to minute;
+select interval '20 15:40:32.99899999' day to second;
+select interval '15:40' hour to minute;
+select interval '15:40:32.99899999' hour to second;
+select interval '40:32.99899999' minute to second;
+select interval '40:32' minute to second;
+select interval 30 day day;
+select interval 30 days days;
+
+-- invalid day-time string intervals
+select interval '20 15:40:32.99899999' day to hour;
+select interval '20 15:40:32.99899999' day to minute;
+select interval '15:40:32.99899999' hour to minute;
+select interval '15:40.99899999' hour to second;
+select interval '15:40' hour to second;
+select interval '20 40:32.99899999' minute to second;
+
+-- ns is not supported
+select interval 10 nanoseconds;
+
+-- map + interval test
+select map(1, interval 1 day, 2, interval 3 week);
+select map(1, interval 1 day, 2, interval 2 day);
+select map(1, interval 1 year, 2, interval 2 month);
+select map(1, interval 1 month, 2, interval 2 month);
+select map(1, interval 1 week, 2, interval 2 day);
+select map(1, interval 2 millisecond, 3, interval 3 microsecond);
+
+-- typed interval expression
+select interval 'interval 3 year 1 month';
+select interval '3 year 1 month';
+SELECT interval 'interval 2 weeks 2 days 1 hour 3 minutes 2 seconds 100 millisecond 200 microseconds';
+SELECT interval '2 weeks 2 days 1 hour 3 minutes 2 seconds 100 millisecond 200 microseconds';
+
+-- malformed interval literal
+select interval 1 fake_unit;
+select interval 1 year to month;
+select interval '1' year to second;
+select interval '10-9' year to month '2-1' year to month;
+select interval '10-9' year to month '12:11:10' hour to second;
+select interval '1 15:11' day to minute '12:11:10' hour to second;
+select interval 1 year '2-1' year to month;
+select interval 1 year '12:11:10' hour to second;
+select interval '10-9' year to month '1' year;
+select interval '12:11:10' hour to second '1' year;
+select interval (-30) day;
+select interval (a + 1) day;
+select interval 30 day day day;
+select interval (-30) days;
+select interval (a + 1) days;
+select interval 30 days days days;
+SELECT INTERVAL '178956970-7' YEAR TO MONTH;
+SELECT INTERVAL '178956970-8' YEAR TO MONTH;
+SELECT INTERVAL '-178956970-8' YEAR TO MONTH;
+SELECT INTERVAL -'178956970-8' YEAR TO MONTH;
+
+-- interval +/- interval
+select
+ interval '2-2' year to month + interval '3' month,
+ interval '2' year - interval '3-3' year to month,
+ interval '99 11:22:33.123456789' day to second + interval '10 9:8' day to minute,
+ interval '22:33.123456789' minute to second - interval '10' day;
+-- if one side is string/null literal, promote it to interval type.
+select
+ interval '2' year + '3-3 year to month',
+ interval '2' year - '3 month',
+ '3-2 year to month' + interval '2-2' year to month,
+ '3 year' - interval '2-2' year to month,
+ interval '99 11:22:33.123456789' day to second + '12:12 hour to second',
+ interval '99 11:22:33.123456789' day to second - '12 hour',
+ '4 day' + interval '10' day,
+ '4 22 day to hour' - interval '10' day;
+select
+ interval '2' year + null,
+ interval '2' year - null,
+ interval '2' hour + null,
+ interval '2' hour - null,
+ null + interval '2' year,
+ null - interval '2' year,
+ null + interval '2' hour,
+ null - interval '2' hour;
+
+-- invalid: malformed interval string
+select interval '2' year + '3-3';
+select interval '2' year - '4';
+select '4 11:11' - interval '4 22:12' day to minute;
+select '4 12:12:12' + interval '4 22:12' day to minute;
+-- invalid: non-literal string column
+create temporary view interval_view as select '1' str;
+select interval '2' year + str from interval_view;
+select interval '2' year - str from interval_view;
+select str - interval '4 22:12' day to minute from interval_view;
+select str + interval '4 22:12' day to minute from interval_view;
+
+-- invalid: mixed year-month and day-time interval
+select interval '2-2' year to month + interval '3' day;
+select interval '3' day + interval '2-2' year to month;
+select interval '2-2' year to month - interval '3' day;
+select interval '3' day - interval '2-2' year to month;
+
+-- invalid: number +/- interval
+select 1 - interval '2' second;
+select 1 + interval '2' month;
+select interval '2' second + 1;
+select interval '2' month - 1;
+
+-- control characters as white spaces
+select interval '\t interval 1 day';
+select interval 'interval \t 1\tday';
+select interval 'interval\t1\tday';
+select interval '1\t' day;
+select interval '1 ' day;
+select interval '2-2\t' year to month;
+select interval '-\t2-2\t' year to month;
+select interval '\n0 12:34:46.789\t' day to second;
+select interval '\n-\t10\t 12:34:46.789\t' day to second;
+select interval '中文 interval 1 day';
+select interval 'interval中文 1 day';
+select interval 'interval 1中文day';
+
+-- interval overflow: if (ansi) exception else NULL
+select -(a) from values (interval '-2147483648 months', interval '2147483647 months') t(a, b);
+select a - b from values (interval '-2147483648 months', interval '2147483647 months') t(a, b);
+select b + interval '1 month' from values (interval '-2147483648 months', interval '2147483647 months') t(a, b);
+select a * 1.1 from values (interval '-2147483648 months', interval '2147483647 months') t(a, b);
+select a / 0.5 from values (interval '-2147483648 months', interval '2147483647 months') t(a, b);
+
+-- interval support for csv and json functions
+SELECT
+ from_csv('1, 1 day', 'a INT, b interval'),
+ from_csv('1, 1', 'a INT, b interval day'),
+ to_csv(from_csv('1, 1 day', 'a INT, b interval')),
+ to_csv(from_csv('1, 1', 'a INT, b interval day')),
+ to_csv(named_struct('a', interval 32 hour, 'b', interval 70 minute)),
+ from_csv(to_csv(named_struct('a', interval 32 hour, 'b', interval 70 minute)), 'a interval hour, b interval minute');
+SELECT
+ from_json('{"a":"1 days"}', 'a interval'),
+ from_csv('1, 1', 'a INT, b interval year'),
+ to_json(from_json('{"a":"1 days"}', 'a interval')),
+ to_csv(from_csv('1, 1', 'a INT, b interval year')),
+ to_csv(named_struct('a', interval 32 year, 'b', interval 10 month)),
+ from_csv(to_csv(named_struct('a', interval 32 year, 'b', interval 10 month)), 'a interval year, b interval month');
+SELECT
+ from_json('{"a":"1"}', 'a interval day'),
+ to_json(from_json('{"a":"1"}', 'a interval day')),
+ to_json(map('a', interval 100 day 130 minute)),
+ from_json(to_json(map('a', interval 100 day 130 minute)), 'a interval day to minute');
+SELECT
+ from_json('{"a":"1"}', 'a interval year'),
+ to_json(from_json('{"a":"1"}', 'a interval year')),
+ to_json(map('a', interval 32 year 10 month)),
+ from_json(to_json(map('a', interval 32 year 10 month)), 'a interval year to month');
+
+select interval '+';
+select interval '+.';
+select interval '1';
+select interval '1.2';
+select interval '- 2';
+select interval '1 day -';
+select interval '1 day 1';
+
+select interval '1 day 2' day;
+select interval 'interval 1' day;
+select interval '-\t 1' day;
+
+SELECT (INTERVAL '-178956970-8' YEAR TO MONTH) / 2;
+SELECT (INTERVAL '-178956970-8' YEAR TO MONTH) / 5;
+SELECT (INTERVAL '-178956970-8' YEAR TO MONTH) / -1;
+SELECT (INTERVAL '-178956970-8' YEAR TO MONTH) / -1L;
+SELECT (INTERVAL '-178956970-8' YEAR TO MONTH) / -1.0;
+SELECT (INTERVAL '-178956970-8' YEAR TO MONTH) / -1.0D;
+
+SELECT (INTERVAL '-106751991 04:00:54.775808' DAY TO SECOND) / 2;
+SELECT (INTERVAL '-106751991 04:00:54.775808' DAY TO SECOND) / 5;
+SELECT (INTERVAL '-106751991 04:00:54.775808' DAY TO SECOND) / -1;
+SELECT (INTERVAL '-106751991 04:00:54.775808' DAY TO SECOND) / -1L;
+SELECT (INTERVAL '-106751991 04:00:54.775808' DAY TO SECOND) / -1.0;
+SELECT (INTERVAL '-106751991 04:00:54.775808' DAY TO SECOND) / -1.0D;
+
+SELECT INTERVAL '106751991 04' DAY TO HOUR;
+SELECT INTERVAL '106751991 04:00' DAY TO MINUTE;
+SELECT INTERVAL '106751991 04:00:54.775807' DAY TO SECOND;
+SELECT INTERVAL '2562047788:00' HOUR TO MINUTE;
+SELECT INTERVAL '2562047788:00:54.775807' HOUR TO SECOND;
+SELECT INTERVAL '153722867280:54.775807' MINUTE TO SECOND;
+SELECT INTERVAL '-106751991 04' DAY TO HOUR;
+SELECT INTERVAL '-106751991 04:00' DAY TO MINUTE;
+SELECT INTERVAL '-106751991 04:00:54.775808' DAY TO SECOND;
+SELECT INTERVAL '-2562047788:00' HOUR TO MINUTE;
+SELECT INTERVAL '-2562047788:00:54.775808' HOUR TO SECOND;
+SELECT INTERVAL '-153722867280:54.775808' MINUTE TO SECOND;
+
+SELECT INTERVAL '106751992 04' DAY TO HOUR;
+SELECT INTERVAL '-106751992 04' DAY TO HOUR;
+SELECT INTERVAL '2562047789:00' HOUR TO MINUTE;
+SELECT INTERVAL '-2562047789:00' HOUR TO MINUTE;
+SELECT INTERVAL '153722867281:54.775808' MINUTE TO SECOND;
+SELECT INTERVAL '-153722867281:54.775808' MINUTE TO SECOND;
+
+SELECT INTERVAL '178956970' YEAR;
+SELECT INTERVAL '-178956970' YEAR;
+SELECT INTERVAL '2147483647' MONTH;
+SELECT INTERVAL '-2147483647' MONTH;
+
+SELECT INTERVAL '106751991' DAY;
+SELECT INTERVAL '-106751991' DAY;
+SELECT INTERVAL '2562047788' HOUR;
+SELECT INTERVAL '-2562047788' HOUR;
+SELECT INTERVAL '153722867280' MINUTE;
+SELECT INTERVAL '-153722867280' MINUTE;
+SELECT INTERVAL '54.775807' SECOND;
+SELECT INTERVAL '-54.775807' SECOND;
+
+SELECT INTERVAL '1' DAY > INTERVAL '1' HOUR;
+SELECT INTERVAL '1 02' DAY TO HOUR = INTERVAL '02:10:55' HOUR TO SECOND;
+SELECT INTERVAL '1' YEAR < INTERVAL '1' MONTH;
+SELECT INTERVAL '-1-1' YEAR TO MONTH = INTERVAL '-13' MONTH;
+SELECT INTERVAL 1 MONTH > INTERVAL 20 DAYS;
+
+-- compare interval with string
+SELECT INTERVAL '1' DAY < '1';
+SELECT INTERVAL '1' DAY = '1';
+SELECT INTERVAL '1' DAY > '1';
+SELECT '1' < INTERVAL '1' DAY;
+SELECT '1' = INTERVAL '1' DAY;
+SELECT '1' > INTERVAL '1' DAY;
+SELECT INTERVAL '1' YEAR < '1';
+SELECT INTERVAL '1' YEAR = '1';
+SELECT INTERVAL '1' YEAR > '1';
+SELECT '1' < INTERVAL '1' YEAR;
+SELECT '1' = INTERVAL '1' YEAR;
+SELECT '1' > INTERVAL '1' YEAR;
+
+SELECT array(INTERVAL '1' YEAR, INTERVAL '1' MONTH);
+SELECT array(INTERVAL '1' DAY, INTERVAL '01:01' HOUR TO MINUTE);
+SELECT array(INTERVAL 1 MONTH, INTERVAL 20 DAYS);
+SELECT coalesce(INTERVAL '1' YEAR, INTERVAL '1' MONTH);
+SELECT coalesce(INTERVAL '1' DAY, INTERVAL '01:01' HOUR TO MINUTE);
+SELECT coalesce(INTERVAL 1 MONTH, INTERVAL 20 DAYS);
+SELECT abs(INTERVAL '-10' YEAR);
+SELECT abs(INTERVAL -'1 02:03:04.123' DAY TO SECOND);
+SELECT div(INTERVAL '1-1' YEAR TO MONTH, INTERVAL '1' YEAR);
+SELECT div(INTERVAL '1-1' YEAR TO MONTH, INTERVAL '-1' MONTH);
+SELECT div(INTERVAL '1 06' DAY TO HOUR, INTERVAL '1' DAY);
+SELECT div(INTERVAL '1 06' DAY TO HOUR, INTERVAL '-1' HOUR);
+SELECT div(INTERVAL '1' MONTH, INTERVAL '-1' DAY);
+SELECT signum(INTERVAL '-10' YEAR);
+SELECT signum(INTERVAL '10' MONTH);
+SELECT signum(INTERVAL '0-0' YEAR TO MONTH);
+SELECT signum(INTERVAL '-10' DAY);
+SELECT signum(INTERVAL '10' HOUR);
+SELECT signum(INTERVAL '0 0:0:0' DAY TO SECOND);
+SELECT width_bucket(INTERVAL '0' YEAR, INTERVAL '0' YEAR, INTERVAL '10' YEAR, 10);
+SELECT width_bucket(INTERVAL '-1' YEAR, INTERVAL -'1-2' YEAR TO MONTH, INTERVAL '1-2' YEAR TO MONTH, 10);
+SELECT width_bucket(INTERVAL '0' DAY, INTERVAL '0' DAY, INTERVAL '10' DAY, 10);
+SELECT width_bucket(INTERVAL '-59' MINUTE, INTERVAL -'1 01' DAY TO HOUR, INTERVAL '1 2:3:4.001' DAY TO SECOND, 10);
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/linear-regression.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/linear-regression.sql
similarity index 100%
rename from gluten-ut/spark35/src/test/resources/sql-tests/inputs/linear-regression.sql
rename to gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/linear-regression.sql
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/misc-functions.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/misc-functions.sql
similarity index 70%
rename from gluten-ut/spark35/src/test/resources/sql-tests/inputs/misc-functions.sql
rename to gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/misc-functions.sql
index 907ff33000..b12ce86e97 100644
--- a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/misc-functions.sql
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/misc-functions.sql
@@ -1,4 +1,5 @@
-- test for misc functions
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
-- typeof
select typeof(null);
@@ -9,6 +10,8 @@ select typeof(date '1986-05-23'), typeof(timestamp '1986-05-23'), typeof(interv
select typeof(x'ABCD'), typeof('SPARK');
select typeof(array(1, 2)), typeof(map(1, 2)), typeof(named_struct('a', 1, 'b', 'spark'));
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
-- Spark-32793: Rewrite AssertTrue with RaiseError
SELECT assert_true(true), assert_true(boolean(1));
SELECT assert_true(false);
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/percentiles.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/percentiles.sql
new file mode 100644
index 0000000000..20da110181
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/percentiles.sql
@@ -0,0 +1,389 @@
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW aggr AS SELECT * FROM VALUES
+(0, 0), (0, 10), (0, 20), (0, 30), (0, 40), (1, 10), (1, 20), (2, 10), (2, 20), (2, 25), (2, 30), (3, 60), (4, null)
+AS aggr(k, v);
+
+CREATE OR REPLACE TEMPORARY VIEW basic_pays AS SELECT * FROM VALUES
+('Diane Murphy','Accounting',8435),
+('Mary Patterson','Accounting',9998),
+('Jeff Firrelli','Accounting',8992),
+('William Patterson','Accounting',8870),
+('Gerard Bondur','Accounting',11472),
+('Anthony Bow','Accounting',6627),
+('Leslie Jennings','IT',8113),
+('Leslie Thompson','IT',5186),
+('Julie Firrelli','Sales',9181),
+('Steve Patterson','Sales',9441),
+('Foon Yue Tseng','Sales',6660),
+('George Vanauf','Sales',10563),
+('Loui Bondur','SCM',10449),
+('Gerard Hernandez','SCM',6949),
+('Pamela Castillo','SCM',11303),
+('Larry Bott','SCM',11798),
+('Barry Jones','SCM',10586)
+AS basic_pays(employee_name, department, salary);
+
+SELECT
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY v),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY v) FILTER (WHERE k > 0),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY v DESC),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY v DESC) FILTER (WHERE k > 0)
+FROM aggr;
+
+SELECT
+ k,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY v),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY v) FILTER (WHERE k > 0),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY v DESC),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY v DESC) FILTER (WHERE k > 0)
+FROM aggr
+GROUP BY k
+ORDER BY k;
+
+SELECT
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY v),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY v) FILTER (WHERE k > 0),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY v DESC),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY v DESC) FILTER (WHERE k > 0)
+FROM aggr;
+
+SELECT
+ k,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY v),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY v) FILTER (WHERE k > 0),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY v DESC),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY v DESC) FILTER (WHERE k > 0)
+FROM aggr
+GROUP BY k
+ORDER BY k;
+
+SELECT
+ median(v),
+ percentile(v, 0.5),
+ percentile_cont(0.5) WITHIN GROUP (ORDER BY v)
+FROM aggr;
+
+SELECT
+ k,
+ median(v),
+ percentile(v, 0.5),
+ percentile_cont(0.5) WITHIN GROUP (ORDER BY v)
+FROM aggr
+GROUP BY k
+ORDER BY k;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) OVER (PARTITION BY department),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) OVER (PARTITION BY department),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER (PARTITION BY department),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER (PARTITION BY department)
+FROM basic_pays
+ORDER BY salary;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) OVER (PARTITION BY department ORDER BY salary),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER (PARTITION BY department ORDER BY salary)
+FROM basic_pays
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) OVER (PARTITION BY department ORDER BY salary),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER (PARTITION BY department ORDER BY salary)
+FROM basic_pays
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ median(salary) OVER (PARTITION BY department ORDER BY salary)
+FROM basic_pays
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) OVER (PARTITION BY department ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER (PARTITION BY department ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)
+FROM basic_pays
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) OVER (PARTITION BY department ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER (PARTITION BY department ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)
+FROM basic_pays
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ median(salary) OVER (PARTITION BY department ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)
+FROM basic_pays
+ORDER BY salary;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) OVER w,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) OVER w,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER w,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER w
+FROM basic_pays
+WINDOW w AS (PARTITION BY department)
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ median(salary) OVER w,
+ percentile_cont(0.5) WITHIN GROUP (ORDER BY salary) OVER w,
+ percentile_disc(0.5) WITHIN GROUP (ORDER BY salary) OVER w,
+ percentile_cont(0.5) WITHIN GROUP (ORDER BY salary DESC) OVER w,
+ percentile_disc(0.5) WITHIN GROUP (ORDER BY salary DESC) OVER w
+FROM basic_pays
+WHERE salary > 8900
+WINDOW w AS (PARTITION BY department)
+ORDER BY salary;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) OVER w,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER w
+FROM basic_pays
+WINDOW w AS (PARTITION BY department ORDER BY salary)
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) OVER w,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER w
+FROM basic_pays
+WINDOW w AS (PARTITION BY department ORDER BY salary)
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ median(salary) OVER w
+FROM basic_pays
+WINDOW w AS (PARTITION BY department ORDER BY salary)
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary) OVER w,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER w
+FROM basic_pays
+WINDOW w AS (PARTITION BY department ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary) OVER w,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY salary DESC) OVER w
+FROM basic_pays
+WINDOW w AS (PARTITION BY department ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ median(salary) OVER w
+FROM basic_pays
+WINDOW w AS (PARTITION BY department ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)
+ORDER BY salary;
+
+CREATE OR REPLACE TEMPORARY VIEW intervals AS SELECT * FROM VALUES
+(0, INTERVAL '0' MONTH, INTERVAL '0' SECOND, INTERVAL '0' MINUTE),
+(0, INTERVAL '10' MONTH, INTERVAL '10' SECOND, INTERVAL '10' MINUTE),
+(0, INTERVAL '20' MONTH, INTERVAL '20' SECOND, INTERVAL '20' MINUTE),
+(0, INTERVAL '30' MONTH, INTERVAL '30' SECOND, INTERVAL '30' MINUTE),
+(0, INTERVAL '40' MONTH, INTERVAL '40' SECOND, INTERVAL '40' MINUTE),
+(1, INTERVAL '10' MONTH, INTERVAL '10' SECOND, INTERVAL '10' MINUTE),
+(1, INTERVAL '20' MONTH, INTERVAL '20' SECOND, INTERVAL '20' MINUTE),
+(2, INTERVAL '10' MONTH, INTERVAL '10' SECOND, INTERVAL '10' MINUTE),
+(2, INTERVAL '20' MONTH, INTERVAL '20' SECOND, INTERVAL '20' MINUTE),
+(2, INTERVAL '25' MONTH, INTERVAL '25' SECOND, INTERVAL '25' MINUTE),
+(2, INTERVAL '30' MONTH, INTERVAL '30' SECOND, INTERVAL '30' MINUTE),
+(3, INTERVAL '60' MONTH, INTERVAL '60' SECOND, INTERVAL '60' MINUTE),
+(4, null, null, null)
+AS intervals(k, dt, ym, dt2);
+
+SELECT
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY dt),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY dt DESC)
+FROM intervals;
+
+SELECT
+ k,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY ym),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY ym DESC)
+FROM intervals
+GROUP BY k
+ORDER BY k;
+
+SELECT
+ k,
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY dt2),
+ percentile_cont(0.25) WITHIN GROUP (ORDER BY dt2 DESC)
+FROM intervals
+GROUP BY k
+ORDER BY k;
+
+SELECT
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY dt),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY dt DESC)
+FROM intervals;
+
+SELECT
+ k,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY ym),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY ym DESC)
+FROM intervals
+GROUP BY k
+ORDER BY k;
+
+SELECT
+ k,
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY dt2),
+ percentile_disc(0.25) WITHIN GROUP (ORDER BY dt2 DESC)
+FROM intervals
+GROUP BY k
+ORDER BY k;
+
+SELECT
+ median(dt),
+ percentile(dt, 0.5),
+ percentile_cont(0.5) WITHIN GROUP (ORDER BY dt)
+FROM intervals;
+
+SELECT
+ k,
+ median(ym),
+ percentile(ym, 0.5),
+ percentile_cont(0.5) WITHIN GROUP (ORDER BY ym)
+FROM intervals
+GROUP BY k
+ORDER BY k;
+
+SELECT
+ k,
+ median(dt2),
+ percentile(dt2, 0.5),
+ percentile_cont(0.5) WITHIN GROUP (ORDER BY dt2)
+FROM intervals
+GROUP BY k
+ORDER BY k;
+
+-- SPARK-44871: Fix percentile_disc behaviour
+SELECT
+ percentile_disc(0.0) WITHIN GROUP (ORDER BY a) as p0,
+ percentile_disc(0.1) WITHIN GROUP (ORDER BY a) as p1,
+ percentile_disc(0.2) WITHIN GROUP (ORDER BY a) as p2,
+ percentile_disc(0.3) WITHIN GROUP (ORDER BY a) as p3,
+ percentile_disc(0.4) WITHIN GROUP (ORDER BY a) as p4,
+ percentile_disc(0.5) WITHIN GROUP (ORDER BY a) as p5,
+ percentile_disc(0.6) WITHIN GROUP (ORDER BY a) as p6,
+ percentile_disc(0.7) WITHIN GROUP (ORDER BY a) as p7,
+ percentile_disc(0.8) WITHIN GROUP (ORDER BY a) as p8,
+ percentile_disc(0.9) WITHIN GROUP (ORDER BY a) as p9,
+ percentile_disc(1.0) WITHIN GROUP (ORDER BY a) as p10
+FROM VALUES (0) AS v(a);
+
+SELECT
+ percentile_disc(0.0) WITHIN GROUP (ORDER BY a) as p0,
+ percentile_disc(0.1) WITHIN GROUP (ORDER BY a) as p1,
+ percentile_disc(0.2) WITHIN GROUP (ORDER BY a) as p2,
+ percentile_disc(0.3) WITHIN GROUP (ORDER BY a) as p3,
+ percentile_disc(0.4) WITHIN GROUP (ORDER BY a) as p4,
+ percentile_disc(0.5) WITHIN GROUP (ORDER BY a) as p5,
+ percentile_disc(0.6) WITHIN GROUP (ORDER BY a) as p6,
+ percentile_disc(0.7) WITHIN GROUP (ORDER BY a) as p7,
+ percentile_disc(0.8) WITHIN GROUP (ORDER BY a) as p8,
+ percentile_disc(0.9) WITHIN GROUP (ORDER BY a) as p9,
+ percentile_disc(1.0) WITHIN GROUP (ORDER BY a) as p10
+FROM VALUES (0), (1) AS v(a);
+
+SELECT
+ percentile_disc(0.0) WITHIN GROUP (ORDER BY a) as p0,
+ percentile_disc(0.1) WITHIN GROUP (ORDER BY a) as p1,
+ percentile_disc(0.2) WITHIN GROUP (ORDER BY a) as p2,
+ percentile_disc(0.3) WITHIN GROUP (ORDER BY a) as p3,
+ percentile_disc(0.4) WITHIN GROUP (ORDER BY a) as p4,
+ percentile_disc(0.5) WITHIN GROUP (ORDER BY a) as p5,
+ percentile_disc(0.6) WITHIN GROUP (ORDER BY a) as p6,
+ percentile_disc(0.7) WITHIN GROUP (ORDER BY a) as p7,
+ percentile_disc(0.8) WITHIN GROUP (ORDER BY a) as p8,
+ percentile_disc(0.9) WITHIN GROUP (ORDER BY a) as p9,
+ percentile_disc(1.0) WITHIN GROUP (ORDER BY a) as p10
+FROM VALUES (0), (1), (2) AS v(a);
+
+SELECT
+ percentile_disc(0.0) WITHIN GROUP (ORDER BY a) as p0,
+ percentile_disc(0.1) WITHIN GROUP (ORDER BY a) as p1,
+ percentile_disc(0.2) WITHIN GROUP (ORDER BY a) as p2,
+ percentile_disc(0.3) WITHIN GROUP (ORDER BY a) as p3,
+ percentile_disc(0.4) WITHIN GROUP (ORDER BY a) as p4,
+ percentile_disc(0.5) WITHIN GROUP (ORDER BY a) as p5,
+ percentile_disc(0.6) WITHIN GROUP (ORDER BY a) as p6,
+ percentile_disc(0.7) WITHIN GROUP (ORDER BY a) as p7,
+ percentile_disc(0.8) WITHIN GROUP (ORDER BY a) as p8,
+ percentile_disc(0.9) WITHIN GROUP (ORDER BY a) as p9,
+ percentile_disc(1.0) WITHIN GROUP (ORDER BY a) as p10
+FROM VALUES (0), (1), (2), (3), (4) AS v(a);
+
+SET spark.sql.legacy.percentileDiscCalculation = true;
+
+SELECT
+ percentile_disc(0.0) WITHIN GROUP (ORDER BY a) as p0,
+ percentile_disc(0.1) WITHIN GROUP (ORDER BY a) as p1,
+ percentile_disc(0.2) WITHIN GROUP (ORDER BY a) as p2,
+ percentile_disc(0.3) WITHIN GROUP (ORDER BY a) as p3,
+ percentile_disc(0.4) WITHIN GROUP (ORDER BY a) as p4,
+ percentile_disc(0.5) WITHIN GROUP (ORDER BY a) as p5,
+ percentile_disc(0.6) WITHIN GROUP (ORDER BY a) as p6,
+ percentile_disc(0.7) WITHIN GROUP (ORDER BY a) as p7,
+ percentile_disc(0.8) WITHIN GROUP (ORDER BY a) as p8,
+ percentile_disc(0.9) WITHIN GROUP (ORDER BY a) as p9,
+ percentile_disc(1.0) WITHIN GROUP (ORDER BY a) as p10
+FROM VALUES (0), (1), (2), (3), (4) AS v(a);
+
+SELECT
+ percentile_cont(b) WITHIN GROUP (ORDER BY a DESC) as p0
+FROM values (12, 0.25), (13, 0.25), (22, 0.25) as v(a, b);
+
+SET spark.sql.legacy.percentileDiscCalculation = false;
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/window_part1.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/window_part1.sql
new file mode 100644
index 0000000000..dac7670fca
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/window_part1.sql
@@ -0,0 +1,365 @@
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+-- Window Functions Testing
+-- https://github.com/postgres/postgres/blob/REL_12_STABLE/src/test/regress/sql/window.sql#L1-L319
+
+-- Test window operator with codegen on and off.
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=true
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=CODEGEN_ONLY
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=NO_CODEGEN
+
+CREATE TEMPORARY VIEW tenk2 AS SELECT * FROM tenk1;
+
+-- [SPARK-29540] Thrift in some cases can't parse string to date
+-- CREATE TABLE empsalary (
+-- depname string,
+-- empno integer,
+-- salary int,
+-- enroll_date date
+-- ) USING parquet;
+
+-- [SPARK-29540] Thrift in some cases can't parse string to date
+-- INSERT INTO empsalary VALUES ('develop', 10, 5200, '2007-08-01');
+-- INSERT INTO empsalary VALUES ('sales', 1, 5000, '2006-10-01');
+-- INSERT INTO empsalary VALUES ('personnel', 5, 3500, '2007-12-10');
+-- INSERT INTO empsalary VALUES ('sales', 4, 4800, '2007-08-08');
+-- INSERT INTO empsalary VALUES ('personnel', 2, 3900, '2006-12-23');
+-- INSERT INTO empsalary VALUES ('develop', 7, 4200, '2008-01-01');
+-- INSERT INTO empsalary VALUES ('develop', 9, 4500, '2008-01-01');
+-- INSERT INTO empsalary VALUES ('sales', 3, 4800, '2007-08-01');
+-- INSERT INTO empsalary VALUES ('develop', 8, 6000, '2006-10-01');
+-- INSERT INTO empsalary VALUES ('develop', 11, 5200, '2007-08-15');
+
+-- [SPARK-29540] Thrift in some cases can't parse string to date
+-- SELECT depname, empno, salary, sum(salary) OVER (PARTITION BY depname) FROM empsalary ORDER BY depname, salary;
+
+-- [SPARK-29540] Thrift in some cases can't parse string to date
+-- SELECT depname, empno, salary, rank() OVER (PARTITION BY depname ORDER BY salary) FROM empsalary;
+
+-- with GROUP BY
+SELECT four, ten, SUM(SUM(four)) OVER (PARTITION BY four), AVG(ten) FROM tenk1
+GROUP BY four, ten ORDER BY four, ten;
+
+-- [SPARK-29540] Thrift in some cases can't parse string to date
+-- SELECT depname, empno, salary, sum(salary) OVER w FROM empsalary WINDOW w AS (PARTITION BY depname);
+
+-- [SPARK-28064] Order by does not accept a call to rank()
+-- SELECT depname, empno, salary, rank() OVER w FROM empsalary WINDOW w AS (PARTITION BY depname ORDER BY salary) ORDER BY rank() OVER w;
+
+-- empty window specification
+SELECT COUNT(*) OVER () FROM tenk1 WHERE unique2 < 10;
+
+SELECT COUNT(*) OVER w FROM tenk1 WHERE unique2 < 10 WINDOW w AS ();
+
+-- no window operation
+SELECT four FROM tenk1 WHERE FALSE WINDOW w AS (PARTITION BY ten);
+
+-- cumulative aggregate
+SELECT sum(four) OVER (PARTITION BY ten ORDER BY unique2) AS sum_1, ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT row_number() OVER (ORDER BY unique2) FROM tenk1 WHERE unique2 < 10;
+
+SELECT rank() OVER (PARTITION BY four ORDER BY ten) AS rank_1, ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT dense_rank() OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT percent_rank() OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT cume_dist() OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT ntile(3) OVER (ORDER BY ten, four), ten, four FROM tenk1 WHERE unique2 < 10;
+
+-- [SPARK-28065] ntile does not accept NULL as input
+-- SELECT ntile(NULL) OVER (ORDER BY ten, four), ten, four FROM tenk1 LIMIT 2;
+
+SELECT lag(ten) OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+-- [SPARK-28068] `lag` second argument must be a literal in Spark
+-- SELECT lag(ten, four) OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+-- [SPARK-28068] `lag` second argument must be a literal in Spark
+-- SELECT lag(ten, four, 0) OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT lead(ten) OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT lead(ten * 2, 1) OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT lead(ten * 2, 1, -1) OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT first(ten) OVER (PARTITION BY four ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+-- last returns the last row of the frame, which is CURRENT ROW in ORDER BY window.
+SELECT last(four) OVER (ORDER BY ten), ten, four FROM tenk1 WHERE unique2 < 10;
+
+SELECT last(ten) OVER (PARTITION BY four), ten, four FROM
+(SELECT * FROM tenk1 WHERE unique2 < 10 ORDER BY four, ten)s
+ORDER BY four, ten;
+
+-- [SPARK-30707] Lead/Lag window function throws AnalysisException without ORDER BY clause
+-- SELECT nth_value(ten, four + 1) OVER (PARTITION BY four), ten, four
+-- FROM (SELECT * FROM tenk1 WHERE unique2 < 10 ORDER BY four, ten)s;
+
+SELECT ten, two, sum(hundred) AS gsum, sum(sum(hundred)) OVER (PARTITION BY two ORDER BY ten) AS wsum
+FROM tenk1 GROUP BY ten, two;
+
+SELECT count(*) OVER (PARTITION BY four), four FROM (SELECT * FROM tenk1 WHERE two = 1)s WHERE unique2 < 10;
+
+SELECT (count(*) OVER (PARTITION BY four ORDER BY ten) +
+ sum(hundred) OVER (PARTITION BY four ORDER BY ten)) AS cntsum
+ FROM tenk1 WHERE unique2 < 10;
+
+-- opexpr with different windows evaluation.
+SELECT * FROM(
+ SELECT count(*) OVER (PARTITION BY four ORDER BY ten) +
+ sum(hundred) OVER (PARTITION BY two ORDER BY ten) AS total,
+ count(*) OVER (PARTITION BY four ORDER BY ten) AS fourcount,
+ sum(hundred) OVER (PARTITION BY two ORDER BY ten) AS twosum
+ FROM tenk1
+)sub WHERE total <> fourcount + twosum;
+
+SELECT avg(four) OVER (PARTITION BY four ORDER BY thousand / 100) FROM tenk1 WHERE unique2 < 10;
+
+SELECT ten, two, sum(hundred) AS gsum, sum(sum(hundred)) OVER win AS wsum
+FROM tenk1 GROUP BY ten, two WINDOW win AS (PARTITION BY two ORDER BY ten);
+
+-- [SPARK-29540] Thrift in some cases can't parse string to date
+-- more than one window with GROUP BY
+-- SELECT sum(salary),
+-- row_number() OVER (ORDER BY depname),
+-- sum(sum(salary)) OVER (ORDER BY depname DESC)
+-- FROM empsalary GROUP BY depname;
+
+-- [SPARK-29540] Thrift in some cases can't parse string to date
+-- identical windows with different names
+-- SELECT sum(salary) OVER w1, count(*) OVER w2
+-- FROM empsalary WINDOW w1 AS (ORDER BY salary), w2 AS (ORDER BY salary);
+
+-- subplan
+-- Cannot specify window frame for lead function
+-- SELECT lead(ten, (SELECT two FROM tenk1 WHERE s.unique2 = unique2)) OVER (PARTITION BY four ORDER BY ten)
+-- FROM tenk1 s WHERE unique2 < 10;
+
+-- empty table
+SELECT count(*) OVER (PARTITION BY four) FROM (SELECT * FROM tenk1 WHERE FALSE)s;
+
+-- [SPARK-29540] Thrift in some cases can't parse string to date
+-- mixture of agg/wfunc in the same window
+-- SELECT sum(salary) OVER w, rank() OVER w FROM empsalary WINDOW w AS (PARTITION BY depname ORDER BY salary DESC);
+
+-- Cannot safely cast 'enroll_date': string to date;
+-- SELECT empno, depname, salary, bonus, depadj, MIN(bonus) OVER (ORDER BY empno), MAX(depadj) OVER () FROM(
+-- SELECT *,
+-- CASE WHEN enroll_date < '2008-01-01' THEN 2008 - extract(year FROM enroll_date) END * 500 AS bonus,
+-- CASE WHEN
+-- AVG(salary) OVER (PARTITION BY depname) < salary
+-- THEN 200 END AS depadj FROM empsalary
+-- )s;
+
+create temporary view int4_tbl as select * from values
+ (0),
+ (123456),
+ (-123456),
+ (2147483647),
+ (-2147483647)
+ as int4_tbl(f1);
+
+-- window function over ungrouped agg over empty row set (bug before 9.1)
+SELECT SUM(COUNT(f1)) OVER () FROM int4_tbl WHERE f1=42;
+
+-- window function with ORDER BY an expression involving aggregates (9.1 bug)
+select ten,
+ sum(unique1) + sum(unique2) as res,
+ rank() over (order by sum(unique1) + sum(unique2)) as rank
+from tenk1
+group by ten order by ten;
+
+-- window and aggregate with GROUP BY expression (9.2 bug)
+-- explain
+-- select first(max(x)) over (), y
+-- from (select unique1 as x, ten+four as y from tenk1) ss
+-- group by y;
+
+-- test non-default frame specifications
+SELECT four, ten,
+sum(ten) over (partition by four order by ten),
+last(ten) over (partition by four order by ten)
+FROM (select distinct ten, four from tenk1) ss;
+
+SELECT four, ten,
+sum(ten) over (partition by four order by ten range between unbounded preceding and current row),
+last(ten) over (partition by four order by ten range between unbounded preceding and current row)
+FROM (select distinct ten, four from tenk1) ss;
+
+SELECT four, ten,
+sum(ten) over (partition by four order by ten range between unbounded preceding and unbounded following),
+last(ten) over (partition by four order by ten range between unbounded preceding and unbounded following)
+FROM (select distinct ten, four from tenk1) ss;
+
+-- [SPARK-29451] Some queries with divisions in SQL windows are failling in Thrift
+-- SELECT four, ten/4 as two,
+-- sum(ten/4) over (partition by four order by ten/4 range between unbounded preceding and current row),
+-- last(ten/4) over (partition by four order by ten/4 range between unbounded preceding and current row)
+-- FROM (select distinct ten, four from tenk1) ss;
+
+-- [SPARK-29451] Some queries with divisions in SQL windows are failling in Thrift
+-- SELECT four, ten/4 as two,
+-- sum(ten/4) over (partition by four order by ten/4 rows between unbounded preceding and current row),
+-- last(ten/4) over (partition by four order by ten/4 rows between unbounded preceding and current row)
+-- FROM (select distinct ten, four from tenk1) ss;
+
+SELECT sum(unique1) over (order by four range between current row and unbounded following),
+unique1, four
+FROM tenk1 WHERE unique1 < 10;
+
+SELECT sum(unique1) over (rows between current row and unbounded following),
+unique1, four
+FROM tenk1 WHERE unique1 < 10;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+SELECT sum(unique1) over (rows between 2 preceding and 2 following),
+unique1, four
+FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (rows between 2 preceding and 2 following exclude no others),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (rows between 2 preceding and 2 following exclude current row),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (rows between 2 preceding and 2 following exclude group),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (rows between 2 preceding and 2 following exclude ties),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT first(unique1) over (ORDER BY four rows between current row and 2 following exclude current row),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT first(unique1) over (ORDER BY four rows between current row and 2 following exclude group),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT first(unique1) over (ORDER BY four rows between current row and 2 following exclude ties),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT last(unique1) over (ORDER BY four rows between current row and 2 following exclude current row),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT last(unique1) over (ORDER BY four rows between current row and 2 following exclude group),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT last(unique1) over (ORDER BY four rows between current row and 2 following exclude ties),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+SELECT sum(unique1) over (rows between 2 preceding and 1 preceding),
+unique1, four
+FROM tenk1 WHERE unique1 < 10;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+SELECT sum(unique1) over (rows between 1 following and 3 following),
+unique1, four
+FROM tenk1 WHERE unique1 < 10;
+
+SELECT sum(unique1) over (rows between unbounded preceding and 1 following),
+unique1, four
+FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (w range between current row and unbounded following),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10 WINDOW w AS (order by four);
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (w range between unbounded preceding and current row exclude current row),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10 WINDOW w AS (order by four);
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (w range between unbounded preceding and current row exclude group),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10 WINDOW w AS (order by four);
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (w range between unbounded preceding and current row exclude ties),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10 WINDOW w AS (order by four);
+
+-- [SPARK-30707] Lead/Lag window function throws AnalysisException without ORDER BY clause
+-- SELECT first_value(unique1) over w,
+-- nth_value(unique1, 2) over w AS nth_2,
+-- last_value(unique1) over w, unique1, four
+-- FROM tenk1 WHERE unique1 < 10
+-- WINDOW w AS (order by four range between current row and unbounded following);
+
+-- [SPARK-28501] Frame bound value must be a literal.
+-- SELECT sum(unique1) over
+-- (order by unique1
+-- rows (SELECT unique1 FROM tenk1 ORDER BY unique1 LIMIT 1) + 1 PRECEDING),
+-- unique1
+-- FROM tenk1 WHERE unique1 < 10;
+
+CREATE TEMP VIEW v_window AS
+SELECT i.id, sum(i.id) over (order by i.id rows between 1 preceding and 1 following) as sum_rows
+FROM range(1, 11) i;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+SELECT * FROM v_window;
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- CREATE OR REPLACE TEMP VIEW v_window AS
+-- SELECT i, sum(i) over (order by i rows between 1 preceding and 1 following
+-- exclude current row) as sum_rows FROM range(1, 10) i;
+
+-- SELECT * FROM v_window;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- CREATE OR REPLACE TEMP VIEW v_window AS
+-- SELECT i, sum(i) over (order by i rows between 1 preceding and 1 following
+-- exclude group) as sum_rows FROM range(1, 10) i;
+-- SELECT * FROM v_window;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- CREATE OR REPLACE TEMP VIEW v_window AS
+-- SELECT i, sum(i) over (order by i rows between 1 preceding and 1 following
+-- exclude ties) as sum_rows FROM generate_series(1, 10) i;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- CREATE OR REPLACE TEMP VIEW v_window AS
+-- SELECT i, sum(i) over (order by i rows between 1 preceding and 1 following
+-- exclude no others) as sum_rows FROM generate_series(1, 10) i;
+-- SELECT * FROM v_window;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- CREATE OR REPLACE TEMP VIEW v_window AS
+-- SELECT i.id, sum(i.id) over (order by i.id groups between 1 preceding and 1 following) as sum_rows FROM range(1, 11) i;
+-- SELECT * FROM v_window;
+
+DROP VIEW v_window;
+-- [SPARK-29540] Thrift in some cases can't parse string to date
+-- DROP TABLE empsalary;
+DROP VIEW tenk2;
+DROP VIEW int4_tbl;
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/window_part3.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/window_part3.sql
new file mode 100644
index 0000000000..ab8aec2f64
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/window_part3.sql
@@ -0,0 +1,463 @@
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+-- Window Functions Testing
+-- https://github.com/postgres/postgres/blob/REL_12_STABLE/src/test/regress/sql/window.sql#L564-L911
+
+-- Test window operator with codegen on and off.
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=true
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=CODEGEN_ONLY
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=NO_CODEGEN
+
+CREATE TEMPORARY VIEW tenk2 AS SELECT * FROM tenk1;
+
+CREATE TABLE empsalary (
+ depname string,
+ empno integer,
+ salary int,
+ enroll_date date
+) USING parquet;
+
+INSERT INTO empsalary VALUES
+ ('develop', 10, 5200, date '2007-08-01'),
+ ('sales', 1, 5000, date '2006-10-01'),
+ ('personnel', 5, 3500, date '2007-12-10'),
+ ('sales', 4, 4800, date '2007-08-08'),
+ ('personnel', 2, 3900, date '2006-12-23'),
+ ('develop', 7, 4200, date '2008-01-01'),
+ ('develop', 9, 4500, date '2008-01-01'),
+ ('sales', 3, 4800, date '2007-08-01'),
+ ('develop', 8, 6000, date '2006-10-01'),
+ ('develop', 11, 5200, date '2007-08-15');
+
+-- Test in_range for other datetime datatypes
+
+-- Spark only supports timestamp
+-- [SPARK-29636] Spark can't parse '11:00 BST' or '2000-10-19 10:23:54+01' signatures to timestamp
+create table datetimes (
+ id int,
+ f_time timestamp,
+ f_timetz timestamp,
+ f_interval timestamp,
+ f_timestamptz timestamp,
+ f_timestamp timestamp
+) using parquet;
+
+-- Spark cannot safely cast string to timestamp
+-- [SPARK-29636] Spark can't parse '11:00 BST' or '2000-10-19 10:23:54+01' signatures to timestamp
+insert into datetimes values
+(1, timestamp '11:00', cast ('11:00 BST' as timestamp), cast ('1 year' as timestamp), cast ('2000-10-19 10:23:54+01' as timestamp), timestamp '2000-10-19 10:23:54'),
+(2, timestamp '12:00', cast ('12:00 BST' as timestamp), cast ('2 years' as timestamp), cast ('2001-10-19 10:23:54+01' as timestamp), timestamp '2001-10-19 10:23:54'),
+(3, timestamp '13:00', cast ('13:00 BST' as timestamp), cast ('3 years' as timestamp), cast ('2001-10-19 10:23:54+01' as timestamp), timestamp '2001-10-19 10:23:54'),
+(4, timestamp '14:00', cast ('14:00 BST' as timestamp), cast ('4 years' as timestamp), cast ('2002-10-19 10:23:54+01' as timestamp), timestamp '2002-10-19 10:23:54'),
+(5, timestamp '15:00', cast ('15:00 BST' as timestamp), cast ('5 years' as timestamp), cast ('2003-10-19 10:23:54+01' as timestamp), timestamp '2003-10-19 10:23:54'),
+(6, timestamp '15:00', cast ('15:00 BST' as timestamp), cast ('5 years' as timestamp), cast ('2004-10-19 10:23:54+01' as timestamp), timestamp '2004-10-19 10:23:54'),
+(7, timestamp '17:00', cast ('17:00 BST' as timestamp), cast ('7 years' as timestamp), cast ('2005-10-19 10:23:54+01' as timestamp), timestamp '2005-10-19 10:23:54'),
+(8, timestamp '18:00', cast ('18:00 BST' as timestamp), cast ('8 years' as timestamp), cast ('2006-10-19 10:23:54+01' as timestamp), timestamp '2006-10-19 10:23:54'),
+(9, timestamp '19:00', cast ('19:00 BST' as timestamp), cast ('9 years' as timestamp), cast ('2007-10-19 10:23:54+01' as timestamp), timestamp '2007-10-19 10:23:54'),
+(10, timestamp '20:00', cast ('20:00 BST' as timestamp), cast ('10 years' as timestamp), cast ('2008-10-19 10:23:54+01' as timestamp), timestamp '2008-10-19 10:23:54');
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_time, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_time range between
+-- '70 min' preceding and '2 hours' following);
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_time, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_time desc range between
+-- '70 min' preceding and '2 hours' following);
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_timetz, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_timetz range between
+-- '70 min' preceding and '2 hours' following);
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_timetz, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_timetz desc range between
+-- '70 min' preceding and '2 hours' following);
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_interval, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_interval range between
+-- '1 year' preceding and '1 year' following);
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_interval, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_interval desc range between
+-- '1 year' preceding and '1 year' following);
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_timestamptz, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_timestamptz range between
+-- '1 year' preceding and '1 year' following);
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_timestamptz, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_timestamptz desc range between
+-- '1 year' preceding and '1 year' following);
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_timestamp, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_timestamp range between
+-- '1 year' preceding and '1 year' following);
+
+-- [SPARK-28429] SQL Datetime util function being casted to double instead of timestamp
+-- select id, f_timestamp, first(id) over w, last(id) over w
+-- from datetimes
+-- window w as (order by f_timestamp desc range between
+-- '1 year' preceding and '1 year' following);
+
+-- RANGE offset PRECEDING/FOLLOWING error cases
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- select sum(salary) over (order by enroll_date, salary range between '1 year' preceding and '2 years' following
+-- exclude ties), salary, enroll_date from empsalary;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- select sum(salary) over (range between '1 year' preceding and '2 years' following
+-- exclude ties), salary, enroll_date from empsalary;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- select sum(salary) over (order by depname range between '1 year' preceding and '2 years' following
+-- exclude ties), salary, enroll_date from empsalary;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- select max(enroll_date) over (order by enroll_date range between 1 preceding and 2 following
+-- exclude ties), salary, enroll_date from empsalary;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- select max(enroll_date) over (order by salary range between -1 preceding and 2 following
+-- exclude ties), salary, enroll_date from empsalary;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- select max(enroll_date) over (order by salary range between 1 preceding and -2 following
+-- exclude ties), salary, enroll_date from empsalary;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- select max(enroll_date) over (order by salary range between '1 year' preceding and '2 years' following
+-- exclude ties), salary, enroll_date from empsalary;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- select max(enroll_date) over (order by enroll_date range between '1 year' preceding and '-2 years' following
+-- exclude ties), salary, enroll_date from empsalary;
+
+-- GROUPS tests
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (order by four groups between unbounded preceding and current row),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (order by four groups between unbounded preceding and unbounded following),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (order by four groups between current row and unbounded following),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (order by four groups between 1 preceding and unbounded following),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (order by four groups between 1 following and unbounded following),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (order by four groups between unbounded preceding and 2 following),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (order by four groups between 2 preceding and 1 preceding),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (order by four groups between 2 preceding and 1 following),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (order by four groups between 0 preceding and 0 following),
+-- unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (order by four groups between 2 preceding and 1 following
+-- exclude current row), unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (order by four range between 2 preceding and 1 following
+-- exclude group), unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- SELECT sum(unique1) over (order by four range between 2 preceding and 1 following
+-- exclude ties), unique1, four
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (partition by ten
+-- order by four groups between 0 preceding and 0 following),unique1, four, ten
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (partition by ten
+-- order by four groups between 0 preceding and 0 following exclude current row), unique1, four, ten
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (partition by ten
+-- order by four groups between 0 preceding and 0 following exclude group), unique1, four, ten
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- SELECT sum(unique1) over (partition by ten
+-- order by four groups between 0 preceding and 0 following exclude ties), unique1, four, ten
+-- FROM tenk1 WHERE unique1 < 10;
+
+-- [SPARK-27951] ANSI SQL: NTH_VALUE function
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- select first_value(salary) over(order by enroll_date groups between 1 preceding and 1 following),
+-- lead(salary) over(order by enroll_date groups between 1 preceding and 1 following),
+-- nth_value(salary, 1) over(order by enroll_date groups between 1 preceding and 1 following),
+-- salary, enroll_date from empsalary;
+
+-- [SPARK-28508] Support for range frame+row frame in the same query
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- select last(salary) over(order by enroll_date groups between 1 preceding and 1 following),
+-- lag(salary) over(order by enroll_date groups between 1 preceding and 1 following),
+-- salary, enroll_date from empsalary;
+
+-- [SPARK-27951] ANSI SQL: NTH_VALUE function
+-- select first_value(salary) over(order by enroll_date groups between 1 following and 3 following
+-- exclude current row),
+-- lead(salary) over(order by enroll_date groups between 1 following and 3 following exclude ties),
+-- nth_value(salary, 1) over(order by enroll_date groups between 1 following and 3 following
+-- exclude ties),
+-- salary, enroll_date from empsalary;
+
+-- [SPARK-28428] Spark `exclude` always expecting `()`
+-- select last(salary) over(order by enroll_date groups between 1 following and 3 following
+-- exclude group),
+-- lag(salary) over(order by enroll_date groups between 1 following and 3 following exclude group),
+-- salary, enroll_date from empsalary;
+
+-- Show differences in offset interpretation between ROWS, RANGE, and GROUPS
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+WITH cte (x) AS (
+ SELECT * FROM range(1, 36, 2)
+)
+SELECT x, (sum(x) over w)
+FROM cte
+WINDOW w AS (ORDER BY x rows between 1 preceding and 1 following);
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+WITH cte (x) AS (
+ SELECT * FROM range(1, 36, 2)
+)
+SELECT x, (sum(x) over w)
+FROM cte
+WINDOW w AS (ORDER BY x range between 1 preceding and 1 following);
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- WITH cte (x) AS (
+-- SELECT * FROM range(1, 36, 2)
+-- )
+-- SELECT x, (sum(x) over w)
+-- FROM cte
+-- WINDOW w AS (ORDER BY x groups between 1 preceding and 1 following);
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+WITH cte (x) AS (
+ select 1 union all select 1 union all select 1 union all
+ SELECT * FROM range(5, 50, 2)
+)
+SELECT x, (sum(x) over w)
+FROM cte
+WINDOW w AS (ORDER BY x rows between 1 preceding and 1 following);
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+WITH cte (x) AS (
+ select 1 union all select 1 union all select 1 union all
+ SELECT * FROM range(5, 50, 2)
+)
+SELECT x, (sum(x) over w)
+FROM cte
+WINDOW w AS (ORDER BY x range between 1 preceding and 1 following);
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- WITH cte (x) AS (
+-- select 1 union all select 1 union all select 1 union all
+-- SELECT * FROM range(5, 50, 2)
+-- )
+-- SELECT x, (sum(x) over w)
+-- FROM cte
+-- WINDOW w AS (ORDER BY x groups between 1 preceding and 1 following);
+
+-- with UNION
+SELECT count(*) OVER (PARTITION BY four) FROM (SELECT * FROM tenk1 UNION ALL SELECT * FROM tenk2)s LIMIT 0;
+
+-- check some degenerate cases
+create table t1 (f1 int, f2 int) using parquet;
+insert into t1 values (1,1),(1,2),(2,2);
+
+select f1, sum(f1) over (partition by f1
+ range between 1 preceding and 1 following)
+from t1 where f1 = f2; -- error, must have order by
+
+-- Since EXPLAIN clause rely on host physical location, it is commented out
+-- explain
+-- select f1, sum(f1) over (partition by f1 order by f2
+-- range between 1 preceding and 1 following)
+-- from t1 where f1 = f2;
+
+select f1, sum(f1) over (partition by f1 order by f2
+range between 1 preceding and 1 following)
+from t1 where f1 = f2;
+
+select f1, sum(f1) over (partition by f1, f1 order by f2
+range between 2 preceding and 1 preceding)
+from t1 where f1 = f2;
+
+select f1, sum(f1) over (partition by f1, f2 order by f2
+range between 1 following and 2 following)
+from t1 where f1 = f2;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- select f1, sum(f1) over (partition by f1,
+-- groups between 1 preceding and 1 following)
+-- from t1 where f1 = f2;
+
+-- Since EXPLAIN clause rely on host physical location, it is commented out
+-- explain
+-- select f1, sum(f1) over (partition by f1 order by f2
+-- range between 1 preceding and 1 following)
+-- from t1 where f1 = f2;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- select f1, sum(f1) over (partition by f1 order by f2
+-- groups between 1 preceding and 1 following)
+-- from t1 where f1 = f2;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- select f1, sum(f1) over (partition by f1, f1 order by f2
+-- groups between 2 preceding and 1 preceding)
+-- from t1 where f1 = f2;
+
+-- [SPARK-28648] Adds support to `groups` unit type in window clauses
+-- select f1, sum(f1) over (partition by f1, f2 order by f2
+-- groups between 1 following and 2 following)
+-- from t1 where f1 = f2;
+
+-- ordering by a non-integer constant is allowed
+SELECT rank() OVER (ORDER BY length('abc'));
+
+-- can't order by another window function
+-- [SPARK-28566] window functions should not be allowed in window definitions
+-- SELECT rank() OVER (ORDER BY rank() OVER (ORDER BY random()));
+
+-- some other errors
+SELECT * FROM empsalary WHERE row_number() OVER (ORDER BY salary) < 10;
+
+SELECT * FROM empsalary INNER JOIN tenk1 ON row_number() OVER (ORDER BY salary) < 10;
+
+SELECT rank() OVER (ORDER BY 1), count(*) FROM empsalary GROUP BY 1;
+
+SELECT * FROM rank() OVER (ORDER BY random());
+
+-- Original query: DELETE FROM empsalary WHERE (rank() OVER (ORDER BY random())) > 10;
+SELECT * FROM empsalary WHERE (rank() OVER (ORDER BY random())) > 10;
+
+-- Original query: DELETE FROM empsalary RETURNING rank() OVER (ORDER BY random());
+SELECT * FROM empsalary WHERE rank() OVER (ORDER BY random());
+
+-- [SPARK-28645] Throw an error on window redefinition
+-- select count(*) OVER w FROM tenk1 WINDOW w AS (ORDER BY unique1), w AS (ORDER BY unique1);
+
+select rank() OVER (PARTITION BY four, ORDER BY ten) FROM tenk1;
+
+-- [SPARK-28646] Allow usage of `count` only for parameterless aggregate function
+-- select count() OVER () FROM tenk1;
+
+-- The output is the expected one: `range` is not a window or aggregate function.
+SELECT range(1, 100) OVER () FROM empsalary;
+
+SELECT ntile(0) OVER (ORDER BY ten), ten, four FROM tenk1;
+
+SELECT nth_value(four, 0) OVER (ORDER BY ten), ten, four FROM tenk1;
+
+-- filter
+
+-- [SPARK-30182] Support nested aggregates
+-- SELECT sum(salary), row_number() OVER (ORDER BY depname), sum(
+-- sum(salary) FILTER (WHERE enroll_date > '2007-01-01')
+-- )
+-- FROM empsalary GROUP BY depname;
+
+-- Test pushdown of quals into a subquery containing window functions
+
+-- pushdown is safe because all PARTITION BY clauses include depname:
+-- Since EXPLAIN clause rely on host physical location, it is commented out
+-- EXPLAIN
+-- SELECT * FROM
+-- (SELECT depname,
+-- sum(salary) OVER (PARTITION BY depname) depsalary,
+-- min(salary) OVER (PARTITION BY depname || 'A', depname) depminsalary
+-- FROM empsalary) emp
+-- WHERE depname = 'sales';
+
+-- pushdown is unsafe because there's a PARTITION BY clause without depname:
+-- Since EXPLAIN clause rely on host physical location, it is commented out
+-- EXPLAIN
+-- SELECT * FROM
+-- (SELECT depname,
+-- sum(salary) OVER (PARTITION BY enroll_date) enroll_salary,
+-- min(salary) OVER (PARTITION BY depname) depminsalary
+-- FROM empsalary) emp
+-- WHERE depname = 'sales';
+
+-- Test Sort node collapsing
+-- Since EXPLAIN clause rely on host physical location, it is commented out
+-- EXPLAIN
+-- SELECT * FROM
+-- (SELECT depname,
+-- sum(salary) OVER (PARTITION BY depname order by empno) depsalary,
+-- min(salary) OVER (PARTITION BY depname, empno order by enroll_date) depminsalary
+-- FROM empsalary) emp
+-- WHERE depname = 'sales';
+
+-- Test Sort node reordering
+-- Since EXPLAIN clause rely on host physical location, it is commented out
+-- EXPLAIN
+-- SELECT
+-- lead(1) OVER (PARTITION BY depname ORDER BY salary, enroll_date),
+-- lag(1) OVER (PARTITION BY depname ORDER BY salary,enroll_date,empno)
+-- FROM empsalary;
+
+-- cleanup
+DROP TABLE empsalary;
+DROP TABLE datetimes;
+DROP TABLE t1;
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/window_part4.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/window_part4.sql
new file mode 100644
index 0000000000..2836f3d2a7
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/window_part4.sql
@@ -0,0 +1,408 @@
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+-- Window Functions Testing
+-- https://github.com/postgres/postgres/blob/REL_12_STABLE/src/test/regress/sql/window.sql#L913-L1278
+
+-- Test window operator with codegen on and off.
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=true
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=CODEGEN_ONLY
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=NO_CODEGEN
+
+-- Spark doesn't handle UDFs in SQL
+-- test user-defined window function with named args and default args
+-- CREATE FUNCTION nth_value_def(val anyelement, n integer = 1) RETURNS anyelement
+-- LANGUAGE internal WINDOW IMMUTABLE STRICT AS 'window_nth_value';
+
+-- Spark doesn't handle UDFs in SQL
+-- SELECT nth_value_def(n := 2, val := ten) OVER (PARTITION BY four), ten, four
+-- FROM (SELECT * FROM tenk1 WHERE unique2 < 10 ORDER BY four, ten) s;
+
+-- Spark doesn't handle UDFs in SQL
+-- SELECT nth_value_def(ten) OVER (PARTITION BY four), ten, four
+-- FROM (SELECT * FROM tenk1 WHERE unique2 < 10 ORDER BY four, ten) s;
+
+--
+-- Test the basic moving-aggregate machinery
+--
+
+-- create aggregates that record the series of transform calls (these are
+-- intentionally not true inverses)
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE FUNCTION logging_sfunc_nonstrict(text, anyelement) RETURNS text AS
+-- $$ SELECT COALESCE($1, '') || '*' || quote_nullable($2) $$
+-- LANGUAGE SQL IMMUTABLE;
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE FUNCTION logging_msfunc_nonstrict(text, anyelement) RETURNS text AS
+-- $$ SELECT COALESCE($1, '') || '+' || quote_nullable($2) $$
+-- LANGUAGE SQL IMMUTABLE;
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE FUNCTION logging_minvfunc_nonstrict(text, anyelement) RETURNS text AS
+-- $$ SELECT $1 || '-' || quote_nullable($2) $$
+-- LANGUAGE SQL IMMUTABLE;
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE AGGREGATE logging_agg_nonstrict (anyelement)
+-- (
+-- stype = text,
+-- sfunc = logging_sfunc_nonstrict,
+-- mstype = text,
+-- msfunc = logging_msfunc_nonstrict,
+-- minvfunc = logging_minvfunc_nonstrict
+-- );
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE AGGREGATE logging_agg_nonstrict_initcond (anyelement)
+-- (
+-- stype = text,
+-- sfunc = logging_sfunc_nonstrict,
+-- mstype = text,
+-- msfunc = logging_msfunc_nonstrict,
+-- minvfunc = logging_minvfunc_nonstrict,
+-- initcond = 'I',
+-- minitcond = 'MI'
+-- );
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE FUNCTION logging_sfunc_strict(text, anyelement) RETURNS text AS
+-- $$ SELECT $1 || '*' || quote_nullable($2) $$
+-- LANGUAGE SQL STRICT IMMUTABLE;
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE FUNCTION logging_msfunc_strict(text, anyelement) RETURNS text AS
+-- $$ SELECT $1 || '+' || quote_nullable($2) $$
+-- LANGUAGE SQL STRICT IMMUTABLE;
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE FUNCTION logging_minvfunc_strict(text, anyelement) RETURNS text AS
+-- $$ SELECT $1 || '-' || quote_nullable($2) $$
+-- LANGUAGE SQL STRICT IMMUTABLE;
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE AGGREGATE logging_agg_strict (text)
+-- (
+-- stype = text,
+-- sfunc = logging_sfunc_strict,
+-- mstype = text,
+-- msfunc = logging_msfunc_strict,
+-- minvfunc = logging_minvfunc_strict
+-- );
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE AGGREGATE logging_agg_strict_initcond (anyelement)
+-- (
+-- stype = text,
+-- sfunc = logging_sfunc_strict,
+-- mstype = text,
+-- msfunc = logging_msfunc_strict,
+-- minvfunc = logging_minvfunc_strict,
+-- initcond = 'I',
+-- minitcond = 'MI'
+-- );
+
+-- Spark doesn't handle UDFs in SQL
+-- test strict and non-strict cases
+-- SELECT
+-- p::text || ',' || i::text || ':' || COALESCE(v::text, 'NULL') AS row,
+-- logging_agg_nonstrict(v) over wnd as nstrict,
+-- logging_agg_nonstrict_initcond(v) over wnd as nstrict_init,
+-- logging_agg_strict(v::text) over wnd as strict,
+-- logging_agg_strict_initcond(v) over wnd as strict_init
+-- FROM (VALUES
+-- (1, 1, NULL),
+-- (1, 2, 'a'),
+-- (1, 3, 'b'),
+-- (1, 4, NULL),
+-- (1, 5, NULL),
+-- (1, 6, 'c'),
+-- (2, 1, NULL),
+-- (2, 2, 'x'),
+-- (3, 1, 'z')
+-- ) AS t(p, i, v)
+-- WINDOW wnd AS (PARTITION BY P ORDER BY i ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)
+-- ORDER BY p, i;
+
+-- Spark doesn't handle UDFs in SQL
+-- and again, but with filter
+-- SELECT
+-- p::text || ',' || i::text || ':' ||
+-- CASE WHEN f THEN COALESCE(v::text, 'NULL') ELSE '-' END as row,
+-- logging_agg_nonstrict(v) filter(where f) over wnd as nstrict_filt,
+-- logging_agg_nonstrict_initcond(v) filter(where f) over wnd as nstrict_init_filt,
+-- logging_agg_strict(v::text) filter(where f) over wnd as strict_filt,
+-- logging_agg_strict_initcond(v) filter(where f) over wnd as strict_init_filt
+-- FROM (VALUES
+-- (1, 1, true, NULL),
+-- (1, 2, false, 'a'),
+-- (1, 3, true, 'b'),
+-- (1, 4, false, NULL),
+-- (1, 5, false, NULL),
+-- (1, 6, false, 'c'),
+-- (2, 1, false, NULL),
+-- (2, 2, true, 'x'),
+-- (3, 1, true, 'z')
+-- ) AS t(p, i, f, v)
+-- WINDOW wnd AS (PARTITION BY p ORDER BY i ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)
+-- ORDER BY p, i;
+
+-- Spark doesn't handle UDFs in SQL
+-- test that volatile arguments disable moving-aggregate mode
+-- SELECT
+-- i::text || ':' || COALESCE(v::text, 'NULL') as row,
+-- logging_agg_strict(v::text)
+-- over wnd as inverse,
+-- logging_agg_strict(v::text || CASE WHEN random() < 0 then '?' ELSE '' END)
+-- over wnd as noinverse
+-- FROM (VALUES
+-- (1, 'a'),
+-- (2, 'b'),
+-- (3, 'c')
+-- ) AS t(i, v)
+-- WINDOW wnd AS (ORDER BY i ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)
+-- ORDER BY i;
+
+-- Spark doesn't handle UDFs in SQL
+-- SELECT
+-- i::text || ':' || COALESCE(v::text, 'NULL') as row,
+-- logging_agg_strict(v::text) filter(where true)
+-- over wnd as inverse,
+-- logging_agg_strict(v::text) filter(where random() >= 0)
+-- over wnd as noinverse
+-- FROM (VALUES
+-- (1, 'a'),
+-- (2, 'b'),
+-- (3, 'c')
+-- ) AS t(i, v)
+-- WINDOW wnd AS (ORDER BY i ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)
+-- ORDER BY i;
+
+-- Spark doesn't handle UDFs in SQL
+-- test that non-overlapping windows don't use inverse transitions
+-- SELECT
+-- logging_agg_strict(v::text) OVER wnd
+-- FROM (VALUES
+-- (1, 'a'),
+-- (2, 'b'),
+-- (3, 'c')
+-- ) AS t(i, v)
+-- WINDOW wnd AS (ORDER BY i ROWS BETWEEN CURRENT ROW AND CURRENT ROW)
+-- ORDER BY i;
+
+-- Spark doesn't handle UDFs in SQL
+-- test that returning NULL from the inverse transition functions
+-- restarts the aggregation from scratch. The second aggregate is supposed
+-- to test cases where only some aggregates restart, the third one checks
+-- that one aggregate restarting doesn't cause others to restart.
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE FUNCTION sum_int_randrestart_minvfunc(int4, int4) RETURNS int4 AS
+-- $$ SELECT CASE WHEN random() < 0.2 THEN NULL ELSE $1 - $2 END $$
+-- LANGUAGE SQL STRICT;
+
+-- Spark doesn't handle UDFs in SQL
+-- CREATE AGGREGATE sum_int_randomrestart (int4)
+-- (
+-- stype = int4,
+-- sfunc = int4pl,
+-- mstype = int4,
+-- msfunc = int4pl,
+-- minvfunc = sum_int_randrestart_minvfunc
+-- );
+
+-- Spark doesn't handle UDFs in SQL
+-- WITH
+-- vs AS (
+-- SELECT i, (random() * 100)::int4 AS v
+-- FROM generate_series(1, 100) AS i
+-- ),
+-- sum_following AS (
+-- SELECT i, SUM(v) OVER
+-- (ORDER BY i DESC ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS s
+-- FROM vs
+-- )
+-- SELECT DISTINCT
+-- sum_following.s = sum_int_randomrestart(v) OVER fwd AS eq1,
+-- -sum_following.s = sum_int_randomrestart(-v) OVER fwd AS eq2,
+-- 100*3+(vs.i-1)*3 = length(logging_agg_nonstrict(''::text) OVER fwd) AS eq3
+-- FROM vs
+-- JOIN sum_following ON sum_following.i = vs.i
+-- WINDOW fwd AS (
+-- ORDER BY vs.i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING
+-- );
+
+--
+-- Test various built-in aggregates that have moving-aggregate support
+--
+
+-- test inverse transition functions handle NULLs properly
+SELECT i,AVG(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT i,AVG(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT i,AVG(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT i,AVG(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1.5),(2,2.5),(3,NULL),(4,NULL)) t(i,v);
+
+-- [SPARK-28602] Spark does not recognize 'interval' type as 'numeric'
+-- SELECT i,AVG(v::interval) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+-- FROM (VALUES(1,'1 sec'),(2,'2 sec'),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT i,SUM(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT i,SUM(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT i,SUM(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+-- The cast syntax is present in PgSQL for legacy reasons and Spark will not recognize a money field
+-- SELECT i,SUM(v::money) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+-- FROM (VALUES(1,'1.10'),(2,'2.20'),(3,NULL),(4,NULL)) t(i,v);
+
+-- [SPARK-28602] Spark does not recognize 'interval' type as 'numeric'
+-- SELECT i,SUM(cast(v as interval)) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+-- FROM (VALUES(1,'1 sec'),(2,'2 sec'),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT i,SUM(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1.1),(2,2.2),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT SUM(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1.01),(2,2),(3,3)) v(i,n);
+
+SELECT i,COUNT(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT i,COUNT(*) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT VAR_POP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VAR_POP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VAR_POP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VAR_POP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VAR_SAMP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VAR_SAMP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VAR_SAMP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VAR_SAMP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VARIANCE(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VARIANCE(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VARIANCE(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT VARIANCE(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT STDDEV_POP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,NULL),(2,600),(3,470),(4,170),(5,430),(6,300)) r(i,n);
+
+SELECT STDDEV_POP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,NULL),(2,600),(3,470),(4,170),(5,430),(6,300)) r(i,n);
+
+SELECT STDDEV_POP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,NULL),(2,600),(3,470),(4,170),(5,430),(6,300)) r(i,n);
+
+SELECT STDDEV_POP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,NULL),(2,600),(3,470),(4,170),(5,430),(6,300)) r(i,n);
+
+-- For the following queries Spark result differs from PgSQL:
+-- Spark handles division by zero as 'NaN' instead of 'NULL', which is the PgSQL behaviour
+SELECT STDDEV_SAMP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,NULL),(2,600),(3,470),(4,170),(5,430),(6,300)) r(i,n);
+
+SELECT STDDEV_SAMP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,NULL),(2,600),(3,470),(4,170),(5,430),(6,300)) r(i,n);
+
+SELECT STDDEV_SAMP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,NULL),(2,600),(3,470),(4,170),(5,430),(6,300)) r(i,n);
+
+SELECT STDDEV_SAMP(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(1,NULL),(2,600),(3,470),(4,170),(5,430),(6,300)) r(i,n);
+
+SELECT STDDEV(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(0,NULL),(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT STDDEV(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(0,NULL),(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT STDDEV(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(0,NULL),(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+SELECT STDDEV(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ FROM (VALUES(0,NULL),(1,600),(2,470),(3,170),(4,430),(5,300)) r(i,n);
+
+-- test that inverse transition functions work with various frame options
+SELECT i,SUM(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND CURRENT ROW)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+SELECT i,SUM(v) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,NULL),(4,NULL)) t(i,v);
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+SELECT i,SUM(v) OVER (ORDER BY i ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING)
+ FROM (VALUES(1,1),(2,2),(3,3),(4,4)) t(i,v);
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+-- [SPARK-29638] Spark handles 'NaN' as 0 in sums
+-- ensure aggregate over numeric properly recovers from NaN values
+SELECT a, b,
+ SUM(b) OVER(ORDER BY A ROWS BETWEEN 1 PRECEDING AND CURRENT ROW)
+FROM (VALUES(1,1),(2,2),(3,(cast('nan' as int))),(4,3),(5,4)) t(a,b);
+
+-- It might be tempting for someone to add an inverse trans function for
+-- float and double precision. This should not be done as it can give incorrect
+-- results. This test should fail if anyone ever does this without thinking too
+-- hard about it.
+-- [SPARK-28516] adds `to_char`
+-- SELECT to_char(SUM(n) OVER (ORDER BY i ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING),'999999999999999999999D9')
+-- FROM (VALUES(1,1e20),(2,1)) n(i,n);
+
+-- [SPARK-27880] Implement boolean aggregates(BOOL_AND, BOOL_OR and EVERY)
+-- SELECT i, b, bool_and(b) OVER w, bool_or(b) OVER w
+-- FROM (VALUES (1,true), (2,true), (3,false), (4,false), (5,true)) v(i,b)
+-- WINDOW w AS (ORDER BY i ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING);
+
+-- Tests for problems with failure to walk or mutate expressions
+-- within window frame clauses.
+
+-- [SPARK-37612] Support window frame ORDER BY i ROWS BETWEEN (('foo' < 'foobar')::integer) PRECEDING AND CURRENT ROW
+-- test walker (fails with collation error if expressions are not walked)
+-- SELECT array_agg(i) OVER w
+-- FROM range(1,6) i
+-- WINDOW w AS (ORDER BY i ROWS BETWEEN (('foo' < 'foobar')::integer) PRECEDING AND CURRENT ROW);
+
+-- Spark doesn't handle UDFs in SQL
+-- test mutator (fails when inlined if expressions are not mutated)
+-- CREATE FUNCTION pg_temp.f(group_size BIGINT) RETURNS SETOF integer[]
+-- AS $$
+-- SELECT array_agg(s) OVER w
+-- FROM generate_series(1,5) s
+-- WINDOW w AS (ORDER BY s ROWS BETWEEN CURRENT ROW AND GROUP_SIZE FOLLOWING)
+-- $$ LANGUAGE SQL STABLE;
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/random.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/random.sql
similarity index 100%
rename from gluten-ut/spark35/src/test/resources/sql-tests/inputs/random.sql
rename to gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/random.sql
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/regexp-functions.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/regexp-functions.sql
new file mode 100644
index 0000000000..f9cc21ed10
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/regexp-functions.sql
@@ -0,0 +1,79 @@
+-- regexp_extract
+SELECT regexp_extract('1a 2b 14m', '\\d+');
+SELECT regexp_extract('1a 2b 14m', '\\d+', 0);
+SELECT regexp_extract('1a 2b 14m', '\\d+', 1);
+SELECT regexp_extract('1a 2b 14m', '\\d+', 2);
+SELECT regexp_extract('1a 2b 14m', '\\d+', -1);
+SELECT regexp_extract('1a 2b 14m', '(\\d+)?', 1);
+SELECT regexp_extract('a b m', '(\\d+)?', 1);
+SELECT regexp_extract('1a 2b 14m', '(\\d+)([a-z]+)');
+SELECT regexp_extract('1a 2b 14m', '(\\d+)([a-z]+)', 0);
+SELECT regexp_extract('1a 2b 14m', '(\\d+)([a-z]+)', 1);
+SELECT regexp_extract('1a 2b 14m', '(\\d+)([a-z]+)', 2);
+SELECT regexp_extract('1a 2b 14m', '(\\d+)([a-z]+)', 3);
+SELECT regexp_extract('1a 2b 14m', '(\\d+)([a-z]+)', -1);
+SELECT regexp_extract('1a 2b 14m', '(\\d+)?([a-z]+)', 1);
+SELECT regexp_extract('a b m', '(\\d+)?([a-z]+)', 1);
+SELECT regexp_extract('1a 2b 14m', '(?l)');
+
+-- regexp_extract_all
+SELECT regexp_extract_all('1a 2b 14m', '\\d+');
+SELECT regexp_extract_all('1a 2b 14m', '\\d+', 0);
+SELECT regexp_extract_all('1a 2b 14m', '\\d+', 1);
+SELECT regexp_extract_all('1a 2b 14m', '\\d+', 2);
+SELECT regexp_extract_all('1a 2b 14m', '\\d+', -1);
+SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)');
+SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', 0);
+SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', 1);
+SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', 2);
+SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', 3);
+SELECT regexp_extract_all('1a 2b 14m', '(\\d+)([a-z]+)', -1);
+SELECT regexp_extract_all('1a 2b 14m', '(\\d+)?([a-z]+)', 1);
+SELECT regexp_extract_all('abc', col0, 1) FROM VALUES('], [') AS t(col0);
+
+-- regexp_replace
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w+thy', 'something');
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w+thy', 'something', -2);
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w+thy', 'something', 0);
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w+thy', 'something', 1);
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w+thy', 'something', 2);
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w+thy', 'something', 8);
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w', 'something', 26);
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w', 'something', 27);
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w', 'something', 30);
+SELECT regexp_replace('healthy, wealthy, and wise', '\\w', 'something', null);
+
+-- regexp_like
+SELECT regexp_like('1a 2b 14m', '\\d+b');
+SELECT regexp_like('1a 2b 14m', '[a-z]+b');
+SELECT regexp('1a 2b 14m', '\\d+b');
+SELECT regexp('1a 2b 14m', '[a-z]+b');
+SELECT rlike('1a 2b 14m', '\\d+b');
+SELECT rlike('1a 2b 14m', '[a-z]+b');
+
+-- regexp_count
+SELECT regexp_count('1a 2b 14m', '\\d+');
+SELECT regexp_count('1a 2b 14m', 'mmm');
+SELECT regexp_count('the fox', 'FOX');
+SELECT regexp_count('the fox', '(?i)FOX');
+SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+');
+SELECT regexp_count(null, 'abc');
+SELECT regexp_count('abc', null);
+
+-- regexp_substr
+SELECT regexp_substr('1a 2b 14m', '\\d+');
+SELECT regexp_substr('1a 2b 14m', '\\d+ ');
+SELECT regexp_substr('1a 2b 14m', '\\d+(a|b|m)');
+SELECT regexp_substr('1a 2b 14m', '\\d{2}(a|b|m)');
+SELECT regexp_substr('1a 2b 14m', '');
+SELECT regexp_substr('Spark', null);
+SELECT regexp_substr(null, '.*');
+
+-- regexp_instr
+SELECT regexp_instr('abc', 'b');
+SELECT regexp_instr('abc', 'x');
+SELECT regexp_instr('ABC', '(?-i)b');
+SELECT regexp_instr('1a 2b 14m', '\\d{2}(a|b|m)');
+SELECT regexp_instr('abc', null);
+SELECT regexp_instr(null, 'b');
+SELECT regexp_instr('abc', col0, 1) FROM VALUES(') ?') AS t(col0);
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/string-functions.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/string-functions.sql
new file mode 100644
index 0000000000..12290c6da2
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/string-functions.sql
@@ -0,0 +1,255 @@
+-- Argument number exception
+select concat_ws();
+select format_string();
+
+-- A pipe operator for string concatenation
+select 'a' || 'b' || 'c';
+
+-- replace function
+select replace('abc', 'b', '123');
+select replace('abc', 'b');
+
+-- uuid
+select length(uuid()), (uuid() <> uuid());
+
+-- position
+select position('bar' in 'foobarbar'), position(null, 'foobarbar'), position('aaads', null);
+
+-- left && right
+select left("abcd", 2), left("abcd", 5), left("abcd", '2'), left("abcd", null);
+select left(null, -2);
+select left("abcd", -2), left("abcd", 0), left("abcd", 'a');
+select right("abcd", 2), right("abcd", 5), right("abcd", '2'), right("abcd", null);
+select right(null, -2);
+select right("abcd", -2), right("abcd", 0), right("abcd", 'a');
+
+-- split function
+SELECT split('aa1cc2ee3', '[1-9]+');
+SELECT split('aa1cc2ee3', '[1-9]+', 2);
+SELECT split('hello', '');
+SELECT split('', '');
+SELECT split('abc', null);
+SELECT split(null, 'b');
+
+-- split_part function
+SELECT split_part('11.12.13', '.', 2);
+SELECT split_part('11.12.13', '.', -1);
+SELECT split_part('11.12.13', '.', -3);
+SELECT split_part('11.12.13', '', 1);
+SELECT split_part('11ab12ab13', 'ab', 1);
+SELECT split_part('11.12.13', '.', 0);
+SELECT split_part('11.12.13', '.', 4);
+SELECT split_part('11.12.13', '.', 5);
+SELECT split_part('11.12.13', '.', -5);
+SELECT split_part(null, '.', 1);
+SELECT split_part(str, delimiter, partNum) FROM VALUES ('11.12.13', '.', 3) AS v1(str, delimiter, partNum);
+
+-- substring function
+SELECT substr('Spark SQL', 5);
+SELECT substr('Spark SQL', -3);
+SELECT substr('Spark SQL', 5, 1);
+SELECT substr('Spark SQL' from 5);
+SELECT substr('Spark SQL' from -3);
+SELECT substr('Spark SQL' from 5 for 1);
+SELECT substring('Spark SQL', 5);
+SELECT substring('Spark SQL', -3);
+SELECT substring('Spark SQL', 5, 1);
+SELECT substring('Spark SQL' from 5);
+SELECT substring('Spark SQL' from -3);
+SELECT substring('Spark SQL' from 5 for 1);
+
+-- trim
+SELECT trim(" xyz "), ltrim(" xyz "), rtrim(" xyz ");
+SELECT trim(BOTH 'xyz' FROM 'yxTomxx'), trim('xyz' FROM 'yxTomxx');
+SELECT trim(BOTH 'x' FROM 'xxxbarxxx'), trim('x' FROM 'xxxbarxxx');
+SELECT trim(LEADING 'xyz' FROM 'zzzytest');
+SELECT trim(LEADING 'xyz' FROM 'zzzytestxyz');
+SELECT trim(LEADING 'xy' FROM 'xyxXxyLAST WORD');
+SELECT trim(TRAILING 'xyz' FROM 'testxxzx');
+SELECT trim(TRAILING 'xyz' FROM 'xyztestxxzx');
+SELECT trim(TRAILING 'xy' FROM 'TURNERyxXxy');
+
+-- btrim
+SELECT btrim('xyxtrimyyx', 'xy');
+SELECT btrim(encode(" xyz ", 'utf-8'));
+SELECT btrim(encode('yxTomxx', 'utf-8'), encode('xyz', 'utf-8'));
+SELECT btrim(encode('xxxbarxxx', 'utf-8'), encode('x', 'utf-8'));
+
+-- Check lpad/rpad with invalid length parameter
+SELECT lpad('hi', 'invalid_length');
+SELECT rpad('hi', 'invalid_length');
+
+-- lpad for BINARY inputs
+SELECT hex(lpad(unhex(''), 5));
+SELECT hex(lpad(unhex('aabb'), 5));
+SELECT hex(lpad(unhex('aabbcc'), 2));
+SELECT hex(lpad(unhex('123'), 2));
+SELECT hex(lpad(unhex('12345'), 2));
+SELECT hex(lpad(unhex(''), 5, unhex('1f')));
+SELECT hex(lpad(unhex('aa'), 5, unhex('1f')));
+SELECT hex(lpad(unhex('aa'), 6, unhex('1f')));
+SELECT hex(lpad(unhex(''), 5, unhex('1f2e')));
+SELECT hex(lpad(unhex('aa'), 5, unhex('1f2e')));
+SELECT hex(lpad(unhex('aa'), 6, unhex('1f2e')));
+SELECT hex(lpad(unhex(''), 6, unhex('')));
+SELECT hex(lpad(unhex('aabbcc'), 6, unhex('')));
+SELECT hex(lpad(unhex('aabbcc'), 2, unhex('ff')));
+
+-- rpad for BINARY inputs
+SELECT hex(rpad(unhex(''), 5));
+SELECT hex(rpad(unhex('aabb'), 5));
+SELECT hex(rpad(unhex('aabbcc'), 2));
+SELECT hex(rpad(unhex('123'), 2));
+SELECT hex(rpad(unhex('12345'), 2));
+SELECT hex(rpad(unhex(''), 5, unhex('1f')));
+SELECT hex(rpad(unhex('aa'), 5, unhex('1f')));
+SELECT hex(rpad(unhex('aa'), 6, unhex('1f')));
+SELECT hex(rpad(unhex(''), 5, unhex('1f2e')));
+SELECT hex(rpad(unhex('aa'), 5, unhex('1f2e')));
+SELECT hex(rpad(unhex('aa'), 6, unhex('1f2e')));
+SELECT hex(rpad(unhex(''), 6, unhex('')));
+SELECT hex(rpad(unhex('aabbcc'), 6, unhex('')));
+SELECT hex(rpad(unhex('aabbcc'), 2, unhex('ff')));
+
+-- lpad/rpad with mixed STRING and BINARY input
+SELECT lpad('abc', 5, x'57');
+SELECT lpad(x'57', 5, 'abc');
+SELECT rpad('abc', 5, x'57');
+SELECT rpad(x'57', 5, 'abc');
+
+-- decode
+select decode();
+select decode(encode('abc', 'utf-8'));
+select decode(encode('abc', 'utf-8'), 'utf-8');
+select decode(1, 1, 'Southlake');
+select decode(2, 1, 'Southlake');
+select decode(2, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
+select decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle', 'Non domestic');
+select decode(6, 1, 'Southlake', 2, 'San Francisco', 3, 'New Jersey', 4, 'Seattle');
+select decode(null, 6, 'Spark', NULL, 'SQL', 4, 'rocks');
+select decode(null, 6, 'Spark', NULL, 'SQL', 4, 'rocks', NULL, '.');
+
+-- contains
+SELECT CONTAINS(null, 'Spark');
+SELECT CONTAINS('Spark SQL', null);
+SELECT CONTAINS(null, null);
+SELECT CONTAINS('Spark SQL', 'Spark');
+SELECT CONTAINS('Spark SQL', 'SQL');
+SELECT CONTAINS('Spark SQL', 'SPARK');
+
+SELECT startswith('Spark SQL', 'ark');
+SELECT startswith('Spark SQL', 'Spa');
+SELECT startswith(null, 'Spark');
+SELECT startswith('Spark', null);
+SELECT startswith(null, null);
+
+SELECT endswith('Spark SQL', 'QL');
+SELECT endswith('Spark SQL', 'Spa');
+SELECT endswith(null, 'Spark');
+SELECT endswith('Spark', null);
+SELECT endswith(null, null);
+
+SELECT contains(x'537061726b2053514c', x'537061726b');
+SELECT contains(x'', x'');
+SELECT contains(x'537061726b2053514c', null);
+SELECT contains(12, '1');
+SELECT contains(true, 'ru');
+SELECT contains(x'12', 12);
+SELECT contains(true, false);
+
+SELECT startswith(x'537061726b2053514c', x'537061726b');
+SELECT startswith(x'537061726b2053514c', x'');
+SELECT startswith(x'', x'');
+SELECT startswith(x'537061726b2053514c', null);
+
+SELECT endswith(x'537061726b2053514c', x'53516c');
+SELECT endsWith(x'537061726b2053514c', x'537061726b');
+SELECT endsWith(x'537061726b2053514c', x'');
+SELECT endsWith(x'', x'');
+SELECT endsWith(x'537061726b2053514c', null);
+
+-- to_number
+select to_number('454', '000');
+select to_number('454.2', '000.0');
+select to_number('12,454', '00,000');
+select to_number('$78.12', '$00.00');
+select to_number('+454', 'S000');
+select to_number('-454', 'S000');
+select to_number('12,454.8-', '00,000.9MI');
+select to_number('00,454.8-', '00,000.9MI');
+select to_number('<00,454.8>', '00,000.9PR');
+
+-- to_binary
+-- base64 valid
+select to_binary('', 'base64');
+select to_binary(' ', 'base64');
+select to_binary(' ab cd ', 'base64');
+select to_binary(' ab c=', 'base64');
+select to_binary(' ab cdef= = ', 'base64');
+select to_binary(
+ concat(' b25lIHR3byB0aHJlZSBmb3VyIGZpdmUgc2l4IHNldmVuIGVpZ2h0IG5pbmUgdGVuIGVsZXZlbiB0',
+ 'd2VsdmUgdGhpcnRlZW4gZm91cnRlZW4gZml2dGVlbiBzaXh0ZWVuIHNldmVudGVlbiBlaWdodGVl'), 'base64');
+-- base64 invalid
+select to_binary('a', 'base64');
+select to_binary('a?', 'base64');
+select to_binary('abcde', 'base64');
+select to_binary('abcd=', 'base64');
+select to_binary('a===', 'base64');
+select to_binary('ab==f', 'base64');
+-- utf-8
+select to_binary(
+ '∮ E⋅da = Q, n → ∞, ∑ f(i) = ∏ g(i), ∀x∈ℝ: ⌈x⌉ = −⌊−x⌋, α ∧ ¬β = ¬(¬α ∨ β)', 'utf-8');
+select to_binary('大千世界', 'utf8');
+select to_binary('', 'utf-8');
+select to_binary(' ', 'utf8');
+-- hex valid
+select to_binary('737472696E67');
+select to_binary('737472696E67', 'hex');
+select to_binary('');
+select to_binary('1', 'hex');
+select to_binary('FF');
+select to_binary('123', 'hex');
+select to_binary('12345', 'hex');
+-- 'format' parameter can be any foldable string value, not just literal.
+select to_binary('abc', concat('utf', '-8'));
+select to_binary(' ab cdef= = ', substr('base64whynot', 0, 6));
+-- 'format' parameter is case insensitive.
+select to_binary('abc', 'Hex');
+-- null inputs lead to null result.
+select to_binary('abc', null);
+select to_binary(null, 'utf-8');
+select to_binary(null, null);
+select to_binary(null, cast(null as string));
+-- invalid format
+select to_binary('abc', 1);
+select to_binary('abc', 'invalidFormat');
+CREATE TEMPORARY VIEW fmtTable(fmtField) AS SELECT * FROM VALUES ('invalidFormat');
+SELECT to_binary('abc', fmtField) FROM fmtTable;
+-- Clean up
+DROP VIEW IF EXISTS fmtTable;
+-- luhn_check
+-- basic cases
+select luhn_check('4111111111111111');
+select luhn_check('5500000000000004');
+select luhn_check('340000000000009');
+select luhn_check('6011000000000004');
+select luhn_check('6011000000000005');
+select luhn_check('378282246310006');
+select luhn_check('0');
+-- spaces in the beginning/middle/end
+select luhn_check('4111111111111111 ');
+select luhn_check('4111111 111111111');
+select luhn_check(' 4111111111111111');
+-- space
+select luhn_check('');
+select luhn_check(' ');
+-- non-digits
+select luhn_check('510B105105105106');
+select luhn_check('ABCDED');
+-- null
+select luhn_check(null);
+-- non string (test implicit cast)
+select luhn_check(6011111111111117);
+select luhn_check(6011111111111118);
+select luhn_check(123.456);
+
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/subquery/in-subquery/in-null-semantics.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/subquery/in-subquery/in-null-semantics.sql
new file mode 100644
index 0000000000..5c69b895c1
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/subquery/in-subquery/in-null-semantics.sql
@@ -0,0 +1,62 @@
+create temp view v (c) as values (1), (null);
+create temp view v_empty (e) as select 1 where false;
+
+-- Note: tables and temp views hit different optimization/execution codepaths: expressions over temp views are evaled at query compilation time by ConvertToLocalRelation
+create table t(c int) using json;
+insert into t values (1), (null);
+create table t2(d int) using json;
+insert into t2 values (2);
+create table t_empty(e int) using json;
+
+
+
+set spark.sql.legacy.nullInEmptyListBehavior = false;
+
+-- null IN (empty subquery)
+-- Correct results: c in (emptylist) should always be false
+
+select c, c in (select e from t_empty) from t;
+select c, c in (select e from v_empty) from v;
+select c, c not in (select e from t_empty) from t;
+select c, c not in (select e from v_empty) from v;
+
+-- constant null IN (empty subquery) - rewritten by NullPropagation rule
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding;
+
+select null in (select e from t_empty);
+select null in (select e from v_empty);
+select null not in (select e from t_empty);
+select null not in (select e from v_empty);
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+-- IN subquery which is not rewritten to join - here we use IN in the ON condition because that is a case that doesn't get rewritten to join in RewritePredicateSubquery, so we can observe the execution behavior of InSubquery directly
+-- Correct results: column t2.d should be NULL because the ON condition is always false
+select * from t left join t2 on (t.c in (select e from t_empty)) is null;
+select * from t left join t2 on (t.c not in (select e from t_empty)) is null;
+
+
+
+-- Test legacy behavior flag
+set spark.sql.legacy.nullInEmptyListBehavior = true;
+
+-- constant null IN (empty subquery) - rewritten by NullPropagation rule
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding;
+
+select null in (select e from t_empty);
+select null in (select e from v_empty);
+select null not in (select e from t_empty);
+select null not in (select e from v_empty);
+
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation;
+
+-- IN subquery which is not rewritten to join - here we use IN in the ON condition because that is a case that doesn't get rewritten to join in RewritePredicateSubquery, so we can observe the execution behavior of InSubquery directly
+-- Correct results: column t2.d should be NULL because the ON condition is always false
+select * from t left join t2 on (t.c in (select e from t_empty)) is null;
+select * from t left join t2 on (t.c not in (select e from t_empty)) is null;
+
+reset spark.sql.legacy.nullInEmptyListBehavior;
+
+drop table t;
+drop table t2;
+drop table t_empty;
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/table-valued-functions.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/table-valued-functions.sql
similarity index 100%
rename from gluten-ut/spark35/src/test/resources/sql-tests/inputs/table-valued-functions.sql
rename to gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/table-valued-functions.sql
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/timestamp.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/timestamp.sql
new file mode 100644
index 0000000000..ecdbe65f3e
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/timestamp.sql
@@ -0,0 +1,145 @@
+-- timestamp literals, functions and operations
+
+select timestamp '2019-01-01\t';
+select timestamp '2019-01-01中文';
+
+-- invalid: year too large
+select timestamp'4294967297';
+-- invalid: minute field can have at most 2 digits
+select timestamp'2021-01-01T12:30:4294967297.123456';
+
+select current_timestamp = current_timestamp;
+-- under ANSI mode, `current_timestamp` can't be a function name.
+select current_timestamp() = current_timestamp();
+
+select localtimestamp() = localtimestamp();
+
+-- timestamp numeric fields constructor
+SELECT make_timestamp(2021, 07, 11, 6, 30, 45.678);
+SELECT make_timestamp(2021, 07, 11, 6, 30, 45.678, 'CET');
+SELECT make_timestamp(2021, 07, 11, 6, 30, 60.007);
+SELECT make_timestamp(1, 1, 1, 1, 1, 1);
+SELECT make_timestamp(1, 1, 1, 1, 1, 60);
+SELECT make_timestamp(1, 1, 1, 1, 1, 61);
+SELECT make_timestamp(1, 1, 1, 1, 1, null);
+SELECT make_timestamp(1, 1, 1, 1, 1, 59.999999);
+SELECT make_timestamp(1, 1, 1, 1, 1, 99.999999);
+SELECT make_timestamp(1, 1, 1, 1, 1, 999.999999);
+
+-- [SPARK-31710] TIMESTAMP_SECONDS, TIMESTAMP_MILLISECONDS and TIMESTAMP_MICROSECONDS that always create timestamp_ltz
+select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null);
+select TIMESTAMP_SECONDS(1.23), TIMESTAMP_SECONDS(1.23d), TIMESTAMP_SECONDS(FLOAT(1.23));
+select TIMESTAMP_MILLIS(1230219000123),TIMESTAMP_MILLIS(-1230219000123),TIMESTAMP_MILLIS(null);
+select TIMESTAMP_MICROS(1230219000123123),TIMESTAMP_MICROS(-1230219000123123),TIMESTAMP_MICROS(null);
+-- overflow exception
+select TIMESTAMP_SECONDS(1230219000123123);
+select TIMESTAMP_SECONDS(-1230219000123123);
+select TIMESTAMP_MILLIS(92233720368547758);
+select TIMESTAMP_MILLIS(-92233720368547758);
+-- truncate exception
+select TIMESTAMP_SECONDS(0.1234567);
+-- truncation is OK for float/double
+select TIMESTAMP_SECONDS(0.1234567d), TIMESTAMP_SECONDS(FLOAT(0.1234567));
+
+create temporary view ttf2 as select * from values
+ (1, 2),
+ (2, 3)
+ as ttf2(a, b);
+select current_date = current_date(), current_timestamp = current_timestamp(), a, b from ttf2;
+select a, b from ttf2 order by a, current_date;
+
+
+-- UNIX_SECONDS, UNIX_MILLISECONDS and UNIX_MICROSECONDS
+select UNIX_SECONDS(timestamp'2020-12-01 14:30:08Z'), UNIX_SECONDS(timestamp'2020-12-01 14:30:08.999999Z'), UNIX_SECONDS(null);
+select UNIX_MILLIS(timestamp'2020-12-01 14:30:08Z'), UNIX_MILLIS(timestamp'2020-12-01 14:30:08.999999Z'), UNIX_MILLIS(null);
+select UNIX_MICROS(timestamp'2020-12-01 14:30:08Z'), UNIX_MICROS(timestamp'2020-12-01 14:30:08.999999Z'), UNIX_MICROS(null);
+
+select to_timestamp(null), to_timestamp('2016-12-31 00:12:00'), to_timestamp('2016-12-31', 'yyyy-MM-dd');
+select to_timestamp(1);
+-- variable-length second fraction tests
+select to_timestamp('2019-10-06 10:11:12.', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+select to_timestamp('2019-10-06 10:11:12.0', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+select to_timestamp('2019-10-06 10:11:12.1', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+select to_timestamp('2019-10-06 10:11:12.12', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+select to_timestamp('2019-10-06 10:11:12.123UTC', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+select to_timestamp('2019-10-06 10:11:12.1234', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+select to_timestamp('2019-10-06 10:11:12.12345CST', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+select to_timestamp('2019-10-06 10:11:12.123456PST', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+-- second fraction exceeded max variable length
+select to_timestamp('2019-10-06 10:11:12.1234567PST', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+-- special cases
+select to_timestamp('123456 2019-10-06 10:11:12.123456PST', 'SSSSSS yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+select to_timestamp('223456 2019-10-06 10:11:12.123456PST', 'SSSSSS yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
+select to_timestamp('2019-10-06 10:11:12.1234', 'yyyy-MM-dd HH:mm:ss.[SSSSSS]');
+select to_timestamp('2019-10-06 10:11:12.123', 'yyyy-MM-dd HH:mm:ss[.SSSSSS]');
+select to_timestamp('2019-10-06 10:11:12', 'yyyy-MM-dd HH:mm:ss[.SSSSSS]');
+select to_timestamp('2019-10-06 10:11:12.12', 'yyyy-MM-dd HH:mm[:ss.SSSSSS]');
+select to_timestamp('2019-10-06 10:11', 'yyyy-MM-dd HH:mm[:ss.SSSSSS]');
+
+select to_timestamp("2019-10-06S", "yyyy-MM-dd'S'");
+select to_timestamp("S2019-10-06", "'S'yyyy-MM-dd");
+
+select to_timestamp("2019-10-06T10:11:12'", "yyyy-MM-dd'T'HH:mm:ss''"); -- tail
+select to_timestamp("'2019-10-06T10:11:12", "''yyyy-MM-dd'T'HH:mm:ss"); -- head
+select to_timestamp("P2019-10-06T10:11:12", "'P'yyyy-MM-dd'T'HH:mm:ss"); -- head but as single quote
+
+-- missing fields
+select to_timestamp("2019 40", "yyyy mm");
+select to_timestamp("2019 10:10:10", "yyyy hh:mm:ss");
+
+-- timestamp - timestamp
+select timestamp'2011-11-11 11:11:11' - timestamp'2011-11-11 11:11:10';
+select date'2020-01-01' - timestamp'2019-10-06 10:11:12.345678';
+select timestamp'2019-10-06 10:11:12.345678' - date'2020-01-01';
+-- if one side is string/null literal, promote it to timestamp type.
+select timestamp'2011-11-11 11:11:11' - '2011-11-11 11:11:10';
+select '2011-11-11 11:11:11' - timestamp'2011-11-11 11:11:10';
+select timestamp'2011-11-11 11:11:11' - null;
+select null - timestamp'2011-11-11 11:11:11';
+-- invalid: non-literal string column
+create temporary view ts_view as select '2011-11-11 11:11:11' str;
+select str - timestamp'2011-11-11 11:11:11' from ts_view;
+select timestamp'2011-11-11 11:11:11' - str from ts_view;
+
+-- invalid: timestamp + string literal
+select timestamp'2011-11-11 11:11:11' + '1';
+select '1' + timestamp'2011-11-11 11:11:11';
+
+-- null result: timestamp + null
+select timestamp'2011-11-11 11:11:11' + null;
+select null + timestamp'2011-11-11 11:11:11';
+
+-- timestamp +/- interval and interval + timestamp
+select timestamp'2011-11-11 11:11:11' + interval '2' day,
+ timestamp'2011-11-11 11:11:11' - interval '2-2' year to month,
+ timestamp'2011-11-11 11:11:11' + interval '-2' second,
+ timestamp'2011-11-11 11:11:11' - interval '12:12:12.123456789' hour to second,
+ - interval 2 years + timestamp'2011-11-11 11:11:11',
+ interval '1 12' day to hour + timestamp'2011-11-11 11:11:11';
+-- promote date to timestamp if the interval is hour to second.
+select date '2012-01-01' - interval 3 hours,
+ date '2012-01-01' + interval '12:12:12' hour to second,
+ interval '2' minute + date '2012-01-01';
+
+-- Unsupported narrow text style
+select to_timestamp('2019-10-06 A', 'yyyy-MM-dd GGGGG');
+select from_json('{"t":"26/October/2015"}', 't Timestamp', map('timestampFormat', 'dd/MMMMM/yyyy'));
+select from_csv('26/October/2015', 't Timestamp', map('timestampFormat', 'dd/MMMMM/yyyy'));
+
+-- Add a number of units to a timestamp or a date
+select timestampadd(MONTH, -1, timestamp'2022-02-14 01:02:03');
+select timestampadd(MINUTE, 58, timestamp'2022-02-14 01:02:03');
+select timestampadd(YEAR, 1, date'2022-02-15');
+select timestampadd(SECOND, -1, date'2022-02-15');
+
+select timestampadd('MONTH', -1, timestamp'2022-02-14 01:02:03');
+select timestampadd('SECOND', -1, date'2022-02-15');
+
+-- Get the difference between timestamps in the specified units
+select timestampdiff(MONTH, timestamp'2022-02-14 01:02:03', timestamp'2022-01-14 01:02:03');
+select timestampdiff(MINUTE, timestamp'2022-02-14 01:02:03', timestamp'2022-02-14 02:00:03');
+select timestampdiff(YEAR, date'2022-02-15', date'2023-02-15');
+select timestampdiff(SECOND, date'2022-02-15', timestamp'2022-02-14 23:59:59');
+
+select timestampdiff('MINUTE', timestamp'2022-02-14 01:02:03', timestamp'2022-02-14 02:00:03');
+select timestampdiff('YEAR', date'2022-02-15', date'2023-02-15');
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_arithmetic.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_arithmetic.sql
new file mode 100644
index 0000000000..c7957e0f39
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_arithmetic.sql
@@ -0,0 +1,88 @@
+-- Numeric + Numeric
+SELECT try_add(1, 1);
+SELECT try_add(2147483647, 1);
+SELECT try_add(2147483647, decimal(1));
+SELECT try_add(2147483647, "1");
+SELECT try_add(-2147483648, -1);
+SELECT try_add(9223372036854775807L, 1);
+SELECT try_add(-9223372036854775808L, -1);
+SELECT try_add(1, 1.0 / 0.0);
+
+-- Date + Integer
+SELECT try_add(date'2021-01-01', 1);
+SELECT try_add(1, date'2021-01-01');
+
+-- Date + Interval
+SELECT try_add(date'2021-01-01', interval 2 year);
+SELECT try_add(date'2021-01-01', interval 2 second);
+SELECT try_add(interval 2 year, date'2021-01-01');
+SELECT try_add(interval 2 second, date'2021-01-01');
+
+-- Timestamp + Interval
+SELECT try_add(timestamp_ltz'2021-01-01 00:00:00', interval 2 year);
+SELECT try_add(timestamp_ntz'2021-01-01 00:00:00', interval 2 second);
+SELECT try_add(interval 2 year, timestamp_ltz'2021-01-01 00:00:00');
+SELECT try_add(interval 2 second, timestamp_ntz'2021-01-01 00:00:00');
+
+-- Interval + Interval
+SELECT try_add(interval 2 year, interval 2 year);
+SELECT try_add(interval 2 second, interval 2 second);
+SELECT try_add(interval 2 year, interval 2 second);
+SELECT try_add(interval 2147483647 month, interval 2 month);
+SELECT try_add(interval 106751991 day, interval 3 day);
+
+-- Numeric / Numeric
+SELECT try_divide(1, 0.5);
+SELECT try_divide(1, 0);
+SELECT try_divide(0, 0);
+SELECT try_divide(1, (2147483647 + 1));
+SELECT try_divide(1L, (9223372036854775807L + 1L));
+SELECT try_divide(1, 1.0 / 0.0);
+SELECT try_divide(1, decimal(0));
+SELECT try_divide(1, "0");
+
+-- Interval / Numeric
+SELECT try_divide(interval 2 year, 2);
+SELECT try_divide(interval 2 second, 2);
+SELECT try_divide(interval 2 year, 0);
+SELECT try_divide(interval 2 second, 0);
+SELECT try_divide(interval 2147483647 month, 0.5);
+SELECT try_divide(interval 106751991 day, 0.5);
+
+-- Numeric - Numeric
+SELECT try_subtract(1, 1);
+SELECT try_subtract(2147483647, -1);
+SELECT try_subtract(2147483647, decimal(-1));
+SELECT try_subtract(2147483647, "-1");
+SELECT try_subtract(-2147483648, 1);
+SELECT try_subtract(9223372036854775807L, -1);
+SELECT try_subtract(-9223372036854775808L, 1);
+SELECT try_subtract(1, (2147483647 + 1));
+SELECT try_subtract(1L, (9223372036854775807L + 1L));
+SELECT try_subtract(1, 1.0 / 0.0);
+
+-- Interval - Interval
+SELECT try_subtract(interval 2 year, interval 3 year);
+SELECT try_subtract(interval 3 second, interval 2 second);
+SELECT try_subtract(interval 2147483647 month, interval -2 month);
+SELECT try_subtract(interval 106751991 day, interval -3 day);
+
+-- Numeric * Numeric
+SELECT try_multiply(2, 3);
+SELECT try_multiply(2147483647, -2);
+SELECT try_multiply(2147483647, decimal(-2));
+SELECT try_multiply(2147483647, "-2");
+SELECT try_multiply(-2147483648, 2);
+SELECT try_multiply(9223372036854775807L, 2);
+SELECT try_multiply(-9223372036854775808L, -2);
+SELECT try_multiply(1, (2147483647 + 1));
+SELECT try_multiply(1L, (9223372036854775807L + 1L));
+SELECT try_multiply(1, 1.0 / 0.0);
+
+-- Interval * Numeric
+SELECT try_multiply(interval 2 year, 2);
+SELECT try_multiply(interval 2 second, 2);
+SELECT try_multiply(interval 2 year, 0);
+SELECT try_multiply(interval 2 second, 0);
+SELECT try_multiply(interval 2147483647 month, 2);
+SELECT try_multiply(interval 106751991 day, 2);
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_cast.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_cast.sql
new file mode 100644
index 0000000000..92c71e2bd4
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_cast.sql
@@ -0,0 +1,50 @@
+-- TRY_CAST string representing a valid fractional number to integral should truncate the number
+
+-- TRY_CAST string which are not numbers to integral should return null
+SELECT TRY_CAST('abc' AS int);
+SELECT TRY_CAST('abc' AS long);
+
+-- TRY_CAST empty string to integral should return null
+SELECT TRY_CAST('' AS int);
+SELECT TRY_CAST('' AS long);
+
+-- TRY_CAST null to integral should return null
+SELECT TRY_CAST(NULL AS int);
+SELECT TRY_CAST(NULL AS long);
+
+-- TRY_CAST invalid decimal string to integral should return null
+SELECT TRY_CAST('123.a' AS int);
+SELECT TRY_CAST('123.a' AS long);
+
+-- '-2147483648' is the smallest int value
+SELECT TRY_CAST('-2147483648' AS int);
+SELECT TRY_CAST('-2147483649' AS int);
+
+-- '2147483647' is the largest int value
+SELECT TRY_CAST('2147483647' AS int);
+SELECT TRY_CAST('2147483648' AS int);
+
+-- '-9223372036854775808' is the smallest long value
+SELECT TRY_CAST('-9223372036854775808' AS long);
+SELECT TRY_CAST('-9223372036854775809' AS long);
+
+-- '9223372036854775807' is the largest long value
+SELECT TRY_CAST('9223372036854775807' AS long);
+SELECT TRY_CAST('9223372036854775808' AS long);
+
+-- TRY_CAST string to interval and interval to string
+SELECT TRY_CAST('interval 3 month 1 hour' AS interval);
+SELECT TRY_CAST('abc' AS interval);
+
+-- TRY_CAST string to boolean
+select TRY_CAST('true' as boolean);
+select TRY_CAST('false' as boolean);
+select TRY_CAST('abc' as boolean);
+
+-- TRY_CAST string to date
+SELECT TRY_CAST("2021-01-01" AS date);
+SELECT TRY_CAST("2021-101-01" AS date);
+
+-- TRY_CAST string to timestamp
+SELECT TRY_CAST("2021-01-01 00:00:00" AS timestamp);
+SELECT TRY_CAST("2021-101-01 00:00:00" AS timestamp);
\ No newline at end of file
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_datetime_functions.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_datetime_functions.sql
new file mode 100644
index 0000000000..755d0542f8
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_datetime_functions.sql
@@ -0,0 +1,4 @@
+select try_to_timestamp(null), try_to_timestamp('2016-12-31 00:12:00'), try_to_timestamp('2016-12-31', 'yyyy-MM-dd');
+select try_to_timestamp(1);
+select try_to_timestamp('2016-12-31 abc');
+select try_to_timestamp('2019-10-06 10:11:12.', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]');
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_element_at.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_element_at.sql
new file mode 100644
index 0000000000..c02c2dcb34
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/try_element_at.sql
@@ -0,0 +1,11 @@
+-- array input
+SELECT try_element_at(array(1, 2, 3), 0);
+SELECT try_element_at(array(1, 2, 3), 1);
+SELECT try_element_at(array(1, 2, 3), 3);
+SELECT try_element_at(array(1, 2, 3), 4);
+SELECT try_element_at(array(1, 2, 3), -1);
+SELECT try_element_at(array(1, 2, 3), -4);
+
+-- map input
+SELECT try_element_at(map('a','b'), 'a');
+SELECT try_element_at(map('a','b'), 'abc');
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/typeCoercion/native/stringCastAndExpressions.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/typeCoercion/native/stringCastAndExpressions.sql
new file mode 100644
index 0000000000..731dbc2dcf
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/typeCoercion/native/stringCastAndExpressions.sql
@@ -0,0 +1,54 @@
+--
+-- 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.
+--
+
+CREATE TEMPORARY VIEW t AS SELECT 'aa' as a;
+
+-- casting to data types which are unable to represent the string input returns NULL
+select cast(a as byte) from t;
+select cast(a as short) from t;
+select cast(a as int) from t;
+select cast(a as long) from t;
+select cast(a as float) from t;
+select cast(a as double) from t;
+select cast(a as decimal) from t;
+select cast(a as boolean) from t;
+select cast(a as timestamp) from t;
+select cast(a as date) from t;
+-- casting to binary works correctly
+select cast(a as binary) from t;
+-- casting to array, struct or map throws exception
+select cast(a as array<string>) from t;
+select cast(a as struct<s:string>) from t;
+select cast(a as map<string, string>) from t;
+
+-- all timestamp/date expressions return NULL if bad input strings are provided
+select to_timestamp(a) from t;
+select to_unix_timestamp(a) from t;
+select unix_timestamp(a) from t;
+select from_unixtime(a) from t;
+select from_unixtime('2018-01-01', a) from t;
+select next_day(a, 'MO') from t;
+select next_day('2018-01-01', a) from t;
+select trunc(a, 'MM') from t;
+select trunc('2018-01-01', a) from t;
+
+-- some functions return NULL if bad input is provided
+select unhex('-123');
+select sha2(a, a) from t;
+select get_json_object(a, a) from t;
+select json_tuple(a, a) from t;
+select from_json(a, 'a INT') from t;
diff --git a/gluten-ut/spark35/src/test/resources/sql-tests/inputs/udf/udf-group-by.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/udf/udf-group-by.sql
similarity index 100%
rename from gluten-ut/spark35/src/test/resources/sql-tests/inputs/udf/udf-group-by.sql
rename to gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/udf/udf-group-by.sql
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/url-functions.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/url-functions.sql
new file mode 100644
index 0000000000..be69e5ffb8
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/url-functions.sql
@@ -0,0 +1,20 @@
+-- parse_url function
+select parse_url('http://userinfo@spark.apache.org/path?query=1#Ref', 'HOST');
+select parse_url('http://userinfo@spark.apache.org/path?query=1#Ref', 'PATH');
+select parse_url('http://userinfo@spark.apache.org/path?query=1#Ref', 'QUERY');
+select parse_url('http://userinfo@spark.apache.org/path?query=1#Ref', 'REF');
+select parse_url('http://userinfo@spark.apache.org/path?query=1#Ref', 'PROTOCOL');
+select parse_url('http://userinfo@spark.apache.org/path?query=1#Ref', 'FILE');
+select parse_url('http://userinfo@spark.apache.org/path?query=1#Ref', 'AUTHORITY');
+select parse_url('http://userinfo@spark.apache.org/path?query=1#Ref', 'USERINFO');
+
+-- url_encode function
+select url_encode('https://spark.apache.org');
+select url_encode('inva lid://user:pass@host/file\\;param?query\\;p2');
+select url_encode(null);
+
+-- url_decode function
+select url_decode('https%3A%2F%2Fspark.apache.org');
+select url_decode('http%3A%2F%2spark.apache.org');
+select url_decode('inva lid://user:pass@host/file\\;param?query\\;p2');
+select url_decode(null);
\ No newline at end of file
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/window.sql b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/window.sql
new file mode 100644
index 0000000000..a1728a1961
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/inputs/window.sql
@@ -0,0 +1,477 @@
+-- Test window operator with codegen on and off.
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=true
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=CODEGEN_ONLY
+--CONFIG_DIM1 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=NO_CODEGEN
+--CONFIG_DIM2 spark.sql.optimizer.windowGroupLimitThreshold=-1
+--CONFIG_DIM2 spark.sql.optimizer.windowGroupLimitThreshold=1000
+
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(null, 1L, 1.0D, date("2017-08-01"), timestamp_seconds(1501545600), "a"),
+(1, 1L, 1.0D, date("2017-08-01"), timestamp_seconds(1501545600), "a"),
+(1, 2L, 2.5D, date("2017-08-02"), timestamp_seconds(1502000000), "a"),
+(2, 2147483650L, 100.001D, date("2020-12-31"), timestamp_seconds(1609372800), "a"),
+(1, null, 1.0D, date("2017-08-01"), timestamp_seconds(1501545600), "b"),
+(2, 3L, 3.3D, date("2017-08-03"), timestamp_seconds(1503000000), "b"),
+(3, 2147483650L, 100.001D, date("2020-12-31"), timestamp_seconds(1609372800), "b"),
+(null, null, null, null, null, null),
+(3, 1L, 1.0D, date("2017-08-01"), timestamp_seconds(1501545600), null)
+AS testData(val, val_long, val_double, val_date, val_timestamp, cate);
+
+CREATE OR REPLACE TEMPORARY VIEW basic_pays AS SELECT * FROM VALUES
+('Diane Murphy','Accounting',8435),
+('Mary Patterson','Accounting',9998),
+('Jeff Firrelli','Accounting',8992),
+('William Patterson','Accounting',8870),
+('Gerard Bondur','Accounting',11472),
+('Anthony Bow','Accounting',6627),
+('Leslie Jennings','IT',8113),
+('Leslie Thompson','IT',5186),
+('Julie Firrelli','Sales',9181),
+('Steve Patterson','Sales',9441),
+('Foon Yue Tseng','Sales',6660),
+('George Vanauf','Sales',10563),
+('Loui Bondur','SCM',10449),
+('Gerard Hernandez','SCM',6949),
+('Pamela Castillo','SCM',11303),
+('Larry Bott','SCM',11798),
+('Barry Jones','SCM',10586)
+AS basic_pays(employee_name, department, salary);
+
+CREATE OR REPLACE TEMPORARY VIEW test_ignore_null AS SELECT * FROM VALUES
+('a', 0, null),
+('a', 1, 'x'),
+('b', 2, null),
+('c', 3, null),
+('a', 4, 'y'),
+('b', 5, null),
+('a', 6, 'z'),
+('a', 7, 'v'),
+('a', 8, null)
+AS test_ignore_null(content, id, v);
+
+-- RowsBetween
+SELECT val, cate, count(val) OVER(PARTITION BY cate ORDER BY val ROWS CURRENT ROW) FROM testData
+ORDER BY cate, val;
+SELECT val, cate, sum(val) OVER(PARTITION BY cate ORDER BY val
+ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING) FROM testData ORDER BY cate, val;
+SELECT val_long, cate, sum(val_long) OVER(PARTITION BY cate ORDER BY val_long
+ROWS BETWEEN CURRENT ROW AND 2147483648 FOLLOWING) FROM testData ORDER BY cate, val_long;
+
+-- RangeBetween
+SELECT val, cate, count(val) OVER(PARTITION BY cate ORDER BY val RANGE 1 PRECEDING) FROM testData
+ORDER BY cate, val;
+SELECT val, cate, sum(val) OVER(PARTITION BY cate ORDER BY val
+RANGE BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM testData ORDER BY cate, val;
+SELECT val_long, cate, sum(val_long) OVER(PARTITION BY cate ORDER BY val_long
+RANGE BETWEEN CURRENT ROW AND 2147483648 FOLLOWING) FROM testData ORDER BY cate, val_long;
+SELECT val_double, cate, sum(val_double) OVER(PARTITION BY cate ORDER BY val_double
+RANGE BETWEEN CURRENT ROW AND 2.5 FOLLOWING) FROM testData ORDER BY cate, val_double;
+SELECT val_date, cate, max(val_date) OVER(PARTITION BY cate ORDER BY val_date
+RANGE BETWEEN CURRENT ROW AND 2 FOLLOWING) FROM testData ORDER BY cate, val_date;
+SELECT val_timestamp, cate, avg(val_timestamp) OVER(PARTITION BY cate ORDER BY val_timestamp
+RANGE BETWEEN CURRENT ROW AND interval 23 days 4 hours FOLLOWING) FROM testData
+ORDER BY cate, val_timestamp;
+SELECT val_timestamp, cate, avg(val_timestamp) OVER(PARTITION BY cate ORDER BY to_timestamp_ntz(val_timestamp)
+RANGE BETWEEN CURRENT ROW AND interval 23 days 4 hours FOLLOWING) FROM testData
+ORDER BY cate, to_timestamp_ntz(val_timestamp);
+SELECT val_timestamp, cate, avg(val_timestamp) OVER(PARTITION BY cate ORDER BY val_timestamp
+RANGE BETWEEN CURRENT ROW AND interval '1-1' year to month FOLLOWING) FROM testData
+ORDER BY cate, val_timestamp;
+SELECT val_timestamp, cate, avg(val_timestamp) OVER(PARTITION BY cate ORDER BY to_timestamp_ntz(val_timestamp)
+RANGE BETWEEN CURRENT ROW AND interval '1-1' year to month FOLLOWING) FROM testData
+ORDER BY cate, to_timestamp_ntz(val_timestamp);
+SELECT val_timestamp, cate, avg(val_timestamp) OVER(PARTITION BY cate ORDER BY val_timestamp
+RANGE BETWEEN CURRENT ROW AND interval '1 2:3:4.001' day to second FOLLOWING) FROM testData
+ORDER BY cate, val_timestamp;
+SELECT val_timestamp, cate, avg(val_timestamp) OVER(PARTITION BY cate ORDER BY to_timestamp_ntz(val_timestamp)
+RANGE BETWEEN CURRENT ROW AND interval '1 2:3:4.001' day to second FOLLOWING) FROM testData
+ORDER BY cate, to_timestamp_ntz(val_timestamp);
+SELECT val_date, cate, avg(val_timestamp) OVER(PARTITION BY cate ORDER BY val_date
+RANGE BETWEEN CURRENT ROW AND interval '1 2:3:4.001' day to second FOLLOWING) FROM testData
+ORDER BY cate, val_date;
+
+-- RangeBetween with reverse OrderBy
+SELECT val, cate, sum(val) OVER(PARTITION BY cate ORDER BY val DESC
+RANGE BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM testData ORDER BY cate, val;
+
+-- Invalid window frame
+SELECT val, cate, count(val) OVER(PARTITION BY cate
+ROWS BETWEEN UNBOUNDED FOLLOWING AND 1 FOLLOWING) FROM testData ORDER BY cate, val;
+SELECT val, cate, count(val) OVER(PARTITION BY cate
+RANGE BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM testData ORDER BY cate, val;
+SELECT val, cate, count(val) OVER(PARTITION BY cate ORDER BY val, cate
+RANGE BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM testData ORDER BY cate, val;
+SELECT val, cate, count(val) OVER(PARTITION BY cate ORDER BY current_timestamp
+RANGE BETWEEN CURRENT ROW AND 1 FOLLOWING) FROM testData ORDER BY cate, val;
+SELECT val, cate, count(val) OVER(PARTITION BY cate ORDER BY val
+RANGE BETWEEN 1 FOLLOWING AND 1 PRECEDING) FROM testData ORDER BY cate, val;
+SELECT val, cate, count(val) OVER(PARTITION BY cate ORDER BY val
+RANGE BETWEEN CURRENT ROW AND current_date PRECEDING) FROM testData ORDER BY cate, val;
+
+
+-- Window functions
+SELECT val, cate,
+max(val) OVER w AS max,
+min(val) OVER w AS min,
+min(val) OVER w AS min,
+count(val) OVER w AS count,
+sum(val) OVER w AS sum,
+avg(val) OVER w AS avg,
+stddev(val) OVER w AS stddev,
+first_value(val) OVER w AS first_value,
+first_value(val, true) OVER w AS first_value_ignore_null,
+first_value(val, false) OVER w AS first_value_contain_null,
+any_value(val) OVER w AS any_value,
+any_value(val, true) OVER w AS any_value_ignore_null,
+any_value(val, false) OVER w AS any_value_contain_null,
+last_value(val) OVER w AS last_value,
+last_value(val, true) OVER w AS last_value_ignore_null,
+last_value(val, false) OVER w AS last_value_contain_null,
+rank() OVER w AS rank,
+dense_rank() OVER w AS dense_rank,
+cume_dist() OVER w AS cume_dist,
+percent_rank() OVER w AS percent_rank,
+ntile(2) OVER w AS ntile,
+row_number() OVER w AS row_number,
+var_pop(val) OVER w AS var_pop,
+var_samp(val) OVER w AS var_samp,
+approx_count_distinct(val) OVER w AS approx_count_distinct,
+covar_pop(val, val_long) OVER w AS covar_pop,
+corr(val, val_long) OVER w AS corr,
+stddev_samp(val) OVER w AS stddev_samp,
+stddev_pop(val) OVER w AS stddev_pop,
+collect_list(val) OVER w AS collect_list,
+collect_set(val) OVER w AS collect_set,
+skewness(val_double) OVER w AS skewness,
+kurtosis(val_double) OVER w AS kurtosis
+FROM testData
+WINDOW w AS (PARTITION BY cate ORDER BY val)
+ORDER BY cate, val;
+
+-- Null inputs
+SELECT val, cate, avg(null) OVER(PARTITION BY cate ORDER BY val) FROM testData ORDER BY cate, val;
+
+-- OrderBy not specified
+SELECT val, cate, row_number() OVER(PARTITION BY cate) FROM testData ORDER BY cate, val;
+
+-- Over clause is empty
+SELECT val, cate, sum(val) OVER(), avg(val) OVER() FROM testData ORDER BY cate, val;
+
+-- first_value()/last_value()/any_value() over ()
+SELECT val, cate,
+first_value(false) OVER w AS first_value,
+first_value(true, true) OVER w AS first_value_ignore_null,
+first_value(false, false) OVER w AS first_value_contain_null,
+any_value(false) OVER w AS any_value,
+any_value(true, true) OVER w AS any_value_ignore_null,
+any_value(false, false) OVER w AS any_value_contain_null,
+last_value(false) OVER w AS last_value,
+last_value(true, true) OVER w AS last_value_ignore_null,
+last_value(false, false) OVER w AS last_value_contain_null
+FROM testData
+WINDOW w AS ()
+ORDER BY cate, val;
+
+-- parentheses around window reference
+SELECT cate, sum(val) OVER (w)
+FROM testData
+WHERE val is not null
+WINDOW w AS (PARTITION BY cate ORDER BY val);
+
+-- with filter predicate
+SELECT val, cate,
+count(val) FILTER (WHERE val > 1) OVER(PARTITION BY cate)
+FROM testData ORDER BY cate, val;
+
+-- nth_value()/first_value()/any_value() over ()
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (ORDER BY salary DESC)
+ORDER BY salary DESC;
+
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (ORDER BY salary DESC RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+ORDER BY salary DESC;
+
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (ORDER BY salary DESC ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+ORDER BY salary DESC;
+
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (ORDER BY salary RANGE BETWEEN 2000 PRECEDING AND 1000 FOLLOWING)
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (ORDER BY salary DESC ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)
+ORDER BY salary DESC;
+
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (ORDER BY salary DESC RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ORDER BY salary DESC;
+
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (ORDER BY salary DESC RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
+ORDER BY salary DESC;
+
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (ORDER BY salary DESC ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
+ORDER BY salary DESC;
+
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (ORDER BY salary DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)
+ORDER BY salary DESC;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ FIRST_VALUE(employee_name) OVER w highest_salary,
+ NTH_VALUE(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW w AS (
+ PARTITION BY department
+ ORDER BY salary DESC
+ RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING
+)
+ORDER BY department;
+
+SELECT
+ employee_name,
+ salary,
+ first_value(employee_name) OVER w highest_salary,
+ any_value(employee_name) OVER w highest_salary,
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays
+WINDOW
+ w AS (ORDER BY salary DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING),
+ w AS (ORDER BY salary DESC ROWS BETWEEN UNBOUNDED PRECEDING AND 2 FOLLOWING)
+ORDER BY salary DESC;
+
+SELECT
+ content,
+ id,
+ v,
+ lead(v, 0) IGNORE NULLS OVER w lead_0,
+ lead(v, 1) IGNORE NULLS OVER w lead_1,
+ lead(v, 2) IGNORE NULLS OVER w lead_2,
+ lead(v, 3) IGNORE NULLS OVER w lead_3,
+ lag(v, 0) IGNORE NULLS OVER w lag_0,
+ lag(v, 1) IGNORE NULLS OVER w lag_1,
+ lag(v, 2) IGNORE NULLS OVER w lag_2,
+ lag(v, 3) IGNORE NULLS OVER w lag_3,
+ nth_value(v, 1) IGNORE NULLS OVER w nth_value_1,
+ nth_value(v, 2) IGNORE NULLS OVER w nth_value_2,
+ nth_value(v, 3) IGNORE NULLS OVER w nth_value_3,
+ first_value(v) IGNORE NULLS OVER w first_value,
+ any_value(v) IGNORE NULLS OVER w any_value,
+ last_value(v) IGNORE NULLS OVER w last_value
+FROM
+ test_ignore_null
+WINDOW w AS (ORDER BY id)
+ORDER BY id;
+
+SELECT
+ content,
+ id,
+ v,
+ nth_value(v, 1) IGNORE NULLS OVER w nth_value_1,
+ nth_value(v, 2) IGNORE NULLS OVER w nth_value_2,
+ nth_value(v, 3) IGNORE NULLS OVER w nth_value_3,
+ first_value(v) IGNORE NULLS OVER w first_value,
+ any_value(v) IGNORE NULLS OVER w any_value,
+ last_value(v) IGNORE NULLS OVER w last_value
+FROM
+ test_ignore_null
+WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+ORDER BY id;
+
+SELECT
+ content,
+ id,
+ v,
+ nth_value(v, 1) IGNORE NULLS OVER w nth_value_1,
+ nth_value(v, 2) IGNORE NULLS OVER w nth_value_2,
+ nth_value(v, 3) IGNORE NULLS OVER w nth_value_3,
+ first_value(v) IGNORE NULLS OVER w first_value,
+ any_value(v) IGNORE NULLS OVER w any_value,
+ last_value(v) IGNORE NULLS OVER w last_value
+FROM
+ test_ignore_null
+WINDOW w AS (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW)
+ORDER BY id;
+
+SELECT
+ content,
+ id,
+ v,
+ nth_value(v, 1) IGNORE NULLS OVER w nth_value_1,
+ nth_value(v, 2) IGNORE NULLS OVER w nth_value_2,
+ nth_value(v, 3) IGNORE NULLS OVER w nth_value_3,
+ first_value(v) IGNORE NULLS OVER w first_value,
+ any_value(v) IGNORE NULLS OVER w any_value,
+ last_value(v) IGNORE NULLS OVER w last_value
+FROM
+ test_ignore_null
+WINDOW w AS (ORDER BY id RANGE BETWEEN 2 PRECEDING AND 2 FOLLOWING)
+ORDER BY id;
+
+SELECT
+ content,
+ id,
+ v,
+ nth_value(v, 1) IGNORE NULLS OVER w nth_value_1,
+ nth_value(v, 2) IGNORE NULLS OVER w nth_value_2,
+ nth_value(v, 3) IGNORE NULLS OVER w nth_value_3,
+ first_value(v) IGNORE NULLS OVER w first_value,
+ any_value(v) IGNORE NULLS OVER w any_value,
+ last_value(v) IGNORE NULLS OVER w last_value
+FROM
+ test_ignore_null
+WINDOW w AS (ORDER BY id ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING)
+ORDER BY id;
+
+SELECT
+ content,
+ id,
+ v,
+ nth_value(v, 1) IGNORE NULLS OVER w nth_value_1,
+ nth_value(v, 2) IGNORE NULLS OVER w nth_value_2,
+ nth_value(v, 3) IGNORE NULLS OVER w nth_value_3,
+ first_value(v) IGNORE NULLS OVER w first_value,
+ any_value(v) IGNORE NULLS OVER w any_value,
+ last_value(v) IGNORE NULLS OVER w last_value
+FROM
+ test_ignore_null
+WINDOW w AS (ORDER BY id RANGE BETWEEN CURRENT ROW AND UNBOUNDED FOLLOWING)
+ORDER BY id;
+
+SELECT
+ content,
+ id,
+ v,
+ nth_value(v, 1) IGNORE NULLS OVER w nth_value_1,
+ nth_value(v, 2) IGNORE NULLS OVER w nth_value_2,
+ nth_value(v, 3) IGNORE NULLS OVER w nth_value_3,
+ first_value(v) IGNORE NULLS OVER w first_value,
+ any_value(v) IGNORE NULLS OVER w any_value,
+ last_value(v) IGNORE NULLS OVER w last_value
+FROM
+ test_ignore_null
+WINDOW w AS (ORDER BY id RANGE BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
+ORDER BY id;
+
+SELECT
+ content,
+ id,
+ v,
+ nth_value(v, 1) IGNORE NULLS OVER w nth_value_1,
+ nth_value(v, 2) IGNORE NULLS OVER w nth_value_2,
+ nth_value(v, 3) IGNORE NULLS OVER w nth_value_3,
+ first_value(v) IGNORE NULLS OVER w first_value,
+ any_value(v) IGNORE NULLS OVER w any_value,
+ last_value(v) IGNORE NULLS OVER w last_value
+FROM
+ test_ignore_null
+WINDOW w AS (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING)
+ORDER BY id;
+
+SELECT
+ content,
+ id,
+ v,
+ nth_value(v, 1) IGNORE NULLS OVER w nth_value_1,
+ nth_value(v, 2) IGNORE NULLS OVER w nth_value_2,
+ nth_value(v, 3) IGNORE NULLS OVER w nth_value_3,
+ first_value(v) IGNORE NULLS OVER w first_value,
+ any_value(v) IGNORE NULLS OVER w any_value,
+ last_value(v) IGNORE NULLS OVER w last_value
+FROM
+ test_ignore_null
+WINDOW w AS (ORDER BY id ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)
+ORDER BY id;
+
+SELECT
+ nth_value(employee_name, 2) OVER w second_highest_salary
+FROM
+ basic_pays;
+
+SELECT
+ SUM(salary) OVER w sum_salary
+FROM
+ basic_pays;
+
+-- Test cases for InferWindowGroupLimit
+create or replace temp view t1 (p, o) as values (1, 1), (1, 1), (1, 2), (2, 1), (2, 1), (2, 2);
+select * from (select *, dense_rank() over (partition by p order by o) as rnk from t1) where rnk = 1;
+
+SELECT * FROM (SELECT cate, val, rank() OVER(PARTITION BY cate ORDER BY val) as r FROM testData) where r = 1;
+SELECT * FROM (SELECT cate, val, rank() OVER(PARTITION BY cate ORDER BY val) as r FROM testData) where r <= 2;
+SELECT * FROM (SELECT cate, val, dense_rank() OVER(PARTITION BY cate ORDER BY val) as r FROM testData) where r = 1;
+SELECT * FROM (SELECT cate, val, dense_rank() OVER(PARTITION BY cate ORDER BY val) as r FROM testData) where r <= 2;
+SELECT * FROM (SELECT cate, val, row_number() OVER(PARTITION BY cate ORDER BY val) as r FROM testData) where r = 1;
+SELECT * FROM (SELECT cate, val, row_number() OVER(PARTITION BY cate ORDER BY val) as r FROM testData) where r <= 2;
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/array.sql.out b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/array.sql.out
new file mode 100644
index 0000000000..ef1e96b1ba
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/array.sql.out
@@ -0,0 +1,794 @@
+-- Replace exception with GlutenException
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+create temporary view data as select * from values
+ ("one", array(11, 12, 13), array(array(111, 112, 113), array(121, 122, 123))),
+ ("two", array(21, 22, 23), array(array(211, 212, 213), array(221, 222, 223)))
+ as data(a, b, c)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+select * from data
+-- !query schema
+struct<a:string,b:array<int>,c:array<array<int>>>
+-- !query output
+one [11,12,13] [[111,112,113],[121,122,123]]
+two [21,22,23] [[211,212,213],[221,222,223]]
+
+
+-- !query
+select a, b[0], b[0] + b[1] from data
+-- !query schema
+struct<a:string,b[0]:int,(b[0] + b[1]):int>
+-- !query output
+one 11 23
+two 21 43
+
+
+-- !query
+select a, c[0][0] + c[0][0 + 1] from data
+-- !query schema
+struct<a:string,(c[0][0] + c[0][(0 + 1)]):int>
+-- !query output
+one 223
+two 423
+
+
+-- !query
+create temporary view primitive_arrays as select * from values (
+ array(true),
+ array(2Y, 1Y),
+ array(2S, 1S),
+ array(2, 1),
+ array(2L, 1L),
+ array(9223372036854775809, 9223372036854775808),
+ array(2.0D, 1.0D),
+ array(float(2.0), float(1.0)),
+ array(date '2016-03-14', date '2016-03-13'),
+ array(timestamp '2016-11-15 20:54:00.000', timestamp '2016-11-12 20:54:00.000')
+) as primitive_arrays(
+ boolean_array,
+ tinyint_array,
+ smallint_array,
+ int_array,
+ bigint_array,
+ decimal_array,
+ double_array,
+ float_array,
+ date_array,
+ timestamp_array
+)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+select * from primitive_arrays
+-- !query schema
+struct<boolean_array:array<boolean>,tinyint_array:array<tinyint>,smallint_array:array<smallint>,int_array:array<int>,bigint_array:array<bigint>,decimal_array:array<decimal(19,0)>,double_array:array<double>,float_array:array<float>,date_array:array<date>,timestamp_array:array<timestamp>>
+-- !query output
+[true] [2,1] [2,1] [2,1] [2,1] [9223372036854775809,9223372036854775808] [2.0,1.0] [2.0,1.0] [2016-03-14,2016-03-13] [2016-11-15 20:54:00,2016-11-12 20:54:00]
+
+
+-- !query
+select
+ array_contains(boolean_array, true), array_contains(boolean_array, false),
+ array_contains(tinyint_array, 2Y), array_contains(tinyint_array, 0Y),
+ array_contains(smallint_array, 2S), array_contains(smallint_array, 0S),
+ array_contains(int_array, 2), array_contains(int_array, 0),
+ array_contains(bigint_array, 2L), array_contains(bigint_array, 0L),
+ array_contains(decimal_array, 9223372036854775809), array_contains(decimal_array, 1),
+ array_contains(double_array, 2.0D), array_contains(double_array, 0.0D),
+ array_contains(float_array, float(2.0)), array_contains(float_array, float(0.0)),
+ array_contains(date_array, date '2016-03-14'), array_contains(date_array, date '2016-01-01'),
+ array_contains(timestamp_array, timestamp '2016-11-15 20:54:00.000'), array_contains(timestamp_array, timestamp '2016-01-01 20:54:00.000')
+from primitive_arrays
+-- !query schema
+struct<array_contains(boolean_array, true):boolean,array_contains(boolean_array, false):boolean,array_contains(tinyint_array, 2):boolean,array_contains(tinyint_array, 0):boolean,array_contains(smallint_array, 2):boolean,array_contains(smallint_array, 0):boolean,array_contains(int_array, 2):boolean,array_contains(int_array, 0):boolean,array_contains(bigint_array, 2):boolean,array_contains(bigint_array, 0):boolean,array_contains(decimal_array, 9223372036854775809):boolean,array_contains(de [...]
+-- !query output
+true false true false true false true false true false true false true false true false true false true false
+
+
+-- !query
+select array_contains(b, 11), array_contains(c, array(111, 112, 113)) from data
+-- !query schema
+struct<array_contains(b, 11):boolean,array_contains(c, array(111, 112, 113)):boolean>
+-- !query output
+false false
+true true
+
+
+-- !query
+select
+ sort_array(boolean_array),
+ sort_array(tinyint_array),
+ sort_array(smallint_array),
+ sort_array(int_array),
+ sort_array(bigint_array),
+ sort_array(decimal_array),
+ sort_array(double_array),
+ sort_array(float_array),
+ sort_array(date_array),
+ sort_array(timestamp_array)
+from primitive_arrays
+-- !query schema
+struct<sort_array(boolean_array, true):array<boolean>,sort_array(tinyint_array, true):array<tinyint>,sort_array(smallint_array, true):array<smallint>,sort_array(int_array, true):array<int>,sort_array(bigint_array, true):array<bigint>,sort_array(decimal_array, true):array<decimal(19,0)>,sort_array(double_array, true):array<double>,sort_array(float_array, true):array<float>,sort_array(date_array, true):array<date>,sort_array(timestamp_array, true):array<timestamp>>
+-- !query output
+[true] [1,2] [1,2] [1,2] [1,2] [9223372036854775808,9223372036854775809] [1.0,2.0] [1.0,2.0] [2016-03-13,2016-03-14] [2016-11-12 20:54:00,2016-11-15 20:54:00]
+
+
+-- !query
+select sort_array(array('b', 'd'), '1')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "2",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"sort_array(array(b, d), 1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 39,
+ "fragment" : "sort_array(array('b', 'd'), '1')"
+ } ]
+}
+
+
+-- !query
+select sort_array(array('b', 'd'), cast(NULL as boolean))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"CAST(NULL AS BOOLEAN)\"",
+ "inputType" : "\"BOOLEAN\"",
+ "paramIndex" : "2",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"sort_array(array(b, d), CAST(NULL AS BOOLEAN))\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 57,
+ "fragment" : "sort_array(array('b', 'd'), cast(NULL as boolean))"
+ } ]
+}
+
+
+-- !query
+select
+ size(boolean_array),
+ size(tinyint_array),
+ size(smallint_array),
+ size(int_array),
+ size(bigint_array),
+ size(decimal_array),
+ size(double_array),
+ size(float_array),
+ size(date_array),
+ size(timestamp_array)
+from primitive_arrays
+-- !query schema
+struct<size(boolean_array):int,size(tinyint_array):int,size(smallint_array):int,size(int_array):int,size(bigint_array):int,size(decimal_array):int,size(double_array):int,size(float_array):int,size(date_array):int,size(timestamp_array):int>
+-- !query output
+1 2 2 2 2 2 2 2 2 2
+
+
+-- !query
+select element_at(array(1, 2, 3), 5)
+-- !query schema
+struct<element_at(array(1, 2, 3), 5):int>
+-- !query output
+NULL
+
+
+-- !query
+select element_at(array(1, 2, 3), -5)
+-- !query schema
+struct<element_at(array(1, 2, 3), -5):int>
+-- !query output
+NULL
+
+
+-- !query
+select element_at(array(1, 2, 3), 0)
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+SQL array indices start at 1
+
+
+-- !query
+select elt(4, '123', '456')
+-- !query schema
+struct<elt(4, 123, 456):string>
+-- !query output
+NULL
+
+
+-- !query
+select elt(0, '123', '456')
+-- !query schema
+struct<elt(0, 123, 456):string>
+-- !query output
+NULL
+
+
+-- !query
+select elt(-1, '123', '456')
+-- !query schema
+struct<elt(-1, 123, 456):string>
+-- !query output
+NULL
+
+
+-- !query
+select elt(null, '123', '456')
+-- !query schema
+struct<elt(NULL, 123, 456):string>
+-- !query output
+NULL
+
+
+-- !query
+select elt(null, '123', null)
+-- !query schema
+struct<elt(NULL, 123, NULL):string>
+-- !query output
+NULL
+
+
+-- !query
+select elt(1, '123', null)
+-- !query schema
+struct<elt(1, 123, NULL):string>
+-- !query output
+123
+
+
+-- !query
+select elt(2, '123', null)
+-- !query schema
+struct<elt(2, 123, NULL):string>
+-- !query output
+NULL
+
+
+-- !query
+select array(1, 2, 3)[5]
+-- !query schema
+struct<array(1, 2, 3)[5]:int>
+-- !query output
+NULL
+
+
+-- !query
+select array(1, 2, 3)[-1]
+-- !query schema
+struct<array(1, 2, 3)[-1]:int>
+-- !query output
+NULL
+
+
+-- !query
+select array_size(array())
+-- !query schema
+struct<array_size(array()):int>
+-- !query output
+0
+
+
+-- !query
+select array_size(array(true))
+-- !query schema
+struct<array_size(array(true)):int>
+-- !query output
+1
+
+
+-- !query
+select array_size(array(2, 1))
+-- !query schema
+struct<array_size(array(2, 1)):int>
+-- !query output
+2
+
+
+-- !query
+select array_size(NULL)
+-- !query schema
+struct<array_size(NULL):int>
+-- !query output
+NULL
+
+
+-- !query
+select array_size(map('a', 1, 'b', 2))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"map(a, 1, b, 2)\"",
+ "inputType" : "\"MAP<STRING, INT>\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"ARRAY\"",
+ "sqlExpr" : "\"array_size(map(a, 1, b, 2))\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 38,
+ "fragment" : "array_size(map('a', 1, 'b', 2))"
+ } ]
+}
+
+
+-- !query
+select size(arrays_zip(array(1, 2, 3), array(4), array(7, 8, 9, 10)))
+-- !query schema
+struct<size(arrays_zip(array(1, 2, 3), array(4), array(7, 8, 9, 10))):int>
+-- !query output
+4
+
+
+-- !query
+select size(arrays_zip(array(), array(1, 2, 3), array(4), array(7, 8, 9, 10)))
+-- !query schema
+struct<size(arrays_zip(array(), array(1, 2, 3), array(4), array(7, 8, 9, 10))):int>
+-- !query output
+4
+
+
+-- !query
+select size(arrays_zip(array(1, 2, 3), array(4), null, array(7, 8, 9, 10)))
+-- !query schema
+struct<size(arrays_zip(array(1, 2, 3), array(4), NULL, array(7, 8, 9, 10))):int>
+-- !query output
+-1
+
+
+-- !query
+select isnotnull(arrays_zip(array(), array(4), array(7, 8, 9, 10)))
+-- !query schema
+struct<(arrays_zip(array(), array(4), array(7, 8, 9, 10)) IS NOT NULL):boolean>
+-- !query output
+true
+
+
+-- !query
+select isnotnull(arrays_zip(array(1, 2, 3), array(4), array(7, 8, 9, 10)))
+-- !query schema
+struct<(arrays_zip(array(1, 2, 3), array(4), array(7, 8, 9, 10)) IS NOT NULL):boolean>
+-- !query output
+true
+
+
+-- !query
+select isnotnull(arrays_zip(array(1, 2, 3), NULL, array(4), array(7, 8, 9, 10)))
+-- !query schema
+struct<(arrays_zip(array(1, 2, 3), NULL, array(4), array(7, 8, 9, 10)) IS NOT NULL):boolean>
+-- !query output
+false
+
+
+-- !query
+select get(array(1, 2, 3), 0)
+-- !query schema
+struct<get(array(1, 2, 3), 0):int>
+-- !query output
+1
+
+
+-- !query
+select get(array(1, 2, 3), 3)
+-- !query schema
+struct<get(array(1, 2, 3), 3):int>
+-- !query output
+NULL
+
+
+-- !query
+select get(array(1, 2, 3), null)
+-- !query schema
+struct<get(array(1, 2, 3), NULL):int>
+-- !query output
+NULL
+
+
+-- !query
+select get(array(1, 2, 3), -1)
+-- !query schema
+struct<get(array(1, 2, 3), -1):int>
+-- !query output
+NULL
+
+
+-- !query
+select array_insert(array(1, 2, 3), 3, 4)
+-- !query schema
+struct<array_insert(array(1, 2, 3), 3, 4):array<int>>
+-- !query output
+[1,2,4,3]
+
+
+-- !query
+select array_insert(array(2, 3, 4), 0, 1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+(0 vs. 0) Array insert position should not be 0.
+
+
+-- !query
+select array_insert(array(2, 3, 4), 1, 1)
+-- !query schema
+struct<array_insert(array(2, 3, 4), 1, 1):array<int>>
+-- !query output
+[1,2,3,4]
+
+
+-- !query
+select array_insert(array(1, 3, 4), -2, 2)
+-- !query schema
+struct<array_insert(array(1, 3, 4), -2, 2):array<int>>
+-- !query output
+[1,3,2,4]
+
+
+-- !query
+select array_insert(array(1, 2, 3), 3, "4")
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.ARRAY_FUNCTION_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "dataType" : "\"ARRAY\"",
+ "functionName" : "`array_insert`",
+ "leftType" : "\"ARRAY<INT>\"",
+ "rightType" : "\"STRING\"",
+ "sqlExpr" : "\"array_insert(array(1, 2, 3), 3, 4)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 43,
+ "fragment" : "array_insert(array(1, 2, 3), 3, \"4\")"
+ } ]
+}
+
+
+-- !query
+select array_insert(cast(NULL as ARRAY<INT>), 1, 1)
+-- !query schema
+struct<array_insert(NULL, 1, 1):array<int>>
+-- !query output
+NULL
+
+
+-- !query
+select array_insert(array(1, 2, 3, NULL), cast(NULL as INT), 4)
+-- !query schema
+struct<array_insert(array(1, 2, 3, NULL), CAST(NULL AS INT), 4):array<int>>
+-- !query output
+NULL
+
+
+-- !query
+select array_insert(array(1, 2, 3, NULL), 4, cast(NULL as INT))
+-- !query schema
+struct<array_insert(array(1, 2, 3, NULL), 4, CAST(NULL AS INT)):array<int>>
+-- !query output
+[1,2,3,null,null]
+
+
+-- !query
+select array_insert(array(2, 3, NULL, 4), 5, 5)
+-- !query schema
+struct<array_insert(array(2, 3, NULL, 4), 5, 5):array<int>>
+-- !query output
+[2,3,null,4,5]
+
+
+-- !query
+select array_insert(array(2, 3, NULL, 4), -5, 1)
+-- !query schema
+struct<array_insert(array(2, 3, NULL, 4), -5, 1):array<int>>
+-- !query output
+[1,2,3,null,4]
+
+
+-- !query
+select array_insert(array(1), 2, cast(2 as tinyint))
+-- !query schema
+struct<array_insert(array(1), 2, CAST(2 AS TINYINT)):array<int>>
+-- !query output
+[1,2]
+
+
+-- !query
+set spark.sql.legacy.negativeIndexInArrayInsert=true
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.legacy.negativeIndexInArrayInsert true
+
+
+-- !query
+select array_insert(array(1, 3, 4), -2, 2)
+-- !query schema
+struct<array_insert(array(1, 3, 4), -2, 2):array<int>>
+-- !query output
+[1,2,3,4]
+
+
+-- !query
+select array_insert(array(2, 3, NULL, 4), -5, 1)
+-- !query schema
+struct<array_insert(array(2, 3, NULL, 4), -5, 1):array<int>>
+-- !query output
+[1,null,2,3,null,4]
+
+
+-- !query
+set spark.sql.legacy.negativeIndexInArrayInsert=false
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.legacy.negativeIndexInArrayInsert false
+
+
+-- !query
+select array_compact(id) from values (1) as t(id)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"id\"",
+ "inputType" : "\"INT\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"ARRAY\"",
+ "sqlExpr" : "\"array_compact(id)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 24,
+ "fragment" : "array_compact(id)"
+ } ]
+}
+
+
+-- !query
+select array_compact(array("1", null, "2", null))
+-- !query schema
+struct<array_compact(array(1, NULL, 2, NULL)):array<string>>
+-- !query output
+["1","2"]
+
+
+-- !query
+select array_compact(array("a", "b", "c"))
+-- !query schema
+struct<array_compact(array(a, b, c)):array<string>>
+-- !query output
+["a","b","c"]
+
+
+-- !query
+select array_compact(array(1D, null, 2D, null))
+-- !query schema
+struct<array_compact(array(1.0, NULL, 2.0, NULL)):array<double>>
+-- !query output
+[1.0,2.0]
+
+
+-- !query
+select array_compact(array(array(1, 2, 3, null), null, array(4, null, 6)))
+-- !query schema
+struct<array_compact(array(array(1, 2, 3, NULL), NULL, array(4, NULL, 6))):array<array<int>>>
+-- !query output
+[[1,2,3,null],[4,null,6]]
+
+
+-- !query
+select array_compact(array(null))
+-- !query schema
+struct<array_compact(array(NULL)):array<void>>
+-- !query output
+[]
+
+
+-- !query
+select array_append(array(1, 2, 3), 4)
+-- !query schema
+struct<array_append(array(1, 2, 3), 4):array<int>>
+-- !query output
+[1,2,3,4]
+
+
+-- !query
+select array_append(array('a', 'b', 'c'), 'd')
+-- !query schema
+struct<array_append(array(a, b, c), d):array<string>>
+-- !query output
+["a","b","c","d"]
+
+
+-- !query
+select array_append(array(1, 2, 3, NULL), NULL)
+-- !query schema
+struct<array_append(array(1, 2, 3, NULL), NULL):array<int>>
+-- !query output
+[1,2,3,null,null]
+
+
+-- !query
+select array_append(array('a', 'b', 'c', NULL), NULL)
+-- !query schema
+struct<array_append(array(a, b, c, NULL), NULL):array<string>>
+-- !query output
+["a","b","c",null,null]
+
+
+-- !query
+select array_append(CAST(null AS ARRAY<String>), 'a')
+-- !query schema
+struct<array_append(NULL, a):array<string>>
+-- !query output
+NULL
+
+
+-- !query
+select array_append(CAST(null AS ARRAY<String>), CAST(null as String))
+-- !query schema
+struct<array_append(NULL, CAST(NULL AS STRING)):array<string>>
+-- !query output
+NULL
+
+
+-- !query
+select array_append(array(), 1)
+-- !query schema
+struct<array_append(array(), 1):array<int>>
+-- !query output
+[1]
+
+
+-- !query
+select array_append(CAST(array() AS ARRAY<String>), CAST(NULL AS String))
+-- !query schema
+struct<array_append(array(), CAST(NULL AS STRING)):array<string>>
+-- !query output
+[null]
+
+
+-- !query
+select array_append(array(CAST(NULL AS String)), CAST(NULL AS String))
+-- !query schema
+struct<array_append(array(CAST(NULL AS STRING)), CAST(NULL AS STRING)):array<string>>
+-- !query output
+[null,null]
+
+
+-- !query
+select array_prepend(array(1, 2, 3), 4)
+-- !query schema
+struct<array_prepend(array(1, 2, 3), 4):array<int>>
+-- !query output
+[4,1,2,3]
+
+
+-- !query
+select array_prepend(array('a', 'b', 'c'), 'd')
+-- !query schema
+struct<array_prepend(array(a, b, c), d):array<string>>
+-- !query output
+["d","a","b","c"]
+
+
+-- !query
+select array_prepend(array(1, 2, 3, NULL), NULL)
+-- !query schema
+struct<array_prepend(array(1, 2, 3, NULL), NULL):array<int>>
+-- !query output
+[null,1,2,3,null]
+
+
+-- !query
+select array_prepend(array('a', 'b', 'c', NULL), NULL)
+-- !query schema
+struct<array_prepend(array(a, b, c, NULL), NULL):array<string>>
+-- !query output
+[null,"a","b","c",null]
+
+
+-- !query
+select array_prepend(CAST(null AS ARRAY<String>), 'a')
+-- !query schema
+struct<array_prepend(NULL, a):array<string>>
+-- !query output
+NULL
+
+
+-- !query
+select array_prepend(CAST(null AS ARRAY<String>), CAST(null as String))
+-- !query schema
+struct<array_prepend(NULL, CAST(NULL AS STRING)):array<string>>
+-- !query output
+NULL
+
+
+-- !query
+select array_prepend(array(), 1)
+-- !query schema
+struct<array_prepend(array(), 1):array<int>>
+-- !query output
+[1]
+
+
+-- !query
+select array_prepend(CAST(array() AS ARRAY<String>), CAST(NULL AS String))
+-- !query schema
+struct<array_prepend(array(), CAST(NULL AS STRING)):array<string>>
+-- !query output
+[null]
+
+
+-- !query
+select array_prepend(array(CAST(NULL AS String)), CAST(NULL AS String))
+-- !query schema
+struct<array_prepend(array(CAST(NULL AS STRING)), CAST(NULL AS STRING)):array<string>>
+-- !query output
+[null,null]
+
+
+-- !query
+select array_union(array(0.0, -0.0, DOUBLE("NaN")), array(0.0, -0.0, DOUBLE("NaN")))
+-- !query schema
+struct<array_union(array(0.0, 0.0, NaN), array(0.0, 0.0, NaN)):array<double>>
+-- !query output
+[0.0,NaN]
+
+
+-- !query
+select array_distinct(array(0.0, -0.0, -0.0, DOUBLE("NaN"), DOUBLE("NaN")))
+-- !query schema
+struct<array_distinct(array(0.0, 0.0, 0.0, NaN, NaN)):array<double>>
+-- !query output
+[0.0,NaN]
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/bitwise.sql.out b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/bitwise.sql.out
new file mode 100644
index 0000000000..852e50f17b
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/bitwise.sql.out
@@ -0,0 +1,306 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+select bit_count(null)
+-- !query schema
+struct<bit_count(NULL):int>
+-- !query output
+NULL
+
+
+-- !query
+select bit_count(true)
+-- !query schema
+struct<bit_count(true):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count(false)
+-- !query schema
+struct<bit_count(false):int>
+-- !query output
+0
+
+
+-- !query
+select bit_count(cast(1 as tinyint))
+-- !query schema
+struct<bit_count(CAST(1 AS TINYINT)):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count(cast(2 as tinyint))
+-- !query schema
+struct<bit_count(CAST(2 AS TINYINT)):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count(cast(3 as tinyint))
+-- !query schema
+struct<bit_count(CAST(3 AS TINYINT)):int>
+-- !query output
+2
+
+
+-- !query
+select bit_count(1S)
+-- !query schema
+struct<bit_count(1):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count(2S)
+-- !query schema
+struct<bit_count(2):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count(3S)
+-- !query schema
+struct<bit_count(3):int>
+-- !query output
+2
+
+
+-- !query
+select bit_count(1)
+-- !query schema
+struct<bit_count(1):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count(2)
+-- !query schema
+struct<bit_count(2):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count(3)
+-- !query schema
+struct<bit_count(3):int>
+-- !query output
+2
+
+
+-- !query
+select bit_count(1L)
+-- !query schema
+struct<bit_count(1):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count(2L)
+-- !query schema
+struct<bit_count(2):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count(3L)
+-- !query schema
+struct<bit_count(3):int>
+-- !query output
+2
+
+
+-- !query
+select bit_count(-1L)
+-- !query schema
+struct<bit_count(-1):int>
+-- !query output
+64
+
+
+-- !query
+select bit_count(9223372036854775807L)
+-- !query schema
+struct<bit_count(9223372036854775807):int>
+-- !query output
+63
+
+
+-- !query
+select bit_count(-9223372036854775808L)
+-- !query schema
+struct<bit_count(-9223372036854775808):int>
+-- !query output
+1
+
+
+-- !query
+select bit_count("bit count")
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"bit count\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "1",
+ "requiredType" : "(\"INTEGRAL\" or \"BOOLEAN\")",
+ "sqlExpr" : "\"bit_count(bit count)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 29,
+ "fragment" : "bit_count(\"bit count\")"
+ } ]
+}
+
+
+-- !query
+select bit_count('a')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"a\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "1",
+ "requiredType" : "(\"INTEGRAL\" or \"BOOLEAN\")",
+ "sqlExpr" : "\"bit_count(a)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 21,
+ "fragment" : "bit_count('a')"
+ } ]
+}
+
+
+-- !query
+CREATE OR REPLACE TEMPORARY VIEW bitwise_test AS SELECT * FROM VALUES
+ (1, 1, 1, 1L),
+ (2, 3, 4, null),
+ (7, 7, 7, 3L) AS bitwise_test(b1, b2, b3, b4)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT BIT_XOR(b3) AS n1 FROM bitwise_test where 1 = 0
+-- !query schema
+struct<n1:int>
+-- !query output
+NULL
+
+
+-- !query
+SELECT BIT_XOR(b4) AS n1 FROM bitwise_test where b4 is null
+-- !query schema
+struct<n1:bigint>
+-- !query output
+NULL
+
+
+-- !query
+SELECT
+ BIT_XOR(cast(b1 as tinyint)) AS a4,
+ BIT_XOR(cast(b2 as smallint)) AS b5,
+ BIT_XOR(b3) AS c2,
+ BIT_XOR(b4) AS d2,
+ BIT_XOR(distinct b4) AS e2
+FROM bitwise_test
+-- !query schema
+struct<a4:tinyint,b5:smallint,c2:int,d2:bigint,e2:bigint>
+-- !query output
+4 5 2 2 2
+
+
+-- !query
+SELECT bit_xor(b3) FROM bitwise_test GROUP BY b1 & 1
+-- !query schema
+struct<bit_xor(b3):int>
+-- !query output
+4
+6
+
+
+-- !query
+SELECT b1, bit_xor(b2) FROM bitwise_test GROUP BY b1 HAVING bit_and(b2) < 7
+-- !query schema
+struct<b1:int,bit_xor(b2):int>
+-- !query output
+1 1
+2 3
+
+
+-- !query
+SELECT b1, b2, bit_xor(b2) OVER (PARTITION BY b1 ORDER BY b2) FROM bitwise_test
+-- !query schema
+struct<b1:int,b2:int,bit_xor(b2) OVER (PARTITION BY b1 ORDER BY b2 ASC NULLS FIRST RANGE BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW):int>
+-- !query output
+1 1 1
+2 3 3
+7 7 7
+
+
+-- !query
+select getbit(11L, 3), getbit(11L, 2), getbit(11L, 1), getbit(11L, 0)
+-- !query schema
+struct<getbit(11, 3):tinyint,getbit(11, 2):tinyint,getbit(11, 1):tinyint,getbit(11, 0):tinyint>
+-- !query output
+1 0 1 1
+
+
+-- !query
+select getbit(11L, 2 + 1), getbit(11L, 3 - 1), getbit(10L + 1, 1 * 1), getbit(cast(11L / 1 AS long), 1 - 1)
+-- !query schema
+struct<getbit(11, (2 + 1)):tinyint,getbit(11, (3 - 1)):tinyint,getbit((10 + 1), (1 * 1)):tinyint,getbit(CAST((11 / 1) AS BIGINT), (1 - 1)):tinyint>
+-- !query output
+1 0 1 1
+
+
+-- !query
+select getbit(11L, 63)
+-- !query schema
+struct<getbit(11, 63):tinyint>
+-- !query output
+0
+
+
+-- !query
+select getbit(11L, -1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+(-1 vs. 0) The value of 'pos' argument must be greater than or equal to zero.
+
+
+-- !query
+select getbit(11L, 64)
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+(64 vs. 64) The value of 'pos' argument must not exceed the number of bits in 'x' - 1.
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/charvarchar.sql.out b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/charvarchar.sql.out
new file mode 100644
index 0000000000..1221be7d5b
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/charvarchar.sql.out
@@ -0,0 +1,1243 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+create table char_tbl(c char(5), v varchar(6)) using parquet
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_tbl
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_tbl
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_tbl
+
+
+-- !query
+desc formatted char_tbl c
+-- !query schema
+struct<info_name:string,info_value:string>
+-- !query output
+col_name c
+data_type char(5)
+comment NULL
+min NULL
+max NULL
+num_nulls NULL
+distinct_count NULL
+avg_col_len NULL
+max_col_len NULL
+histogram NULL
+
+
+-- !query
+show create table char_tbl
+-- !query schema
+struct<createtab_stmt:string>
+-- !query output
+CREATE TABLE spark_catalog.default.char_tbl (
+ c CHAR(5),
+ v VARCHAR(6))
+USING parquet
+
+
+-- !query
+create table char_tbl2 using parquet as select * from char_tbl
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+show create table char_tbl2
+-- !query schema
+struct<createtab_stmt:string>
+-- !query output
+CREATE TABLE spark_catalog.default.char_tbl2 (
+ c CHAR(5),
+ v VARCHAR(6))
+USING parquet
+
+
+-- !query
+desc formatted char_tbl2
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_tbl2
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_tbl2
+
+
+-- !query
+desc formatted char_tbl2 c
+-- !query schema
+struct<info_name:string,info_value:string>
+-- !query output
+col_name c
+data_type char(5)
+comment NULL
+min NULL
+max NULL
+num_nulls NULL
+distinct_count NULL
+avg_col_len NULL
+max_col_len NULL
+histogram NULL
+
+
+-- !query
+create table char_tbl3 like char_tbl
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_tbl3
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_tbl3
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_tbl3
+
+
+-- !query
+desc formatted char_tbl3 c
+-- !query schema
+struct<info_name:string,info_value:string>
+-- !query output
+col_name c
+data_type char(5)
+comment NULL
+min NULL
+max NULL
+num_nulls NULL
+distinct_count NULL
+avg_col_len NULL
+max_col_len NULL
+histogram NULL
+
+
+-- !query
+show create table char_tbl3
+-- !query schema
+struct<createtab_stmt:string>
+-- !query output
+CREATE TABLE spark_catalog.default.char_tbl3 (
+ c CHAR(5),
+ v VARCHAR(6))
+USING parquet
+
+
+-- !query
+create view char_view as select * from char_tbl
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_view
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_view
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type VIEW
+View Text select * from char_tbl
+View Original Text select * from char_tbl
+View Catalog and Namespace spark_catalog.default
+View Query Output Columns [c, v]
+
+
+-- !query
+desc formatted char_view c
+-- !query schema
+struct<info_name:string,info_value:string>
+-- !query output
+col_name c
+data_type char(5)
+comment NULL
+min NULL
+max NULL
+num_nulls NULL
+distinct_count NULL
+avg_col_len NULL
+max_col_len NULL
+histogram NULL
+
+
+-- !query
+show create table char_view
+-- !query schema
+struct<createtab_stmt:string>
+-- !query output
+CREATE VIEW default.char_view (
+ c,
+ v)
+AS select * from char_tbl
+
+
+-- !query
+alter table char_tbl rename to char_tbl1
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_tbl1
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_tbl1
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_tbl1
+
+
+-- !query
+alter table char_tbl1 change column c type char(6)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "NOT_SUPPORTED_CHANGE_COLUMN",
+ "messageParameters" : {
+ "newName" : "`c`",
+ "newType" : "\"CHAR(6)\"",
+ "originName" : "`c`",
+ "originType" : "\"CHAR(5)\"",
+ "table" : "`spark_catalog`.`default`.`char_tbl1`"
+ }
+}
+
+
+-- !query
+alter table char_tbl1 change column c type char(5)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_tbl1
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_tbl1
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_tbl1
+
+
+-- !query
+alter table char_tbl1 add columns (d char(5))
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_tbl1
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+d char(5)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_tbl1
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_tbl1
+
+
+-- !query
+alter view char_view as select * from char_tbl2
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_view
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_view
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type VIEW
+View Text select * from char_tbl2
+View Original Text select * from char_tbl2
+View Catalog and Namespace spark_catalog.default
+View Query Output Columns [c, v]
+
+
+-- !query
+alter table char_tbl1 SET TBLPROPERTIES('yes'='no')
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_tbl1
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+d char(5)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_tbl1
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Table Properties [yes=no]
+Location [not included in comparison]/{warehouse_dir}/char_tbl1
+
+
+-- !query
+alter view char_view SET TBLPROPERTIES('yes'='no')
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_view
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_view
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type VIEW
+View Text select * from char_tbl2
+View Original Text select * from char_tbl2
+View Catalog and Namespace spark_catalog.default
+View Query Output Columns [c, v]
+Table Properties [yes=no]
+
+
+-- !query
+alter table char_tbl1 UNSET TBLPROPERTIES('yes')
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_tbl1
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+d char(5)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_tbl1
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_tbl1
+
+
+-- !query
+alter view char_view UNSET TBLPROPERTIES('yes')
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_view
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_view
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type VIEW
+View Text select * from char_tbl2
+View Original Text select * from char_tbl2
+View Catalog and Namespace spark_catalog.default
+View Query Output Columns [c, v]
+
+
+-- !query
+alter table char_tbl1 SET SERDEPROPERTIES('yes'='no')
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_tbl1
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c char(5)
+v varchar(6)
+d char(5)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_tbl1
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_tbl1
+Storage Properties [yes=no]
+
+
+-- !query
+create table char_part(c1 char(5), c2 char(2), v1 varchar(6), v2 varchar(2)) using parquet partitioned by (v2, c2)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_part
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c1 char(5)
+v1 varchar(6)
+v2 varchar(2)
+c2 char(2)
+# Partition Information
+# col_name data_type comment
+v2 varchar(2)
+c2 char(2)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_part
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_part
+Partition Provider Catalog
+
+
+-- !query
+alter table char_part add partition (v2='ke', c2='nt') location 'loc1'
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_part
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c1 char(5)
+v1 varchar(6)
+v2 varchar(2)
+c2 char(2)
+# Partition Information
+# col_name data_type comment
+v2 varchar(2)
+c2 char(2)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_part
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_part
+Partition Provider Catalog
+
+
+-- !query
+alter table char_part partition (v2='ke') rename to partition (v2='nt')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "_LEGACY_ERROR_TEMP_1232",
+ "messageParameters" : {
+ "partitionColumnNames" : "v2, c2",
+ "specKeys" : "v2",
+ "tableName" : "`spark_catalog`.`default`.`char_part`"
+ }
+}
+
+
+-- !query
+desc formatted char_part
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c1 char(5)
+v1 varchar(6)
+v2 varchar(2)
+c2 char(2)
+# Partition Information
+# col_name data_type comment
+v2 varchar(2)
+c2 char(2)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_part
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_part
+Partition Provider Catalog
+
+
+-- !query
+alter table char_part partition (v2='ke', c2='nt') set location 'loc2'
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_part
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c1 char(5)
+v1 varchar(6)
+v2 varchar(2)
+c2 char(2)
+# Partition Information
+# col_name data_type comment
+v2 varchar(2)
+c2 char(2)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_part
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_part
+Partition Provider Catalog
+
+
+-- !query
+MSCK REPAIR TABLE char_part
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+desc formatted char_part
+-- !query schema
+struct<col_name:string,data_type:string,comment:string>
+-- !query output
+c1 char(5)
+v1 varchar(6)
+v2 varchar(2)
+c2 char(2)
+# Partition Information
+# col_name data_type comment
+v2 varchar(2)
+c2 char(2)
+
+# Detailed Table Information
+Catalog spark_catalog
+Database default
+Table char_part
+Created Time [not included in comparison]
+Last Access [not included in comparison]
+Created By [not included in comparison]
+Type MANAGED
+Provider parquet
+Location [not included in comparison]/{warehouse_dir}/char_part
+Partition Provider Catalog
+
+
+-- !query
+create temporary view str_view as select c, v from values
+ (null, null),
+ (null, 'S'),
+ ('N', 'N '),
+ ('Ne', 'Sp'),
+ ('Net ', 'Spa '),
+ ('NetE', 'Spar'),
+ ('NetEa ', 'Spark '),
+ ('NetEas ', 'Spark'),
+ ('NetEase', 'Spark-') t(c, v)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+create table char_tbl4(c7 char(7), c8 char(8), v varchar(6), s string) using parquet
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+insert into char_tbl4 select c, c, v, c from str_view
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+select c7, c8, v, s from char_tbl4
+-- !query schema
+struct<c7:string,c8:string,v:string,s:string>
+-- !query output
+N N N N
+NULL NULL NULL NULL
+NULL NULL S NULL
+Ne Ne Sp Ne
+Net Net Spa Net
+NetE NetE Spar NetE
+NetEa NetEa Spark NetEa
+NetEas NetEas Spark NetEas
+NetEase NetEase Spark- NetEase
+
+
+-- !query
+select c7, c8, v, s from char_tbl4 where c7 = c8
+-- !query schema
+struct<c7:string,c8:string,v:string,s:string>
+-- !query output
+N N N N
+Ne Ne Sp Ne
+Net Net Spa Net
+NetE NetE Spar NetE
+NetEa NetEa Spark NetEa
+NetEas NetEas Spark NetEas
+NetEase NetEase Spark- NetEase
+
+
+-- !query
+select c7, c8, v, s from char_tbl4 where c7 = v
+-- !query schema
+struct<c7:string,c8:string,v:string,s:string>
+-- !query output
+
+
+
+-- !query
+select c7, c8, v, s from char_tbl4 where c7 = s
+-- !query schema
+struct<c7:string,c8:string,v:string,s:string>
+-- !query output
+NetEas NetEas Spark NetEas
+NetEase NetEase Spark- NetEase
+
+
+-- !query
+select c7, c8, v, s from char_tbl4 where c7 = 'NetEase '
+-- !query schema
+struct<c7:string,c8:string,v:string,s:string>
+-- !query output
+NetEase NetEase Spark- NetEase
+
+
+-- !query
+select c7, c8, v, s from char_tbl4 where v = 'Spark '
+-- !query schema
+struct<c7:string,c8:string,v:string,s:string>
+-- !query output
+NetEa NetEa Spark NetEa
+
+
+-- !query
+select c7, c8, v, s from char_tbl4 order by c7
+-- !query schema
+struct<c7:string,c8:string,v:string,s:string>
+-- !query output
+NULL NULL NULL NULL
+NULL NULL S NULL
+N N N N
+Ne Ne Sp Ne
+Net Net Spa Net
+NetE NetE Spar NetE
+NetEa NetEa Spark NetEa
+NetEas NetEas Spark NetEas
+NetEase NetEase Spark- NetEase
+
+
+-- !query
+select c7, c8, v, s from char_tbl4 order by v
+-- !query schema
+struct<c7:string,c8:string,v:string,s:string>
+-- !query output
+NULL NULL NULL NULL
+N N N N
+NULL NULL S NULL
+Ne Ne Sp Ne
+Net Net Spa Net
+NetE NetE Spar NetE
+NetEas NetEas Spark NetEas
+NetEa NetEa Spark NetEa
+NetEase NetEase Spark- NetEase
+
+
+-- !query
+select ascii(c7), ascii(c8), ascii(v), ascii(s) from char_tbl4
+-- !query schema
+struct<ascii(c7):int,ascii(c8):int,ascii(v):int,ascii(s):int>
+-- !query output
+78 78 78 78
+78 78 83 78
+78 78 83 78
+78 78 83 78
+78 78 83 78
+78 78 83 78
+78 78 83 78
+NULL NULL 83 NULL
+NULL NULL NULL NULL
+
+
+-- !query
+select base64(c7), base64(c8), base64(v), ascii(s) from char_tbl4
+-- !query schema
+struct<base64(c7):string,base64(c8):string,base64(v):string,ascii(s):int>
+-- !query output
+NULL NULL NULL NULL
+NULL NULL Uw== NULL
+TiAgICAgIA== TiAgICAgICA= TiA= 78
+TmUgICAgIA== TmUgICAgICA= U3A= 78
+TmV0ICAgIA== TmV0ICAgICA= U3BhICA= 78
+TmV0RSAgIA== TmV0RSAgICA= U3Bhcg== 78
+TmV0RWEgIA== TmV0RWEgICA= U3Bhcmsg 78
+TmV0RWFzIA== TmV0RWFzICA= U3Bhcms= 78
+TmV0RWFzZQ== TmV0RWFzZSA= U3Bhcmst 78
+
+
+-- !query
+select bit_length(c7), bit_length(c8), bit_length(v), bit_length(s) from char_tbl4
+-- !query schema
+struct<bit_length(c7):int,bit_length(c8):int,bit_length(v):int,bit_length(s):int>
+-- !query output
+56 64 16 16
+56 64 16 8
+56 64 32 32
+56 64 40 40
+56 64 40 56
+56 64 48 48
+56 64 48 56
+NULL NULL 8 NULL
+NULL NULL NULL NULL
+
+
+-- !query
+select char_length(c7), char_length(c8), char_length(v), char_length(s) from char_tbl4
+-- !query schema
+struct<char_length(c7):int,char_length(c8):int,char_length(v):int,char_length(s):int>
+-- !query output
+7 8 2 1
+7 8 2 2
+7 8 4 4
+7 8 5 5
+7 8 5 7
+7 8 6 6
+7 8 6 7
+NULL NULL 1 NULL
+NULL NULL NULL NULL
+
+
+-- !query
+select octet_length(c7), octet_length(c8), octet_length(v), octet_length(s) from char_tbl4
+-- !query schema
+struct<octet_length(c7):int,octet_length(c8):int,octet_length(v):int,octet_length(s):int>
+-- !query output
+7 8 2 1
+7 8 2 2
+7 8 4 4
+7 8 5 5
+7 8 5 7
+7 8 6 6
+7 8 6 7
+NULL NULL 1 NULL
+NULL NULL NULL NULL
+
+
+-- !query
+select concat_ws('|', c7, c8), concat_ws('|', c7, v), concat_ws('|', c7, s), concat_ws('|', v, s) from char_tbl4
+-- !query schema
+struct<concat_ws(|, c7, c8):string,concat_ws(|, c7, v):string,concat_ws(|, c7, s):string,concat_ws(|, v, s):string>
+-- !query output
+
+ S S
+N |N N |N N |N N |N
+Ne |Ne Ne |Sp Ne |Ne Sp|Ne
+Net |Net Net |Spa Net |Net Spa |Net
+NetE |NetE NetE |Spar NetE |NetE Spar|NetE
+NetEa |NetEa NetEa |Spark NetEa |NetEa Spark |NetEa
+NetEas |NetEas NetEas |Spark NetEas |NetEas Spark|NetEas
+NetEase|NetEase NetEase|Spark- NetEase|NetEase Spark-|NetEase
+
+
+-- !query
+select concat(c7, c8), concat(c7, v), concat(c7, s), concat(v, s) from char_tbl4
+-- !query schema
+struct<concat(c7, c8):string,concat(c7, v):string,concat(c7, s):string,concat(v, s):string>
+-- !query output
+N N N N N N N N
+NULL NULL NULL NULL
+NULL NULL NULL NULL
+Ne Ne Ne Sp Ne Ne SpNe
+Net Net Net Spa Net Net Spa Net
+NetE NetE NetE Spar NetE NetE SparNetE
+NetEa NetEa NetEa Spark NetEa NetEa Spark NetEa
+NetEas NetEas NetEas Spark NetEas NetEas SparkNetEas
+NetEaseNetEase NetEaseSpark- NetEaseNetEase Spark-NetEase
+
+
+-- !query
+select like(c7, 'Ne _'), like(c8, 'Ne _') from char_tbl4
+-- !query schema
+struct<c7 LIKE Ne _:boolean,c8 LIKE Ne _:boolean>
+-- !query output
+NULL NULL
+NULL NULL
+false false
+false false
+false false
+false false
+false false
+false false
+false true
+
+
+-- !query
+select like(v, 'Spark_') from char_tbl4
+-- !query schema
+struct<v LIKE Spark_:boolean>
+-- !query output
+NULL
+false
+false
+false
+false
+false
+false
+true
+true
+
+
+-- !query
+select c7 = c8, upper(c7) = upper(c8), lower(c7) = lower(c8) from char_tbl4 where s = 'NetEase'
+-- !query schema
+struct<(c7 = c8):boolean,(upper(c7) = upper(c8)):boolean,(lower(c7) = lower(c8)):boolean>
+-- !query output
+true false false
+
+
+-- !query
+select c7 = s, upper(c7) = upper(s), lower(c7) = lower(s) from char_tbl4 where s = 'NetEase'
+-- !query schema
+struct<(c7 = s):boolean,(upper(c7) = upper(s)):boolean,(lower(c7) = lower(s)):boolean>
+-- !query output
+true true true
+
+
+-- !query
+select c7 = 'NetEase', upper(c7) = upper('NetEase'), lower(c7) = lower('NetEase') from char_tbl4 where s = 'NetEase'
+-- !query schema
+struct<(c7 = NetEase):boolean,(upper(c7) = upper(NetEase)):boolean,(lower(c7) = lower(NetEase)):boolean>
+-- !query output
+true true true
+
+
+-- !query
+select printf('Hey, %s%s%s%s', c7, c8, v, s) from char_tbl4
+-- !query schema
+struct<printf(Hey, %s%s%s%s, c7, c8, v, s):string>
+-- !query output
+Hey, N N N N
+Hey, Ne Ne SpNe
+Hey, Net Net Spa Net
+Hey, NetE NetE SparNetE
+Hey, NetEa NetEa Spark NetEa
+Hey, NetEas NetEas SparkNetEas
+Hey, NetEaseNetEase Spark-NetEase
+Hey, nullnullSnull
+Hey, nullnullnullnull
+
+
+-- !query
+select repeat(c7, 2), repeat(c8, 2), repeat(v, 2), repeat(s, 2) from char_tbl4
+-- !query schema
+struct<repeat(c7, 2):string,repeat(c8, 2):string,repeat(v, 2):string,repeat(s, 2):string>
+-- !query output
+N N N N N N NN
+NULL NULL NULL NULL
+NULL NULL SS NULL
+Ne Ne Ne Ne SpSp NeNe
+Net Net Net Net Spa Spa Net Net
+NetE NetE NetE NetE SparSpar NetENetE
+NetEa NetEa NetEa NetEa Spark Spark NetEa NetEa
+NetEas NetEas NetEas NetEas SparkSpark NetEas NetEas
+NetEaseNetEase NetEase NetEase Spark-Spark- NetEaseNetEase
+
+
+-- !query
+select replace(c7, 'Net', 'Apache'), replace(c8, 'Net', 'Apache'), replace(v, 'Spark', 'Kyuubi'), replace(s, 'Net', 'Apache') from char_tbl4
+-- !query schema
+struct<replace(c7, Net, Apache):string,replace(c8, Net, Apache):string,replace(v, Spark, Kyuubi):string,replace(s, Net, Apache):string>
+-- !query output
+Apache Apache Spa Apache
+ApacheE ApacheE Spar ApacheE
+ApacheEa ApacheEa Kyuubi ApacheEa
+ApacheEas ApacheEas Kyuubi ApacheEas
+ApacheEase ApacheEase Kyuubi- ApacheEase
+N N N N
+NULL NULL NULL NULL
+NULL NULL S NULL
+Ne Ne Sp Ne
+
+
+-- !query
+select rpad(c7, 10), rpad(c8, 5), rpad(v, 5), rpad(s, 5) from char_tbl4
+-- !query schema
+struct<rpad(c7, 10, ):string,rpad(c8, 5, ):string,rpad(v, 5, ):string,rpad(s, 5, ):string>
+-- !query output
+N N N N
+NULL NULL NULL NULL
+NULL NULL S NULL
+Ne Ne Sp Ne
+Net Net Spa Net
+NetE NetE Spar NetE
+NetEa NetEa Spark NetEa
+NetEas NetEa Spark NetEa
+NetEase NetEa Spark NetEa
+
+
+-- !query
+select rtrim(c7), rtrim(c8), rtrim(v), rtrim(s) from char_tbl4
+-- !query schema
+struct<rtrim(c7):string,rtrim(c8):string,rtrim(v):string,rtrim(s):string>
+-- !query output
+N N N N
+NULL NULL NULL NULL
+NULL NULL S NULL
+Ne Ne Sp Ne
+Net Net Spa Net
+NetE NetE Spar NetE
+NetEa NetEa Spark NetEa
+NetEas NetEas Spark NetEas
+NetEase NetEase Spark- NetEase
+
+
+-- !query
+select split(c7, 'e'), split(c8, 'e'), split(v, 'a'), split(s, 'e') from char_tbl4
+-- !query schema
+struct<split(c7, e, -1):array<string>,split(c8, e, -1):array<string>,split(v, a, -1):array<string>,split(s, e, -1):array<string>>
+-- !query output
+NULL NULL NULL NULL
+NULL NULL ["S"] NULL
+["N "] ["N "] ["N "] ["N"]
+["N"," "] ["N"," "] ["Sp"] ["N",""]
+["N","t "] ["N","t "] ["Sp"," "] ["N","t "]
+["N","tE "] ["N","tE "] ["Sp","r"] ["N","tE"]
+["N","tEa "] ["N","tEa "] ["Sp","rk "] ["N","tEa "]
+["N","tEas "] ["N","tEas "] ["Sp","rk"] ["N","tEas "]
+["N","tEas",""] ["N","tEas"," "] ["Sp","rk-"] ["N","tEas",""]
+
+
+-- !query
+select substring(c7, 2), substring(c8, 2), substring(v, 3), substring(s, 2) from char_tbl4
+-- !query schema
+struct<substring(c7, 2, 2147483647):string,substring(c8, 2, 2147483647):string,substring(v, 3, 2147483647):string,substring(s, 2, 2147483647):string>
+-- !query output
+
+NULL NULL NULL
+NULL NULL NULL NULL
+e e e
+et et a et
+etE etE ar etE
+etEa etEa ark etEa
+etEas etEas ark etEas
+etEase etEase ark- etEase
+
+
+-- !query
+select left(c7, 2), left(c8, 2), left(v, 3), left(s, 2) from char_tbl4
+-- !query schema
+struct<left(c7, 2):string,left(c8, 2):string,left(v, 3):string,left(s, 2):string>
+-- !query output
+N N N N
+NULL NULL NULL NULL
+NULL NULL S NULL
+Ne Ne Sp Ne
+Ne Ne Spa Ne
+Ne Ne Spa Ne
+Ne Ne Spa Ne
+Ne Ne Spa Ne
+Ne Ne Spa Ne
+
+
+-- !query
+select right(c7, 2), right(c8, 2), right(v, 3), right(s, 2) from char_tbl4
+-- !query schema
+struct<right(c7, 2):string,right(c8, 2):string,right(v, 3):string,right(s, 2):string>
+-- !query output
+ N N
+ Sp Ne
+ a
+ par tE
+ rk a
+NULL NULL NULL NULL
+NULL NULL S NULL
+s ark s
+se e rk- se
+
+
+-- !query
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.optimizer.excludedRules org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+
+
+-- !query
+select typeof(c7), typeof(c8), typeof(v), typeof(s) from char_tbl4 limit 1
+-- !query schema
+struct<typeof(c7):string,typeof(c8):string,typeof(v):string,typeof(s):string>
+-- !query output
+string string string string
+
+
+-- !query
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.optimizer.excludedRules org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+
+
+-- !query
+select cast(c7 as char(1)), cast(c8 as char(10)), cast(v as char(1)), cast(v as varchar(1)), cast(s as char(5)) from char_tbl4
+-- !query schema
+struct<c7:string,c8:string,v:string,v:string,s:string>
+-- !query output
+N N N N N
+NULL NULL NULL NULL NULL
+NULL NULL S S NULL
+Ne Ne Sp Sp Ne
+Net Net Spa Spa Net
+NetE NetE Spar Spar NetE
+NetEa NetEa Spark Spark NetEa
+NetEas NetEas Spark Spark NetEas
+NetEase NetEase Spark- Spark- NetEase
+
+
+-- !query
+drop table char_tbl1
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+drop table char_tbl2
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+drop table char_tbl3
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+drop table char_tbl4
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+select ascii('§'), ascii('÷'), ascii('×10')
+-- !query schema
+struct<ascii(§):int,ascii(÷):int,ascii(×10):int>
+-- !query output
+167 247 215
+
+
+-- !query
+select chr(167), chr(247), chr(215)
+-- !query schema
+struct<chr(167):string,chr(247):string,chr(215):string>
+-- !query output
+§ ÷ ×
+
+
+-- !query
+SELECT to_varchar(78.12, '$99.99')
+-- !query schema
+struct<to_char(78.12, $99.99):string>
+-- !query output
+$78.12
+
+
+-- !query
+SELECT to_varchar(111.11, '99.9')
+-- !query schema
+struct<to_char(111.11, 99.9):string>
+-- !query output
+##.#
+
+
+-- !query
+SELECT to_varchar(12454.8, '99,999.9S')
+-- !query schema
+struct<to_char(12454.8, 99,999.9S):string>
+-- !query output
+12,454.8+
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/count.sql.out b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/count.sql.out
new file mode 100644
index 0000000000..714c95cdd3
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/count.sql.out
@@ -0,0 +1,214 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (1, 1), (null, 2), (1, null), (null, null)
+AS testData(a, b)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT
+ count(*), count(1), count(null), count(a), count(b), count(a + b), count((a, b))
+FROM testData
+-- !query schema
+struct<count(1):bigint,count(1):bigint,count(NULL):bigint,count(a):bigint,count(b):bigint,count((a + b)):bigint,count(named_struct(a, a, b, b)):bigint>
+-- !query output
+7 7 0 5 5 4 7
+
+
+-- !query
+SELECT
+ count(DISTINCT 1),
+ count(DISTINCT null),
+ count(DISTINCT a),
+ count(DISTINCT b),
+ count(DISTINCT (a + b)),
+ count(DISTINCT (a, b))
+FROM testData
+-- !query schema
+struct<count(DISTINCT 1):bigint,count(DISTINCT NULL):bigint,count(DISTINCT a):bigint,count(DISTINCT b):bigint,count(DISTINCT (a + b)):bigint,count(DISTINCT named_struct(a, a, b, b)):bigint>
+-- !query output
+1 0 2 2 2 6
+
+
+-- !query
+SELECT count(a, b), count(b, a), count(testData.*, testData.*) FROM testData
+-- !query schema
+struct<count(a, b):bigint,count(b, a):bigint,count(a, b, a, b):bigint>
+-- !query output
+4 4 4
+
+
+-- !query
+SELECT
+ count(DISTINCT a, b), count(DISTINCT b, a), count(DISTINCT *), count(DISTINCT testData.*, testData.*)
+FROM testData
+-- !query schema
+struct<count(DISTINCT a, b):bigint,count(DISTINCT b, a):bigint,count(DISTINCT a, b):bigint,count(DISTINCT a, b, a, b):bigint>
+-- !query output
+3 3 3 3
+
+
+-- !query
+SELECT count(DISTINCT 3,2)
+-- !query schema
+struct<count(DISTINCT 3, 2):bigint>
+-- !query output
+1
+
+
+-- !query
+SELECT count(DISTINCT 2), count(DISTINCT 2,3)
+-- !query schema
+struct<count(DISTINCT 2):bigint,count(DISTINCT 2, 3):bigint>
+-- !query output
+1 1
+
+
+-- !query
+SELECT count(DISTINCT 2), count(DISTINCT 3,2)
+-- !query schema
+struct<count(DISTINCT 2):bigint,count(DISTINCT 3, 2):bigint>
+-- !query output
+1 1
+
+
+-- !query
+SELECT count(DISTINCT a), count(DISTINCT 2,3) FROM testData
+-- !query schema
+struct<count(DISTINCT a):bigint,count(DISTINCT 2, 3):bigint>
+-- !query output
+2 1
+
+
+-- !query
+SELECT count(DISTINCT a), count(DISTINCT 3,2) FROM testData
+-- !query schema
+struct<count(DISTINCT a):bigint,count(DISTINCT 3, 2):bigint>
+-- !query output
+2 1
+
+
+-- !query
+SELECT count(DISTINCT a), count(DISTINCT 2), count(DISTINCT 2,3) FROM testData
+-- !query schema
+struct<count(DISTINCT a):bigint,count(DISTINCT 2):bigint,count(DISTINCT 2, 3):bigint>
+-- !query output
+2 1 1
+
+
+-- !query
+SELECT count(DISTINCT a), count(DISTINCT 2), count(DISTINCT 3,2) FROM testData
+-- !query schema
+struct<count(DISTINCT a):bigint,count(DISTINCT 2):bigint,count(DISTINCT 3, 2):bigint>
+-- !query output
+2 1 1
+
+
+-- !query
+SELECT count(distinct 0.8), percentile_approx(distinct a, 0.8) FROM testData
+-- !query schema
+struct<count(DISTINCT 0.8):bigint,percentile_approx(DISTINCT a, 0.8, 10000):int>
+-- !query output
+1 2
+
+
+-- !query
+set spark.sql.legacy.allowParameterlessCount=true
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.legacy.allowParameterlessCount true
+
+
+-- !query
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.optimizer.excludedRules org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding
+
+
+-- !query
+SELECT count() FROM testData
+-- !query schema
+struct<count():bigint>
+-- !query output
+0
+
+
+-- !query
+set spark.sql.legacy.allowParameterlessCount=false
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.legacy.allowParameterlessCount false
+
+
+-- !query
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.optimizer.excludedRules org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+
+
+-- !query
+SELECT count() FROM testData
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "WRONG_NUM_ARGS.WITH_SUGGESTION",
+ "sqlState" : "42605",
+ "messageParameters" : {
+ "actualNum" : "0",
+ "expectedNum" : " >= 1",
+ "functionName" : "`count`",
+ "legacyConfKey" : "\"spark.sql.legacy.allowParameterlessCount\"",
+ "legacyConfValue" : "\"true\"",
+ "legacyNum" : "0"
+ }
+}
+
+
+-- !query
+set spark.sql.legacy.allowStarWithSingleTableIdentifierInCount=true
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.legacy.allowStarWithSingleTableIdentifierInCount true
+
+
+-- !query
+SELECT count(testData.*) FROM testData
+-- !query schema
+struct<count(a, b):bigint>
+-- !query output
+4
+
+
+-- !query
+set spark.sql.legacy.allowStarWithSingleTableIdentifierInCount=false
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.legacy.allowStarWithSingleTableIdentifierInCount false
+
+
+-- !query
+SELECT count(testData.*) FROM testData
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "_LEGACY_ERROR_TEMP_1021",
+ "messageParameters" : {
+ "targetString" : "testData"
+ }
+}
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/cte.sql.out b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/cte.sql.out
new file mode 100644
index 0000000000..9b7b6f2808
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/cte.sql.out
@@ -0,0 +1,595 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+create temporary view t as select * from values 0, 1, 2 as t(id)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+create temporary view t2 as select * from values 0, 1 as t(id)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+WITH s AS (SELECT 1 FROM s) SELECT * FROM s
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "TABLE_OR_VIEW_NOT_FOUND",
+ "sqlState" : "42P01",
+ "messageParameters" : {
+ "relationName" : "`s`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 26,
+ "stopIndex" : 26,
+ "fragment" : "s"
+ } ]
+}
+
+
+-- !query
+WITH r AS (SELECT (SELECT * FROM r))
+SELECT * FROM r
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "TABLE_OR_VIEW_NOT_FOUND",
+ "sqlState" : "42P01",
+ "messageParameters" : {
+ "relationName" : "`r`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 34,
+ "stopIndex" : 34,
+ "fragment" : "r"
+ } ]
+}
+
+
+-- !query
+WITH t AS (SELECT 1 FROM t) SELECT * FROM t
+-- !query schema
+struct<1:int>
+-- !query output
+1
+1
+1
+
+
+-- !query
+WITH s1 AS (SELECT 1 FROM s2), s2 AS (SELECT 1 FROM s1) SELECT * FROM s1, s2
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "TABLE_OR_VIEW_NOT_FOUND",
+ "sqlState" : "42P01",
+ "messageParameters" : {
+ "relationName" : "`s2`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 27,
+ "stopIndex" : 28,
+ "fragment" : "s2"
+ } ]
+}
+
+
+-- !query
+WITH t1 AS (SELECT * FROM t2), t2 AS (SELECT 2 FROM t1) SELECT * FROM t1 cross join t2
+-- !query schema
+struct<id:int,2:int>
+-- !query output
+0 2
+0 2
+1 2
+1 2
+
+
+-- !query
+WITH CTE1 AS (
+ SELECT b.id AS id
+ FROM T2 a
+ CROSS JOIN (SELECT id AS id FROM T2) b
+)
+SELECT t1.id AS c1,
+ t2.id AS c2
+FROM CTE1 t1
+ CROSS JOIN CTE1 t2
+-- !query schema
+struct<c1:int,c2:int>
+-- !query output
+0 0
+0 0
+0 0
+0 0
+0 1
+0 1
+0 1
+0 1
+1 0
+1 0
+1 0
+1 0
+1 1
+1 1
+1 1
+1 1
+
+
+-- !query
+WITH t(x) AS (SELECT 1)
+SELECT * FROM t WHERE x = 1
+-- !query schema
+struct<x:int>
+-- !query output
+1
+
+
+-- !query
+WITH t(x, y) AS (SELECT 1, 2)
+SELECT * FROM t WHERE x = 1 AND y = 2
+-- !query schema
+struct<x:int,y:int>
+-- !query output
+1 2
+
+
+-- !query
+WITH t(x, x) AS (SELECT 1, 2)
+SELECT * FROM t
+-- !query schema
+struct<x:int,x:int>
+-- !query output
+1 2
+
+
+-- !query
+WITH t() AS (SELECT 1)
+SELECT * FROM t
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "PARSE_SYNTAX_ERROR",
+ "sqlState" : "42601",
+ "messageParameters" : {
+ "error" : "')'",
+ "hint" : ""
+ }
+}
+
+
+-- !query
+WITH
+ t(x) AS (SELECT 1),
+ t(x) AS (SELECT 2)
+SELECT * FROM t
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "_LEGACY_ERROR_TEMP_0038",
+ "messageParameters" : {
+ "duplicateNames" : "'t'"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 63,
+ "fragment" : "WITH\n t(x) AS (SELECT 1),\n t(x) AS (SELECT 2)\nSELECT * FROM t"
+ } ]
+}
+
+
+-- !query
+WITH t AS (SELECT 1 FROM non_existing_table)
+SELECT 2
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "TABLE_OR_VIEW_NOT_FOUND",
+ "sqlState" : "42P01",
+ "messageParameters" : {
+ "relationName" : "`non_existing_table`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 26,
+ "stopIndex" : 43,
+ "fragment" : "non_existing_table"
+ } ]
+}
+
+
+-- !query
+SELECT count(*) FROM (
+ WITH q1(x) AS (SELECT random() FROM range(1, 5))
+ SELECT * FROM q1
+ UNION
+ SELECT * FROM q1
+) ss
+-- !query schema
+struct<count(1):bigint>
+-- !query output
+4
+
+
+-- !query
+WITH w1(c1) AS
+ (WITH w2(c2) AS
+ (WITH w3(c3) AS
+ (WITH w4(c4) AS
+ (WITH w5(c5) AS
+ (WITH w6(c6) AS
+ (WITH w7(c7) AS
+ (WITH w8(c8) AS
+ (SELECT 1)
+ SELECT * FROM w8)
+ SELECT * FROM w7)
+ SELECT * FROM w6)
+ SELECT * FROM w5)
+ SELECT * FROM w4)
+ SELECT * FROM w3)
+ SELECT * FROM w2)
+SELECT * FROM w1
+-- !query schema
+struct<c1:int>
+-- !query output
+1
+
+
+-- !query
+SELECT ( WITH cte(foo) AS ( VALUES(id) )
+ SELECT (SELECT foo FROM cte) )
+FROM t
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "INVALID_INLINE_TABLE.CANNOT_EVALUATE_EXPRESSION_IN_INLINE_TABLE",
+ "messageParameters" : {
+ "expr" : "\"outer(t.id)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 36,
+ "stopIndex" : 37,
+ "fragment" : "id"
+ } ]
+}
+
+
+-- !query
+WITH same_name AS (SELECT 42)
+SELECT * FROM same_name, (SELECT 10) AS same_name
+-- !query schema
+struct<42:int,10:int>
+-- !query output
+42 10
+
+
+-- !query
+WITH same_name(x) AS (SELECT 42)
+SELECT same_name.x FROM (SELECT 10) AS same_name(x), same_name
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "AMBIGUOUS_REFERENCE",
+ "sqlState" : "42704",
+ "messageParameters" : {
+ "name" : "`same_name`.`x`",
+ "referenceNames" : "[`same_name`.`x`, `same_name`.`x`]"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 41,
+ "stopIndex" : 51,
+ "fragment" : "same_name.x"
+ } ]
+}
+
+
+-- !query
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.optimizer.excludedRules org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+
+
+-- !query
+WITH q AS (SELECT 'foo' AS x)
+SELECT x, typeof(x) FROM q
+-- !query schema
+struct<x:string,typeof(x):string>
+-- !query output
+foo string
+
+
+-- !query
+set spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+-- !query schema
+struct<key:string,value:string>
+-- !query output
+spark.sql.optimizer.excludedRules org.apache.spark.sql.catalyst.optimizer.ConvertToLocalRelation,org.apache.spark.sql.catalyst.optimizer.ConstantFolding,org.apache.spark.sql.catalyst.optimizer.NullPropagation
+
+
+-- !query
+with cte as (select id as id_alias from t)
+select id from cte
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ "sqlState" : "42703",
+ "messageParameters" : {
+ "objectName" : "`id`",
+ "proposal" : "`id_alias`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 51,
+ "stopIndex" : 52,
+ "fragment" : "id"
+ } ]
+}
+
+
+-- !query
+with r1 as (select * from r2),
+ r2 as (select 1)
+select 2
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "TABLE_OR_VIEW_NOT_FOUND",
+ "sqlState" : "42P01",
+ "messageParameters" : {
+ "relationName" : "`r2`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 27,
+ "stopIndex" : 28,
+ "fragment" : "r2"
+ } ]
+}
+
+
+-- !query
+SELECT * FROM
+ (WITH q AS (select 1 x) SELECT x+1 AS y FROM q)
+-- !query schema
+struct<y:int>
+-- !query output
+2
+
+
+-- !query
+select (with q as (select 1 x) select * from q)
+-- !query schema
+struct<scalarsubquery():int>
+-- !query output
+1
+
+
+-- !query
+select 1 in (with q as (select 1) select * from q)
+-- !query schema
+struct<(1 IN (listquery())):boolean>
+-- !query output
+true
+
+
+-- !query
+SELECT * FROM
+ (WITH q AS (select 1 x) SELECT x+1 AS y FROM q),
+ q
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "TABLE_OR_VIEW_NOT_FOUND",
+ "sqlState" : "42P01",
+ "messageParameters" : {
+ "relationName" : "`q`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 68,
+ "stopIndex" : 68,
+ "fragment" : "q"
+ } ]
+}
+
+
+-- !query
+WITH T1 as (select 1 a)
+select *
+from
+ T1 x,
+ (WITH T1 as (select 2 b) select * from T1) y,
+ T1 z
+-- !query schema
+struct<a:int,b:int,a:int>
+-- !query output
+1 2 1
+
+
+-- !query
+WITH TTtt as (select 1 a),
+ `tTTt_2` as (select 2 a)
+select *
+from
+ (WITH TtTt as (select 3 c) select * from ttTT, `tttT_2`)
+-- !query schema
+struct<c:int,a:int>
+-- !query output
+3 2
+
+
+-- !query
+select
+ (WITH q AS (select T.x) select * from q)
+from (select 1 x, 2 y) T
+-- !query schema
+struct<scalarsubquery(x):int>
+-- !query output
+1
+
+
+-- !query
+select
+ (WITH q AS (select 3 z) select x + t.y + z from q)
+from (select 1 x, 2 y) T
+-- !query schema
+struct<scalarsubquery(x, y):int>
+-- !query output
+6
+
+
+-- !query
+WITH q1 as (select 1 x)
+select * from
+ (with q2 as (select * from q1) select * from q2)
+-- !query schema
+struct<x:int>
+-- !query output
+1
+
+
+-- !query
+WITH q1 as (select 1 x)
+select * from
+ (with q1 as (select x+1 from q1) select * from q1)
+-- !query schema
+struct<(x + 1):int>
+-- !query output
+2
+
+
+-- !query
+with cte1 as (select 42), cte1 as (select 42) select * FROM cte1
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "_LEGACY_ERROR_TEMP_0038",
+ "messageParameters" : {
+ "duplicateNames" : "'cte1'"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 64,
+ "fragment" : "with cte1 as (select 42), cte1 as (select 42) select * FROM cte1"
+ } ]
+}
+
+
+-- !query
+with cte1 as (Select id as j from t)
+select * from cte1 where j = (select max(j) from cte1 as cte2)
+-- !query schema
+struct<j:int>
+-- !query output
+2
+
+
+-- !query
+with cte AS (SELECT * FROM va) SELECT * FROM cte
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "TABLE_OR_VIEW_NOT_FOUND",
+ "sqlState" : "42P01",
+ "messageParameters" : {
+ "relationName" : "`va`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 28,
+ "stopIndex" : 29,
+ "fragment" : "va"
+ } ]
+}
+
+
+-- !query
+with cte as (select * from cte) select * from cte
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "TABLE_OR_VIEW_NOT_FOUND",
+ "sqlState" : "42P01",
+ "messageParameters" : {
+ "relationName" : "`cte`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 28,
+ "stopIndex" : 30,
+ "fragment" : "cte"
+ } ]
+}
+
+
+-- !query
+DROP VIEW IF EXISTS t
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+DROP VIEW IF EXISTS t2
+-- !query schema
+struct<>
+-- !query output
+
diff --git a/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/datetime-legacy.sql.out b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/datetime-legacy.sql.out
new file mode 100644
index 0000000000..5e2a4d61e1
--- /dev/null
+++ b/gluten-ut/spark35/src/test/resources/backends-velox/sql-tests/results/datetime-legacy.sql.out
@@ -0,0 +1,2154 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+create temporary view date_view as select '2011-11-11' date_str, '1' int_str
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+select date '2019-01-01\t'
+-- !query schema
+struct<DATE '2019-01-01':date>
+-- !query output
+2019-01-01
+
+
+-- !query
+select date '2020-01-01中文'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_TYPED_LITERAL",
+ "sqlState" : "42604",
+ "messageParameters" : {
+ "value" : "'2020-01-01中文'",
+ "valueType" : "\"DATE\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 26,
+ "fragment" : "date '2020-01-01中文'"
+ } ]
+}
+
+
+-- !query
+select make_date(2019, 1, 1), make_date(12, 12, 12)
+-- !query schema
+struct<make_date(2019, 1, 1):date,make_date(12, 12, 12):date>
+-- !query output
+2019-01-01 0012-12-12
+
+
+-- !query
+select make_date(2000, 13, 1)
+-- !query schema
+struct<make_date(2000, 13, 1):date>
+-- !query output
+NULL
+
+
+-- !query
+select make_date(2000, 1, 33)
+-- !query schema
+struct<make_date(2000, 1, 33):date>
+-- !query output
+NULL
+
+
+-- !query
+select date'015'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_TYPED_LITERAL",
+ "sqlState" : "42604",
+ "messageParameters" : {
+ "value" : "'015'",
+ "valueType" : "\"DATE\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 16,
+ "fragment" : "date'015'"
+ } ]
+}
+
+
+-- !query
+select date'2021-4294967297-11'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_TYPED_LITERAL",
+ "sqlState" : "42604",
+ "messageParameters" : {
+ "value" : "'2021-4294967297-11'",
+ "valueType" : "\"DATE\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 31,
+ "fragment" : "date'2021-4294967297-11'"
+ } ]
+}
+
+
+-- !query
+select current_date = current_date
+-- !query schema
+struct<(current_date() = current_date()):boolean>
+-- !query output
+true
+
+
+-- !query
+select current_date() = current_date()
+-- !query schema
+struct<(current_date() = current_date()):boolean>
+-- !query output
+true
+
+
+-- !query
+select curdate(1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION",
+ "sqlState" : "42605",
+ "messageParameters" : {
+ "actualNum" : "1",
+ "docroot" : "https://spark.apache.org/docs/latest",
+ "expectedNum" : "0",
+ "functionName" : "`curdate`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 17,
+ "fragment" : "curdate(1)"
+ } ]
+}
+
+
+-- !query
+select DATE_FROM_UNIX_DATE(0), DATE_FROM_UNIX_DATE(1000), DATE_FROM_UNIX_DATE(null)
+-- !query schema
+struct<date_from_unix_date(0):date,date_from_unix_date(1000):date,date_from_unix_date(NULL):date>
+-- !query output
+1970-01-01 1972-09-27 NULL
+
+
+-- !query
+select UNIX_DATE(DATE('1970-01-01')), UNIX_DATE(DATE('2020-12-04')), UNIX_DATE(null)
+-- !query schema
+struct<unix_date(1970-01-01):int,unix_date(2020-12-04):int,unix_date(NULL):int>
+-- !query output
+0 18600 NULL
+
+
+-- !query
+select to_date(null), to_date('2016-12-31'), to_date('2016-12-31', 'yyyy-MM-dd')
+-- !query schema
+struct<to_date(NULL):date,to_date(2016-12-31):date,to_date(2016-12-31, yyyy-MM-dd):date>
+-- !query output
+NULL 2016-12-31 2016-12-31
+
+
+-- !query
+select dayofweek('2007-02-03'), dayofweek('2009-07-30'), dayofweek('2017-05-27'), dayofweek(null),
+ dayofweek('1582-10-15 13:10:15'), dayofweek(timestamp_ltz'1582-10-15 13:10:15'), dayofweek(timestamp_ntz'1582-10-15 13:10:15')
+-- !query schema
+struct<dayofweek(2007-02-03):int,dayofweek(2009-07-30):int,dayofweek(2017-05-27):int,dayofweek(NULL):int,dayofweek(1582-10-15 13:10:15):int,dayofweek(TIMESTAMP '1582-10-15 13:10:15'):int,dayofweek(TIMESTAMP_NTZ '1582-10-15 13:10:15'):int>
+-- !query output
+7 5 7 NULL 6 6 6
+
+
+-- !query
+select weekday('2007-02-03'), weekday('2009-07-30'), weekday('2017-05-27'), weekday(null),
+ weekday('1582-10-15 13:10:15'), weekday(timestamp_ltz'1582-10-15 13:10:15'), weekday(timestamp_ntz'1582-10-15 13:10:15')
+-- !query schema
+struct<weekday(2007-02-03):int,weekday(2009-07-30):int,weekday(2017-05-27):int,weekday(NULL):int,weekday(1582-10-15 13:10:15):int,weekday(TIMESTAMP '1582-10-15 13:10:15'):int,weekday(TIMESTAMP_NTZ '1582-10-15 13:10:15'):int>
+-- !query output
+5 3 5 NULL 4 4 4
+
+
+-- !query
+select year('1500-01-01'), year('1582-10-15 13:10:15'), year(timestamp_ltz'1582-10-15 13:10:15'), year(timestamp_ntz'1582-10-15 13:10:15')
+-- !query schema
+struct<year(1500-01-01):int,year(1582-10-15 13:10:15):int,year(TIMESTAMP '1582-10-15 13:10:15'):int,year(TIMESTAMP_NTZ '1582-10-15 13:10:15'):int>
+-- !query output
+1500 1582 1582 1582
+
+
+-- !query
+select month('1500-01-01'), month('1582-10-15 13:10:15'), month(timestamp_ltz'1582-10-15 13:10:15'), month(timestamp_ntz'1582-10-15 13:10:15')
+-- !query schema
+struct<month(1500-01-01):int,month(1582-10-15 13:10:15):int,month(TIMESTAMP '1582-10-15 13:10:15'):int,month(TIMESTAMP_NTZ '1582-10-15 13:10:15'):int>
+-- !query output
+1 10 10 10
+
+
+-- !query
+select dayOfYear('1500-01-01'), dayOfYear('1582-10-15 13:10:15'), dayOfYear(timestamp_ltz'1582-10-15 13:10:15'), dayOfYear(timestamp_ntz'1582-10-15 13:10:15')
+-- !query schema
+struct<dayofyear(1500-01-01):int,dayofyear(1582-10-15 13:10:15):int,dayofyear(TIMESTAMP '1582-10-15 13:10:15'):int,dayofyear(TIMESTAMP_NTZ '1582-10-15 13:10:15'):int>
+-- !query output
+1 288 288 288
+
+
+-- !query
+select next_day("2015-07-23", "Mon")
+-- !query schema
+struct<next_day(2015-07-23, Mon):date>
+-- !query output
+2015-07-27
+
+
+-- !query
+select next_day("2015-07-23", "xx")
+-- !query schema
+struct<next_day(2015-07-23, xx):date>
+-- !query output
+NULL
+
+
+-- !query
+select next_day("2015-07-23 12:12:12", "Mon")
+-- !query schema
+struct<next_day(2015-07-23 12:12:12, Mon):date>
+-- !query output
+2015-07-27
+
+
+-- !query
+select next_day(timestamp_ltz"2015-07-23 12:12:12", "Mon")
+-- !query schema
+struct<next_day(TIMESTAMP '2015-07-23 12:12:12', Mon):date>
+-- !query output
+2015-07-27
+
+
+-- !query
+select next_day(timestamp_ntz"2015-07-23 12:12:12", "Mon")
+-- !query schema
+struct<next_day(TIMESTAMP_NTZ '2015-07-23 12:12:12', Mon):date>
+-- !query output
+2015-07-27
+
+
+-- !query
+select next_day("xx", "Mon")
+-- !query schema
+struct<next_day(xx, Mon):date>
+-- !query output
+NULL
+
+
+-- !query
+select next_day(null, "Mon")
+-- !query schema
+struct<next_day(NULL, Mon):date>
+-- !query output
+NULL
+
+
+-- !query
+select next_day(null, "xx")
+-- !query schema
+struct<next_day(NULL, xx):date>
+-- !query output
+NULL
+
+
+-- !query
+select date_add(date'2011-11-11', 1)
+-- !query schema
+struct<date_add(DATE '2011-11-11', 1):date>
+-- !query output
+2011-11-12
+
+
+-- !query
+select date_add('2011-11-11', 1)
+-- !query schema
+struct<date_add(2011-11-11, 1):date>
+-- !query output
+2011-11-12
+
+
+-- !query
+select date_add('2011-11-11', 1Y)
+-- !query schema
+struct<date_add(2011-11-11, 1):date>
+-- !query output
+2011-11-12
+
+
+-- !query
+select date_add('2011-11-11', 1S)
+-- !query schema
+struct<date_add(2011-11-11, 1):date>
+-- !query output
+2011-11-12
+
+
+-- !query
+select date_add('2011-11-11', 1L)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"BIGINT\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_add(2011-11-11, 1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 33,
+ "fragment" : "date_add('2011-11-11', 1L)"
+ } ]
+}
+
+
+-- !query
+select date_add('2011-11-11', 1.0)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1.0\"",
+ "inputType" : "\"DECIMAL(2,1)\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_add(2011-11-11, 1.0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 34,
+ "fragment" : "date_add('2011-11-11', 1.0)"
+ } ]
+}
+
+
+-- !query
+select date_add('2011-11-11', 1E1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"10.0\"",
+ "inputType" : "\"DOUBLE\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_add(2011-11-11, 10.0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 34,
+ "fragment" : "date_add('2011-11-11', 1E1)"
+ } ]
+}
+
+
+-- !query
+select date_add('2011-11-11', '1')
+-- !query schema
+struct<date_add(2011-11-11, 1):date>
+-- !query output
+2011-11-12
+
+
+-- !query
+select date_add('2011-11-11', '1.2')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "SECOND_FUNCTION_ARGUMENT_NOT_INTEGER",
+ "sqlState" : "22023",
+ "messageParameters" : {
+ "functionName" : "date_add"
+ }
+}
+
+
+-- !query
+select date_add(null, 1)
+-- !query schema
+struct<date_add(NULL, 1):date>
+-- !query output
+NULL
+
+
+-- !query
+select date_add(date'2011-11-11', null)
+-- !query schema
+struct<date_add(DATE '2011-11-11', NULL):date>
+-- !query output
+NULL
+
+
+-- !query
+select date_add(timestamp_ltz'2011-11-11 12:12:12', 1)
+-- !query schema
+struct<date_add(TIMESTAMP '2011-11-11 12:12:12', 1):date>
+-- !query output
+2011-11-12
+
+
+-- !query
+select date_add(timestamp_ntz'2011-11-11 12:12:12', 1)
+-- !query schema
+struct<date_add(TIMESTAMP_NTZ '2011-11-11 12:12:12', 1):date>
+-- !query output
+2011-11-12
+
+
+-- !query
+select date_sub(date'2011-11-11', 1)
+-- !query schema
+struct<date_sub(DATE '2011-11-11', 1):date>
+-- !query output
+2011-11-10
+
+
+-- !query
+select date_sub('2011-11-11', 1)
+-- !query schema
+struct<date_sub(2011-11-11, 1):date>
+-- !query output
+2011-11-10
+
+
+-- !query
+select date_sub('2011-11-11', 1Y)
+-- !query schema
+struct<date_sub(2011-11-11, 1):date>
+-- !query output
+2011-11-10
+
+
+-- !query
+select date_sub('2011-11-11', 1S)
+-- !query schema
+struct<date_sub(2011-11-11, 1):date>
+-- !query output
+2011-11-10
+
+
+-- !query
+select date_sub('2011-11-11', 1L)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"BIGINT\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_sub(2011-11-11, 1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 33,
+ "fragment" : "date_sub('2011-11-11', 1L)"
+ } ]
+}
+
+
+-- !query
+select date_sub('2011-11-11', 1.0)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1.0\"",
+ "inputType" : "\"DECIMAL(2,1)\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_sub(2011-11-11, 1.0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 34,
+ "fragment" : "date_sub('2011-11-11', 1.0)"
+ } ]
+}
+
+
+-- !query
+select date_sub('2011-11-11', 1E1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"10.0\"",
+ "inputType" : "\"DOUBLE\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_sub(2011-11-11, 10.0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 34,
+ "fragment" : "date_sub('2011-11-11', 1E1)"
+ } ]
+}
+
+
+-- !query
+select date_sub(date'2011-11-11', '1')
+-- !query schema
+struct<date_sub(DATE '2011-11-11', 1):date>
+-- !query output
+2011-11-10
+
+
+-- !query
+select date_sub(date'2011-11-11', '1.2')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "SECOND_FUNCTION_ARGUMENT_NOT_INTEGER",
+ "sqlState" : "22023",
+ "messageParameters" : {
+ "functionName" : "date_sub"
+ }
+}
+
+
+-- !query
+select date_sub(null, 1)
+-- !query schema
+struct<date_sub(NULL, 1):date>
+-- !query output
+NULL
+
+
+-- !query
+select date_sub(date'2011-11-11', null)
+-- !query schema
+struct<date_sub(DATE '2011-11-11', NULL):date>
+-- !query output
+NULL
+
+
+-- !query
+select date_sub(timestamp_ltz'2011-11-11 12:12:12', 1)
+-- !query schema
+struct<date_sub(TIMESTAMP '2011-11-11 12:12:12', 1):date>
+-- !query output
+2011-11-10
+
+
+-- !query
+select date_sub(timestamp_ntz'2011-11-11 12:12:12', 1)
+-- !query schema
+struct<date_sub(TIMESTAMP_NTZ '2011-11-11 12:12:12', 1):date>
+-- !query output
+2011-11-10
+
+
+-- !query
+select date_add('2011-11-11', int_str) from date_view
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"int_str\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_add(2011-11-11, int_str)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 38,
+ "fragment" : "date_add('2011-11-11', int_str)"
+ } ]
+}
+
+
+-- !query
+select date_sub('2011-11-11', int_str) from date_view
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"int_str\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_sub(2011-11-11, int_str)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 38,
+ "fragment" : "date_sub('2011-11-11', int_str)"
+ } ]
+}
+
+
+-- !query
+select date_add(date_str, 1) from date_view
+-- !query schema
+struct<date_add(date_str, 1):date>
+-- !query output
+2011-11-12
+
+
+-- !query
+select date_sub(date_str, 1) from date_view
+-- !query schema
+struct<date_sub(date_str, 1):date>
+-- !query output
+2011-11-10
+
+
+-- !query
+select date '2011-11-11' + 1E1
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"10.0\"",
+ "inputType" : "\"DOUBLE\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_add(DATE '2011-11-11', 10.0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 30,
+ "fragment" : "date '2011-11-11' + 1E1"
+ } ]
+}
+
+
+-- !query
+select date '2001-09-28' + 7Y
+-- !query schema
+struct<date_add(DATE '2001-09-28', 7):date>
+-- !query output
+2001-10-05
+
+
+-- !query
+select 7S + date '2001-09-28'
+-- !query schema
+struct<date_add(DATE '2001-09-28', 7):date>
+-- !query output
+2001-10-05
+
+
+-- !query
+select date '2001-10-01' - 7
+-- !query schema
+struct<date_sub(DATE '2001-10-01', 7):date>
+-- !query output
+2001-09-24
+
+
+-- !query
+select date '2001-10-01' - date '2001-09-28'
+-- !query schema
+struct<(DATE '2001-10-01' - DATE '2001-09-28'):interval day>
+-- !query output
+3 00:00:00.000000000
+
+
+-- !query
+select date '2001-10-01' - '2001-09-28'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"2001-09-28\"",
+ "inputType" : "\"DOUBLE\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_sub(DATE '2001-10-01', 2001-09-28)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 39,
+ "fragment" : "date '2001-10-01' - '2001-09-28'"
+ } ]
+}
+
+
+-- !query
+select '2001-10-01' - date '2001-09-28'
+-- !query schema
+struct<(2001-10-01 - DATE '2001-09-28'):interval day>
+-- !query output
+3 00:00:00.000000000
+
+
+-- !query
+select date '2001-09-28' - null
+-- !query schema
+struct<date_sub(DATE '2001-09-28', NULL):date>
+-- !query output
+NULL
+
+
+-- !query
+select null - date '2019-10-06'
+-- !query schema
+struct<(NULL - DATE '2019-10-06'):interval day>
+-- !query output
+NULL
+
+
+-- !query
+select date_str - date '2001-09-28' from date_view
+-- !query schema
+struct<(date_str - DATE '2001-09-28'):interval day>
+-- !query output
+3696 00:00:00.000000000
+
+
+-- !query
+select date '2001-09-28' - date_str from date_view
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"date_str\"",
+ "inputType" : "\"DOUBLE\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_sub(DATE '2001-09-28', date_str)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 35,
+ "fragment" : "date '2001-09-28' - date_str"
+ } ]
+}
+
+
+-- !query
+select date'2011-11-11' + '1'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"DOUBLE\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_add(DATE '2011-11-11', 1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 29,
+ "fragment" : "date'2011-11-11' + '1'"
+ } ]
+}
+
+
+-- !query
+select '1' + date'2011-11-11'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"DOUBLE\"",
+ "paramIndex" : "2",
+ "requiredType" : "(\"INT\" or \"SMALLINT\" or \"TINYINT\")",
+ "sqlExpr" : "\"date_add(DATE '2011-11-11', 1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 29,
+ "fragment" : "'1' + date'2011-11-11'"
+ } ]
+}
+
+
+-- !query
+select date'2011-11-11' + null
+-- !query schema
+struct<date_add(DATE '2011-11-11', NULL):date>
+-- !query output
+NULL
+
+
+-- !query
+select null + date'2011-11-11'
+-- !query schema
+struct<date_add(DATE '2011-11-11', NULL):date>
+-- !query output
+NULL
+
+
+-- !query
+select date '2012-01-01' - interval '2-2' year to month,
+ date '2011-11-11' - interval '2' day,
+ date '2012-01-01' + interval '-2-2' year to month,
+ date '2011-11-11' + interval '-2' month,
+ - interval '2-2' year to month + date '2012-01-01',
+ interval '-2' day + date '2011-11-11'
+-- !query schema
+struct<DATE '2012-01-01' - INTERVAL '2-2' YEAR TO MONTH:date,date_add(DATE '2011-11-11', (- extractansiintervaldays(INTERVAL '2' DAY))):date,DATE '2012-01-01' + INTERVAL '-2-2' YEAR TO MONTH:date,DATE '2011-11-11' + INTERVAL '-2' MONTH:date,DATE '2012-01-01' + (- INTERVAL '2-2' YEAR TO MONTH):date,date_add(DATE '2011-11-11', extractansiintervaldays(INTERVAL '-2' DAY)):date>
+-- !query output
+2009-11-01 2011-11-09 2009-11-01 2011-09-11 2009-11-01 2011-11-09
+
+
+-- !query
+select to_date('26/October/2015', 'dd/MMMMM/yyyy')
+-- !query schema
+struct<to_date(26/October/2015, dd/MMMMM/yyyy):date>
+-- !query output
+2015-10-26
+
+
+-- !query
+select from_json('{"d":"26/October/2015"}', 'd Date', map('dateFormat', 'dd/MMMMM/yyyy'))
+-- !query schema
+struct<from_json({"d":"26/October/2015"}):struct<d:date>>
+-- !query output
+{"d":2015-10-26}
+
+
+-- !query
+select from_csv('26/October/2015', 'd Date', map('dateFormat', 'dd/MMMMM/yyyy'))
+-- !query schema
+struct<from_csv(26/October/2015):struct<d:date>>
+-- !query output
+{"d":2015-10-26}
+
+
+-- !query
+select dateadd(MICROSECOND, 1001, timestamp'2022-02-25 01:02:03.123')
+-- !query schema
+struct<timestampadd(MICROSECOND, 1001, TIMESTAMP '2022-02-25 01:02:03.123'):timestamp>
+-- !query output
+2022-02-25 01:02:03.124001
+
+
+-- !query
+select date_add(MILLISECOND, -1, timestamp'2022-02-25 01:02:03.456')
+-- !query schema
+struct<timestampadd(MILLISECOND, -1, TIMESTAMP '2022-02-25 01:02:03.456'):timestamp>
+-- !query output
+2022-02-25 01:02:03.455
+
+
+-- !query
+select dateadd(SECOND, 58, timestamp'2022-02-25 01:02:03')
+-- !query schema
+struct<timestampadd(SECOND, 58, TIMESTAMP '2022-02-25 01:02:03'):timestamp>
+-- !query output
+2022-02-25 01:03:01
+
+
+-- !query
+select date_add(MINUTE, -100, date'2022-02-25')
+-- !query schema
+struct<timestampadd(MINUTE, -100, DATE '2022-02-25'):timestamp>
+-- !query output
+2022-02-24 22:20:00
+
+
+-- !query
+select dateadd(HOUR, -1, timestamp'2022-02-25 01:02:03')
+-- !query schema
+struct<timestampadd(HOUR, -1, TIMESTAMP '2022-02-25 01:02:03'):timestamp>
+-- !query output
+2022-02-25 00:02:03
+
+
+-- !query
+select date_add(DAY, 367, date'2022-02-25')
+-- !query schema
+struct<timestampadd(DAY, 367, DATE '2022-02-25'):timestamp>
+-- !query output
+2023-02-27 00:00:00
+
+
+-- !query
+select dateadd(WEEK, -4, timestamp'2022-02-25 01:02:03')
+-- !query schema
+struct<timestampadd(WEEK, -4, TIMESTAMP '2022-02-25 01:02:03'):timestamp>
+-- !query output
+2022-01-28 01:02:03
+
+
+-- !query
+select date_add(MONTH, -1, timestamp'2022-02-25 01:02:03')
+-- !query schema
+struct<timestampadd(MONTH, -1, TIMESTAMP '2022-02-25 01:02:03'):timestamp>
+-- !query output
+2022-01-25 01:02:03
+
+
+-- !query
+select dateadd(QUARTER, 5, date'2022-02-25')
+-- !query schema
+struct<timestampadd(QUARTER, 5, DATE '2022-02-25'):timestamp>
+-- !query output
+2023-05-25 00:00:00
+
+
+-- !query
+select date_add(YEAR, 1, date'2022-02-25')
+-- !query schema
+struct<timestampadd(YEAR, 1, DATE '2022-02-25'):timestamp>
+-- !query output
+2023-02-25 00:00:00
+
+
+-- !query
+select dateadd('MICROSECOND', 1001, timestamp'2022-02-25 01:02:03.123')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_PARAMETER_VALUE.DATETIME_UNIT",
+ "sqlState" : "22023",
+ "messageParameters" : {
+ "functionName" : "`dateadd`",
+ "invalidValue" : "'MICROSECOND'",
+ "parameter" : "`unit`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 71,
+ "fragment" : "dateadd('MICROSECOND', 1001, timestamp'2022-02-25 01:02:03.123')"
+ } ]
+}
+
+
+-- !query
+select date_add('QUARTER', 5, date'2022-02-25')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_PARAMETER_VALUE.DATETIME_UNIT",
+ "sqlState" : "22023",
+ "messageParameters" : {
+ "functionName" : "`date_add`",
+ "invalidValue" : "'QUARTER'",
+ "parameter" : "`unit`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 47,
+ "fragment" : "date_add('QUARTER', 5, date'2022-02-25')"
+ } ]
+}
+
+
+-- !query
+select datediff(MICROSECOND, timestamp'2022-02-25 01:02:03.123', timestamp'2022-02-25 01:02:03.124001')
+-- !query schema
+struct<timestampdiff(MICROSECOND, TIMESTAMP '2022-02-25 01:02:03.123', TIMESTAMP '2022-02-25 01:02:03.124001'):bigint>
+-- !query output
+1001
+
+
+-- !query
+select date_diff(MILLISECOND, timestamp'2022-02-25 01:02:03.456', timestamp'2022-02-25 01:02:03.455')
+-- !query schema
+struct<timestampdiff(MILLISECOND, TIMESTAMP '2022-02-25 01:02:03.456', TIMESTAMP '2022-02-25 01:02:03.455'):bigint>
+-- !query output
+-1
+
+
+-- !query
+select datediff(SECOND, timestamp'2022-02-25 01:02:03', timestamp'2022-02-25 01:03:01')
+-- !query schema
+struct<timestampdiff(SECOND, TIMESTAMP '2022-02-25 01:02:03', TIMESTAMP '2022-02-25 01:03:01'):bigint>
+-- !query output
+58
+
+
+-- !query
+select date_diff(MINUTE, date'2022-02-25', timestamp'2022-02-24 22:20:00')
+-- !query schema
+struct<timestampdiff(MINUTE, DATE '2022-02-25', TIMESTAMP '2022-02-24 22:20:00'):bigint>
+-- !query output
+-100
+
+
+-- !query
+select datediff(HOUR, timestamp'2022-02-25 01:02:03', timestamp'2022-02-25 00:02:03')
+-- !query schema
+struct<timestampdiff(HOUR, TIMESTAMP '2022-02-25 01:02:03', TIMESTAMP '2022-02-25 00:02:03'):bigint>
+-- !query output
+-1
+
+
+-- !query
+select date_diff(DAY, date'2022-02-25', timestamp'2023-02-27 00:00:00')
+-- !query schema
+struct<timestampdiff(DAY, DATE '2022-02-25', TIMESTAMP '2023-02-27 00:00:00'):bigint>
+-- !query output
+367
+
+
+-- !query
+select datediff(WEEK, timestamp'2022-02-25 01:02:03', timestamp'2022-01-28 01:02:03')
+-- !query schema
+struct<timestampdiff(WEEK, TIMESTAMP '2022-02-25 01:02:03', TIMESTAMP '2022-01-28 01:02:03'):bigint>
+-- !query output
+-4
+
+
+-- !query
+select date_diff(MONTH, timestamp'2022-02-25 01:02:03', timestamp'2022-01-25 01:02:03')
+-- !query schema
+struct<timestampdiff(MONTH, TIMESTAMP '2022-02-25 01:02:03', TIMESTAMP '2022-01-25 01:02:03'):bigint>
+-- !query output
+-1
+
+
+-- !query
+select datediff(QUARTER, date'2022-02-25', date'2023-05-25')
+-- !query schema
+struct<timestampdiff(QUARTER, DATE '2022-02-25', DATE '2023-05-25'):bigint>
+-- !query output
+5
+
+
+-- !query
+select date_diff(YEAR, date'2022-02-25', date'2023-02-25')
+-- !query schema
+struct<timestampdiff(YEAR, DATE '2022-02-25', DATE '2023-02-25'):bigint>
+-- !query output
+1
+
+
+-- !query
+select date_diff('MILLISECOND', timestamp'2022-02-25 01:02:03.456', timestamp'2022-02-25 01:02:03.455')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_PARAMETER_VALUE.DATETIME_UNIT",
+ "sqlState" : "22023",
+ "messageParameters" : {
+ "functionName" : "`date_diff`",
+ "invalidValue" : "'MILLISECOND'",
+ "parameter" : "`unit`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 103,
+ "fragment" : "date_diff('MILLISECOND', timestamp'2022-02-25 01:02:03.456', timestamp'2022-02-25 01:02:03.455')"
+ } ]
+}
+
+
+-- !query
+select datediff('YEAR', date'2022-02-25', date'2023-02-25')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_PARAMETER_VALUE.DATETIME_UNIT",
+ "sqlState" : "22023",
+ "messageParameters" : {
+ "functionName" : "`datediff`",
+ "invalidValue" : "'YEAR'",
+ "parameter" : "`unit`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 59,
+ "fragment" : "datediff('YEAR', date'2022-02-25', date'2023-02-25')"
+ } ]
+}
+
+
+-- !query
+select timestamp '2019-01-01\t'
+-- !query schema
+struct<TIMESTAMP '2019-01-01 00:00:00':timestamp>
+-- !query output
+2019-01-01 00:00:00
+
+
+-- !query
+select timestamp '2019-01-01中文'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_TYPED_LITERAL",
+ "sqlState" : "42604",
+ "messageParameters" : {
+ "value" : "'2019-01-01中文'",
+ "valueType" : "\"TIMESTAMP\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 31,
+ "fragment" : "timestamp '2019-01-01中文'"
+ } ]
+}
+
+
+-- !query
+select timestamp'4294967297'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_TYPED_LITERAL",
+ "sqlState" : "42604",
+ "messageParameters" : {
+ "value" : "'4294967297'",
+ "valueType" : "\"TIMESTAMP\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 28,
+ "fragment" : "timestamp'4294967297'"
+ } ]
+}
+
+
+-- !query
+select timestamp'2021-01-01T12:30:4294967297.123456'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_TYPED_LITERAL",
+ "sqlState" : "42604",
+ "messageParameters" : {
+ "value" : "'2021-01-01T12:30:4294967297.123456'",
+ "valueType" : "\"TIMESTAMP\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 52,
+ "fragment" : "timestamp'2021-01-01T12:30:4294967297.123456'"
+ } ]
+}
+
+
+-- !query
+select current_timestamp = current_timestamp
+-- !query schema
+struct<(current_timestamp() = current_timestamp()):boolean>
+-- !query output
+true
+
+
+-- !query
+select current_timestamp() = current_timestamp()
+-- !query schema
+struct<(current_timestamp() = current_timestamp()):boolean>
+-- !query output
+true
+
+
+-- !query
+select localtimestamp() = localtimestamp()
+-- !query schema
+struct<(localtimestamp() = localtimestamp()):boolean>
+-- !query output
+true
+
+
+-- !query
+SELECT make_timestamp(2021, 07, 11, 6, 30, 45.678)
+-- !query schema
+struct<make_timestamp(2021, 7, 11, 6, 30, 45.678):timestamp>
+-- !query output
+2021-07-11 06:30:45.678
+
+
+-- !query
+SELECT make_timestamp(2021, 07, 11, 6, 30, 45.678, 'CET')
+-- !query schema
+struct<make_timestamp(2021, 7, 11, 6, 30, 45.678, CET):timestamp>
+-- !query output
+2021-07-10 21:30:45.678
+
+
+-- !query
+SELECT make_timestamp(2021, 07, 11, 6, 30, 60.007)
+-- !query schema
+struct<make_timestamp(2021, 7, 11, 6, 30, 60.007):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+SELECT make_timestamp(1, 1, 1, 1, 1, 1)
+-- !query schema
+struct<make_timestamp(1, 1, 1, 1, 1, 1):timestamp>
+-- !query output
+0001-01-01 01:01:01
+
+
+-- !query
+SELECT make_timestamp(1, 1, 1, 1, 1, 60)
+-- !query schema
+struct<make_timestamp(1, 1, 1, 1, 1, 60):timestamp>
+-- !query output
+0001-01-01 01:02:00
+
+
+-- !query
+SELECT make_timestamp(1, 1, 1, 1, 1, 61)
+-- !query schema
+struct<make_timestamp(1, 1, 1, 1, 1, 61):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+SELECT make_timestamp(1, 1, 1, 1, 1, null)
+-- !query schema
+struct<make_timestamp(1, 1, 1, 1, 1, NULL):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+SELECT make_timestamp(1, 1, 1, 1, 1, 59.999999)
+-- !query schema
+struct<make_timestamp(1, 1, 1, 1, 1, 59.999999):timestamp>
+-- !query output
+0001-01-01 01:01:59.999999
+
+
+-- !query
+SELECT make_timestamp(1, 1, 1, 1, 1, 99.999999)
+-- !query schema
+struct<make_timestamp(1, 1, 1, 1, 1, 99.999999):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+SELECT make_timestamp(1, 1, 1, 1, 1, 999.999999)
+-- !query schema
+struct<make_timestamp(1, 1, 1, 1, 1, 999.999999):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select TIMESTAMP_SECONDS(1230219000),TIMESTAMP_SECONDS(-1230219000),TIMESTAMP_SECONDS(null)
+-- !query schema
+struct<timestamp_seconds(1230219000):timestamp,timestamp_seconds(-1230219000):timestamp,timestamp_seconds(NULL):timestamp>
+-- !query output
+2008-12-25 07:30:00 1931-01-07 00:30:00 NULL
+
+
+-- !query
+select TIMESTAMP_SECONDS(1.23), TIMESTAMP_SECONDS(1.23d), TIMESTAMP_SECONDS(FLOAT(1.23))
+-- !query schema
+struct<timestamp_seconds(1.23):timestamp,timestamp_seconds(1.23):timestamp,timestamp_seconds(1.23):timestamp>
+-- !query output
+1969-12-31 16:00:01.23 1969-12-31 16:00:01.23 1969-12-31 16:00:01.23
+
+
+-- !query
+select TIMESTAMP_MILLIS(1230219000123),TIMESTAMP_MILLIS(-1230219000123),TIMESTAMP_MILLIS(null)
+-- !query schema
+struct<timestamp_millis(1230219000123):timestamp,timestamp_millis(-1230219000123):timestamp,timestamp_millis(NULL):timestamp>
+-- !query output
+2008-12-25 07:30:00.123 1931-01-07 00:29:59.877 NULL
+
+
+-- !query
+select TIMESTAMP_MICROS(1230219000123123),TIMESTAMP_MICROS(-1230219000123123),TIMESTAMP_MICROS(null)
+-- !query schema
+struct<timestamp_micros(1230219000123123):timestamp,timestamp_micros(-1230219000123123):timestamp,timestamp_micros(NULL):timestamp>
+-- !query output
+2008-12-25 07:30:00.123123 1931-01-07 00:29:59.876877 NULL
+
+
+-- !query
+select TIMESTAMP_SECONDS(1230219000123123)
+-- !query schema
+struct<>
+-- !query output
+java.lang.ArithmeticException
+long overflow
+
+
+-- !query
+select TIMESTAMP_SECONDS(-1230219000123123)
+-- !query schema
+struct<>
+-- !query output
+java.lang.ArithmeticException
+long overflow
+
+
+-- !query
+select TIMESTAMP_MILLIS(92233720368547758)
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+Could not convert Timestamp(92233720368547, 758000000) to microseconds
+
+
+-- !query
+select TIMESTAMP_MILLIS(-92233720368547758)
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+Could not convert Timestamp(-92233720368548, 242000000) to microseconds
+
+
+-- !query
+select TIMESTAMP_SECONDS(0.1234567)
+-- !query schema
+struct<>
+-- !query output
+java.lang.ArithmeticException
+Rounding necessary
+
+
+-- !query
+select TIMESTAMP_SECONDS(0.1234567d), TIMESTAMP_SECONDS(FLOAT(0.1234567))
+-- !query schema
+struct<timestamp_seconds(0.1234567):timestamp,timestamp_seconds(0.1234567):timestamp>
+-- !query output
+1969-12-31 16:00:00.123456 1969-12-31 16:00:00.123456
+
+
+-- !query
+create temporary view ttf2 as select * from values
+ (1, 2),
+ (2, 3)
+ as ttf2(a, b)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+select current_date = current_date(), current_timestamp = current_timestamp(), a, b from ttf2
+-- !query schema
+struct<(current_date() = current_date()):boolean,(current_timestamp() = current_timestamp()):boolean,a:int,b:int>
+-- !query output
+true true 1 2
+true true 2 3
+
+
+-- !query
+select a, b from ttf2 order by a, current_date
+-- !query schema
+struct<a:int,b:int>
+-- !query output
+1 2
+2 3
+
+
+-- !query
+select UNIX_SECONDS(timestamp'2020-12-01 14:30:08Z'), UNIX_SECONDS(timestamp'2020-12-01 14:30:08.999999Z'), UNIX_SECONDS(null)
+-- !query schema
+struct<unix_seconds(TIMESTAMP '2020-12-01 06:30:08'):bigint,unix_seconds(TIMESTAMP '2020-12-01 06:30:08.999999'):bigint,unix_seconds(NULL):bigint>
+-- !query output
+1606833008 1606833008 NULL
+
+
+-- !query
+select UNIX_MILLIS(timestamp'2020-12-01 14:30:08Z'), UNIX_MILLIS(timestamp'2020-12-01 14:30:08.999999Z'), UNIX_MILLIS(null)
+-- !query schema
+struct<unix_millis(TIMESTAMP '2020-12-01 06:30:08'):bigint,unix_millis(TIMESTAMP '2020-12-01 06:30:08.999999'):bigint,unix_millis(NULL):bigint>
+-- !query output
+1606833008000 1606833008999 NULL
+
+
+-- !query
+select UNIX_MICROS(timestamp'2020-12-01 14:30:08Z'), UNIX_MICROS(timestamp'2020-12-01 14:30:08.999999Z'), UNIX_MICROS(null)
+-- !query schema
+struct<unix_micros(TIMESTAMP '2020-12-01 06:30:08'):bigint,unix_micros(TIMESTAMP '2020-12-01 06:30:08.999999'):bigint,unix_micros(NULL):bigint>
+-- !query output
+1606833008000000 1606833008999999 NULL
+
+
+-- !query
+select to_timestamp(null), to_timestamp('2016-12-31 00:12:00'), to_timestamp('2016-12-31', 'yyyy-MM-dd')
+-- !query schema
+struct<to_timestamp(NULL):timestamp,to_timestamp(2016-12-31 00:12:00):timestamp,to_timestamp(2016-12-31, yyyy-MM-dd):timestamp>
+-- !query output
+NULL 2016-12-31 00:12:00 2016-12-31 00:00:00
+
+
+-- !query
+select to_timestamp(1)
+-- !query schema
+struct<to_timestamp(1):timestamp>
+-- !query output
+1969-12-31 16:00:01
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12., yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.0', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.0, yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.1', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.1, yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.12', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.12, yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.123UTC', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.123UTC, yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.1234', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.1234, yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.12345CST', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.12345CST, yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.123456PST', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.123456PST, yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.1234567PST', 'yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.1234567PST, yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('123456 2019-10-06 10:11:12.123456PST', 'SSSSSS yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(123456 2019-10-06 10:11:12.123456PST, SSSSSS yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('223456 2019-10-06 10:11:12.123456PST', 'SSSSSS yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]')
+-- !query schema
+struct<to_timestamp(223456 2019-10-06 10:11:12.123456PST, SSSSSS yyyy-MM-dd HH:mm:ss.SSSSSS[zzz]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.1234', 'yyyy-MM-dd HH:mm:ss.[SSSSSS]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.1234, yyyy-MM-dd HH:mm:ss.[SSSSSS]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.123', 'yyyy-MM-dd HH:mm:ss[.SSSSSS]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.123, yyyy-MM-dd HH:mm:ss[.SSSSSS]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12', 'yyyy-MM-dd HH:mm:ss[.SSSSSS]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12, yyyy-MM-dd HH:mm:ss[.SSSSSS]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11:12.12', 'yyyy-MM-dd HH:mm[:ss.SSSSSS]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11:12.12, yyyy-MM-dd HH:mm[:ss.SSSSSS]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp('2019-10-06 10:11', 'yyyy-MM-dd HH:mm[:ss.SSSSSS]')
+-- !query schema
+struct<to_timestamp(2019-10-06 10:11, yyyy-MM-dd HH:mm[:ss.SSSSSS]):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select to_timestamp("2019-10-06S", "yyyy-MM-dd'S'")
+-- !query schema
+struct<to_timestamp(2019-10-06S, yyyy-MM-dd'S'):timestamp>
+-- !query output
+2019-10-06 00:00:00
+
+
+-- !query
+select to_timestamp("S2019-10-06", "'S'yyyy-MM-dd")
+-- !query schema
+struct<to_timestamp(S2019-10-06, 'S'yyyy-MM-dd):timestamp>
+-- !query output
+2019-10-06 00:00:00
+
+
+-- !query
+select to_timestamp("2019-10-06T10:11:12'", "yyyy-MM-dd'T'HH:mm:ss''")
+-- !query schema
+struct<to_timestamp(2019-10-06T10:11:12', yyyy-MM-dd'T'HH:mm:ss''):timestamp>
+-- !query output
+2019-10-06 10:11:12
+
+
+-- !query
+select to_timestamp("'2019-10-06T10:11:12", "''yyyy-MM-dd'T'HH:mm:ss")
+-- !query schema
+struct<to_timestamp('2019-10-06T10:11:12, ''yyyy-MM-dd'T'HH:mm:ss):timestamp>
+-- !query output
+2019-10-06 10:11:12
+
+
+-- !query
+select to_timestamp("P2019-10-06T10:11:12", "'P'yyyy-MM-dd'T'HH:mm:ss")
+-- !query schema
+struct<to_timestamp(P2019-10-06T10:11:12, 'P'yyyy-MM-dd'T'HH:mm:ss):timestamp>
+-- !query output
+2019-10-06 10:11:12
+
+
+-- !query
+select to_timestamp("2019 40", "yyyy mm")
+-- !query schema
+struct<to_timestamp(2019 40, yyyy mm):timestamp>
+-- !query output
+2019-01-01 00:40:00
+
+
+-- !query
+select to_timestamp("2019 10:10:10", "yyyy hh:mm:ss")
+-- !query schema
+struct<to_timestamp(2019 10:10:10, yyyy hh:mm:ss):timestamp>
+-- !query output
+2019-01-01 10:10:10
+
+
+-- !query
+select timestamp'2011-11-11 11:11:11' - timestamp'2011-11-11 11:11:10'
+-- !query schema
+struct<(TIMESTAMP '2011-11-11 11:11:11' - TIMESTAMP '2011-11-11 11:11:10'):interval day to second>
+-- !query output
+0 00:00:01.000000000
+
+
+-- !query
+select date'2020-01-01' - timestamp'2019-10-06 10:11:12.345678'
+-- !query schema
+struct<(DATE '2020-01-01' - TIMESTAMP '2019-10-06 10:11:12.345678'):interval day to second>
+-- !query output
+86 13:48:47.654322000
+
+
+-- !query
+select timestamp'2019-10-06 10:11:12.345678' - date'2020-01-01'
+-- !query schema
+struct<(TIMESTAMP '2019-10-06 10:11:12.345678' - DATE '2020-01-01'):interval day to second>
+-- !query output
+-86 13:48:47.654322000
+
+
+-- !query
+select timestamp'2011-11-11 11:11:11' - '2011-11-11 11:11:10'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"2011-11-11 11:11:10\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "2",
+ "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "sqlExpr" : "\"(TIMESTAMP '2011-11-11 11:11:11' - 2011-11-11 11:11:10)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 61,
+ "fragment" : "timestamp'2011-11-11 11:11:11' - '2011-11-11 11:11:10'"
+ } ]
+}
+
+
+-- !query
+select '2011-11-11 11:11:11' - timestamp'2011-11-11 11:11:10'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"2011-11-11 11:11:11\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "sqlExpr" : "\"(2011-11-11 11:11:11 - TIMESTAMP '2011-11-11 11:11:10')\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 61,
+ "fragment" : "'2011-11-11 11:11:11' - timestamp'2011-11-11 11:11:10'"
+ } ]
+}
+
+
+-- !query
+select timestamp'2011-11-11 11:11:11' - null
+-- !query schema
+struct<(TIMESTAMP '2011-11-11 11:11:11' - NULL):interval day to second>
+-- !query output
+NULL
+
+
+-- !query
+select null - timestamp'2011-11-11 11:11:11'
+-- !query schema
+struct<(NULL - TIMESTAMP '2011-11-11 11:11:11'):interval day to second>
+-- !query output
+NULL
+
+
+-- !query
+create temporary view ts_view as select '2011-11-11 11:11:11' str
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+select str - timestamp'2011-11-11 11:11:11' from ts_view
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"str\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "sqlExpr" : "\"(str - TIMESTAMP '2011-11-11 11:11:11')\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 43,
+ "fragment" : "str - timestamp'2011-11-11 11:11:11'"
+ } ]
+}
+
+
+-- !query
+select timestamp'2011-11-11 11:11:11' - str from ts_view
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"str\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "2",
+ "requiredType" : "\"(TIMESTAMP OR TIMESTAMP WITHOUT TIME ZONE)\"",
+ "sqlExpr" : "\"(TIMESTAMP '2011-11-11 11:11:11' - str)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 43,
+ "fragment" : "timestamp'2011-11-11 11:11:11' - str"
+ } ]
+}
+
+
+-- !query
+select timestamp'2011-11-11 11:11:11' + '1'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "left" : "\"TIMESTAMP\"",
+ "right" : "\"DOUBLE\"",
+ "sqlExpr" : "\"(TIMESTAMP '2011-11-11 11:11:11' + 1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 43,
+ "fragment" : "timestamp'2011-11-11 11:11:11' + '1'"
+ } ]
+}
+
+
+-- !query
+select '1' + timestamp'2011-11-11 11:11:11'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "left" : "\"DOUBLE\"",
+ "right" : "\"TIMESTAMP\"",
+ "sqlExpr" : "\"(1 + TIMESTAMP '2011-11-11 11:11:11')\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 43,
+ "fragment" : "'1' + timestamp'2011-11-11 11:11:11'"
+ } ]
+}
+
+
+-- !query
+select timestamp'2011-11-11 11:11:11' + null
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "left" : "\"TIMESTAMP\"",
+ "right" : "\"VOID\"",
+ "sqlExpr" : "\"(TIMESTAMP '2011-11-11 11:11:11' + NULL)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 44,
+ "fragment" : "timestamp'2011-11-11 11:11:11' + null"
+ } ]
+}
+
+
+-- !query
+select null + timestamp'2011-11-11 11:11:11'
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.BINARY_OP_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "left" : "\"VOID\"",
+ "right" : "\"TIMESTAMP\"",
+ "sqlExpr" : "\"(NULL + TIMESTAMP '2011-11-11 11:11:11')\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 44,
+ "fragment" : "null + timestamp'2011-11-11 11:11:11'"
+ } ]
+}
+
+
+-- !query
+select timestamp'2011-11-11 11:11:11' + interval '2' day,
+ timestamp'2011-11-11 11:11:11' - interval '2-2' year to month,
+ timestamp'2011-11-11 11:11:11' + interval '-2' second,
+ timestamp'2011-11-11 11:11:11' - interval '12:12:12.123456789' hour to second,
+ - interval 2 years + timestamp'2011-11-11 11:11:11',
+ interval '1 12' day to hour + timestamp'2011-11-11 11:11:11'
+-- !query schema
+struct<TIMESTAMP '2011-11-11 11:11:11' + INTERVAL '2' DAY:timestamp,TIMESTAMP '2011-11-11 11:11:11' - INTERVAL '2-2' YEAR TO MONTH:timestamp,TIMESTAMP '2011-11-11 11:11:11' + INTERVAL '-02' SECOND:timestamp,TIMESTAMP '2011-11-11 11:11:11' - INTERVAL '12:12:12.123456' HOUR TO SECOND:timestamp,TIMESTAMP '2011-11-11 11:11:11' + (- INTERVAL '2' YEAR):timestamp,TIMESTAMP '2011-11-11 11:11:11' + INTERVAL '1 12' DAY TO HOUR:timestamp>
+-- !query output
+2011-11-13 11:11:11 2009-09-11 11:11:11 2011-11-11 11:11:09 2011-11-10 22:58:58.876544 2009-11-11 11:11:11 2011-11-12 23:11:11
+
+
+-- !query
+select date '2012-01-01' - interval 3 hours,
+ date '2012-01-01' + interval '12:12:12' hour to second,
+ interval '2' minute + date '2012-01-01'
+-- !query schema
+struct<DATE '2012-01-01' - INTERVAL '03' HOUR:timestamp,DATE '2012-01-01' + INTERVAL '12:12:12' HOUR TO SECOND:timestamp,DATE '2012-01-01' + INTERVAL '02' MINUTE:timestamp>
+-- !query output
+2011-12-31 21:00:00 2012-01-01 12:12:12 2012-01-01 00:02:00
+
+
+-- !query
+select to_timestamp('2019-10-06 A', 'yyyy-MM-dd GGGGG')
+-- !query schema
+struct<to_timestamp(2019-10-06 A, yyyy-MM-dd GGGGG):timestamp>
+-- !query output
+NULL
+
+
+-- !query
+select from_json('{"t":"26/October/2015"}', 't Timestamp', map('timestampFormat', 'dd/MMMMM/yyyy'))
+-- !query schema
+struct<from_json({"t":"26/October/2015"}):struct<t:timestamp>>
+-- !query output
+{"t":2015-10-26 00:00:00}
+
+
+-- !query
+select from_csv('26/October/2015', 't Timestamp', map('timestampFormat', 'dd/MMMMM/yyyy'))
+-- !query schema
+struct<from_csv(26/October/2015):struct<t:timestamp>>
+-- !query output
+{"t":2015-10-26 00:00:00}
+
+
+-- !query
+select timestampadd(MONTH, -1, timestamp'2022-02-14 01:02:03')
+-- !query schema
+struct<timestampadd(MONTH, -1, TIMESTAMP '2022-02-14 01:02:03'):timestamp>
+-- !query output
+2022-01-14 01:02:03
+
+
+-- !query
+select timestampadd(MINUTE, 58, timestamp'2022-02-14 01:02:03')
+-- !query schema
+struct<timestampadd(MINUTE, 58, TIMESTAMP '2022-02-14 01:02:03'):timestamp>
+-- !query output
+2022-02-14 02:00:03
+
+
+-- !query
+select timestampadd(YEAR, 1, date'2022-02-15')
+-- !query schema
+struct<timestampadd(YEAR, 1, DATE '2022-02-15'):timestamp>
+-- !query output
+2023-02-15 00:00:00
+
+
+-- !query
+select timestampadd(SECOND, -1, date'2022-02-15')
+-- !query schema
+struct<timestampadd(SECOND, -1, DATE '2022-02-15'):timestamp>
+-- !query output
+2022-02-14 23:59:59
+
+
+-- !query
+select timestampadd('MONTH', -1, timestamp'2022-02-14 01:02:03')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_PARAMETER_VALUE.DATETIME_UNIT",
+ "sqlState" : "22023",
+ "messageParameters" : {
+ "functionName" : "`timestampadd`",
+ "invalidValue" : "'MONTH'",
+ "parameter" : "`unit`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 64,
+ "fragment" : "timestampadd('MONTH', -1, timestamp'2022-02-14 01:02:03')"
+ } ]
+}
+
+
+-- !query
+select timestampadd('SECOND', -1, date'2022-02-15')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.parser.ParseException
+{
+ "errorClass" : "INVALID_PARAMETER_VALUE.DATETIME_UNIT",
+ "sqlState" : "22023",
+ "messageParameters" : {
+ "functionName" : "`timestampadd`",
+ "invalidValue" : "'SECOND'",
+ "parameter" : "`unit`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 51,
+ "fragment" : "timestampadd('SECOND', -1, date'2022-02-15')"
+ } ]
+}
+
+
+-- !query
+select timestampdiff(MONTH, timestamp'2022-02-14 01:02:03', timestamp'2022-01-14 01:02:03')
+-- !query schema
+struct<timestampdiff(MONTH, TIMESTAMP '2022-02-14 01:02:03', TIMESTAMP '2022-01-14 01:02:03'):bigint>
+-- !query output
+-1
+
+
+-- !query
+select timestampdiff(MINUTE, timestamp'2022-02-14 01:02:03', timestamp'2022-02-14 02:00:03')
+-- !query schema
+struct<timestampdiff(MINUTE, TIMESTAMP '2022-02-14 01:02:03', TIMESTAMP '2022-02-14 02:00:03'):bigint>
+-- !query output
+58
+
+
+-- !query
+select timestampdiff(YEAR, date'2022-02-15', date'2023-02-15')
+-- !query schema
... 13071 lines suppressed ...
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@gluten.apache.org
For additional commands, e-mail: commits-help@gluten.apache.org