diff --git a/.github/workflows/velox_backend_x86.yml b/.github/workflows/velox_backend_x86.yml
index 5ef70a79bc0f..51f71e829c5e 100644
--- a/.github/workflows/velox_backend_x86.yml
+++ b/.github/workflows/velox_backend_x86.yml
@@ -107,7 +107,7 @@ jobs:
fail-fast: false
matrix:
os: [ "ubuntu:20.04", "ubuntu:22.04" ]
- spark: [ "spark-3.2", "spark-3.3", "spark-3.4", "spark-3.5", "spark-4.0" ]
+ spark: [ "spark-3.2", "spark-3.3", "spark-3.4", "spark-3.5", "spark-4.0", "spark-4.1" ]
java: [ "java-8", "java-11", "java-17", "java-21" ]
# Spark supports JDK17 since 3.3.
exclude:
@@ -141,6 +141,10 @@ jobs:
java: java-8
- spark: spark-4.0
java: java-11
+ - spark: spark-4.1
+ java: java-8
+ - spark: spark-4.1
+ java: java-11
runs-on: ubuntu-22.04
container: ${{ matrix.os }}
@@ -182,11 +186,14 @@ jobs:
cd $GITHUB_WORKSPACE/
export JAVA_HOME=/usr/lib/jvm/${{ matrix.java }}-openjdk-amd64
echo "JAVA_HOME: $JAVA_HOME"
- if [ "${{ matrix.spark }}" = "spark-4.0" ]; then
- $MVN_CMD clean install -P${{ matrix.spark }} -P${{ matrix.java }} -Pscala-2.13 -Pbackends-velox -DskipTests
- else
- $MVN_CMD clean install -P${{ matrix.spark }} -P${{ matrix.java }} -Pbackends-velox -DskipTests
- fi
+ case "${{ matrix.spark }}" in
+ spark-4.0|spark-4.1)
+ $MVN_CMD clean install -P${{ matrix.spark }} -P${{ matrix.java }} -Pscala-2.13 -Pbackends-velox -DskipTests
+ ;;
+ *)
+ $MVN_CMD clean install -P${{ matrix.spark }} -P${{ matrix.java }} -Pbackends-velox -DskipTests
+ ;;
+ esac
cd $GITHUB_WORKSPACE/tools/gluten-it
$GITHUB_WORKSPACE/$MVN_CMD clean install -P${{ matrix.spark }} -P${{ matrix.java }}
GLUTEN_IT_JVM_ARGS=-Xmx5G sbin/gluten-it.sh queries-compare \
@@ -200,7 +207,7 @@ jobs:
fail-fast: false
matrix:
os: [ "centos:8" ]
- spark: [ "spark-3.2", "spark-3.3", "spark-3.4", "spark-3.5", "spark-4.0" ]
+ spark: [ "spark-3.2", "spark-3.3", "spark-3.4", "spark-3.5", "spark-4.0", "spark-4.1" ]
java: [ "java-8", "java-11", "java-17" ]
# Spark supports JDK17 since 3.3.
exclude:
@@ -220,6 +227,10 @@ jobs:
java: java-8
- spark: spark-4.0
java: java-11
+ - spark: spark-4.1
+ java: java-8
+ - spark: spark-4.1
+ java: java-11
runs-on: ubuntu-22.04
container: ${{ matrix.os }}
@@ -263,11 +274,14 @@ jobs:
run: |
echo "JAVA_HOME: $JAVA_HOME"
cd $GITHUB_WORKSPACE/
- if [ "${{ matrix.spark }}" = "spark-4.0" ]; then
- $MVN_CMD clean install -P${{ matrix.spark }} -P${{ matrix.java }} -Pscala-2.13 -Pbackends-velox -DskipTests
- else
- $MVN_CMD clean install -P${{ matrix.spark }} -P${{ matrix.java }} -Pbackends-velox -DskipTests
- fi
+ case "${{ matrix.spark }}" in
+ spark-4.0|spark-4.1)
+ $MVN_CMD clean install -P${{ matrix.spark }} -P${{ matrix.java }} -Pscala-2.13 -Pbackends-velox -DskipTests
+ ;;
+ *)
+ $MVN_CMD clean install -P${{ matrix.spark }} -P${{ matrix.java }} -Pbackends-velox -DskipTests
+ ;;
+ esac
cd $GITHUB_WORKSPACE/tools/gluten-it
$GITHUB_WORKSPACE/build/mvn clean install -P${{ matrix.spark }} -P${{ matrix.java }}
- name: Run TPC-H / TPC-DS
@@ -1521,7 +1535,7 @@ jobs:
export PATH=$JAVA_HOME/bin:$PATH
java -version
$MVN_CMD clean test -Pspark-4.1 -Pscala-2.13 -Pjava-17 -Pbackends-velox \
- -Pspark-ut -DargLine="-Dspark.test.home=/opt/shims/spark41/spark_home/" \
+ -Pspark-ut -DargLine="-Dspark.test.home=/opt/shims/spark41/spark_home/ -Dspark.sql.unionOutputPartitioning=false" \
-DtagsToExclude=org.apache.spark.tags.ExtendedSQLTest,org.apache.gluten.tags.UDFTest,org.apache.gluten.tags.EnhancedFeaturesTest,org.apache.gluten.tags.SkipTest
- name: Upload test report
if: always()
@@ -1570,7 +1584,7 @@ jobs:
export PATH=$JAVA_HOME/bin:$PATH
java -version
$MVN_CMD clean test -Pspark-4.1 -Pscala-2.13 -Pjava-17 -Pbackends-velox -Pspark-ut \
- -DargLine="-Dspark.test.home=/opt/shims/spark41/spark_home/" \
+ -DargLine="-Dspark.test.home=/opt/shims/spark41/spark_home/ -Dspark.sql.unionOutputPartitioning=false" \
-DtagsToInclude=org.apache.spark.tags.ExtendedSQLTest
- name: Upload test report
if: always()
diff --git a/backends-velox/src/main/scala/org/apache/gluten/expression/aggregate/VeloxBloomFilterAggregate.scala b/backends-velox/src/main/scala/org/apache/gluten/expression/aggregate/VeloxBloomFilterAggregate.scala
index 976abb9e21fb..a3d6f738a2b5 100644
--- a/backends-velox/src/main/scala/org/apache/gluten/expression/aggregate/VeloxBloomFilterAggregate.scala
+++ b/backends-velox/src/main/scala/org/apache/gluten/expression/aggregate/VeloxBloomFilterAggregate.scala
@@ -25,10 +25,14 @@ import org.apache.spark.sql.catalyst.expressions.Expression
import org.apache.spark.sql.catalyst.expressions.aggregate.TypedImperativeAggregate
import org.apache.spark.sql.catalyst.trees.TernaryLike
import org.apache.spark.sql.internal.SQLConf
+import org.apache.spark.sql.types._
import org.apache.spark.sql.types.DataType
import org.apache.spark.task.TaskResources
+import org.apache.spark.unsafe.types.UTF8String
import org.apache.spark.util.sketch.BloomFilter
+import java.io.Serializable
+
/**
* Velox's bloom-filter implementation uses different algorithms internally comparing to vanilla
* Spark so produces different intermediate aggregate data. Thus we use different filter function /
@@ -61,6 +65,15 @@ case class VeloxBloomFilterAggregate(
.toLong
)
+ // Mark as lazy so that `updater` is not evaluated during tree transformation.
+ private lazy val updater: BloomFilterUpdater = child.dataType match {
+ case LongType => LongUpdater
+ case IntegerType => IntUpdater
+ case ShortType => ShortUpdater
+ case ByteType => ByteUpdater
+ case _: StringType => BinaryUpdater
+ }
+
override def first: Expression = child
override def second: Expression = estimatedNumItemsExpression
@@ -97,7 +110,7 @@ case class VeloxBloomFilterAggregate(
if (value == null) {
return buffer
}
- buffer.putLong(value.asInstanceOf[Long])
+ updater.update(buffer, value)
buffer
}
@@ -128,3 +141,33 @@ case class VeloxBloomFilterAggregate(
copy(inputAggBufferOffset = newOffset)
}
+
+// see https://github.com/apache/spark/pull/42414
+private trait BloomFilterUpdater {
+ def update(bf: BloomFilter, v: Any): Boolean
+}
+
+private object LongUpdater extends BloomFilterUpdater with Serializable {
+ override def update(bf: BloomFilter, v: Any): Boolean =
+ bf.putLong(v.asInstanceOf[Long])
+}
+
+private object IntUpdater extends BloomFilterUpdater with Serializable {
+ override def update(bf: BloomFilter, v: Any): Boolean =
+ bf.putLong(v.asInstanceOf[Int])
+}
+
+private object ShortUpdater extends BloomFilterUpdater with Serializable {
+ override def update(bf: BloomFilter, v: Any): Boolean =
+ bf.putLong(v.asInstanceOf[Short])
+}
+
+private object ByteUpdater extends BloomFilterUpdater with Serializable {
+ override def update(bf: BloomFilter, v: Any): Boolean =
+ bf.putLong(v.asInstanceOf[Byte])
+}
+
+private object BinaryUpdater extends BloomFilterUpdater with Serializable {
+ override def update(bf: BloomFilter, v: Any): Boolean =
+ bf.putBinary(v.asInstanceOf[UTF8String].getBytes)
+}
diff --git a/backends-velox/src/main/scala/org/apache/spark/sql/execution/ColumnarCachedBatchSerializer.scala b/backends-velox/src/main/scala/org/apache/spark/sql/execution/ColumnarCachedBatchSerializer.scala
index a04e7d68fba6..c05eb4a2fa68 100644
--- a/backends-velox/src/main/scala/org/apache/spark/sql/execution/ColumnarCachedBatchSerializer.scala
+++ b/backends-velox/src/main/scala/org/apache/spark/sql/execution/ColumnarCachedBatchSerializer.scala
@@ -115,24 +115,24 @@ class ColumnarCachedBatchSerializer extends CachedBatchSerializer with Logging {
conf: SQLConf): RDD[CachedBatch] = {
val localSchema = toStructType(schema)
if (!validateSchema(localSchema)) {
- // we can not use columnar cache here, as the `RowToColumnar` does not support this schema
- return rowBasedCachedBatchSerializer.convertInternalRowToCachedBatch(
+ // we cannot use columnar cache here, as the `RowToColumnar` does not support this schema
+ rowBasedCachedBatchSerializer.convertInternalRowToCachedBatch(
input,
schema,
storageLevel,
conf)
+ } else {
+ val numRows = conf.columnBatchSize
+ val rddColumnarBatch = input.mapPartitions {
+ it =>
+ RowToVeloxColumnarExec.toColumnarBatchIterator(
+ it,
+ localSchema,
+ numRows,
+ VeloxConfig.get.veloxPreferredBatchBytes)
+ }
+ convertColumnarBatchToCachedBatch(rddColumnarBatch, schema, storageLevel, conf)
}
-
- val numRows = conf.columnBatchSize
- val rddColumnarBatch = input.mapPartitions {
- it =>
- RowToVeloxColumnarExec.toColumnarBatchIterator(
- it,
- localSchema,
- numRows,
- VeloxConfig.get.veloxPreferredBatchBytes)
- }
- convertColumnarBatchToCachedBatch(rddColumnarBatch, schema, storageLevel, conf)
}
override def convertCachedBatchToInternalRow(
@@ -141,18 +141,18 @@ class ColumnarCachedBatchSerializer extends CachedBatchSerializer with Logging {
selectedAttributes: Seq[Attribute],
conf: SQLConf): RDD[InternalRow] = {
if (!validateSchema(cacheAttributes)) {
- // if we do not support this schema that means we are using row-based serializer,
+ // if we do not support this schema, that means we are using row-based serializer,
// see `convertInternalRowToCachedBatch`, so fallback to vanilla Spark serializer
- return rowBasedCachedBatchSerializer.convertCachedBatchToInternalRow(
+ rowBasedCachedBatchSerializer.convertCachedBatchToInternalRow(
input,
cacheAttributes,
selectedAttributes,
conf)
+ } else {
+ val rddColumnarBatch =
+ convertCachedBatchToColumnarBatch(input, cacheAttributes, selectedAttributes, conf)
+ rddColumnarBatch.mapPartitions(it => VeloxColumnarToRowExec.toRowIterator(it))
}
-
- val rddColumnarBatch =
- convertCachedBatchToColumnarBatch(input, cacheAttributes, selectedAttributes, conf)
- rddColumnarBatch.mapPartitions(it => VeloxColumnarToRowExec.toRowIterator(it))
}
override def convertColumnarBatchToCachedBatch(
@@ -190,58 +190,68 @@ class ColumnarCachedBatchSerializer extends CachedBatchSerializer with Logging {
cacheAttributes: Seq[Attribute],
selectedAttributes: Seq[Attribute],
conf: SQLConf): RDD[ColumnarBatch] = {
- // Find the ordinals and data types of the requested columns.
- val requestedColumnIndices = selectedAttributes.map {
- a => cacheAttributes.map(_.exprId).indexOf(a.exprId)
- }
- val shouldSelectAttributes = cacheAttributes != selectedAttributes
- val localSchema = toStructType(cacheAttributes)
- val timezoneId = SQLConf.get.sessionLocalTimeZone
- input.mapPartitions {
- it =>
- val runtime = Runtimes.contextInstance(
- BackendsApiManager.getBackendName,
- "ColumnarCachedBatchSerializer#read")
- val jniWrapper = ColumnarBatchSerializerJniWrapper
- .create(runtime)
- val schema = SparkArrowUtil.toArrowSchema(localSchema, timezoneId)
- val arrowAlloc = ArrowBufferAllocators.contextInstance()
- val cSchema = ArrowSchema.allocateNew(arrowAlloc)
- ArrowAbiUtil.exportSchema(arrowAlloc, schema, cSchema)
- val deserializerHandle = jniWrapper
- .init(cSchema.memoryAddress())
- cSchema.close()
-
- Iterators
- .wrap(new Iterator[ColumnarBatch] {
- override def hasNext: Boolean = it.hasNext
-
- override def next(): ColumnarBatch = {
- val cachedBatch = it.next().asInstanceOf[CachedColumnarBatch]
- val batchHandle =
- jniWrapper
- .deserialize(deserializerHandle, cachedBatch.bytes)
- val batch = ColumnarBatches.create(batchHandle)
- if (shouldSelectAttributes) {
- try {
- ColumnarBatches.select(
- BackendsApiManager.getBackendName,
- batch,
- requestedColumnIndices.toArray)
- } finally {
- batch.close()
+ if (!validateSchema(cacheAttributes)) {
+ // if we do not support this schema, that means we are using row-based serializer,
+ // see `convertInternalRowToCachedBatch`, so fallback to vanilla Spark serializer
+ rowBasedCachedBatchSerializer.convertCachedBatchToColumnarBatch(
+ input,
+ cacheAttributes,
+ selectedAttributes,
+ conf)
+ } else {
+ // Find the ordinals and data types of the requested columns.
+ val requestedColumnIndices = selectedAttributes.map {
+ a => cacheAttributes.map(_.exprId).indexOf(a.exprId)
+ }
+ val shouldSelectAttributes = cacheAttributes != selectedAttributes
+ val localSchema = toStructType(cacheAttributes)
+ val timezoneId = SQLConf.get.sessionLocalTimeZone
+ input.mapPartitions {
+ it =>
+ val runtime = Runtimes.contextInstance(
+ BackendsApiManager.getBackendName,
+ "ColumnarCachedBatchSerializer#read")
+ val jniWrapper = ColumnarBatchSerializerJniWrapper
+ .create(runtime)
+ val schema = SparkArrowUtil.toArrowSchema(localSchema, timezoneId)
+ val arrowAlloc = ArrowBufferAllocators.contextInstance()
+ val cSchema = ArrowSchema.allocateNew(arrowAlloc)
+ ArrowAbiUtil.exportSchema(arrowAlloc, schema, cSchema)
+ val deserializerHandle = jniWrapper
+ .init(cSchema.memoryAddress())
+ cSchema.close()
+
+ Iterators
+ .wrap(new Iterator[ColumnarBatch] {
+ override def hasNext: Boolean = it.hasNext
+
+ override def next(): ColumnarBatch = {
+ val cachedBatch = it.next().asInstanceOf[CachedColumnarBatch]
+ val batchHandle =
+ jniWrapper
+ .deserialize(deserializerHandle, cachedBatch.bytes)
+ val batch = ColumnarBatches.create(batchHandle)
+ if (shouldSelectAttributes) {
+ try {
+ ColumnarBatches.select(
+ BackendsApiManager.getBackendName,
+ batch,
+ requestedColumnIndices.toArray)
+ } finally {
+ batch.close()
+ }
+ } else {
+ batch
}
- } else {
- batch
}
+ })
+ .protectInvocationFlow()
+ .recycleIterator {
+ jniWrapper.close(deserializerHandle)
}
- })
- .protectInvocationFlow()
- .recycleIterator {
- jniWrapper.close(deserializerHandle)
- }
- .recyclePayload(_.close())
- .create()
+ .recyclePayload(_.close())
+ .create()
+ }
}
}
diff --git a/gluten-substrait/src/main/scala/org/apache/gluten/expression/ExpressionConverter.scala b/gluten-substrait/src/main/scala/org/apache/gluten/expression/ExpressionConverter.scala
index 418de8578f5c..a810a4ef1dbd 100644
--- a/gluten-substrait/src/main/scala/org/apache/gluten/expression/ExpressionConverter.scala
+++ b/gluten-substrait/src/main/scala/org/apache/gluten/expression/ExpressionConverter.scala
@@ -831,7 +831,14 @@ object ExpressionConverter extends SQLConfHelper with Logging {
case t: TransformKeys =>
// default is `EXCEPTION`
val mapKeyDedupPolicy = SQLConf.get.getConf(SQLConf.MAP_KEY_DEDUP_POLICY)
- if (mapKeyDedupPolicy == SQLConf.MapKeyDedupPolicy.LAST_WIN.toString) {
+
+ // Calling `.toString` on both sides ensures compatibility across all Spark versions.
+ // Starting from Spark 4.1, `SQLConf.get.getConf(SQLConf.MAP_KEY_DEDUP_POLICY)` returns
+ // an enum instead of a String. Without `.toString`, the comparison
+ // `mapKeyDedupPolicy == SQLConf.MapKeyDedupPolicy.LAST_WIN.toString` would silently fail
+ // in tests, producing only a "Comparing unrelated types" warning in IntelliJ IDEA,
+ // but no compile-time error.
+ if (mapKeyDedupPolicy.toString == SQLConf.MapKeyDedupPolicy.LAST_WIN.toString) {
// TODO: Remove after fix ready for
// https://github.com/facebookincubator/velox/issues/10219
throw new GlutenNotSupportException(
diff --git a/gluten-ut/pom.xml b/gluten-ut/pom.xml
index ec0158c41e82..58b4e6d65835 100644
--- a/gluten-ut/pom.xml
+++ b/gluten-ut/pom.xml
@@ -230,5 +230,11 @@
spark40
+
+ spark-4.1
+
+ spark41
+
+
diff --git a/gluten-ut/spark41/pom.xml b/gluten-ut/spark41/pom.xml
new file mode 100644
index 000000000000..838649a21dc2
--- /dev/null
+++ b/gluten-ut/spark41/pom.xml
@@ -0,0 +1,306 @@
+
+
+ 4.0.0
+
+ org.apache.gluten
+ gluten-ut
+ 1.6.0-SNAPSHOT
+ ../pom.xml
+
+
+ gluten-ut-spark41
+ jar
+ Gluten Unit Test Spark41
+
+
+ 1.16.0
+
+
+
+
+ org.apache.gluten
+ gluten-ut-common
+ ${project.version}
+ test-jar
+ compile
+
+
+ org.apache.parquet
+ parquet-column
+ ${parquet.version}
+ tests
+ test
+
+
+ org.apache.parquet
+ parquet-common
+ ${parquet.version}
+ tests
+ test
+
+
+ org.apache.commons
+ commons-lang3
+ ${commons-lang3.version}
+
+
+ org.apache.hive
+ hive-llap-common
+ 4.0.0
+ test
+
+
+ org.apache.hive
+ hive-common
+
+
+ org.apache.hive
+ hive-serde
+
+
+ org.slf4j
+ slf4j-api
+
+
+
+
+ org.apache.hive
+ hive-llap-client
+ 2.3.10
+ test
+
+
+ org.apache.hive
+ hive-common
+
+
+ org.apache.hive
+ hive-serde
+
+
+ org.apache.hive
+ hive-llap-common
+
+
+ org.apache.curator
+ curator-framework
+
+
+ org.apache.curator
+ apache-curator
+
+
+ org.apache.zookeeper
+ zookeeper
+
+
+ org.slf4j
+ slf4j-api
+
+
+
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-resources-plugin
+
+
+ net.alchim31.maven
+ scala-maven-plugin
+
+
+ org.apache.maven.plugins
+ maven-compiler-plugin
+
+
+ org.scalastyle
+ scalastyle-maven-plugin
+
+
+ com.diffplug.spotless
+ spotless-maven-plugin
+
+
+ org.apache.maven.plugins
+ maven-checkstyle-plugin
+
+
+ org.scalatest
+ scalatest-maven-plugin
+
+ .
+
+
+
+ test
+
+ test
+
+
+
+
+
+ org.apache.maven.plugins
+ maven-jar-plugin
+
+
+ prepare-test-jar
+
+ test-jar
+
+ test-compile
+
+
+
+
+ target/scala-${scala.binary.version}/classes
+ target/scala-${scala.binary.version}/test-classes
+
+
+
+
+ backends-clickhouse
+
+ false
+
+
+
+ org.apache.gluten
+ backends-clickhouse
+ ${project.version}
+ test
+
+
+ org.apache.celeborn
+ celeborn-client-spark-${spark.major.version}-shaded_${scala.binary.version}
+ ${celeborn.version}
+ test
+
+
+ org.apache.arrow
+ arrow-memory-core
+ ${arrow.version}
+ provided
+
+
+ io.netty
+ netty-common
+
+
+ io.netty
+ netty-buffer
+
+
+
+
+ org.apache.arrow
+ arrow-vector
+ ${arrow.version}
+ provided
+
+
+ io.netty
+ netty-common
+
+
+ io.netty
+ netty-buffer
+
+
+
+
+
+
+
+ org.codehaus.mojo
+ build-helper-maven-plugin
+
+
+ add-sources
+
+ add-test-source
+
+ generate-sources
+
+
+ src/test/backends-clickhouse
+
+
+
+
+
+
+
+
+
+ backends-velox
+
+ false
+
+
+
+ org.junit.jupiter
+ junit-jupiter
+ 5.9.3
+ test
+
+
+ net.aichler
+ jupiter-interface
+ 0.11.1
+ test
+
+
+ org.apache.gluten
+ backends-velox
+ ${project.version}
+ test
+
+
+
+ org.slf4j
+ slf4j-api
+ ${slf4j.version}
+ test
+
+
+ org.apache.logging.log4j
+ log4j-slf4j2-impl
+ ${log4j.version}
+ test
+
+
+ com.h2database
+ h2
+ 2.2.220
+ test
+
+
+
+
+
+ org.codehaus.mojo
+ build-helper-maven-plugin
+
+
+ add-sources
+
+ add-test-source
+
+ generate-sources
+
+
+ src/test/backends-velox
+
+
+
+
+
+
+
+
+
+
diff --git a/gluten-ut/spark41/src/test/backends-clickhouse/org/apache/gluten/GlutenColumnarWriteTestSupport.scala b/gluten-ut/spark41/src/test/backends-clickhouse/org/apache/gluten/GlutenColumnarWriteTestSupport.scala
new file mode 100644
index 000000000000..4258cd891a5a
--- /dev/null
+++ b/gluten-ut/spark41/src/test/backends-clickhouse/org/apache/gluten/GlutenColumnarWriteTestSupport.scala
@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.gluten
+
+import org.apache.spark.sql.execution.{ColumnarWriteFilesExec, SparkPlan}
+
+trait GlutenColumnarWriteTestSupport {
+
+ def checkWriteFilesAndGetChild(sparkPlan: SparkPlan): SparkPlan = {
+ assert(sparkPlan.isInstanceOf[ColumnarWriteFilesExec])
+ sparkPlan.asInstanceOf[ColumnarWriteFilesExec].child
+ }
+}
diff --git a/gluten-ut/spark41/src/test/backends-clickhouse/org/apache/gluten/execution/parquet/GlutenParquetV1FilterSuite2.scala b/gluten-ut/spark41/src/test/backends-clickhouse/org/apache/gluten/execution/parquet/GlutenParquetV1FilterSuite2.scala
new file mode 100644
index 000000000000..5b84888376aa
--- /dev/null
+++ b/gluten-ut/spark41/src/test/backends-clickhouse/org/apache/gluten/execution/parquet/GlutenParquetV1FilterSuite2.scala
@@ -0,0 +1,28 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.gluten.execution.parquet
+
+import org.apache.spark.SparkConf
+import org.apache.spark.sql.execution.datasources.parquet.GlutenParquetV1FilterSuite
+
+
+/** testing use_local_format parquet reader. **/
+class GlutenParquetV1FilterSuite2 extends GlutenParquetV1FilterSuite {
+ override def sparkConf: SparkConf =
+ super.sparkConf
+ .set("spark.gluten.sql.columnar.backend.ch.runtime_config.use_local_format", "true")
+}
diff --git a/gluten-ut/spark41/src/test/backends-velox/org/apache/gluten/GlutenColumnarWriteTestSupport.scala b/gluten-ut/spark41/src/test/backends-velox/org/apache/gluten/GlutenColumnarWriteTestSupport.scala
new file mode 100644
index 000000000000..68c0e1c932b5
--- /dev/null
+++ b/gluten-ut/spark41/src/test/backends-velox/org/apache/gluten/GlutenColumnarWriteTestSupport.scala
@@ -0,0 +1,27 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.gluten
+
+import org.apache.spark.sql.execution.{SparkPlan, ColumnarWriteFilesExec}
+
+trait GlutenColumnarWriteTestSupport {
+
+ def checkWriteFilesAndGetChild(sparkPlan: SparkPlan): SparkPlan = {
+ assert(sparkPlan.isInstanceOf[ColumnarWriteFilesExec])
+ sparkPlan.asInstanceOf[ColumnarWriteFilesExec].child
+ }
+}
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by-ordinal.sql b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by-ordinal.sql
new file mode 100644
index 000000000000..b773396c050d
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by-ordinal.sql
@@ -0,0 +1,96 @@
+-- group by ordinal positions
+
+create temporary view data as select * from values
+ (1, 1),
+ (1, 2),
+ (2, 1),
+ (2, 2),
+ (3, 1),
+ (3, 2)
+ as data(a, b);
+
+-- basic case
+select a, sum(b) from data group by 1;
+
+-- constant case
+select 1, 2, sum(b) from data group by 1, 2;
+
+-- duplicate group by column
+select a, 1, sum(b) from data group by a, 1;
+select a, 1, sum(b) from data group by 1, 2;
+
+-- group by a non-aggregate expression's ordinal
+select a, b + 2, count(2) from data group by a, 2;
+
+-- with alias
+select a as aa, b + 2 as bb, count(2) from data group by 1, 2;
+
+-- foldable non-literal: this should be the same as no grouping.
+select sum(b) from data group by 1 + 0;
+
+-- negative cases: ordinal out of range
+select a, b from data group by -1;
+select a, b from data group by 0;
+select a, b from data group by 3;
+
+-- negative case: position is an aggregate expression
+select a, b, sum(b) from data group by 3;
+select a, b, sum(b) + 2 from data group by 3;
+
+-- negative case: nondeterministic expression
+select a, rand(0), sum(b)
+from
+(select /*+ REPARTITION(1) */ a, b from data) group by a, 2;
+
+-- negative case: star
+select * from data group by a, b, 1;
+
+-- group by ordinal followed by order by
+select a, count(a) from (select 1 as a) tmp group by 1 order by 1;
+
+-- group by ordinal followed by having
+select count(a), a from (select 1 as a) tmp group by 2 having a > 0;
+
+-- mixed cases: group-by ordinals and aliases
+select a, a AS k, count(b) from data group by k, 1;
+
+-- can use ordinal in CUBE
+select a, b, count(1) from data group by cube(1, 2);
+
+-- mixed cases: can use ordinal in CUBE
+select a, b, count(1) from data group by cube(1, b);
+
+-- can use ordinal with cube
+select a, b, count(1) from data group by 1, 2 with cube;
+
+-- can use ordinal in ROLLUP
+select a, b, count(1) from data group by rollup(1, 2);
+
+-- mixed cases: can use ordinal in ROLLUP
+select a, b, count(1) from data group by rollup(1, b);
+
+-- can use ordinal with rollup
+select a, b, count(1) from data group by 1, 2 with rollup;
+
+-- can use ordinal in GROUPING SETS
+select a, b, count(1) from data group by grouping sets((1), (2), (1, 2));
+
+-- mixed cases: can use ordinal in GROUPING SETS
+select a, b, count(1) from data group by grouping sets((1), (b), (a, 2));
+
+select a, b, count(1) from data group by a, 2 grouping sets((1), (b), (a, 2));
+
+-- range error
+select a, b, count(1) from data group by a, -1;
+
+select a, b, count(1) from data group by a, 3;
+
+select a, b, count(1) from data group by cube(-1, 2);
+
+select a, b, count(1) from data group by cube(1, 3);
+
+-- turn off group by ordinal
+set spark.sql.groupByOrdinal=false;
+
+-- can now group by negative literal
+select sum(b) from data group by -1;
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by.sql b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by.sql
new file mode 100644
index 000000000000..c35cdb0de271
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/group-by.sql
@@ -0,0 +1,266 @@
+-- Test aggregate 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
+
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (null, 1), (3, null), (null, null)
+AS testData(a, b);
+
+-- Aggregate with empty GroupBy expressions.
+SELECT a, COUNT(b) FROM testData;
+SELECT COUNT(a), COUNT(b) FROM testData;
+
+-- Aggregate with non-empty GroupBy expressions.
+SELECT a, COUNT(b) FROM testData GROUP BY a;
+SELECT a, COUNT(b) FROM testData GROUP BY b;
+SELECT COUNT(a), COUNT(b) FROM testData GROUP BY a;
+
+-- Aggregate grouped by literals.
+SELECT 'foo', COUNT(a) FROM testData GROUP BY 1;
+
+-- Aggregate grouped by literals (whole stage code generation).
+SELECT 'foo' FROM testData WHERE a = 0 GROUP BY 1;
+
+-- Aggregate grouped by literals (hash aggregate).
+SELECT 'foo', APPROX_COUNT_DISTINCT(a) FROM testData WHERE a = 0 GROUP BY 1;
+
+-- Aggregate grouped by literals (sort aggregate).
+SELECT 'foo', MAX(STRUCT(a)) FROM testData WHERE a = 0 GROUP BY 1;
+
+-- Aggregate with complex GroupBy expressions.
+SELECT a + b, COUNT(b) FROM testData GROUP BY a + b;
+SELECT a + 2, COUNT(b) FROM testData GROUP BY a + 1;
+SELECT a + 1 + 1, COUNT(b) FROM testData GROUP BY a + 1;
+
+-- struct() in group by
+SELECT count(1) FROM testData GROUP BY struct(a + 0.1 AS aa);
+
+-- Aggregate with nulls.
+SELECT SKEWNESS(a), KURTOSIS(a), MIN(a), MAX(a), AVG(a), VARIANCE(a), STDDEV(a), SUM(a), COUNT(a)
+FROM testData;
+
+-- Aggregate with foldable input and multiple distinct groups.
+SELECT COUNT(DISTINCT b), COUNT(DISTINCT b, c) FROM (SELECT 1 AS a, 2 AS b, 3 AS c) GROUP BY a;
+
+-- Aliases in SELECT could be used in GROUP BY
+SELECT a AS k, COUNT(b) FROM testData GROUP BY k;
+SELECT a AS k, COUNT(b) FROM testData GROUP BY k HAVING k > 1;
+
+-- GROUP BY alias with invalid col in SELECT list
+SELECT a AS k, COUNT(non_existing) FROM testData GROUP BY k;
+
+-- Aggregate functions cannot be used in GROUP BY
+SELECT COUNT(b) AS k FROM testData GROUP BY k;
+
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testDataHasSameNameWithAlias AS SELECT * FROM VALUES
+(1, 1, 3), (1, 2, 1) AS testDataHasSameNameWithAlias(k, a, v);
+SELECT k AS a, COUNT(v) FROM testDataHasSameNameWithAlias GROUP BY a;
+
+-- turn off group by aliases
+set spark.sql.groupByAliases=false;
+
+-- Check analysis exceptions
+SELECT a AS k, COUNT(b) FROM testData GROUP BY k;
+
+-- Aggregate with empty input and non-empty GroupBy expressions.
+SELECT a, COUNT(1) FROM testData WHERE false GROUP BY a;
+
+-- Aggregate with empty input and empty GroupBy expressions.
+SELECT COUNT(1) FROM testData WHERE false;
+SELECT 1 FROM (SELECT COUNT(1) FROM testData WHERE false) t;
+
+-- Aggregate with empty GroupBy expressions and filter on top
+SELECT 1 from (
+ SELECT 1 AS z,
+ MIN(a.x)
+ FROM (select 1 as x) a
+ WHERE false
+) b
+where b.z != b.z;
+
+-- SPARK-24369 multiple distinct aggregations having the same argument set
+SELECT corr(DISTINCT x, y), corr(DISTINCT y, x), count(*)
+ FROM (VALUES (1, 1), (2, 2), (2, 2)) t(x, y);
+
+-- SPARK-25708 HAVING without GROUP BY means global aggregate
+SELECT 1 FROM range(10) HAVING true;
+
+SELECT 1 FROM range(10) HAVING MAX(id) > 0;
+
+SELECT id FROM range(10) HAVING id > 0;
+
+SET spark.sql.legacy.parser.havingWithoutGroupByAsWhere=true;
+
+SELECT 1 FROM range(10) HAVING true;
+
+SELECT 1 FROM range(10) HAVING MAX(id) > 0;
+
+SELECT id FROM range(10) HAVING id > 0;
+
+SET spark.sql.legacy.parser.havingWithoutGroupByAsWhere=false;
+
+-- Test data
+CREATE OR REPLACE TEMPORARY VIEW test_agg AS SELECT * FROM VALUES
+ (1, true), (1, false),
+ (2, true),
+ (3, false), (3, null),
+ (4, null), (4, null),
+ (5, null), (5, true), (5, false) AS test_agg(k, v);
+
+-- empty table
+SELECT every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg WHERE 1 = 0;
+
+-- all null values
+SELECT every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg WHERE k = 4;
+
+-- aggregates are null Filtering
+SELECT every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg WHERE k = 5;
+
+-- group by
+SELECT k, every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg GROUP BY k;
+
+-- having
+SELECT k, every(v) FROM test_agg GROUP BY k HAVING every(v) = false;
+SELECT k, every(v) FROM test_agg GROUP BY k HAVING every(v) IS NULL;
+
+-- basic subquery path to make sure rewrite happens in both parent and child plans.
+SELECT k,
+ Every(v) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Any(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY k;
+
+-- basic subquery path to make sure rewrite happens in both parent and child plans.
+SELECT k,
+ Every(v) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Every(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY k;
+
+-- input type checking Int
+SELECT every(1);
+
+-- input type checking Short
+SELECT some(1S);
+
+-- input type checking Long
+SELECT any(1L);
+
+-- input type checking String
+SELECT every("true");
+
+-- input type checking Decimal
+SELECT bool_and(1.0);
+
+-- input type checking double
+SELECT bool_or(1.0D);
+
+-- every/some/any aggregates/bool_and/bool_or are supported as windows expression.
+SELECT k, v, every(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT k, v, some(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT k, v, any(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT k, v, bool_and(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT k, v, bool_or(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+
+-- Having referencing aggregate expressions is ok.
+SELECT count(*) FROM test_agg HAVING count(*) > 1L;
+SELECT k, max(v) FROM test_agg GROUP BY k HAVING max(v) = true;
+
+-- Aggrgate expressions can be referenced through an alias
+SELECT * FROM (SELECT COUNT(*) AS cnt FROM test_agg) WHERE cnt > 1L;
+
+-- Error when aggregate expressions are in where clause directly
+SELECT count(*) FROM test_agg WHERE count(*) > 1L;
+SELECT count(*) FROM test_agg WHERE count(*) + 1L > 1L;
+SELECT count(*) FROM test_agg WHERE k = 1 or k = 2 or count(*) + 1L > 1L or max(k) > 1;
+
+-- Aggregate with multiple distinct decimal columns
+SELECT AVG(DISTINCT decimal_col), SUM(DISTINCT decimal_col) FROM VALUES (CAST(1 AS DECIMAL(9, 0))) t(decimal_col);
+
+-- SPARK-34581: Don't optimize out grouping expressions from aggregate expressions without aggregate function
+SELECT not(a IS NULL), count(*) AS c
+FROM testData
+GROUP BY a IS NULL;
+
+SELECT if(not(a IS NULL), rand(0), 1), count(*) AS c
+FROM testData
+GROUP BY a IS NULL;
+
+
+-- Histogram aggregates with different numeric input types
+SELECT
+ histogram_numeric(col, 2) as histogram_2,
+ histogram_numeric(col, 3) as histogram_3,
+ histogram_numeric(col, 5) as histogram_5,
+ histogram_numeric(col, 10) as histogram_10
+FROM VALUES
+ (1), (2), (3), (4), (5), (6), (7), (8), (9), (10),
+ (11), (12), (13), (14), (15), (16), (17), (18), (19), (20),
+ (21), (22), (23), (24), (25), (26), (27), (28), (29), (30),
+ (31), (32), (33), (34), (35), (3), (37), (38), (39), (40),
+ (41), (42), (43), (44), (45), (46), (47), (48), (49), (50) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1), (2), (3) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1L), (2L), (3L) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1F), (2F), (3F) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1D), (2D), (3D) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1S), (2S), (3S) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS BYTE)), (CAST(2 AS BYTE)), (CAST(3 AS BYTE)) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS TINYINT)), (CAST(2 AS TINYINT)), (CAST(3 AS TINYINT)) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS SMALLINT)), (CAST(2 AS SMALLINT)), (CAST(3 AS SMALLINT)) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS BIGINT)), (CAST(2 AS BIGINT)), (CAST(3 AS BIGINT)) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (TIMESTAMP '2017-03-01 00:00:00'),
+ (TIMESTAMP '2017-04-01 00:00:00'), (TIMESTAMP '2017-05-01 00:00:00') AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (INTERVAL '100-00' YEAR TO MONTH),
+ (INTERVAL '110-00' YEAR TO MONTH), (INTERVAL '120-00' YEAR TO MONTH) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (INTERVAL '12 20:4:0' DAY TO SECOND),
+ (INTERVAL '12 21:4:0' DAY TO SECOND), (INTERVAL '12 22:4:0' DAY TO SECOND) AS tab(col);
+SELECT histogram_numeric(col, 3)
+FROM VALUES (NULL), (NULL), (NULL) AS tab(col);
+SELECT histogram_numeric(col, 3)
+FROM VALUES (CAST(NULL AS DOUBLE)), (CAST(NULL AS DOUBLE)), (CAST(NULL AS DOUBLE)) AS tab(col);
+SELECT histogram_numeric(col, 3)
+FROM VALUES (CAST(NULL AS INT)), (CAST(NULL AS INT)), (CAST(NULL AS INT)) AS tab(col);
+
+-- SPARK-27974: Support ANSI Aggregate Function: array_agg
+SELECT
+ collect_list(col),
+ array_agg(col)
+FROM VALUES
+ (1), (2), (1) AS tab(col);
+SELECT
+ a,
+ collect_list(b),
+ array_agg(b)
+FROM VALUES
+ (1,4),(2,3),(1,4),(2,4) AS v(a,b)
+GROUP BY a;
+
+
+SELECT mode(a), mode(b) FROM testData;
+SELECT a, mode(b) FROM testData GROUP BY a ORDER BY a;
+
+
+-- SPARK-44846: PushFoldableIntoBranches in complex grouping expressions cause bindReference error
+SELECT c * 2 AS d
+FROM (
+ SELECT if(b > 1, 1, b) AS c
+ FROM (
+ SELECT if(a < 0, 0, a) AS b
+ FROM VALUES (-1), (1), (2) AS t1(a)
+ ) t2
+ GROUP BY b
+ ) t3
+GROUP BY c;
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/linear-regression.sql b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/linear-regression.sql
new file mode 100644
index 000000000000..c7cb5bf1117a
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/linear-regression.sql
@@ -0,0 +1,52 @@
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testRegression AS SELECT * FROM VALUES
+(1, 10, null), (2, 10, 11), (2, 20, 22), (2, 25, null), (2, 30, 35)
+AS testRegression(k, y, x);
+
+-- SPARK-37613: Support ANSI Aggregate Function: regr_count
+SELECT regr_count(y, x) FROM testRegression;
+SELECT regr_count(y, x) FROM testRegression WHERE x IS NOT NULL;
+SELECT k, count(*), regr_count(y, x) FROM testRegression GROUP BY k;
+SELECT k, count(*) FILTER (WHERE x IS NOT NULL), regr_count(y, x) FROM testRegression GROUP BY k;
+
+-- SPARK-37613: Support ANSI Aggregate Function: regr_r2
+SELECT regr_r2(y, x) FROM testRegression;
+SELECT regr_r2(y, x) FROM testRegression WHERE x IS NOT NULL;
+SELECT k, corr(y, x), regr_r2(y, x) FROM testRegression GROUP BY k;
+SELECT k, corr(y, x) FILTER (WHERE x IS NOT NULL), regr_r2(y, x) FROM testRegression GROUP BY k;
+
+-- SPARK-37614: Support ANSI Aggregate Function: regr_avgx & regr_avgy
+SELECT regr_avgx(y, x), regr_avgy(y, x) FROM testRegression;
+SELECT regr_avgx(y, x), regr_avgy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, avg(x), avg(y), regr_avgx(y, x), regr_avgy(y, x) FROM testRegression GROUP BY k;
+SELECT k, avg(x) FILTER (WHERE x IS NOT NULL AND y IS NOT NULL), avg(y) FILTER (WHERE x IS NOT NULL AND y IS NOT NULL), regr_avgx(y, x), regr_avgy(y, x) FROM testRegression GROUP BY k;
+
+-- SPARK-37672: Support ANSI Aggregate Function: regr_sxx
+SELECT regr_sxx(y, x) FROM testRegression;
+SELECT regr_sxx(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_sxx(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_sxx(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
+
+-- SPARK-37681: Support ANSI Aggregate Function: regr_sxy
+SELECT regr_sxy(y, x) FROM testRegression;
+SELECT regr_sxy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_sxy(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_sxy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
+
+-- SPARK-37702: Support ANSI Aggregate Function: regr_syy
+SELECT regr_syy(y, x) FROM testRegression;
+SELECT regr_syy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_syy(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_syy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
+
+-- SPARK-39230: Support ANSI Aggregate Function: regr_slope
+SELECT regr_slope(y, x) FROM testRegression;
+SELECT regr_slope(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_slope(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_slope(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
+
+-- SPARK-37623: Support ANSI Aggregate Function: regr_intercept
+SELECT regr_intercept(y, x) FROM testRegression;
+SELECT regr_intercept(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_intercept(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_intercept(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/misc-functions.sql b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/misc-functions.sql
new file mode 100644
index 000000000000..907ff33000d8
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/misc-functions.sql
@@ -0,0 +1,22 @@
+-- test for misc functions
+
+-- typeof
+select typeof(null);
+select typeof(true);
+select typeof(1Y), typeof(1S), typeof(1), typeof(1L);
+select typeof(cast(1.0 as float)), typeof(1.0D), typeof(1.2);
+select typeof(date '1986-05-23'), typeof(timestamp '1986-05-23'), typeof(interval '23 days');
+select typeof(x'ABCD'), typeof('SPARK');
+select typeof(array(1, 2)), typeof(map(1, 2)), typeof(named_struct('a', 1, 'b', 'spark'));
+
+-- Spark-32793: Rewrite AssertTrue with RaiseError
+SELECT assert_true(true), assert_true(boolean(1));
+SELECT assert_true(false);
+SELECT assert_true(boolean(0));
+SELECT assert_true(null);
+SELECT assert_true(boolean(null));
+SELECT assert_true(false, 'custom error message');
+
+CREATE TEMPORARY VIEW tbl_misc AS SELECT * FROM (VALUES (1), (8), (2)) AS T(v);
+SELECT raise_error('error message');
+SELECT if(v > 5, raise_error('too big: ' || v), v + 1) FROM tbl_misc;
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/random.sql b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/random.sql
new file mode 100644
index 000000000000..a1aae7b8759d
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/random.sql
@@ -0,0 +1,17 @@
+-- rand with the seed 0
+SELECT rand(0);
+SELECT rand(cast(3 / 7 AS int));
+SELECT rand(NULL);
+SELECT rand(cast(NULL AS int));
+
+-- rand unsupported data type
+SELECT rand(1.0);
+
+-- randn with the seed 0
+SELECT randn(0L);
+SELECT randn(cast(3 / 7 AS long));
+SELECT randn(NULL);
+SELECT randn(cast(NULL AS long));
+
+-- randn unsupported data type
+SELECT rand('1')
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/table-valued-functions.sql b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/table-valued-functions.sql
new file mode 100644
index 000000000000..79d427bc2099
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/table-valued-functions.sql
@@ -0,0 +1,126 @@
+-- unresolved function
+select * from dummy(3);
+
+-- range call with end
+select * from range(6 + cos(3));
+
+-- range call with start and end
+select * from range(5, 10);
+
+-- range call with step
+select * from range(0, 10, 2);
+
+-- range call with numPartitions
+select * from range(0, 10, 1, 200);
+
+-- range call with invalid number of arguments
+select * from range(1, 1, 1, 1, 1);
+
+-- range call with null
+select * from range(1, null);
+
+-- range call with incompatible type
+select * from range(array(1, 2, 3));
+
+-- range call with illegal step
+select * from range(0, 5, 0);
+
+-- range call with a mixed-case function name
+select * from RaNgE(2);
+
+-- range call with alias
+select i from range(0, 2) t(i);
+
+-- explode
+select * from explode(array(1, 2));
+select * from explode(map('a', 1, 'b', 2));
+
+-- explode with empty values
+select * from explode(array());
+select * from explode(map());
+
+-- explode with column aliases
+select * from explode(array(1, 2)) t(c1);
+select * from explode(map('a', 1, 'b', 2)) t(k, v);
+
+-- explode with non-deterministic values
+select * from explode(array(rand(0)));
+
+-- explode with erroneous input
+select * from explode(null);
+select * from explode(null) t(c1);
+select * from explode(1);
+select * from explode(1, 2);
+select * from explode(explode(array(1)));
+select * from explode(array(1, 2)) t(c1, c2);
+
+-- explode_outer
+select * from explode_outer(array(1, 2));
+select * from explode_outer(map('a', 1, 'b', 2));
+select * from explode_outer(array());
+select * from explode_outer(map());
+
+-- table-valued functions with join
+select * from range(2) join explode(array(1, 2));
+select * from range(2) join explode_outer(array());
+
+-- inline
+select * from inline(array(struct(1, 'a'), struct(2, 'b')));
+select * from inline(array(struct(1, 'a'), struct(2, 'b'))) t(x, y);
+select * from inline(array_remove(array(struct(1, 'a')), struct(1, 'a')));
+
+-- inline with erroneous input
+select * from inline(null);
+select * from inline(array(struct(1, 2), struct(2, 3))) t(a, b, c);
+
+-- inline_outer
+select * from inline_outer(array(struct(1, 'a'), struct(2, 'b')));
+select * from inline_outer(array_remove(array(struct(1, 'a')), struct(1, 'a')));
+
+-- posexplode
+select * from posexplode(array());
+select * from posexplode(array(1, 2));
+select * from posexplode(array(1, 2)) t(pos, x);
+select * from posexplode(map());
+select * from posexplode(map('a', 1, 'b', 2));
+select * from posexplode(map('a', 1, 'b', 2)) t(pos, k, v);
+
+-- posexplode with erroneous input
+select * from posexplode(1);
+select * from posexplode(1, 2);
+select * from posexplode(explode(array(1)));
+select * from posexplode(array(1, 2)) t(x);
+
+-- posexplode
+select * from posexplode_outer(array());
+select * from posexplode_outer(array(1, 2));
+select * from posexplode_outer(map());
+select * from posexplode_outer(map('a', 1, 'b', 2));
+
+-- json_tuple
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'b');
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'c');
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'a');
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'b') AS t(x, y);
+select * from json_tuple('{"a": bad, "b": string}', 'a', 'b');
+
+-- json_tuple with erroneous input
+select * from json_tuple();
+select * from json_tuple('{"a": 1}');
+select * from json_tuple('{"a": 1}', 1);
+select * from json_tuple('{"a": 1}', null);
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'b') AS t(x);
+
+-- stack
+select * from stack(1, 1, 2, 3);
+select * from stack(2, 1, 2, 3);
+select * from stack(3, 1, 2, 3) t(x);
+select * from stack(4, 1, 2, 3) t(x);
+select * from stack(2, 1, 1.1, 'a', 2, 2.2, 'b') t(a, b, c);
+select * from stack(2, 1, 1.1, null, 2, null, 'b') t(a, b, c);
+
+-- stack with erroneous input
+select * from stack();
+select * from stack(2, 1, 2, 3) t(a, b, c);
+select * from stack(2, 1, '1.1', 'a', 2, 2.2, 'b');
+select * from stack(2, explode(array(1, 2, 3)));
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/udf/udf-group-by.sql b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/udf/udf-group-by.sql
new file mode 100644
index 000000000000..0cc57c97b020
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/inputs/udf/udf-group-by.sql
@@ -0,0 +1,156 @@
+-- This test file was converted from group-by.sql.
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (null, 1), (3, null), (null, null)
+AS testData(a, b);
+
+-- Aggregate with empty GroupBy expressions.
+SELECT udf(a), udf(COUNT(b)) FROM testData;
+SELECT COUNT(udf(a)), udf(COUNT(b)) FROM testData;
+
+-- Aggregate with non-empty GroupBy expressions.
+SELECT udf(a), COUNT(udf(b)) FROM testData GROUP BY a;
+SELECT udf(a), udf(COUNT(udf(b))) FROM testData GROUP BY b;
+SELECT COUNT(udf(a)), COUNT(udf(b)) FROM testData GROUP BY udf(a);
+
+-- Aggregate grouped by literals.
+SELECT 'foo', COUNT(udf(a)) FROM testData GROUP BY 1;
+
+-- Aggregate grouped by literals (whole stage code generation).
+SELECT 'foo' FROM testData WHERE a = 0 GROUP BY udf(1);
+
+-- Aggregate grouped by literals (hash aggregate).
+SELECT 'foo', udf(APPROX_COUNT_DISTINCT(udf(a))) FROM testData WHERE a = 0 GROUP BY udf(1);
+
+-- Aggregate grouped by literals (sort aggregate).
+SELECT 'foo', MAX(STRUCT(udf(a))) FROM testData WHERE a = 0 GROUP BY udf(1);
+
+-- Aggregate with complex GroupBy expressions.
+SELECT udf(a + b), udf(COUNT(b)) FROM testData GROUP BY a + b;
+SELECT udf(a + 2), udf(COUNT(b)) FROM testData GROUP BY a + 1;
+SELECT udf(a + 1) + 1, udf(COUNT(b)) FROM testData GROUP BY udf(a + 1);
+
+-- Aggregate with nulls.
+SELECT SKEWNESS(udf(a)), udf(KURTOSIS(a)), udf(MIN(a)), MAX(udf(a)), udf(AVG(udf(a))), udf(VARIANCE(a)), STDDEV(udf(a)), udf(SUM(a)), udf(COUNT(a))
+FROM testData;
+
+-- Aggregate with foldable input and multiple distinct groups.
+SELECT COUNT(DISTINCT udf(b)), udf(COUNT(DISTINCT b, c)) FROM (SELECT 1 AS a, 2 AS b, 3 AS c) GROUP BY udf(a);
+
+-- Aliases in SELECT could be used in GROUP BY
+SELECT udf(a) AS k, COUNT(udf(b)) FROM testData GROUP BY k;
+SELECT a AS k, udf(COUNT(b)) FROM testData GROUP BY k HAVING k > 1;
+
+-- Aggregate functions cannot be used in GROUP BY
+SELECT udf(COUNT(b)) AS k FROM testData GROUP BY k;
+
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testDataHasSameNameWithAlias AS SELECT * FROM VALUES
+(1, 1, 3), (1, 2, 1) AS testDataHasSameNameWithAlias(k, a, v);
+SELECT k AS a, udf(COUNT(udf(v))) FROM testDataHasSameNameWithAlias GROUP BY udf(a);
+
+-- turn off group by aliases
+set spark.sql.groupByAliases=false;
+
+-- Check analysis exceptions
+SELECT a AS k, udf(COUNT(udf(b))) FROM testData GROUP BY k;
+
+-- Aggregate with empty input and non-empty GroupBy expressions.
+SELECT udf(a), COUNT(udf(1)) FROM testData WHERE false GROUP BY udf(a);
+
+-- Aggregate with empty input and empty GroupBy expressions.
+SELECT udf(COUNT(1)) FROM testData WHERE false;
+SELECT 1 FROM (SELECT udf(COUNT(1)) FROM testData WHERE false) t;
+
+-- Aggregate with empty GroupBy expressions and filter on top
+SELECT 1 from (
+ SELECT 1 AS z,
+ udf(MIN(a.x))
+ FROM (select 1 as x) a
+ WHERE false
+) b
+where b.z != b.z;
+
+-- SPARK-24369 multiple distinct aggregations having the same argument set
+SELECT corr(DISTINCT x, y), udf(corr(DISTINCT y, x)), count(*)
+ FROM (VALUES (1, 1), (2, 2), (2, 2)) t(x, y);
+
+-- SPARK-25708 HAVING without GROUP BY means global aggregate
+SELECT udf(1) FROM range(10) HAVING true;
+
+SELECT udf(udf(1)) FROM range(10) HAVING MAX(id) > 0;
+
+SELECT udf(id) FROM range(10) HAVING id > 0;
+
+-- Test data
+CREATE OR REPLACE TEMPORARY VIEW test_agg AS SELECT * FROM VALUES
+ (1, true), (1, false),
+ (2, true),
+ (3, false), (3, null),
+ (4, null), (4, null),
+ (5, null), (5, true), (5, false) AS test_agg(k, v);
+
+-- empty table
+SELECT udf(every(v)), udf(some(v)), any(v) FROM test_agg WHERE 1 = 0;
+
+-- all null values
+SELECT udf(every(udf(v))), some(v), any(v) FROM test_agg WHERE k = 4;
+
+-- aggregates are null Filtering
+SELECT every(v), udf(some(v)), any(v) FROM test_agg WHERE k = 5;
+
+-- group by
+SELECT udf(k), every(v), udf(some(v)), any(v) FROM test_agg GROUP BY udf(k);
+
+-- having
+SELECT udf(k), every(v) FROM test_agg GROUP BY k HAVING every(v) = false;
+SELECT udf(k), udf(every(v)) FROM test_agg GROUP BY udf(k) HAVING every(v) IS NULL;
+
+-- basic subquery path to make sure rewrite happens in both parent and child plans.
+SELECT udf(k),
+ udf(Every(v)) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Any(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY udf(k);
+
+-- basic subquery path to make sure rewrite happens in both parent and child plans.
+SELECT udf(udf(k)),
+ Every(v) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Every(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY udf(udf(k));
+
+-- input type checking Int
+SELECT every(udf(1));
+
+-- input type checking Short
+SELECT some(udf(1S));
+
+-- input type checking Long
+SELECT any(udf(1L));
+
+-- input type checking String
+SELECT udf(every("true"));
+
+-- every/some/any aggregates are supported as windows expression.
+SELECT k, v, every(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT k, udf(udf(v)), some(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT udf(udf(k)), v, any(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+
+-- Having referencing aggregate expressions is ok.
+SELECT udf(count(*)) FROM test_agg HAVING count(*) > 1L;
+SELECT k, udf(max(v)) FROM test_agg GROUP BY k HAVING max(v) = true;
+
+-- Aggrgate expressions can be referenced through an alias
+SELECT * FROM (SELECT udf(COUNT(*)) AS cnt FROM test_agg) WHERE cnt > 1L;
+
+-- Error when aggregate expressions are in where clause directly
+SELECT udf(count(*)) FROM test_agg WHERE count(*) > 1L;
+SELECT udf(count(*)) FROM test_agg WHERE count(*) + 1L > 1L;
+SELECT udf(count(*)) FROM test_agg WHERE k = 1 or k = 2 or count(*) + 1L > 1L or max(k) > 1;
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/group-by-ordinal.sql.out b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/group-by-ordinal.sql.out
new file mode 100644
index 000000000000..b968b4e09fac
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/group-by-ordinal.sql.out
@@ -0,0 +1,524 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+create temporary view data as select * from values
+ (1, 1),
+ (1, 2),
+ (2, 1),
+ (2, 2),
+ (3, 1),
+ (3, 2)
+ as data(a, b)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+select a, sum(b) from data group by 1
+-- !query schema
+struct
+-- !query output
+1 3
+2 3
+3 3
+
+
+-- !query
+select 1, 2, sum(b) from data group by 1, 2
+-- !query schema
+struct<1:int,2:int,sum(b):bigint>
+-- !query output
+1 2 9
+
+
+-- !query
+select a, 1, sum(b) from data group by a, 1
+-- !query schema
+struct
+-- !query output
+1 1 3
+2 1 3
+3 1 3
+
+
+-- !query
+select a, 1, sum(b) from data group by 1, 2
+-- !query schema
+struct
+-- !query output
+1 1 3
+2 1 3
+3 1 3
+
+
+-- !query
+select a, b + 2, count(2) from data group by a, 2
+-- !query schema
+struct
+-- !query output
+1 3 1
+1 4 1
+2 3 1
+2 4 1
+3 3 1
+3 4 1
+
+
+-- !query
+select a as aa, b + 2 as bb, count(2) from data group by 1, 2
+-- !query schema
+struct
+-- !query output
+1 3 1
+1 4 1
+2 3 1
+2 4 1
+3 3 1
+3 4 1
+
+
+-- !query
+select sum(b) from data group by 1 + 0
+-- !query schema
+struct
+-- !query output
+9
+
+
+-- !query
+select a, b from data group by -1
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_POS_OUT_OF_RANGE",
+ "sqlState" : "42805",
+ "messageParameters" : {
+ "index" : "-1",
+ "size" : "2"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 32,
+ "stopIndex" : 33,
+ "fragment" : "-1"
+ } ]
+}
+
+
+-- !query
+select a, b from data group by 0
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_POS_OUT_OF_RANGE",
+ "sqlState" : "42805",
+ "messageParameters" : {
+ "index" : "0",
+ "size" : "2"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 32,
+ "stopIndex" : 32,
+ "fragment" : "0"
+ } ]
+}
+
+
+-- !query
+select a, b from data group by 3
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_POS_OUT_OF_RANGE",
+ "sqlState" : "42805",
+ "messageParameters" : {
+ "index" : "3",
+ "size" : "2"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 32,
+ "stopIndex" : 32,
+ "fragment" : "3"
+ } ]
+}
+
+
+-- !query
+select a, b, sum(b) from data group by 3
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_POS_AGGREGATE",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "aggExpr" : "sum(data.b) AS `sum(b)`",
+ "index" : "3"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 40,
+ "stopIndex" : 40,
+ "fragment" : "3"
+ } ]
+}
+
+
+-- !query
+select a, b, sum(b) + 2 from data group by 3
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_POS_AGGREGATE",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "aggExpr" : "(sum(data.b) + CAST(2 AS BIGINT)) AS `(sum(b) + 2)`",
+ "index" : "3"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 44,
+ "stopIndex" : 44,
+ "fragment" : "3"
+ } ]
+}
+
+
+-- !query
+select a, rand(0), sum(b)
+from
+(select /*+ REPARTITION(1) */ a, b from data) group by a, 2
+-- !query schema
+struct
+-- !query output
+1 0.5488135024422883 1
+1 0.7151893651681639 2
+2 0.5448831775801376 2
+2 0.6027633705776989 1
+3 0.4236547969336536 1
+3 0.6458941151817286 2
+
+
+-- !query
+select * from data group by a, b, 1
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "STAR_GROUP_BY_POS",
+ "sqlState" : "0A000"
+}
+
+
+-- !query
+select a, count(a) from (select 1 as a) tmp group by 1 order by 1
+-- !query schema
+struct
+-- !query output
+1 1
+
+
+-- !query
+select count(a), a from (select 1 as a) tmp group by 2 having a > 0
+-- !query schema
+struct
+-- !query output
+1 1
+
+
+-- !query
+select a, a AS k, count(b) from data group by k, 1
+-- !query schema
+struct
+-- !query output
+1 1 2
+2 2 2
+3 3 2
+
+
+-- !query
+select a, b, count(1) from data group by cube(1, 2)
+-- !query schema
+struct
+-- !query output
+1 1 1
+1 2 1
+1 NULL 2
+2 1 1
+2 2 1
+2 NULL 2
+3 1 1
+3 2 1
+3 NULL 2
+NULL 1 3
+NULL 2 3
+NULL NULL 6
+
+
+-- !query
+select a, b, count(1) from data group by cube(1, b)
+-- !query schema
+struct
+-- !query output
+1 1 1
+1 2 1
+1 NULL 2
+2 1 1
+2 2 1
+2 NULL 2
+3 1 1
+3 2 1
+3 NULL 2
+NULL 1 3
+NULL 2 3
+NULL NULL 6
+
+
+-- !query
+select a, b, count(1) from data group by 1, 2 with cube
+-- !query schema
+struct
+-- !query output
+1 1 1
+1 2 1
+1 NULL 2
+2 1 1
+2 2 1
+2 NULL 2
+3 1 1
+3 2 1
+3 NULL 2
+NULL 1 3
+NULL 2 3
+NULL NULL 6
+
+
+-- !query
+select a, b, count(1) from data group by rollup(1, 2)
+-- !query schema
+struct
+-- !query output
+1 1 1
+1 2 1
+1 NULL 2
+2 1 1
+2 2 1
+2 NULL 2
+3 1 1
+3 2 1
+3 NULL 2
+NULL NULL 6
+
+
+-- !query
+select a, b, count(1) from data group by rollup(1, b)
+-- !query schema
+struct
+-- !query output
+1 1 1
+1 2 1
+1 NULL 2
+2 1 1
+2 2 1
+2 NULL 2
+3 1 1
+3 2 1
+3 NULL 2
+NULL NULL 6
+
+
+-- !query
+select a, b, count(1) from data group by 1, 2 with rollup
+-- !query schema
+struct
+-- !query output
+1 1 1
+1 2 1
+1 NULL 2
+2 1 1
+2 2 1
+2 NULL 2
+3 1 1
+3 2 1
+3 NULL 2
+NULL NULL 6
+
+
+-- !query
+select a, b, count(1) from data group by grouping sets((1), (2), (1, 2))
+-- !query schema
+struct
+-- !query output
+1 1 1
+1 2 1
+1 NULL 2
+2 1 1
+2 2 1
+2 NULL 2
+3 1 1
+3 2 1
+3 NULL 2
+NULL 1 3
+NULL 2 3
+
+
+-- !query
+select a, b, count(1) from data group by grouping sets((1), (b), (a, 2))
+-- !query schema
+struct
+-- !query output
+1 1 1
+1 2 1
+1 NULL 2
+2 1 1
+2 2 1
+2 NULL 2
+3 1 1
+3 2 1
+3 NULL 2
+NULL 1 3
+NULL 2 3
+
+
+-- !query
+select a, b, count(1) from data group by a, 2 grouping sets((1), (b), (a, 2))
+-- !query schema
+struct
+-- !query output
+1 1 1
+1 2 1
+1 NULL 2
+2 1 1
+2 2 1
+2 NULL 2
+3 1 1
+3 2 1
+3 NULL 2
+NULL 1 3
+NULL 2 3
+
+
+-- !query
+select a, b, count(1) from data group by a, -1
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_POS_OUT_OF_RANGE",
+ "sqlState" : "42805",
+ "messageParameters" : {
+ "index" : "-1",
+ "size" : "3"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 45,
+ "stopIndex" : 46,
+ "fragment" : "-1"
+ } ]
+}
+
+
+-- !query
+select a, b, count(1) from data group by a, 3
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_POS_AGGREGATE",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "aggExpr" : "count(1) AS `count(1)`",
+ "index" : "3"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 45,
+ "stopIndex" : 45,
+ "fragment" : "3"
+ } ]
+}
+
+
+-- !query
+select a, b, count(1) from data group by cube(-1, 2)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_POS_OUT_OF_RANGE",
+ "sqlState" : "42805",
+ "messageParameters" : {
+ "index" : "-1",
+ "size" : "3"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 47,
+ "stopIndex" : 48,
+ "fragment" : "-1"
+ } ]
+}
+
+
+-- !query
+select a, b, count(1) from data group by cube(1, 3)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_POS_AGGREGATE",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "aggExpr" : "count(1) AS `count(1)`",
+ "index" : "3"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 50,
+ "stopIndex" : 50,
+ "fragment" : "3"
+ } ]
+}
+
+
+-- !query
+set spark.sql.groupByOrdinal=false
+-- !query schema
+struct
+-- !query output
+spark.sql.groupByOrdinal false
+
+
+-- !query
+select sum(b) from data group by -1
+-- !query schema
+struct
+-- !query output
+9
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/group-by.sql.out b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/group-by.sql.out
new file mode 100644
index 000000000000..a4a3f76fa6a7
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/group-by.sql.out
@@ -0,0 +1,1123 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (null, 1), (3, null), (null, null)
+AS testData(a, b)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT a, COUNT(b) FROM testData
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_GROUP_BY",
+ "sqlState" : "42803",
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 32,
+ "fragment" : "SELECT a, COUNT(b) FROM testData"
+ } ]
+}
+
+
+-- !query
+SELECT COUNT(a), COUNT(b) FROM testData
+-- !query schema
+struct
+-- !query output
+7 7
+
+
+-- !query
+SELECT a, COUNT(b) FROM testData GROUP BY a
+-- !query schema
+struct
+-- !query output
+1 2
+2 2
+3 2
+NULL 1
+
+
+-- !query
+SELECT a, COUNT(b) FROM testData GROUP BY b
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_AGGREGATION",
+ "sqlState" : "42803",
+ "messageParameters" : {
+ "expression" : "\"a\"",
+ "expressionAnyValue" : "\"any_value(a)\""
+ }
+}
+
+
+-- !query
+SELECT COUNT(a), COUNT(b) FROM testData GROUP BY a
+-- !query schema
+struct
+-- !query output
+0 1
+2 2
+2 2
+3 2
+
+
+-- !query
+SELECT 'foo', COUNT(a) FROM testData GROUP BY 1
+-- !query schema
+struct
+-- !query output
+foo 7
+
+
+-- !query
+SELECT 'foo' FROM testData WHERE a = 0 GROUP BY 1
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+SELECT 'foo', APPROX_COUNT_DISTINCT(a) FROM testData WHERE a = 0 GROUP BY 1
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+SELECT 'foo', MAX(STRUCT(a)) FROM testData WHERE a = 0 GROUP BY 1
+-- !query schema
+struct>
+-- !query output
+
+
+
+-- !query
+SELECT a + b, COUNT(b) FROM testData GROUP BY a + b
+-- !query schema
+struct<(a + b):int,count(b):bigint>
+-- !query output
+2 1
+3 2
+4 2
+5 1
+NULL 1
+
+
+-- !query
+SELECT a + 2, COUNT(b) FROM testData GROUP BY a + 1
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_AGGREGATION",
+ "sqlState" : "42803",
+ "messageParameters" : {
+ "expression" : "\"a\"",
+ "expressionAnyValue" : "\"any_value(a)\""
+ }
+}
+
+
+-- !query
+SELECT a + 1 + 1, COUNT(b) FROM testData GROUP BY a + 1
+-- !query schema
+struct<((a + 1) + 1):int,count(b):bigint>
+-- !query output
+3 2
+4 2
+5 2
+NULL 1
+
+
+-- !query
+SELECT count(1) FROM testData GROUP BY struct(a + 0.1 AS aa)
+-- !query schema
+struct
+-- !query output
+2
+2
+2
+3
+
+
+-- !query
+SELECT SKEWNESS(a), KURTOSIS(a), MIN(a), MAX(a), AVG(a), VARIANCE(a), STDDEV(a), SUM(a), COUNT(a)
+FROM testData
+-- !query schema
+struct
+-- !query output
+-0.27238010581457284 -1.5069204152249138 1 3 2.142857142857143 0.8095238095238096 0.8997354108424375 15 7
+
+
+-- !query
+SELECT COUNT(DISTINCT b), COUNT(DISTINCT b, c) FROM (SELECT 1 AS a, 2 AS b, 3 AS c) GROUP BY a
+-- !query schema
+struct
+-- !query output
+1 1
+
+
+-- !query
+SELECT a AS k, COUNT(b) FROM testData GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 2
+2 2
+3 2
+NULL 1
+
+
+-- !query
+SELECT a AS k, COUNT(b) FROM testData GROUP BY k HAVING k > 1
+-- !query schema
+struct
+-- !query output
+2 2
+3 2
+
+
+-- !query
+SELECT a AS k, COUNT(non_existing) FROM testData GROUP BY k
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ "sqlState" : "42703",
+ "messageParameters" : {
+ "objectName" : "`non_existing`",
+ "proposal" : "`testdata`.`a`, `testdata`.`b`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 22,
+ "stopIndex" : 33,
+ "fragment" : "non_existing"
+ } ]
+}
+
+
+-- !query
+SELECT COUNT(b) AS k FROM testData GROUP BY k
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_AGGREGATE",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "sqlExpr" : "count(testdata.b)"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 15,
+ "fragment" : "COUNT(b)"
+ } ]
+}
+
+
+-- !query
+CREATE OR REPLACE TEMPORARY VIEW testDataHasSameNameWithAlias AS SELECT * FROM VALUES
+(1, 1, 3), (1, 2, 1) AS testDataHasSameNameWithAlias(k, a, v)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT k AS a, COUNT(v) FROM testDataHasSameNameWithAlias GROUP BY a
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_AGGREGATION",
+ "sqlState" : "42803",
+ "messageParameters" : {
+ "expression" : "\"k\"",
+ "expressionAnyValue" : "\"any_value(k)\""
+ }
+}
+
+
+-- !query
+set spark.sql.groupByAliases=false
+-- !query schema
+struct
+-- !query output
+spark.sql.groupByAliases false
+
+
+-- !query
+SELECT a AS k, COUNT(b) FROM testData GROUP BY k
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ "sqlState" : "42703",
+ "messageParameters" : {
+ "objectName" : "`k`",
+ "proposal" : "`testdata`.`a`, `testdata`.`b`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 48,
+ "stopIndex" : 48,
+ "fragment" : "k"
+ } ]
+}
+
+
+-- !query
+SELECT a, COUNT(1) FROM testData WHERE false GROUP BY a
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+SELECT COUNT(1) FROM testData WHERE false
+-- !query schema
+struct
+-- !query output
+0
+
+
+-- !query
+SELECT 1 FROM (SELECT COUNT(1) FROM testData WHERE false) t
+-- !query schema
+struct<1:int>
+-- !query output
+1
+
+
+-- !query
+SELECT 1 from (
+ SELECT 1 AS z,
+ MIN(a.x)
+ FROM (select 1 as x) a
+ WHERE false
+) b
+where b.z != b.z
+-- !query schema
+struct<1:int>
+-- !query output
+
+
+
+-- !query
+SELECT corr(DISTINCT x, y), corr(DISTINCT y, x), count(*)
+ FROM (VALUES (1, 1), (2, 2), (2, 2)) t(x, y)
+-- !query schema
+struct
+-- !query output
+0.9999999999999999 0.9999999999999999 3
+
+
+-- !query
+SELECT 1 FROM range(10) HAVING true
+-- !query schema
+struct<1:int>
+-- !query output
+1
+
+
+-- !query
+SELECT 1 FROM range(10) HAVING MAX(id) > 0
+-- !query schema
+struct<1:int>
+-- !query output
+1
+
+
+-- !query
+SELECT id FROM range(10) HAVING id > 0
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_GROUP_BY",
+ "sqlState" : "42803",
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 38,
+ "fragment" : "SELECT id FROM range(10) HAVING id > 0"
+ } ]
+}
+
+
+-- !query
+SET spark.sql.legacy.parser.havingWithoutGroupByAsWhere=true
+-- !query schema
+struct
+-- !query output
+spark.sql.legacy.parser.havingWithoutGroupByAsWhere true
+
+
+-- !query
+SELECT 1 FROM range(10) HAVING true
+-- !query schema
+struct<1:int>
+-- !query output
+1
+1
+1
+1
+1
+1
+1
+1
+1
+1
+
+
+-- !query
+SELECT 1 FROM range(10) HAVING MAX(id) > 0
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "INVALID_WHERE_CONDITION",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "condition" : "\"(max(id) > 0)\"",
+ "expressionList" : "max(id)"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 42,
+ "fragment" : "SELECT 1 FROM range(10) HAVING MAX(id) > 0"
+ } ]
+}
+
+
+-- !query
+SELECT id FROM range(10) HAVING id > 0
+-- !query schema
+struct
+-- !query output
+1
+2
+3
+4
+5
+6
+7
+8
+9
+
+
+-- !query
+SET spark.sql.legacy.parser.havingWithoutGroupByAsWhere=false
+-- !query schema
+struct
+-- !query output
+spark.sql.legacy.parser.havingWithoutGroupByAsWhere false
+
+
+-- !query
+CREATE OR REPLACE TEMPORARY VIEW test_agg AS SELECT * FROM VALUES
+ (1, true), (1, false),
+ (2, true),
+ (3, false), (3, null),
+ (4, null), (4, null),
+ (5, null), (5, true), (5, false) AS test_agg(k, v)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg WHERE 1 = 0
+-- !query schema
+struct
+-- !query output
+NULL NULL NULL NULL NULL
+
+
+-- !query
+SELECT every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg WHERE k = 4
+-- !query schema
+struct
+-- !query output
+NULL NULL NULL NULL NULL
+
+
+-- !query
+SELECT every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg WHERE k = 5
+-- !query schema
+struct
+-- !query output
+false true true false true
+
+
+-- !query
+SELECT k, every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 false true true false true
+2 true true true true true
+3 false false false false false
+4 NULL NULL NULL NULL NULL
+5 false true true false true
+
+
+-- !query
+SELECT k, every(v) FROM test_agg GROUP BY k HAVING every(v) = false
+-- !query schema
+struct
+-- !query output
+1 false
+3 false
+5 false
+
+
+-- !query
+SELECT k, every(v) FROM test_agg GROUP BY k HAVING every(v) IS NULL
+-- !query schema
+struct
+-- !query output
+4 NULL
+
+
+-- !query
+SELECT k,
+ Every(v) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Any(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY k
+-- !query schema
+struct
+-- !query output
+2 true
+
+
+-- !query
+SELECT k,
+ Every(v) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Every(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY k
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+SELECT every(1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"INT\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"every(1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 15,
+ "fragment" : "every(1)"
+ } ]
+}
+
+
+-- !query
+SELECT some(1S)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"SMALLINT\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"some(1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 15,
+ "fragment" : "some(1S)"
+ } ]
+}
+
+
+-- !query
+SELECT any(1L)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"BIGINT\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"any(1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 14,
+ "fragment" : "any(1L)"
+ } ]
+}
+
+
+-- !query
+SELECT every("true")
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"true\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"every(true)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 20,
+ "fragment" : "every(\"true\")"
+ } ]
+}
+
+
+-- !query
+SELECT bool_and(1.0)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1.0\"",
+ "inputType" : "\"DECIMAL(2,1)\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"bool_and(1.0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 20,
+ "fragment" : "bool_and(1.0)"
+ } ]
+}
+
+
+-- !query
+SELECT bool_or(1.0D)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1.0\"",
+ "inputType" : "\"DOUBLE\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"bool_or(1.0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 20,
+ "fragment" : "bool_or(1.0D)"
+ } ]
+}
+
+
+-- !query
+SELECT k, v, every(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg
+-- !query schema
+struct
+-- !query output
+1 false false
+1 true false
+2 true true
+3 NULL NULL
+3 false false
+4 NULL NULL
+4 NULL NULL
+5 NULL NULL
+5 false false
+5 true false
+
+
+-- !query
+SELECT k, v, some(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg
+-- !query schema
+struct
+-- !query output
+1 false false
+1 true true
+2 true true
+3 NULL NULL
+3 false false
+4 NULL NULL
+4 NULL NULL
+5 NULL NULL
+5 false false
+5 true true
+
+
+-- !query
+SELECT k, v, any(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg
+-- !query schema
+struct
+-- !query output
+1 false false
+1 true true
+2 true true
+3 NULL NULL
+3 false false
+4 NULL NULL
+4 NULL NULL
+5 NULL NULL
+5 false false
+5 true true
+
+
+-- !query
+SELECT k, v, bool_and(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg
+-- !query schema
+struct
+-- !query output
+1 false false
+1 true false
+2 true true
+3 NULL NULL
+3 false false
+4 NULL NULL
+4 NULL NULL
+5 NULL NULL
+5 false false
+5 true false
+
+
+-- !query
+SELECT k, v, bool_or(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg
+-- !query schema
+struct
+-- !query output
+1 false false
+1 true true
+2 true true
+3 NULL NULL
+3 false false
+4 NULL NULL
+4 NULL NULL
+5 NULL NULL
+5 false false
+5 true true
+
+
+-- !query
+SELECT count(*) FROM test_agg HAVING count(*) > 1L
+-- !query schema
+struct
+-- !query output
+10
+
+
+-- !query
+SELECT k, max(v) FROM test_agg GROUP BY k HAVING max(v) = true
+-- !query schema
+struct
+-- !query output
+1 true
+2 true
+5 true
+
+
+-- !query
+SELECT * FROM (SELECT COUNT(*) AS cnt FROM test_agg) WHERE cnt > 1L
+-- !query schema
+struct
+-- !query output
+10
+
+
+-- !query
+SELECT count(*) FROM test_agg WHERE count(*) > 1L
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "INVALID_WHERE_CONDITION",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "condition" : "\"(count(1) > 1)\"",
+ "expressionList" : "count(1)"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 49,
+ "fragment" : "SELECT count(*) FROM test_agg WHERE count(*) > 1L"
+ } ]
+}
+
+
+-- !query
+SELECT count(*) FROM test_agg WHERE count(*) + 1L > 1L
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "INVALID_WHERE_CONDITION",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "condition" : "\"((count(1) + 1) > 1)\"",
+ "expressionList" : "count(1)"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 54,
+ "fragment" : "SELECT count(*) FROM test_agg WHERE count(*) + 1L > 1L"
+ } ]
+}
+
+
+-- !query
+SELECT count(*) FROM test_agg WHERE k = 1 or k = 2 or count(*) + 1L > 1L or max(k) > 1
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "INVALID_WHERE_CONDITION",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "condition" : "\"(((k = 1) OR (k = 2)) OR (((count(1) + 1) > 1) OR (max(k) > 1)))\"",
+ "expressionList" : "count(1), max(test_agg.k)"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 86,
+ "fragment" : "SELECT count(*) FROM test_agg WHERE k = 1 or k = 2 or count(*) + 1L > 1L or max(k) > 1"
+ } ]
+}
+
+
+-- !query
+SELECT AVG(DISTINCT decimal_col), SUM(DISTINCT decimal_col) FROM VALUES (CAST(1 AS DECIMAL(9, 0))) t(decimal_col)
+-- !query schema
+struct
+-- !query output
+1.0000 1
+
+
+-- !query
+SELECT not(a IS NULL), count(*) AS c
+FROM testData
+GROUP BY a IS NULL
+-- !query schema
+struct<(NOT (a IS NULL)):boolean,c:bigint>
+-- !query output
+false 2
+true 7
+
+
+-- !query
+SELECT if(not(a IS NULL), rand(0), 1), count(*) AS c
+FROM testData
+GROUP BY a IS NULL
+-- !query schema
+struct<(IF((NOT (a IS NULL)), rand(0), 1)):double,c:bigint>
+-- !query output
+0.5488135024422883 7
+1.0 2
+
+
+-- !query
+SELECT
+ histogram_numeric(col, 2) as histogram_2,
+ histogram_numeric(col, 3) as histogram_3,
+ histogram_numeric(col, 5) as histogram_5,
+ histogram_numeric(col, 10) as histogram_10
+FROM VALUES
+ (1), (2), (3), (4), (5), (6), (7), (8), (9), (10),
+ (11), (12), (13), (14), (15), (16), (17), (18), (19), (20),
+ (21), (22), (23), (24), (25), (26), (27), (28), (29), (30),
+ (31), (32), (33), (34), (35), (3), (37), (38), (39), (40),
+ (41), (42), (43), (44), (45), (46), (47), (48), (49), (50) AS tab(col)
+-- !query schema
+struct>,histogram_3:array>,histogram_5:array>,histogram_10:array>>
+-- !query output
+[{"x":12,"y":26.0},{"x":38,"y":24.0}] [{"x":9,"y":20.0},{"x":25,"y":11.0},{"x":40,"y":19.0}] [{"x":5,"y":11.0},{"x":14,"y":8.0},{"x":22,"y":7.0},{"x":30,"y":10.0},{"x":43,"y":14.0}] [{"x":3,"y":6.0},{"x":8,"y":6.0},{"x":13,"y":4.0},{"x":17,"y":3.0},{"x":20,"y":4.0},{"x":25,"y":6.0},{"x":31,"y":7.0},{"x":39,"y":5.0},{"x":43,"y":4.0},{"x":48,"y":5.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES (1), (2), (3) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":1,"y":1.0},{"x":2,"y":1.0},{"x":3,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES (1L), (2L), (3L) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":1,"y":1.0},{"x":2,"y":1.0},{"x":3,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES (1F), (2F), (3F) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":1.0,"y":1.0},{"x":2.0,"y":1.0},{"x":3.0,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES (1D), (2D), (3D) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":1.0,"y":1.0},{"x":2.0,"y":1.0},{"x":3.0,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES (1S), (2S), (3S) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":1,"y":1.0},{"x":2,"y":1.0},{"x":3,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS BYTE)), (CAST(2 AS BYTE)), (CAST(3 AS BYTE)) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":1,"y":1.0},{"x":2,"y":1.0},{"x":3,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS TINYINT)), (CAST(2 AS TINYINT)), (CAST(3 AS TINYINT)) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":1,"y":1.0},{"x":2,"y":1.0},{"x":3,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS SMALLINT)), (CAST(2 AS SMALLINT)), (CAST(3 AS SMALLINT)) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":1,"y":1.0},{"x":2,"y":1.0},{"x":3,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS BIGINT)), (CAST(2 AS BIGINT)), (CAST(3 AS BIGINT)) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":1,"y":1.0},{"x":2,"y":1.0},{"x":3,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES (TIMESTAMP '2017-03-01 00:00:00'),
+ (TIMESTAMP '2017-04-01 00:00:00'), (TIMESTAMP '2017-05-01 00:00:00') AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":2017-03-01 00:00:00,"y":1.0},{"x":2017-04-01 00:00:00,"y":1.0},{"x":2017-05-01 00:00:00,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES (INTERVAL '100-00' YEAR TO MONTH),
+ (INTERVAL '110-00' YEAR TO MONTH), (INTERVAL '120-00' YEAR TO MONTH) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":100-0,"y":1.0},{"x":110-0,"y":1.0},{"x":120-0,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3) FROM VALUES (INTERVAL '12 20:4:0' DAY TO SECOND),
+ (INTERVAL '12 21:4:0' DAY TO SECOND), (INTERVAL '12 22:4:0' DAY TO SECOND) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+[{"x":12 20:04:00.000000000,"y":1.0},{"x":12 21:04:00.000000000,"y":1.0},{"x":12 22:04:00.000000000,"y":1.0}]
+
+
+-- !query
+SELECT histogram_numeric(col, 3)
+FROM VALUES (NULL), (NULL), (NULL) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+NULL
+
+
+-- !query
+SELECT histogram_numeric(col, 3)
+FROM VALUES (CAST(NULL AS DOUBLE)), (CAST(NULL AS DOUBLE)), (CAST(NULL AS DOUBLE)) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+NULL
+
+
+-- !query
+SELECT histogram_numeric(col, 3)
+FROM VALUES (CAST(NULL AS INT)), (CAST(NULL AS INT)), (CAST(NULL AS INT)) AS tab(col)
+-- !query schema
+struct>>
+-- !query output
+NULL
+
+
+-- !query
+SELECT
+ collect_list(col),
+ array_agg(col)
+FROM VALUES
+ (1), (2), (1) AS tab(col)
+-- !query schema
+struct,collect_list(col):array>
+-- !query output
+[1,2,1] [1,2,1]
+
+
+-- !query
+SELECT
+ a,
+ collect_list(b),
+ array_agg(b)
+FROM VALUES
+ (1,4),(2,3),(1,4),(2,4) AS v(a,b)
+GROUP BY a
+-- !query schema
+struct,collect_list(b):array>
+-- !query output
+1 [4,4] [4,4]
+2 [3,4] [3,4]
+
+
+-- !query
+SELECT mode(a), mode(b) FROM testData
+-- !query schema
+struct
+-- !query output
+3 1
+
+
+-- !query
+SELECT a, mode(b) FROM testData GROUP BY a ORDER BY a
+-- !query schema
+struct
+-- !query output
+NULL 1
+1 1
+2 1
+3 1
+
+
+-- !query
+SELECT c * 2 AS d
+FROM (
+ SELECT if(b > 1, 1, b) AS c
+ FROM (
+ SELECT if(a < 0, 0, a) AS b
+ FROM VALUES (-1), (1), (2) AS t1(a)
+ ) t2
+ GROUP BY b
+ ) t3
+GROUP BY c
+-- !query schema
+struct
+-- !query output
+0
+2
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/linear-regression.sql.out b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/linear-regression.sql.out
new file mode 100644
index 000000000000..a73347a2f7f5
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/linear-regression.sql.out
@@ -0,0 +1,276 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+CREATE OR REPLACE TEMPORARY VIEW testRegression AS SELECT * FROM VALUES
+(1, 10, null), (2, 10, 11), (2, 20, 22), (2, 25, null), (2, 30, 35)
+AS testRegression(k, y, x)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT regr_count(y, x) FROM testRegression
+-- !query schema
+struct
+-- !query output
+3
+
+
+-- !query
+SELECT regr_count(y, x) FROM testRegression WHERE x IS NOT NULL
+-- !query schema
+struct
+-- !query output
+3
+
+
+-- !query
+SELECT k, count(*), regr_count(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 1 0
+2 4 3
+
+
+-- !query
+SELECT k, count(*) FILTER (WHERE x IS NOT NULL), regr_count(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 0 0
+2 3 3
+
+
+-- !query
+SELECT regr_r2(y, x) FROM testRegression
+-- !query schema
+struct
+-- !query output
+0.9976905311778291
+
+
+-- !query
+SELECT regr_r2(y, x) FROM testRegression WHERE x IS NOT NULL
+-- !query schema
+struct
+-- !query output
+0.9976905311778291
+
+
+-- !query
+SELECT k, corr(y, x), regr_r2(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 NULL NULL
+2 0.9988445981121532 0.9976905311778291
+
+
+-- !query
+SELECT k, corr(y, x) FILTER (WHERE x IS NOT NULL), regr_r2(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 NULL NULL
+2 0.9988445981121532 0.9976905311778291
+
+
+-- !query
+SELECT regr_avgx(y, x), regr_avgy(y, x) FROM testRegression
+-- !query schema
+struct
+-- !query output
+22.666666666666668 20.0
+
+
+-- !query
+SELECT regr_avgx(y, x), regr_avgy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL
+-- !query schema
+struct
+-- !query output
+22.666666666666668 20.0
+
+
+-- !query
+SELECT k, avg(x), avg(y), regr_avgx(y, x), regr_avgy(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 NULL 10.0 NULL NULL
+2 22.666666666666668 21.25 22.666666666666668 20.0
+
+
+-- !query
+SELECT k, avg(x) FILTER (WHERE x IS NOT NULL AND y IS NOT NULL), avg(y) FILTER (WHERE x IS NOT NULL AND y IS NOT NULL), regr_avgx(y, x), regr_avgy(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 NULL NULL NULL NULL
+2 22.666666666666668 20.0 22.666666666666668 20.0
+
+
+-- !query
+SELECT regr_sxx(y, x) FROM testRegression
+-- !query schema
+struct
+-- !query output
+288.66666666666663
+
+
+-- !query
+SELECT regr_sxx(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL
+-- !query schema
+struct
+-- !query output
+288.66666666666663
+
+
+-- !query
+SELECT k, regr_sxx(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 NULL
+2 288.66666666666663
+
+
+-- !query
+SELECT k, regr_sxx(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k
+-- !query schema
+struct
+-- !query output
+2 288.66666666666663
+
+
+-- !query
+SELECT regr_sxy(y, x) FROM testRegression
+-- !query schema
+struct
+-- !query output
+240.0
+
+
+-- !query
+SELECT regr_sxy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL
+-- !query schema
+struct
+-- !query output
+240.0
+
+
+-- !query
+SELECT k, regr_sxy(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 NULL
+2 240.0
+
+
+-- !query
+SELECT k, regr_sxy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k
+-- !query schema
+struct
+-- !query output
+2 240.0
+
+
+-- !query
+SELECT regr_syy(y, x) FROM testRegression
+-- !query schema
+struct
+-- !query output
+200.0
+
+
+-- !query
+SELECT regr_syy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL
+-- !query schema
+struct
+-- !query output
+200.0
+
+
+-- !query
+SELECT k, regr_syy(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 NULL
+2 200.0
+
+
+-- !query
+SELECT k, regr_syy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k
+-- !query schema
+struct
+-- !query output
+2 200.0
+
+
+-- !query
+SELECT regr_slope(y, x) FROM testRegression
+-- !query schema
+struct
+-- !query output
+0.8314087759815244
+
+
+-- !query
+SELECT regr_slope(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL
+-- !query schema
+struct
+-- !query output
+0.8314087759815244
+
+
+-- !query
+SELECT k, regr_slope(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 NULL
+2 0.8314087759815244
+
+
+-- !query
+SELECT k, regr_slope(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k
+-- !query schema
+struct
+-- !query output
+2 0.8314087759815244
+
+
+-- !query
+SELECT regr_intercept(y, x) FROM testRegression
+-- !query schema
+struct
+-- !query output
+1.1547344110854487
+
+
+-- !query
+SELECT regr_intercept(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL
+-- !query schema
+struct
+-- !query output
+1.1547344110854487
+
+
+-- !query
+SELECT k, regr_intercept(y, x) FROM testRegression GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 NULL
+2 1.1547344110854487
+
+
+-- !query
+SELECT k, regr_intercept(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k
+-- !query schema
+struct
+-- !query output
+2 1.1547344110854487
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/misc-functions.sql.out b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/misc-functions.sql.out
new file mode 100644
index 000000000000..d6d1289a5adb
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/misc-functions.sql.out
@@ -0,0 +1,134 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+select typeof(null)
+-- !query schema
+struct
+-- !query output
+void
+
+
+-- !query
+select typeof(true)
+-- !query schema
+struct
+-- !query output
+boolean
+
+
+-- !query
+select typeof(1Y), typeof(1S), typeof(1), typeof(1L)
+-- !query schema
+struct
+-- !query output
+tinyint smallint int bigint
+
+
+-- !query
+select typeof(cast(1.0 as float)), typeof(1.0D), typeof(1.2)
+-- !query schema
+struct
+-- !query output
+float double decimal(2,1)
+
+
+-- !query
+select typeof(date '1986-05-23'), typeof(timestamp '1986-05-23'), typeof(interval '23 days')
+-- !query schema
+struct
+-- !query output
+date timestamp interval day
+
+
+-- !query
+select typeof(x'ABCD'), typeof('SPARK')
+-- !query schema
+struct
+-- !query output
+binary string
+
+
+-- !query
+select typeof(array(1, 2)), typeof(map(1, 2)), typeof(named_struct('a', 1, 'b', 'spark'))
+-- !query schema
+struct
+-- !query output
+array map struct
+
+
+-- !query
+SELECT assert_true(true), assert_true(boolean(1))
+-- !query schema
+struct
+-- !query output
+NULL NULL
+
+
+-- !query
+SELECT assert_true(false)
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+'false' is not true!
+
+
+-- !query
+SELECT assert_true(boolean(0))
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+'cast(0 as boolean)' is not true!
+
+
+-- !query
+SELECT assert_true(null)
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+'null' is not true!
+
+
+-- !query
+SELECT assert_true(boolean(null))
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+'cast(null as boolean)' is not true!
+
+
+-- !query
+SELECT assert_true(false, 'custom error message')
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+custom error message
+
+
+-- !query
+CREATE TEMPORARY VIEW tbl_misc AS SELECT * FROM (VALUES (1), (8), (2)) AS T(v)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT raise_error('error message')
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+error message
+
+
+-- !query
+SELECT if(v > 5, raise_error('too big: ' || v), v + 1) FROM tbl_misc
+-- !query schema
+struct<>
+-- !query output
+org.apache.gluten.exception.GlutenException
+too big: 8
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/random.sql.out b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/random.sql.out
new file mode 100644
index 000000000000..17e6f871b9c5
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/random.sql.out
@@ -0,0 +1,115 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+SELECT rand(0)
+-- !query schema
+struct
+-- !query output
+0.5488135024422883
+
+
+-- !query
+SELECT rand(cast(3 / 7 AS int))
+-- !query schema
+struct
+-- !query output
+0.5488135024422883
+
+
+-- !query
+SELECT rand(NULL)
+-- !query schema
+struct
+-- !query output
+0.5488135024422883
+
+
+-- !query
+SELECT rand(cast(NULL AS int))
+-- !query schema
+struct
+-- !query output
+0.5488135024422883
+
+
+-- !query
+SELECT rand(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" : "1",
+ "requiredType" : "(\"INT\" or \"BIGINT\")",
+ "sqlExpr" : "\"rand(1.0)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 16,
+ "fragment" : "rand(1.0)"
+ } ]
+}
+
+
+-- !query
+SELECT randn(0L)
+-- !query schema
+struct
+-- !query output
+1.6034991609278433
+
+
+-- !query
+SELECT randn(cast(3 / 7 AS long))
+-- !query schema
+struct
+-- !query output
+1.6034991609278433
+
+
+-- !query
+SELECT randn(NULL)
+-- !query schema
+struct
+-- !query output
+1.6034991609278433
+
+
+-- !query
+SELECT randn(cast(NULL AS long))
+-- !query schema
+struct
+-- !query output
+1.6034991609278433
+
+
+-- !query
+SELECT rand('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" : "1",
+ "requiredType" : "(\"INT\" or \"BIGINT\")",
+ "sqlExpr" : "\"rand(1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 16,
+ "fragment" : "rand('1')"
+ } ]
+}
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/table-valued-functions.sql.out b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/table-valued-functions.sql.out
new file mode 100644
index 000000000000..0d5675fa6fde
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/table-valued-functions.sql.out
@@ -0,0 +1,1017 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+select * from dummy(3)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "UNRESOLVABLE_TABLE_VALUED_FUNCTION",
+ "messageParameters" : {
+ "name" : "`dummy`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 22,
+ "fragment" : "dummy(3)"
+ } ]
+}
+
+
+-- !query
+select * from range(6 + cos(3))
+-- !query schema
+struct
+-- !query output
+0
+1
+2
+3
+4
+
+
+-- !query
+select * from range(5, 10)
+-- !query schema
+struct
+-- !query output
+5
+6
+7
+8
+9
+
+
+-- !query
+select * from range(0, 10, 2)
+-- !query schema
+struct
+-- !query output
+0
+2
+4
+6
+8
+
+
+-- !query
+select * from range(0, 10, 1, 200)
+-- !query schema
+struct
+-- !query output
+0
+1
+2
+3
+4
+5
+6
+7
+8
+9
+
+
+-- !query
+select * from range(1, 1, 1, 1, 1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION",
+ "sqlState" : "42605",
+ "messageParameters" : {
+ "actualNum" : "5",
+ "docroot" : "https://spark.apache.org/docs/latest",
+ "expectedNum" : "[1, 2, 3, 4]",
+ "functionName" : "`range`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 34,
+ "fragment" : "range(1, 1, 1, 1, 1)"
+ } ]
+}
+
+
+-- !query
+select * from range(1, null)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "functionName" : "`range`",
+ "inputSql" : "\"NULL\"",
+ "inputType" : "\"VOID\"",
+ "paramIndex" : "2",
+ "requiredType" : "\"BIGINT\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 28,
+ "fragment" : "range(1, null)"
+ } ]
+}
+
+
+-- !query
+select * from range(array(1, 2, 3))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "functionName" : "`range`",
+ "inputSql" : "\"array(1, 2, 3)\"",
+ "inputType" : "\"ARRAY\"",
+ "paramIndex" : "2",
+ "requiredType" : "\"BIGINT\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 35,
+ "fragment" : "range(array(1, 2, 3))"
+ } ]
+}
+
+
+-- !query
+select * from range(0, 5, 0)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "FAILED_FUNCTION_CALL",
+ "sqlState" : "38000",
+ "messageParameters" : {
+ "funcName" : "`range`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 28,
+ "fragment" : "range(0, 5, 0)"
+ } ]
+}
+
+
+-- !query
+select * from RaNgE(2)
+-- !query schema
+struct
+-- !query output
+0
+1
+
+
+-- !query
+select i from range(0, 2) t(i)
+-- !query schema
+struct
+-- !query output
+0
+1
+
+
+-- !query
+select * from explode(array(1, 2))
+-- !query schema
+struct
+-- !query output
+1
+2
+
+
+-- !query
+select * from explode(map('a', 1, 'b', 2))
+-- !query schema
+struct
+-- !query output
+a 1
+b 2
+
+
+-- !query
+select * from explode(array())
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+select * from explode(map())
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+select * from explode(array(1, 2)) t(c1)
+-- !query schema
+struct
+-- !query output
+1
+2
+
+
+-- !query
+select * from explode(map('a', 1, 'b', 2)) t(k, v)
+-- !query schema
+struct
+-- !query output
+a 1
+b 2
+
+
+-- !query
+select * from explode(array(rand(0)))
+-- !query schema
+struct
+-- !query output
+0.5488135024422883
+
+
+-- !query
+select * from explode(null)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"NULL\"",
+ "inputType" : "\"VOID\"",
+ "paramIndex" : "1",
+ "requiredType" : "(\"ARRAY\" or \"MAP\")",
+ "sqlExpr" : "\"explode(NULL)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 27,
+ "fragment" : "explode(null)"
+ } ]
+}
+
+
+-- !query
+select * from explode(null) t(c1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"NULL\"",
+ "inputType" : "\"VOID\"",
+ "paramIndex" : "1",
+ "requiredType" : "(\"ARRAY\" or \"MAP\")",
+ "sqlExpr" : "\"explode(NULL)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 33,
+ "fragment" : "explode(null) t(c1)"
+ } ]
+}
+
+
+-- !query
+select * from explode(1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"INT\"",
+ "paramIndex" : "1",
+ "requiredType" : "(\"ARRAY\" or \"MAP\")",
+ "sqlExpr" : "\"explode(1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 24,
+ "fragment" : "explode(1)"
+ } ]
+}
+
+
+-- !query
+select * from explode(1, 2)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION",
+ "sqlState" : "42605",
+ "messageParameters" : {
+ "actualNum" : "2",
+ "docroot" : "https://spark.apache.org/docs/latest",
+ "expectedNum" : "1",
+ "functionName" : "`explode`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 27,
+ "fragment" : "explode(1, 2)"
+ } ]
+}
+
+
+-- !query
+select * from explode(explode(array(1)))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "UNSUPPORTED_GENERATOR.NESTED_IN_EXPRESSIONS",
+ "sqlState" : "0A000",
+ "messageParameters" : {
+ "expression" : "\"explode(explode(array(1)))\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 40,
+ "fragment" : "explode(explode(array(1)))"
+ } ]
+}
+
+
+-- !query
+select * from explode(array(1, 2)) t(c1, c2)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "NUM_TABLE_VALUE_ALIASES_MISMATCH",
+ "messageParameters" : {
+ "aliasesNum" : "2",
+ "funcName" : "`explode`",
+ "outColsNum" : "1"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 44,
+ "fragment" : "explode(array(1, 2)) t(c1, c2)"
+ } ]
+}
+
+
+-- !query
+select * from explode_outer(array(1, 2))
+-- !query schema
+struct
+-- !query output
+1
+2
+
+
+-- !query
+select * from explode_outer(map('a', 1, 'b', 2))
+-- !query schema
+struct
+-- !query output
+a 1
+b 2
+
+
+-- !query
+select * from explode_outer(array())
+-- !query schema
+struct
+-- !query output
+NULL
+
+
+-- !query
+select * from explode_outer(map())
+-- !query schema
+struct
+-- !query output
+NULL NULL
+
+
+-- !query
+select * from range(2) join explode(array(1, 2))
+-- !query schema
+struct
+-- !query output
+0 1
+0 2
+1 1
+1 2
+
+
+-- !query
+select * from range(2) join explode_outer(array())
+-- !query schema
+struct
+-- !query output
+0 NULL
+1 NULL
+
+
+-- !query
+select * from inline(array(struct(1, 'a'), struct(2, 'b')))
+-- !query schema
+struct
+-- !query output
+1 a
+2 b
+
+
+-- !query
+select * from inline(array(struct(1, 'a'), struct(2, 'b'))) t(x, y)
+-- !query schema
+struct
+-- !query output
+1 a
+2 b
+
+
+-- !query
+select * from inline(array_remove(array(struct(1, 'a')), struct(1, 'a')))
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+select * from inline(null)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"NULL\"",
+ "inputType" : "\"VOID\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"ARRAY\"",
+ "sqlExpr" : "\"inline(NULL)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 26,
+ "fragment" : "inline(null)"
+ } ]
+}
+
+
+-- !query
+select * from inline(array(struct(1, 2), struct(2, 3))) t(a, b, c)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "NUM_TABLE_VALUE_ALIASES_MISMATCH",
+ "messageParameters" : {
+ "aliasesNum" : "3",
+ "funcName" : "`inline`",
+ "outColsNum" : "2"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 66,
+ "fragment" : "inline(array(struct(1, 2), struct(2, 3))) t(a, b, c)"
+ } ]
+}
+
+
+-- !query
+select * from inline_outer(array(struct(1, 'a'), struct(2, 'b')))
+-- !query schema
+struct
+-- !query output
+1 a
+2 b
+
+
+-- !query
+select * from inline_outer(array_remove(array(struct(1, 'a')), struct(1, 'a')))
+-- !query schema
+struct
+-- !query output
+NULL NULL
+
+
+-- !query
+select * from posexplode(array())
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+select * from posexplode(array(1, 2))
+-- !query schema
+struct
+-- !query output
+0 1
+1 2
+
+
+-- !query
+select * from posexplode(array(1, 2)) t(pos, x)
+-- !query schema
+struct
+-- !query output
+0 1
+1 2
+
+
+-- !query
+select * from posexplode(map())
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+select * from posexplode(map('a', 1, 'b', 2))
+-- !query schema
+struct
+-- !query output
+0 a 1
+1 b 2
+
+
+-- !query
+select * from posexplode(map('a', 1, 'b', 2)) t(pos, k, v)
+-- !query schema
+struct
+-- !query output
+0 a 1
+1 b 2
+
+
+-- !query
+select * from posexplode(1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"1\"",
+ "inputType" : "\"INT\"",
+ "paramIndex" : "1",
+ "requiredType" : "(\"ARRAY\" or \"MAP\")",
+ "sqlExpr" : "\"posexplode(1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 27,
+ "fragment" : "posexplode(1)"
+ } ]
+}
+
+
+-- !query
+select * from posexplode(1, 2)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION",
+ "sqlState" : "42605",
+ "messageParameters" : {
+ "actualNum" : "2",
+ "docroot" : "https://spark.apache.org/docs/latest",
+ "expectedNum" : "1",
+ "functionName" : "`posexplode`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 30,
+ "fragment" : "posexplode(1, 2)"
+ } ]
+}
+
+
+-- !query
+select * from posexplode(explode(array(1)))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "UNSUPPORTED_GENERATOR.NESTED_IN_EXPRESSIONS",
+ "sqlState" : "0A000",
+ "messageParameters" : {
+ "expression" : "\"posexplode(explode(array(1)))\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 43,
+ "fragment" : "posexplode(explode(array(1)))"
+ } ]
+}
+
+
+-- !query
+select * from posexplode(array(1, 2)) t(x)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "NUM_TABLE_VALUE_ALIASES_MISMATCH",
+ "messageParameters" : {
+ "aliasesNum" : "1",
+ "funcName" : "`posexplode`",
+ "outColsNum" : "2"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 42,
+ "fragment" : "posexplode(array(1, 2)) t(x)"
+ } ]
+}
+
+
+-- !query
+select * from posexplode_outer(array())
+-- !query schema
+struct
+-- !query output
+NULL NULL
+
+
+-- !query
+select * from posexplode_outer(array(1, 2))
+-- !query schema
+struct
+-- !query output
+0 1
+1 2
+
+
+-- !query
+select * from posexplode_outer(map())
+-- !query schema
+struct
+-- !query output
+NULL NULL NULL
+
+
+-- !query
+select * from posexplode_outer(map('a', 1, 'b', 2))
+-- !query schema
+struct
+-- !query output
+0 a 1
+1 b 2
+
+
+-- !query
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'b')
+-- !query schema
+struct
+-- !query output
+1 2
+
+
+-- !query
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'c')
+-- !query schema
+struct
+-- !query output
+1 NULL
+
+
+-- !query
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'a')
+-- !query schema
+struct
+-- !query output
+1 1
+
+
+-- !query
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'b') AS t(x, y)
+-- !query schema
+struct
+-- !query output
+1 2
+
+
+-- !query
+select * from json_tuple('{"a": bad, "b": string}', 'a', 'b')
+-- !query schema
+struct
+-- !query output
+NULL NULL
+
+
+-- !query
+select * from json_tuple()
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION",
+ "sqlState" : "42605",
+ "messageParameters" : {
+ "actualNum" : "0",
+ "docroot" : "https://spark.apache.org/docs/latest",
+ "expectedNum" : "> 1",
+ "functionName" : "`json_tuple`"
+ }
+}
+
+
+-- !query
+select * from json_tuple('{"a": 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" : "> 1",
+ "functionName" : "`json_tuple`"
+ }
+}
+
+
+-- !query
+select * from json_tuple('{"a": 1}', 1)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.NON_STRING_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "funcName" : "`json_tuple`",
+ "sqlExpr" : "\"json_tuple({\"a\": 1}, 1)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 39,
+ "fragment" : "json_tuple('{\"a\": 1}', 1)"
+ } ]
+}
+
+
+-- !query
+select * from json_tuple('{"a": 1}', null)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.NON_STRING_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "funcName" : "`json_tuple`",
+ "sqlExpr" : "\"json_tuple({\"a\": 1}, NULL)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 42,
+ "fragment" : "json_tuple('{\"a\": 1}', null)"
+ } ]
+}
+
+
+-- !query
+select * from json_tuple('{"a": 1, "b": 2}', 'a', 'b') AS t(x)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "NUM_TABLE_VALUE_ALIASES_MISMATCH",
+ "messageParameters" : {
+ "aliasesNum" : "1",
+ "funcName" : "`json_tuple`",
+ "outColsNum" : "2"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 62,
+ "fragment" : "json_tuple('{\"a\": 1, \"b\": 2}', 'a', 'b') AS t(x)"
+ } ]
+}
+
+
+-- !query
+select * from stack(1, 1, 2, 3)
+-- !query schema
+struct
+-- !query output
+1 2 3
+
+
+-- !query
+select * from stack(2, 1, 2, 3)
+-- !query schema
+struct
+-- !query output
+1 2
+3 NULL
+
+
+-- !query
+select * from stack(3, 1, 2, 3) t(x)
+-- !query schema
+struct
+-- !query output
+1
+2
+3
+
+
+-- !query
+select * from stack(4, 1, 2, 3) t(x)
+-- !query schema
+struct
+-- !query output
+1
+2
+3
+NULL
+
+
+-- !query
+select * from stack(2, 1, 1.1, 'a', 2, 2.2, 'b') t(a, b, c)
+-- !query schema
+struct
+-- !query output
+1 1.1 a
+2 2.2 b
+
+
+-- !query
+select * from stack(2, 1, 1.1, null, 2, null, 'b') t(a, b, c)
+-- !query schema
+struct
+-- !query output
+1 1.1 NULL
+2 NULL b
+
+
+-- !query
+select * from stack()
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "WRONG_NUM_ARGS.WITHOUT_SUGGESTION",
+ "sqlState" : "42605",
+ "messageParameters" : {
+ "actualNum" : "0",
+ "docroot" : "https://spark.apache.org/docs/latest",
+ "expectedNum" : "> 1",
+ "functionName" : "`stack`"
+ }
+}
+
+
+-- !query
+select * from stack(2, 1, 2, 3) t(a, b, c)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "NUM_TABLE_VALUE_ALIASES_MISMATCH",
+ "messageParameters" : {
+ "aliasesNum" : "3",
+ "funcName" : "`stack`",
+ "outColsNum" : "2"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 42,
+ "fragment" : "stack(2, 1, 2, 3) t(a, b, c)"
+ } ]
+}
+
+
+-- !query
+select * from stack(2, 1, '1.1', 'a', 2, 2.2, 'b')
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.catalyst.ExtendedAnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.STACK_COLUMN_DIFF_TYPES",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "columnIndex" : "1",
+ "leftParamIndex" : "2",
+ "leftType" : "\"STRING\"",
+ "rightParamIndex" : "5",
+ "rightType" : "\"DECIMAL(2,1)\"",
+ "sqlExpr" : "\"stack(2, 1, 1.1, a, 2, 2.2, b)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 50,
+ "fragment" : "stack(2, 1, '1.1', 'a', 2, 2.2, 'b')"
+ } ]
+}
+
+
+-- !query
+select * from stack(2, explode(array(1, 2, 3)))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "UNSUPPORTED_GENERATOR.NESTED_IN_EXPRESSIONS",
+ "sqlState" : "0A000",
+ "messageParameters" : {
+ "expression" : "\"stack(2, explode(array(1, 2, 3)))\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 15,
+ "stopIndex" : 47,
+ "fragment" : "stack(2, explode(array(1, 2, 3)))"
+ } ]
+}
diff --git a/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/udf/udf-group-by.sql.out b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/udf/udf-group-by.sql.out
new file mode 100644
index 000000000000..d3735acf0f08
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-clickhouse/sql-tests/results/udf/udf-group-by.sql.out
@@ -0,0 +1,689 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (null, 1), (3, null), (null, null)
+AS testData(a, b)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT udf(a), udf(COUNT(b)) FROM testData
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_GROUP_BY",
+ "sqlState" : "42803",
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 42,
+ "fragment" : "SELECT udf(a), udf(COUNT(b)) FROM testData"
+ } ]
+}
+
+
+-- !query
+SELECT COUNT(udf(a)), udf(COUNT(b)) FROM testData
+-- !query schema
+struct
+-- !query output
+7 7
+
+
+-- !query
+SELECT udf(a), COUNT(udf(b)) FROM testData GROUP BY a
+-- !query schema
+struct
+-- !query output
+1 2
+2 2
+3 2
+NULL 1
+
+
+-- !query
+SELECT udf(a), udf(COUNT(udf(b))) FROM testData GROUP BY b
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_AGGREGATION",
+ "sqlState" : "42803",
+ "messageParameters" : {
+ "expression" : "\"a\"",
+ "expressionAnyValue" : "\"any_value(a)\""
+ }
+}
+
+
+-- !query
+SELECT COUNT(udf(a)), COUNT(udf(b)) FROM testData GROUP BY udf(a)
+-- !query schema
+struct
+-- !query output
+0 1
+2 2
+2 2
+3 2
+
+
+-- !query
+SELECT 'foo', COUNT(udf(a)) FROM testData GROUP BY 1
+-- !query schema
+struct
+-- !query output
+foo 7
+
+
+-- !query
+SELECT 'foo' FROM testData WHERE a = 0 GROUP BY udf(1)
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+SELECT 'foo', udf(APPROX_COUNT_DISTINCT(udf(a))) FROM testData WHERE a = 0 GROUP BY udf(1)
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+SELECT 'foo', MAX(STRUCT(udf(a))) FROM testData WHERE a = 0 GROUP BY udf(1)
+-- !query schema
+struct>
+-- !query output
+
+
+
+-- !query
+SELECT udf(a + b), udf(COUNT(b)) FROM testData GROUP BY a + b
+-- !query schema
+struct
+-- !query output
+2 1
+3 2
+4 2
+5 1
+NULL 1
+
+
+-- !query
+SELECT udf(a + 2), udf(COUNT(b)) FROM testData GROUP BY a + 1
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_AGGREGATION",
+ "sqlState" : "42803",
+ "messageParameters" : {
+ "expression" : "\"a\"",
+ "expressionAnyValue" : "\"any_value(a)\""
+ }
+}
+
+
+-- !query
+SELECT udf(a + 1) + 1, udf(COUNT(b)) FROM testData GROUP BY udf(a + 1)
+-- !query schema
+struct<(udf((a + 1)) + 1):int,udf(count(b)):bigint>
+-- !query output
+3 2
+4 2
+5 2
+NULL 1
+
+
+-- !query
+SELECT SKEWNESS(udf(a)), udf(KURTOSIS(a)), udf(MIN(a)), MAX(udf(a)), udf(AVG(udf(a))), udf(VARIANCE(a)), STDDEV(udf(a)), udf(SUM(a)), udf(COUNT(a))
+FROM testData
+-- !query schema
+struct
+-- !query output
+-0.27238010581457284 -1.5069204152249138 1 3 2.142857142857143 0.8095238095238096 0.8997354108424375 15 7
+
+
+-- !query
+SELECT COUNT(DISTINCT udf(b)), udf(COUNT(DISTINCT b, c)) FROM (SELECT 1 AS a, 2 AS b, 3 AS c) GROUP BY udf(a)
+-- !query schema
+struct
+-- !query output
+1 1
+
+
+-- !query
+SELECT udf(a) AS k, COUNT(udf(b)) FROM testData GROUP BY k
+-- !query schema
+struct
+-- !query output
+1 2
+2 2
+3 2
+NULL 1
+
+
+-- !query
+SELECT a AS k, udf(COUNT(b)) FROM testData GROUP BY k HAVING k > 1
+-- !query schema
+struct
+-- !query output
+2 2
+3 2
+
+
+-- !query
+SELECT udf(COUNT(b)) AS k FROM testData GROUP BY k
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "GROUP_BY_AGGREGATE",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "sqlExpr" : "CAST(udf(cast(count(b) as string)) AS BIGINT)"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 20,
+ "fragment" : "udf(COUNT(b))"
+ } ]
+}
+
+
+-- !query
+CREATE OR REPLACE TEMPORARY VIEW testDataHasSameNameWithAlias AS SELECT * FROM VALUES
+(1, 1, 3), (1, 2, 1) AS testDataHasSameNameWithAlias(k, a, v)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT k AS a, udf(COUNT(udf(v))) FROM testDataHasSameNameWithAlias GROUP BY udf(a)
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_AGGREGATION",
+ "sqlState" : "42803",
+ "messageParameters" : {
+ "expression" : "\"k\"",
+ "expressionAnyValue" : "\"any_value(k)\""
+ }
+}
+
+
+-- !query
+set spark.sql.groupByAliases=false
+-- !query schema
+struct
+-- !query output
+spark.sql.groupByAliases false
+
+
+-- !query
+SELECT a AS k, udf(COUNT(udf(b))) FROM testData GROUP BY k
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "UNRESOLVED_COLUMN.WITH_SUGGESTION",
+ "sqlState" : "42703",
+ "messageParameters" : {
+ "objectName" : "`k`",
+ "proposal" : "`testdata`.`a`, `testdata`.`b`"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 58,
+ "stopIndex" : 58,
+ "fragment" : "k"
+ } ]
+}
+
+
+-- !query
+SELECT udf(a), COUNT(udf(1)) FROM testData WHERE false GROUP BY udf(a)
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+SELECT udf(COUNT(1)) FROM testData WHERE false
+-- !query schema
+struct
+-- !query output
+0
+
+
+-- !query
+SELECT 1 FROM (SELECT udf(COUNT(1)) FROM testData WHERE false) t
+-- !query schema
+struct<1:int>
+-- !query output
+1
+
+
+-- !query
+SELECT 1 from (
+ SELECT 1 AS z,
+ udf(MIN(a.x))
+ FROM (select 1 as x) a
+ WHERE false
+) b
+where b.z != b.z
+-- !query schema
+struct<1:int>
+-- !query output
+
+
+
+-- !query
+SELECT corr(DISTINCT x, y), udf(corr(DISTINCT y, x)), count(*)
+ FROM (VALUES (1, 1), (2, 2), (2, 2)) t(x, y)
+-- !query schema
+struct
+-- !query output
+0.9999999999999999 0.9999999999999999 3
+
+
+-- !query
+SELECT udf(1) FROM range(10) HAVING true
+-- !query schema
+struct
+-- !query output
+1
+
+
+-- !query
+SELECT udf(udf(1)) FROM range(10) HAVING MAX(id) > 0
+-- !query schema
+struct
+-- !query output
+1
+
+
+-- !query
+SELECT udf(id) FROM range(10) HAVING id > 0
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "MISSING_GROUP_BY",
+ "sqlState" : "42803",
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 43,
+ "fragment" : "SELECT udf(id) FROM range(10) HAVING id > 0"
+ } ]
+}
+
+
+-- !query
+CREATE OR REPLACE TEMPORARY VIEW test_agg AS SELECT * FROM VALUES
+ (1, true), (1, false),
+ (2, true),
+ (3, false), (3, null),
+ (4, null), (4, null),
+ (5, null), (5, true), (5, false) AS test_agg(k, v)
+-- !query schema
+struct<>
+-- !query output
+
+
+
+-- !query
+SELECT udf(every(v)), udf(some(v)), any(v) FROM test_agg WHERE 1 = 0
+-- !query schema
+struct
+-- !query output
+NULL NULL NULL
+
+
+-- !query
+SELECT udf(every(udf(v))), some(v), any(v) FROM test_agg WHERE k = 4
+-- !query schema
+struct
+-- !query output
+NULL NULL NULL
+
+
+-- !query
+SELECT every(v), udf(some(v)), any(v) FROM test_agg WHERE k = 5
+-- !query schema
+struct
+-- !query output
+false true true
+
+
+-- !query
+SELECT udf(k), every(v), udf(some(v)), any(v) FROM test_agg GROUP BY udf(k)
+-- !query schema
+struct
+-- !query output
+1 false true true
+2 true true true
+3 false false false
+4 NULL NULL NULL
+5 false true true
+
+
+-- !query
+SELECT udf(k), every(v) FROM test_agg GROUP BY k HAVING every(v) = false
+-- !query schema
+struct
+-- !query output
+1 false
+3 false
+5 false
+
+
+-- !query
+SELECT udf(k), udf(every(v)) FROM test_agg GROUP BY udf(k) HAVING every(v) IS NULL
+-- !query schema
+struct
+-- !query output
+4 NULL
+
+
+-- !query
+SELECT udf(k),
+ udf(Every(v)) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Any(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY udf(k)
+-- !query schema
+struct
+-- !query output
+2 true
+
+
+-- !query
+SELECT udf(udf(k)),
+ Every(v) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Every(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY udf(udf(k))
+-- !query schema
+struct
+-- !query output
+
+
+
+-- !query
+SELECT every(udf(1))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"udf(1)\"",
+ "inputType" : "\"INT\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"every(udf(1))\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 20,
+ "fragment" : "every(udf(1))"
+ } ]
+}
+
+
+-- !query
+SELECT some(udf(1S))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"udf(1)\"",
+ "inputType" : "\"SMALLINT\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"some(udf(1))\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 20,
+ "fragment" : "some(udf(1S))"
+ } ]
+}
+
+
+-- !query
+SELECT any(udf(1L))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"udf(1)\"",
+ "inputType" : "\"BIGINT\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"any(udf(1))\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 8,
+ "stopIndex" : 19,
+ "fragment" : "any(udf(1L))"
+ } ]
+}
+
+
+-- !query
+SELECT udf(every("true"))
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "DATATYPE_MISMATCH.UNEXPECTED_INPUT_TYPE",
+ "sqlState" : "42K09",
+ "messageParameters" : {
+ "inputSql" : "\"true\"",
+ "inputType" : "\"STRING\"",
+ "paramIndex" : "1",
+ "requiredType" : "\"BOOLEAN\"",
+ "sqlExpr" : "\"every(true)\""
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 12,
+ "stopIndex" : 24,
+ "fragment" : "every(\"true\")"
+ } ]
+}
+
+
+-- !query
+SELECT k, v, every(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg
+-- !query schema
+struct
+-- !query output
+1 false false
+1 true false
+2 true true
+3 NULL NULL
+3 false false
+4 NULL NULL
+4 NULL NULL
+5 NULL NULL
+5 false false
+5 true false
+
+
+-- !query
+SELECT k, udf(udf(v)), some(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg
+-- !query schema
+struct
+-- !query output
+1 false false
+1 true true
+2 true true
+3 NULL NULL
+3 false false
+4 NULL NULL
+4 NULL NULL
+5 NULL NULL
+5 false false
+5 true true
+
+
+-- !query
+SELECT udf(udf(k)), v, any(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg
+-- !query schema
+struct
+-- !query output
+1 false false
+1 true true
+2 true true
+3 NULL NULL
+3 false false
+4 NULL NULL
+4 NULL NULL
+5 NULL NULL
+5 false false
+5 true true
+
+
+-- !query
+SELECT udf(count(*)) FROM test_agg HAVING count(*) > 1L
+-- !query schema
+struct
+-- !query output
+10
+
+
+-- !query
+SELECT k, udf(max(v)) FROM test_agg GROUP BY k HAVING max(v) = true
+-- !query schema
+struct
+-- !query output
+1 true
+2 true
+5 true
+
+
+-- !query
+SELECT * FROM (SELECT udf(COUNT(*)) AS cnt FROM test_agg) WHERE cnt > 1L
+-- !query schema
+struct
+-- !query output
+10
+
+
+-- !query
+SELECT udf(count(*)) FROM test_agg WHERE count(*) > 1L
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "INVALID_WHERE_CONDITION",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "condition" : "\"(count(1) > 1)\"",
+ "expressionList" : "count(1)"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 54,
+ "fragment" : "SELECT udf(count(*)) FROM test_agg WHERE count(*) > 1L"
+ } ]
+}
+
+
+-- !query
+SELECT udf(count(*)) FROM test_agg WHERE count(*) + 1L > 1L
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "INVALID_WHERE_CONDITION",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "condition" : "\"((count(1) + 1) > 1)\"",
+ "expressionList" : "count(1)"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 59,
+ "fragment" : "SELECT udf(count(*)) FROM test_agg WHERE count(*) + 1L > 1L"
+ } ]
+}
+
+
+-- !query
+SELECT udf(count(*)) FROM test_agg WHERE k = 1 or k = 2 or count(*) + 1L > 1L or max(k) > 1
+-- !query schema
+struct<>
+-- !query output
+org.apache.spark.sql.AnalysisException
+{
+ "errorClass" : "INVALID_WHERE_CONDITION",
+ "sqlState" : "42903",
+ "messageParameters" : {
+ "condition" : "\"(((k = 1) OR (k = 2)) OR (((count(1) + 1) > 1) OR (max(k) > 1)))\"",
+ "expressionList" : "count(1), max(test_agg.k)"
+ },
+ "queryContext" : [ {
+ "objectType" : "",
+ "objectName" : "",
+ "startIndex" : 1,
+ "stopIndex" : 91,
+ "fragment" : "SELECT udf(count(*)) FROM test_agg WHERE k = 1 or k = 2 or count(*) + 1L > 1L or max(k) > 1"
+ } ]
+}
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/array.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/array.sql
new file mode 100644
index 000000000000..865dc8bac4ea
--- /dev/null
+++ b/gluten-ut/spark41/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), 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), 'a');
+select array_append(CAST(null AS ARRAY), CAST(null as String));
+select array_append(array(), 1);
+select array_append(CAST(array() AS ARRAY), 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), 'a');
+select array_prepend(CAST(null AS ARRAY), CAST(null as String));
+select array_prepend(array(), 1);
+select array_prepend(CAST(array() AS ARRAY), 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/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary.sql
new file mode 100644
index 000000000000..8da97e466341
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary.sql
@@ -0,0 +1,8 @@
+--SET spark.sql.binaryOutputStyle=UTF-8
+
+SELECT X'';
+SELECT X'4561736F6E2059616F20323031382D31312D31373A31333A33333A3333';
+SELECT CAST('Spark' as BINARY);
+SELECT array( X'', X'4561736F6E2059616F20323031382D31312D31373A31333A33333A3333', CAST('Spark' as BINARY));
+SELECT to_csv(named_struct('n', 1, 'info', X'4561736F6E2059616F20323031382D31312D31373A31333A33333A3333'));
+select to_xml(named_struct('name', binary('Eason'), 'birth', 2018, 'org', binary('Kindergarten Cop')));
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_base64.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_base64.sql
new file mode 100644
index 000000000000..853eedd51773
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_base64.sql
@@ -0,0 +1,3 @@
+--IMPORT binary.sql
+
+--SET spark.sql.binaryOutputStyle=BASE64
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_basic.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_basic.sql
new file mode 100644
index 000000000000..1a5b64bdf7e0
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_basic.sql
@@ -0,0 +1,4 @@
+--IMPORT binary.sql
+
+--SET spark.sql.binaryOutputStyle=BASIC
+
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_hex.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_hex.sql
new file mode 100644
index 000000000000..7863da737a72
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_hex.sql
@@ -0,0 +1,3 @@
+--IMPORT binary.sql
+
+--SET spark.sql.binaryOutputStyle=HEX
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_hex_discrete.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_hex_discrete.sql
new file mode 100644
index 000000000000..282a7634cbc5
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/binary_hex_discrete.sql
@@ -0,0 +1,3 @@
+--IMPORT binary.sql
+
+--SET spark.sql.binaryOutputStyle=HEX_DISCRETE
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/bitwise.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/bitwise.sql
new file mode 100644
index 000000000000..e080fdd32a4a
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/bitwise.sql
@@ -0,0 +1,93 @@
+-- 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);
+
+SELECT 20181117 >> 2;
+SELECT 20181117 << 2;
+SELECT 20181117 >>> 2;
+SELECT 20181117 > > 2;
+SELECT 20181117 < < 2;
+SELECT 20181117 > >> 2;
+SELECT 20181117 <<< 2;
+SELECT 20181117 >>>> 2;
+select cast(null as array>), 20181117 >> 2;
+select cast(null as array>), 20181117 >>> 2;
+select cast(null as map>), 20181117 >> 2;
+
+select 1 << 1 + 2 as plus_over_shift; -- if correct, the result is 8. otherwise, 4
+select 2 >> 1 << 1 as left_to_right; -- if correct, the result is 2. otherwise, 0
+select 1 & 2 >> 1 as shift_over_ampersand; -- if correct, the result is 1. otherwise, 0
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cast.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cast.sql
new file mode 100644
index 000000000000..2bf53f9730b3
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cast.sql
@@ -0,0 +1,179 @@
+-- cast string representing a valid fractional number to integral should truncate the number
+SELECT CAST('1.23' AS int);
+SELECT CAST('1.23' AS long);
+SELECT CAST('-4.56' AS int);
+SELECT CAST('-4.56' AS long);
+
+-- cast string which are not numbers to numeric types
+SELECT CAST('abc' AS int);
+SELECT CAST('abc' AS long);
+SELECT CAST('abc' AS float);
+SELECT CAST('abc' AS double);
+
+-- cast string representing a very large number to integral should return null
+SELECT CAST('1234567890123' AS int);
+SELECT CAST('12345678901234567890123' AS long);
+
+-- cast empty string to integral should return null
+SELECT CAST('' AS int);
+SELECT CAST('' AS long);
+SELECT CAST('' AS float);
+SELECT CAST('' AS double);
+
+-- cast null to integral should return null
+SELECT CAST(NULL AS int);
+SELECT CAST(NULL AS long);
+
+-- cast invalid decimal string to numeric types
+SELECT CAST('123.a' AS int);
+SELECT CAST('123.a' AS long);
+SELECT CAST('123.a' AS float);
+SELECT CAST('123.a' AS double);
+
+-- '-2147483648' is the smallest int value
+SELECT CAST('-2147483648' AS int);
+SELECT CAST('-2147483649' AS int);
+
+-- '2147483647' is the largest int value
+SELECT CAST('2147483647' AS int);
+SELECT CAST('2147483648' AS int);
+
+-- '-9223372036854775808' is the smallest long value
+SELECT CAST('-9223372036854775808' AS long);
+SELECT CAST('-9223372036854775809' AS long);
+
+-- '9223372036854775807' is the largest long value
+SELECT CAST('9223372036854775807' AS long);
+SELECT CAST('9223372036854775808' AS long);
+
+-- cast string to its binary representation
+SELECT HEX(CAST('abc' AS binary));
+
+-- cast integral values to their corresponding binary representation
+SELECT HEX(CAST(CAST(123 AS byte) AS binary));
+SELECT HEX(CAST(CAST(-123 AS byte) AS binary));
+SELECT HEX(CAST(123S AS binary));
+SELECT HEX(CAST(-123S AS binary));
+SELECT HEX(CAST(123 AS binary));
+SELECT HEX(CAST(-123 AS binary));
+SELECT HEX(CAST(123L AS binary));
+SELECT HEX(CAST(-123L AS binary));
+
+DESC FUNCTION boolean;
+DESC FUNCTION EXTENDED boolean;
+-- TODO: migrate all cast tests here.
+
+-- cast string to interval and interval to string
+SELECT CAST('interval 3 month 1 hour' AS interval);
+SELECT CAST("interval '3-1' year to month" AS interval year to month);
+SELECT CAST("interval '3 00:00:01' day to second" AS interval day to second);
+SELECT CAST(interval 3 month 1 hour AS string);
+SELECT CAST(interval 3 year 1 month AS string);
+SELECT CAST(interval 3 day 1 second AS string);
+
+-- trim string before cast to numeric
+select cast(' 1' as tinyint);
+select cast(' 1\t' as tinyint);
+select cast(' 1' as smallint);
+select cast(' 1' as INT);
+select cast(' 1' as bigint);
+select cast(' 1' as float);
+select cast(' 1 ' as DOUBLE);
+select cast('1.0 ' as DEC);
+select cast('1中文' as tinyint);
+select cast('1中文' as smallint);
+select cast('1中文' as INT);
+select cast('中文1' as bigint);
+select cast('1中文' as bigint);
+
+-- trim string before cast to boolean
+select cast('\t\t true \n\r ' as boolean);
+select cast('\t\n false \t\r' as boolean);
+select cast('\t\n xyz \t\r' as boolean);
+
+select cast('23.45' as decimal(4, 2));
+select cast('123.45' as decimal(4, 2));
+select cast('xyz' as decimal(4, 2));
+
+select cast('2022-01-01' as date);
+select cast('a' as date);
+select cast('2022-01-01 00:00:00' as timestamp);
+select cast('a' as timestamp);
+select cast('2022-01-01 00:00:00' as timestamp_ntz);
+select cast('a' as timestamp_ntz);
+
+select cast(cast('inf' as double) as timestamp);
+select cast(cast('inf' as float) as timestamp);
+
+-- cast ANSI intervals to integrals
+select cast(interval '1' year as tinyint);
+select cast(interval '-10-2' year to month as smallint);
+select cast(interval '1000' month as int);
+select cast(interval -'10.123456' second as tinyint);
+select cast(interval '23:59:59' hour to second as smallint);
+select cast(interval -'1 02:03:04.123' day to second as int);
+select cast(interval '10' day as bigint);
+
+select cast(interval '-1000' month as tinyint);
+select cast(interval '1000000' second as smallint);
+
+-- cast integrals to ANSI intervals
+select cast(1Y as interval year);
+select cast(-122S as interval year to month);
+select cast(ym as interval year to month) from values(-122S) as t(ym);
+select cast(1000 as interval month);
+select cast(-10L as interval second);
+select cast(100Y as interval hour to second);
+select cast(dt as interval hour to second) from values(100Y) as t(dt);
+select cast(-1000S as interval day to second);
+select cast(10 as interval day);
+
+select cast(2147483647 as interval year);
+select cast(-9223372036854775808L as interval day);
+
+-- cast ANSI intervals to decimals
+select cast(interval '-1' year as decimal(10, 0));
+select cast(interval '1.000001' second as decimal(10, 6));
+select cast(interval '08:11:10.001' hour to second as decimal(10, 4));
+select cast(interval '1 01:02:03.1' day to second as decimal(8, 1));
+select cast(interval '10.123' second as decimal(4, 2));
+select cast(interval '10.005' second as decimal(4, 2));
+select cast(interval '10.123' second as decimal(5, 2));
+select cast(interval '10.123' second as decimal(1, 0));
+
+-- cast decimals to ANSI intervals
+select cast(10.123456BD as interval day to second);
+select cast(80.654321BD as interval hour to minute);
+select cast(-10.123456BD as interval year to month);
+select cast(10.654321BD as interval month);
+
+-- cast double colon syntax tests
+SELECT '1.23' :: int;
+SELECT 'abc' :: int;
+SELECT '12345678901234567890123' :: long;
+SELECT '' :: int;
+SELECT NULL :: int;
+SELECT '123.a' :: int;
+SELECT '-2147483648' :: int;
+SELECT HEX('abc' :: binary);
+SELECT HEX((123 :: byte) :: binary);
+SELECT 'interval 3 month 1 hour' :: interval;
+SELECT interval 3 day 1 second :: string;
+select ' 1 ' :: DOUBLE;
+select '1.0 ' :: DEC;
+select '\t\t true \n\r ' :: boolean;
+select '2022-01-01 00:00:00' :: timestamp;
+select interval '-10-2' year to month :: smallint;
+select -10L :: interval second;
+select interval '08:11:10.001' hour to second :: decimal(10, 4);
+select 10.123456BD :: interval day to second;
+
+SELECT '1.23' :: int :: long;
+SELECT '2147483648' :: long :: int;
+SELECT CAST('2147483648' :: long AS int);
+SELECT map(1, '123', 2, '456')[1] :: int;
+
+-- cast double colon syntax negative tests
+SELECT '2147483648' :: BINT;
+SELECT '2147483648' :: SELECT;
+SELECT FALSE IS NOT NULL :: string;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ceil-floor-with-scale-param.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ceil-floor-with-scale-param.sql
new file mode 100644
index 000000000000..c05429b3ef77
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ceil-floor-with-scale-param.sql
@@ -0,0 +1,31 @@
+-- Tests different scenarios of ceil and floor functions with scale parameters
+SELECT CEIL(2.5, 0);
+SELECT CEIL(3.5, 0);
+SELECT CEIL(-2.5, 0);
+SELECT CEIL(-3.5, 0);
+SELECT CEIL(-0.35, 1);
+SELECT CEIL(-35, -1);
+SELECT CEIL(-0.1, 0);
+SELECT CEIL(5, 0);
+SELECT CEIL(3.14115, -3);
+SELECT CEIL(9.9, 0);
+SELECT CEIL(CAST(99 AS DECIMAL(2, 0)), -1);
+SELECT CEIL(2.5, null);
+SELECT CEIL(2.5, 'a');
+SELECT CEIL(2.5, 0, 0);
+
+-- Same inputs with floor function
+SELECT FLOOR(2.5, 0);
+SELECT FLOOR(3.5, 0);
+SELECT FLOOR(-2.5, 0);
+SELECT FLOOR(-3.5, 0);
+SELECT FLOOR(-0.35, 1);
+SELECT FLOOR(-35, -1);
+SELECT FLOOR(-0.1, 0);
+SELECT FLOOR(5, 0);
+SELECT FLOOR(3.14115, -3);
+SELECT FLOOR(-9.9, 0);
+SELECT FLOOR(CAST(-99 AS DECIMAL(2, 0)), -1);
+SELECT FLOOR(2.5, null);
+SELECT FLOOR(2.5, 'a');
+SELECT FLOOR(2.5, 0, 0);
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/change-column.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/change-column.sql
new file mode 100644
index 000000000000..2b57891cfcbc
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/change-column.sql
@@ -0,0 +1,49 @@
+-- Create the origin table
+CREATE TABLE test_change(a INT, b STRING, c INT) using parquet;
+DESC test_change;
+
+-- ALTER TABLE CHANGE COLUMN must change either type or comment
+ALTER TABLE test_change CHANGE a;
+DESC test_change;
+
+-- Change column name (not supported on v1 table)
+ALTER TABLE test_change RENAME COLUMN a TO a1;
+DESC test_change;
+
+-- Change column dataType (not supported yet)
+ALTER TABLE test_change CHANGE a TYPE STRING;
+DESC test_change;
+
+-- Change column position (not supported yet)
+ALTER TABLE test_change CHANGE a AFTER b;
+ALTER TABLE test_change CHANGE b FIRST;
+DESC test_change;
+
+-- Change column comment
+ALTER TABLE test_change CHANGE a COMMENT 'this is column a';
+ALTER TABLE test_change CHANGE b COMMENT '#*02?`';
+ALTER TABLE test_change CHANGE c COMMENT '';
+DESC test_change;
+
+-- Don't change anything.
+ALTER TABLE test_change CHANGE a TYPE INT;
+ALTER TABLE test_change CHANGE a COMMENT 'this is column a';
+DESC test_change;
+
+-- Change a invalid column
+ALTER TABLE test_change CHANGE invalid_col TYPE INT;
+DESC test_change;
+
+-- Check case insensitivity.
+ALTER TABLE test_change CHANGE A COMMENT 'case insensitivity';
+DESC test_change;
+
+-- Change column can't apply to a temporary/global_temporary view
+CREATE TEMPORARY VIEW temp_view(a, b) AS SELECT 1, "one";
+ALTER TABLE temp_view CHANGE a TYPE INT;
+CREATE GLOBAL TEMPORARY VIEW global_temp_view(a, b) AS SELECT 1, "one";
+ALTER TABLE global_temp.global_temp_view CHANGE a TYPE INT;
+
+-- DROP TEST TABLE
+DROP TABLE test_change;
+DROP VIEW global_temp.global_temp_view;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/charvarchar.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/charvarchar.sql
new file mode 100644
index 000000000000..f5b20f99c8a0
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/charvarchar.sql
@@ -0,0 +1,128 @@
+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 change column c1 comment 'char comment';
+alter table char_part change column v1 comment 'varchar comment';
+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/spark41/src/test/resources/backends-velox/sql-tests/inputs/collations.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/collations.sql
new file mode 100644
index 000000000000..17815ed5dde6
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/collations.sql
@@ -0,0 +1,527 @@
+-- test cases for collation support
+
+-- Create a test table with data
+create table t1(utf8_binary string collate utf8_binary, utf8_lcase string collate utf8_lcase) using parquet;
+insert into t1 values('aaa', 'aaa');
+insert into t1 values('AAA', 'AAA');
+insert into t1 values('bbb', 'bbb');
+insert into t1 values('BBB', 'BBB');
+
+-- describe
+describe table t1;
+
+-- group by and count utf8_binary
+select count(*) from t1 group by utf8_binary;
+
+-- group by and count utf8_lcase
+select count(*) from t1 group by utf8_lcase;
+
+-- filter equal utf8_binary
+select * from t1 where utf8_binary = 'aaa';
+
+-- filter equal utf8_lcase
+select * from t1 where utf8_lcase = 'aaa' collate utf8_lcase;
+
+-- filter less then utf8_binary
+select * from t1 where utf8_binary < 'bbb';
+
+-- filter less then utf8_lcase
+select * from t1 where utf8_lcase < 'bbb' collate utf8_lcase;
+
+-- inner join
+select l.utf8_binary, r.utf8_lcase from t1 l join t1 r on l.utf8_lcase = r.utf8_lcase;
+
+-- create second table for anti-join
+create table t2(utf8_binary string collate utf8_binary, utf8_lcase string collate utf8_lcase) using parquet;
+insert into t2 values('aaa', 'aaa');
+insert into t2 values('bbb', 'bbb');
+
+-- anti-join on lcase
+select * from t1 anti join t2 on t1.utf8_lcase = t2.utf8_lcase;
+
+drop table t2;
+drop table t1;
+
+-- set operations
+select col1 collate utf8_lcase from values ('aaa'), ('AAA'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') except select col1 collate utf8_lcase from values ('aaa'), ('bbb');
+select col1 collate utf8_lcase from values ('aaa'), ('AAA'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') except all select col1 collate utf8_lcase from values ('aaa'), ('bbb');
+select col1 collate utf8_lcase from values ('aaa'), ('AAA'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') union select col1 collate utf8_lcase from values ('aaa'), ('bbb');
+select col1 collate utf8_lcase from values ('aaa'), ('AAA'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') union all select col1 collate utf8_lcase from values ('aaa'), ('bbb');
+select col1 collate utf8_lcase from values ('aaa'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') intersect select col1 collate utf8_lcase from values ('aaa'), ('bbb');
+
+-- set operations with conflicting collations
+select col1 collate utf8_lcase from values ('aaa'), ('AAA'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') except select col1 collate unicode_ci from values ('aaa'), ('bbb');
+select col1 collate utf8_lcase from values ('aaa'), ('AAA'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') except all select col1 collate unicode_ci from values ('aaa'), ('bbb');
+select col1 collate utf8_lcase from values ('aaa'), ('AAA'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') union select col1 collate unicode_ci from values ('aaa'), ('bbb');
+select col1 collate utf8_lcase from values ('aaa'), ('AAA'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') union all select col1 collate unicode_ci from values ('aaa'), ('bbb');
+select col1 collate utf8_lcase from values ('aaa'), ('bbb'), ('BBB'), ('zzz'), ('ZZZ') intersect select col1 collate unicode_ci from values ('aaa'), ('bbb');
+
+-- create table with struct field
+create table t1 (c1 struct) USING PARQUET;
+
+insert into t1 values (named_struct('utf8_binary', 'aaa', 'utf8_lcase', 'aaa'));
+insert into t1 values (named_struct('utf8_binary', 'AAA', 'utf8_lcase', 'AAA'));
+
+-- aggregate against nested field utf8_binary
+select count(*) from t1 group by c1.utf8_binary;
+
+-- aggregate against nested field utf8_lcase
+select count(*) from t1 group by c1.utf8_lcase;
+
+drop table t1;
+
+-- array function tests
+select array_contains(ARRAY('aaa' collate utf8_lcase),'AAA' collate utf8_lcase);
+select array_position(ARRAY('aaa' collate utf8_lcase, 'bbb' collate utf8_lcase),'BBB' collate utf8_lcase);
+
+-- utility
+select nullif('aaa' COLLATE utf8_lcase, 'AAA' COLLATE utf8_lcase);
+select least('aaa' COLLATE utf8_lcase, 'AAA' collate utf8_lcase, 'a' collate utf8_lcase);
+
+-- array operations
+select arrays_overlap(array('aaa' collate utf8_lcase), array('AAA' collate utf8_lcase));
+select array_distinct(array('aaa' collate utf8_lcase, 'AAA' collate utf8_lcase));
+select array_union(array('aaa' collate utf8_lcase), array('AAA' collate utf8_lcase));
+select array_intersect(array('aaa' collate utf8_lcase), array('AAA' collate utf8_lcase));
+select array_except(array('aaa' collate utf8_lcase), array('AAA' collate utf8_lcase));
+
+-- ICU collations (all statements return true)
+select 'a' collate unicode < 'A';
+select 'a' collate unicode_ci = 'A';
+select 'a' collate unicode_ai = 'å';
+select 'a' collate unicode_ci_ai = 'Å';
+select 'a' collate en < 'A';
+select 'a' collate en_ci = 'A';
+select 'a' collate en_ai = 'å';
+select 'a' collate en_ci_ai = 'Å';
+select 'Kypper' collate sv < 'Köpfe';
+select 'Kypper' collate de > 'Köpfe';
+select 'I' collate tr_ci = 'ı';
+
+-- create table for str_to_map
+create table t4 (text string collate utf8_binary, pairDelim string collate utf8_lcase, keyValueDelim string collate utf8_binary) using parquet;
+
+insert into t4 values('a:1,b:2,c:3', ',', ':');
+
+select str_to_map(text, pairDelim, keyValueDelim) from t4;
+select str_to_map(text collate utf8_binary, pairDelim collate utf8_lcase, keyValueDelim collate utf8_binary) from t4;
+select str_to_map(text collate utf8_binary, pairDelim collate utf8_binary, keyValueDelim collate utf8_binary) from t4;
+select str_to_map(text collate unicode_ai, pairDelim collate unicode_ai, keyValueDelim collate unicode_ai) from t4;
+
+drop table t4;
+
+create table t5(s string, utf8_binary string collate utf8_binary, utf8_lcase string collate utf8_lcase) using parquet;
+insert into t5 values ('Spark', 'Spark', 'SQL');
+insert into t5 values ('aaAaAAaA', 'aaAaAAaA', 'aaAaAAaA');
+insert into t5 values ('aaAaAAaA', 'aaAaAAaA', 'aaAaaAaA');
+insert into t5 values ('aaAaAAaA', 'aaAaAAaA', 'aaAaaAaAaaAaaAaAaaAaaAaA');
+insert into t5 values ('bbAbaAbA', 'bbAbAAbA', 'a');
+insert into t5 values ('İo', 'İo', 'İo');
+insert into t5 values ('İo', 'İo', 'İo ');
+insert into t5 values ('İo', 'İo ', 'İo');
+insert into t5 values ('İo', 'İo', 'i̇o');
+insert into t5 values ('efd2', 'efd2', 'efd2');
+insert into t5 values ('Hello, world! Nice day.', 'Hello, world! Nice day.', 'Hello, world! Nice day.');
+insert into t5 values ('Something else. Nothing here.', 'Something else. Nothing here.', 'Something else. Nothing here.');
+insert into t5 values ('kitten', 'kitten', 'sitTing');
+insert into t5 values ('abc', 'abc', 'abc');
+insert into t5 values ('abcdcba', 'abcdcba', 'aBcDCbA');
+
+create table t6(ascii long) using parquet;
+insert into t6 values (97);
+insert into t6 values (66);
+
+create table t7(ascii double) using parquet;
+insert into t7 values (97.52143);
+insert into t7 values (66.421);
+
+create table t8(format string collate utf8_binary, utf8_binary string collate utf8_binary, utf8_lcase string collate utf8_lcase) using parquet;
+insert into t8 values ('%s%s', 'abCdE', 'abCdE');
+
+create table t9(num long) using parquet;
+insert into t9 values (97);
+insert into t9 values (66);
+
+create table t10(utf8_binary string collate utf8_binary, utf8_lcase string collate utf8_lcase) using parquet;
+insert into t10 values ('aaAaAAaA', 'aaAaaAaA');
+insert into t10 values ('efd2', 'efd2');
+
+-- ConcatWs
+select concat_ws(' ', utf8_lcase, utf8_lcase) from t5;
+select concat_ws(' ', utf8_binary, utf8_lcase) from t5;
+select concat_ws(' ' collate utf8_binary, utf8_binary, 'SQL' collate utf8_lcase) from t5;
+select concat_ws(' ' collate utf8_lcase, utf8_binary, 'SQL' collate utf8_lcase) from t5;
+select concat_ws(',', utf8_lcase, 'word'), concat_ws(',', utf8_binary, 'word') from t5;
+select concat_ws(',', utf8_lcase, 'word' collate utf8_binary), concat_ws(',', utf8_binary, 'word' collate utf8_lcase) from t5;
+
+-- Elt
+select elt(2, s, utf8_binary) from t5;
+select elt(2, utf8_binary, utf8_lcase, s) from t5;
+select elt(1, utf8_binary collate utf8_binary, utf8_lcase collate utf8_lcase) from t5;
+select elt(1, utf8_binary collate utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select elt(1, utf8_binary collate utf8_binary, utf8_lcase) from t5;
+select elt(1, utf8_binary, 'word'), elt(1, utf8_lcase, 'word') from t5;
+select elt(1, utf8_binary, 'word' collate utf8_lcase), elt(1, utf8_lcase, 'word' collate utf8_binary) from t5;
+
+-- SplitPart
+select split_part(utf8_binary, utf8_lcase, 3) from t5;
+select split_part(s, utf8_binary, 1) from t5;
+select split_part(utf8_binary collate utf8_binary, s collate utf8_lcase, 1) from t5;
+select split_part(utf8_binary, utf8_lcase collate utf8_binary, 2) from t5;
+select split_part(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase, 2) from t5;
+select split_part(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai, 2) from t5;
+select split_part(utf8_binary, 'a', 3), split_part(utf8_lcase, 'a', 3) from t5;
+select split_part(utf8_binary, 'a' collate utf8_lcase, 3), split_part(utf8_lcase, 'a' collate utf8_binary, 3) from t5;
+select split_part(utf8_binary, 'a ' collate utf8_lcase_rtrim, 3), split_part(utf8_lcase, 'a' collate utf8_binary, 3) from t5;
+
+-- Contains
+select contains(utf8_binary, utf8_lcase) from t5;
+select contains(s, utf8_binary) from t5;
+select contains(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select contains(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select contains(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select contains(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai) from t5;
+select contains(utf8_binary, 'a'), contains(utf8_lcase, 'a') from t5;
+select contains(utf8_binary, 'AaAA' collate utf8_lcase), contains(utf8_lcase, 'AAa' collate utf8_binary) from t5;
+select contains(utf8_binary, 'AaAA ' collate utf8_lcase_rtrim), contains(utf8_lcase, 'AAa ' collate utf8_binary_rtrim) from t5;
+
+-- SubstringIndex
+select substring_index(utf8_binary, utf8_lcase, 2) from t5;
+select substring_index(s, utf8_binary,1) from t5;
+select substring_index(utf8_binary collate utf8_binary, s collate utf8_lcase, 3) from t5;
+select substring_index(utf8_binary, utf8_lcase collate utf8_binary, 2) from t5;
+select substring_index(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase, 2) from t5;
+select substring_index(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai, 2) from t5;
+select substring_index(utf8_binary, 'a', 2), substring_index(utf8_lcase, 'a', 2) from t5;
+select substring_index(utf8_binary, 'AaAA' collate utf8_lcase, 2), substring_index(utf8_lcase, 'AAa' collate utf8_binary, 2) from t5;
+select substring_index(utf8_binary, 'AaAA ' collate utf8_lcase_rtrim, 2), substring_index(utf8_lcase, 'AAa' collate utf8_binary, 2) from t5;
+
+-- StringInStr
+select instr(utf8_binary, utf8_lcase) from t5;
+select instr(s, utf8_binary) from t5;
+select instr(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select instr(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select instr(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select instr(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai) from t5;
+select instr(utf8_binary, 'a'), instr(utf8_lcase, 'a') from t5;
+select instr(utf8_binary, 'AaAA' collate utf8_lcase), instr(utf8_lcase, 'AAa' collate utf8_binary) from t5;
+
+-- FindInSet
+select find_in_set(utf8_binary, utf8_lcase) from t5;
+select find_in_set(s, utf8_binary) from t5;
+select find_in_set(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select find_in_set(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select find_in_set(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select find_in_set(utf8_binary, 'aaAaaAaA,i̇o'), find_in_set(utf8_lcase, 'aaAaaAaA,i̇o') from t5;
+select find_in_set(utf8_binary, 'aaAaaAaA,i̇o' collate utf8_lcase), find_in_set(utf8_lcase, 'aaAaaAaA,i̇o' collate utf8_binary) from t5;
+select find_in_set(utf8_binary, 'aaAaaAaA,i̇o ' collate utf8_lcase_rtrim), find_in_set(utf8_lcase, 'aaAaaAaA,i̇o' collate utf8_binary) from t5;
+-- StartsWith
+select startswith(utf8_binary, utf8_lcase) from t5;
+select startswith(s, utf8_binary) from t5;
+select startswith(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select startswith(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select startswith(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select startswith(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai) from t5;
+select startswith(utf8_binary, 'aaAaaAaA'), startswith(utf8_lcase, 'aaAaaAaA') from t5;
+select startswith(utf8_binary, 'aaAaaAaA' collate utf8_lcase), startswith(utf8_lcase, 'aaAaaAaA' collate utf8_binary) from t5;
+select startswith(utf8_binary, 'aaAaaAaA ' collate utf8_lcase_rtrim), startswith(utf8_lcase, 'aaAaaAaA' collate utf8_binary) from t5;
+
+-- StringTranslate
+select translate(utf8_lcase, utf8_lcase, '12345') from t5;
+select translate(utf8_binary, utf8_lcase, '12345') from t5;
+select translate(utf8_binary, 'aBc' collate utf8_lcase, '12345' collate utf8_binary) from t5;
+select translate(utf8_binary, 'SQL' collate utf8_lcase, '12345' collate utf8_lcase) from t5;
+select translate(utf8_binary, 'SQL' collate unicode_ai, '12345' collate unicode_ai) from t5;
+select translate(utf8_lcase, 'aaAaaAaA', '12345'), translate(utf8_binary, 'aaAaaAaA', '12345') from t5;
+select translate(utf8_lcase, 'aBc' collate utf8_binary, '12345'), translate(utf8_binary, 'aBc' collate utf8_lcase, '12345') from t5;
+select translate(utf8_lcase, 'aBc ' collate utf8_binary_rtrim, '12345'), translate(utf8_binary, 'aBc' collate utf8_lcase, '12345') from t5;
+
+-- Replace
+select replace(utf8_binary, utf8_lcase, 'abc') from t5;
+select replace(s, utf8_binary, 'abc') from t5;
+select replace(utf8_binary collate utf8_binary, s collate utf8_lcase, 'abc') from t5;
+select replace(utf8_binary, utf8_lcase collate utf8_binary, 'abc') from t5;
+select replace(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase, 'abc') from t5;
+select replace(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai, 'abc') from t5;
+select replace(utf8_binary, 'aaAaaAaA', 'abc'), replace(utf8_lcase, 'aaAaaAaA', 'abc') from t5;
+select replace(utf8_binary, 'aaAaaAaA' collate utf8_lcase, 'abc'), replace(utf8_lcase, 'aaAaaAaA' collate utf8_binary, 'abc') from t5;
+select replace(utf8_binary, 'aaAaaAaA ' collate utf8_lcase_rtrim, 'abc'), replace(utf8_lcase, 'aaAaaAaA' collate utf8_binary, 'abc') from t5;
+
+-- EndsWith
+select endswith(utf8_binary, utf8_lcase) from t5;
+select endswith(s, utf8_binary) from t5;
+select endswith(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select endswith(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select endswith(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select endswith(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai) from t5;
+select endswith(utf8_binary, 'aaAaaAaA'), endswith(utf8_lcase, 'aaAaaAaA') from t5;
+select endswith(utf8_binary, 'aaAaaAaA' collate utf8_lcase), endswith(utf8_lcase, 'aaAaaAaA' collate utf8_binary) from t5;
+select endswith(utf8_binary, 'aaAaaAaA ' collate utf8_lcase_rtrim), endswith(utf8_lcase, 'aaAaaAaA' collate utf8_binary) from t5;
+
+-- StringRepeat
+select repeat(utf8_binary, 3), repeat(utf8_lcase, 2) from t5;
+select repeat(utf8_binary collate utf8_lcase, 3), repeat(utf8_lcase collate utf8_binary, 2) from t5;
+
+-- Ascii & UnBase64 string expressions
+select ascii(utf8_binary), ascii(utf8_lcase) from t5;
+select ascii(utf8_binary collate utf8_lcase), ascii(utf8_lcase collate utf8_binary) from t5;
+select unbase64(utf8_binary), unbase64(utf8_lcase) from t10;
+select unbase64(utf8_binary collate utf8_lcase), unbase64(utf8_lcase collate utf8_binary) from t10;
+
+-- Chr
+select chr(ascii) from t6;
+
+-- Base64, Decode
+select base64(utf8_binary), base64(utf8_lcase) from t5;
+select base64(utf8_binary collate utf8_lcase), base64(utf8_lcase collate utf8_binary) from t5;
+select decode(encode(utf8_binary, 'utf-8'), 'utf-8'), decode(encode(utf8_lcase, 'utf-8'), 'utf-8') from t5;
+select decode(encode(utf8_binary collate utf8_lcase, 'utf-8'), 'utf-8'), decode(encode(utf8_lcase collate utf8_binary, 'utf-8'), 'utf-8') from t5;
+
+-- FormatNumber
+select format_number(ascii, '###.###') from t7;
+select format_number(ascii, '###.###' collate utf8_lcase) from t7;
+
+-- Encode, ToBinary
+select encode(utf8_binary, 'utf-8'), encode(utf8_lcase, 'utf-8') from t5;
+select encode(utf8_binary collate utf8_lcase, 'utf-8'), encode(utf8_lcase collate utf8_binary, 'utf-8') from t5;
+select to_binary(utf8_binary, 'utf-8'), to_binary(utf8_lcase, 'utf-8') from t5;
+select to_binary(utf8_binary collate utf8_lcase, 'utf-8'), to_binary(utf8_lcase collate utf8_binary, 'utf-8') from t5;
+
+-- Sentences
+select sentences(utf8_binary), sentences(utf8_lcase) from t5;
+select sentences(utf8_binary collate utf8_lcase), sentences(utf8_lcase collate utf8_binary) from t5;
+
+-- Upper
+select upper(utf8_binary), upper(utf8_lcase) from t5;
+select upper(utf8_binary collate utf8_lcase), upper(utf8_lcase collate utf8_binary) from t5;
+
+-- Lower
+select lower(utf8_binary), lower(utf8_lcase) from t5;
+select lower(utf8_binary collate utf8_lcase), lower(utf8_lcase collate utf8_binary) from t5;
+
+-- InitCap
+select initcap(utf8_binary), initcap(utf8_lcase) from t5;
+select initcap(utf8_binary collate utf8_lcase), initcap(utf8_lcase collate utf8_binary) from t5;
+
+-- Overlay
+select overlay(utf8_binary, utf8_lcase, 2) from t5;
+select overlay(s, utf8_binary,1) from t5;
+select overlay(utf8_binary collate utf8_binary, s collate utf8_lcase, 3) from t5;
+select overlay(utf8_binary, utf8_lcase collate utf8_binary, 2) from t5;
+select overlay(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase, 2) from t5;
+select overlay(utf8_binary, 'a', 2), overlay(utf8_lcase, 'a', 2) from t5;
+select overlay(utf8_binary, 'AaAA' collate utf8_lcase, 2), overlay(utf8_lcase, 'AAa' collate utf8_binary, 2) from t5;
+
+-- FormatString
+select format_string(format, utf8_binary, utf8_lcase) from t8;
+select format_string(format collate utf8_lcase, utf8_lcase, utf8_binary collate utf8_lcase, 3), format_string(format, utf8_lcase collate utf8_binary, utf8_binary) from t8;
+select format_string(format, utf8_binary, utf8_lcase) from t8;
+
+-- SoundEx
+select soundex(utf8_binary), soundex(utf8_lcase) from t5;
+select soundex(utf8_binary collate utf8_lcase), soundex(utf8_lcase collate utf8_binary) from t5;
+
+-- Length, BitLength & OctetLength
+select length(utf8_binary), length(utf8_lcase) from t5;
+select length(utf8_binary collate utf8_lcase), length(utf8_lcase collate utf8_binary) from t5;
+select bit_length(utf8_binary), bit_length(utf8_lcase) from t5;
+select bit_length(utf8_binary collate utf8_lcase), bit_length(utf8_lcase collate utf8_binary) from t5;
+select octet_length(utf8_binary), octet_length(utf8_lcase) from t5;
+select octet_length(utf8_binary collate utf8_lcase), octet_length(utf8_lcase collate utf8_binary) from t5;
+select octet_length(utf8_binary collate utf8_lcase_rtrim), octet_length(utf8_lcase collate utf8_binary_rtrim) from t5;
+
+-- Luhncheck
+select luhn_check(num) from t9;
+
+-- Levenshtein
+select levenshtein(utf8_binary, utf8_lcase) from t5;
+select levenshtein(s, utf8_binary) from t5;
+select levenshtein(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select levenshtein(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select levenshtein(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select levenshtein(utf8_binary, 'a'), levenshtein(utf8_lcase, 'a') from t5;
+select levenshtein(utf8_binary, 'AaAA' collate utf8_lcase, 3), levenshtein(utf8_lcase, 'AAa' collate utf8_binary, 4) from t5;
+
+-- IsValidUTF8
+select is_valid_utf8(utf8_binary), is_valid_utf8(utf8_lcase) from t5;
+select is_valid_utf8(utf8_binary collate utf8_lcase), is_valid_utf8(utf8_lcase collate utf8_binary) from t5;
+select is_valid_utf8(utf8_binary collate utf8_lcase_rtrim), is_valid_utf8(utf8_lcase collate utf8_binary_rtrim) from t5;
+
+-- MakeValidUTF8
+select make_valid_utf8(utf8_binary), make_valid_utf8(utf8_lcase) from t5;
+select make_valid_utf8(utf8_binary collate utf8_lcase), make_valid_utf8(utf8_lcase collate utf8_binary) from t5;
+select make_valid_utf8(utf8_binary collate utf8_lcase_rtrim), make_valid_utf8(utf8_lcase collate utf8_binary_rtrim) from t5;
+
+-- ValidateUTF8
+select validate_utf8(utf8_binary), validate_utf8(utf8_lcase) from t5;
+select validate_utf8(utf8_binary collate utf8_lcase), validate_utf8(utf8_lcase collate utf8_binary) from t5;
+select validate_utf8(utf8_binary collate utf8_lcase_rtrim), validate_utf8(utf8_lcase collate utf8_binary_rtrim) from t5;
+
+-- TryValidateUTF8
+select try_validate_utf8(utf8_binary), try_validate_utf8(utf8_lcase) from t5;
+select try_validate_utf8(utf8_binary collate utf8_lcase), try_validate_utf8(utf8_lcase collate utf8_binary) from t5;
+select try_validate_utf8(utf8_binary collate utf8_lcase_rtrim), try_validate_utf8(utf8_lcase collate utf8_binary_rtrim) from t5;
+
+-- Left/Right/Substr
+select substr(utf8_binary, 2, 2), substr(utf8_lcase, 2, 2) from t5;
+select substr(utf8_binary collate utf8_lcase, 2, 2), substr(utf8_lcase collate utf8_binary, 2, 2) from t5;
+select right(utf8_binary, 2), right(utf8_lcase, 2) from t5;
+select right(utf8_binary collate utf8_lcase, 2), right(utf8_lcase collate utf8_binary, 2) from t5;
+select left(utf8_binary, '2' collate utf8_lcase), left(utf8_lcase, 2) from t5;
+select left(utf8_binary collate utf8_lcase, 2), left(utf8_lcase collate utf8_binary, 2) from t5;
+
+-- StringRPad
+select rpad(utf8_binary, 8, utf8_lcase) from t5;
+select rpad(s, 8, utf8_binary) from t5;
+select rpad(utf8_binary collate utf8_binary, 8, s collate utf8_lcase) from t5;
+select rpad(utf8_binary, 8, utf8_lcase collate utf8_binary) from t5;
+select rpad(utf8_binary collate utf8_lcase, 8, utf8_lcase collate utf8_lcase) from t5;
+select lpad(utf8_binary collate utf8_binary_rtrim, 8, utf8_lcase collate utf8_binary_rtrim) from t5;
+select rpad(utf8_binary, 8, 'a'), rpad(utf8_lcase, 8, 'a') from t5;
+select rpad(utf8_binary, 8, 'AaAA' collate utf8_lcase), rpad(utf8_lcase, 8, 'AAa' collate utf8_binary) from t5;
+
+-- StringLPad
+select lpad(utf8_binary, 8, utf8_lcase) from t5;
+select lpad(s, 8, utf8_binary) from t5;
+select lpad(utf8_binary collate utf8_binary, 8, s collate utf8_lcase) from t5;
+select lpad(utf8_binary, 8, utf8_lcase collate utf8_binary) from t5;
+select lpad(utf8_binary collate utf8_lcase, 8, utf8_lcase collate utf8_lcase) from t5;
+select lpad(utf8_binary collate utf8_binary_rtrim, 8, utf8_lcase collate utf8_binary_rtrim) from t5;
+select lpad(utf8_binary, 8, 'a'), lpad(utf8_lcase, 8, 'a') from t5;
+select lpad(utf8_binary, 8, 'AaAA' collate utf8_lcase), lpad(utf8_lcase, 8, 'AAa' collate utf8_binary) from t5;
+
+-- Locate
+select locate(utf8_binary, utf8_lcase) from t5;
+select locate(s, utf8_binary) from t5;
+select locate(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select locate(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select locate(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase, 3) from t5;
+select locate(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai, 3) from t5;
+select locate(utf8_binary, 'a'), locate(utf8_lcase, 'a') from t5;
+select locate(utf8_binary, 'AaAA' collate utf8_lcase, 4), locate(utf8_lcase, 'AAa' collate utf8_binary, 4) from t5;
+select locate(utf8_binary, 'AaAA ' collate utf8_binary_rtrim, 4), locate(utf8_lcase, 'AAa ' collate utf8_binary, 4) from t5;
+
+-- StringTrim
+select TRIM(utf8_binary, utf8_lcase) from t5;
+select TRIM(s, utf8_binary) from t5;
+select TRIM(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select TRIM(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select TRIM(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select TRIM(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai) from t5;
+select TRIM(utf8_binary collate utf8_binary_rtrim, utf8_lcase collate utf8_binary_rtrim) from t5;
+select TRIM('ABc', utf8_binary), TRIM('ABc', utf8_lcase) from t5;
+select TRIM('ABc' collate utf8_lcase, utf8_binary), TRIM('AAa' collate utf8_binary, utf8_lcase) from t5;
+-- StringTrimBoth
+select BTRIM(utf8_binary, utf8_lcase) from t5;
+select BTRIM(s, utf8_binary) from t5;
+select BTRIM(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select BTRIM(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select BTRIM(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select BTRIM(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai) from t5;
+select BTRIM(utf8_binary collate utf8_binary_rtrim, utf8_lcase collate utf8_binary_rtrim) from t5;
+select BTRIM('ABc', utf8_binary), BTRIM('ABc', utf8_lcase) from t5;
+select BTRIM('ABc' collate utf8_lcase, utf8_binary), BTRIM('AAa' collate utf8_binary, utf8_lcase) from t5;
+-- StringTrimLeft
+select LTRIM(utf8_binary, utf8_lcase) from t5;
+select LTRIM(s, utf8_binary) from t5;
+select LTRIM(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select LTRIM(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select LTRIM(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select LTRIM(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai) from t5;
+select LTRIM(utf8_binary collate utf8_binary_rtrim, utf8_lcase collate utf8_binary_rtrim) from t5;
+select LTRIM('ABc', utf8_binary), LTRIM('ABc', utf8_lcase) from t5;
+select LTRIM('ABc' collate utf8_lcase, utf8_binary), LTRIM('AAa' collate utf8_binary, utf8_lcase) from t5;
+-- StringTrimRight
+select RTRIM(utf8_binary, utf8_lcase) from t5;
+select RTRIM(s, utf8_binary) from t5;
+select RTRIM(utf8_binary collate utf8_binary, s collate utf8_lcase) from t5;
+select RTRIM(utf8_binary, utf8_lcase collate utf8_binary) from t5;
+select RTRIM(utf8_binary collate utf8_lcase, utf8_lcase collate utf8_lcase) from t5;
+select RTRIM(utf8_binary collate unicode_ai, utf8_lcase collate unicode_ai) from t5;
+select RTRIM(utf8_binary collate utf8_binary_rtrim, utf8_lcase collate utf8_binary_rtrim) from t5;
+select RTRIM('ABc', utf8_binary), RTRIM('ABc', utf8_lcase) from t5;
+select RTRIM('ABc' collate utf8_lcase, utf8_binary), RTRIM('AAa' collate utf8_binary, utf8_lcase) from t5;
+
+-- Implicit aliases to collated expression trees are correctly generated
+
+-- Simple select
+select concat_ws(' ', utf8_lcase, utf8_lcase) from t5;
+
+-- Select by implicit alias
+select `concat_ws(' ' collate UTF8_LCASE, utf8_lcase, utf8_lcase)` from (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5
+);
+
+-- Select by star
+select * from (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5
+);
+
+-- Select by qualified star
+select subq1.* from (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5
+) AS subq1;
+
+-- Implicit alias in CTE output
+with cte as (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5
+)
+select * from cte;
+
+-- Implicit alias in EXISTS subquery output
+select * from values (1) where exists (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5
+);
+
+-- Implicit alias in scalar subquery output
+select (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5 limit 1
+);
+
+-- Scalar subquery with CTE with implicit alias
+select (
+ with cte as (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5
+ )
+ select * from cte limit 1
+);
+
+-- Outer reference to implicit alias
+select * from (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5 limit 1
+)
+where (
+ `concat_ws(' ' collate UTF8_LCASE, utf8_lcase, utf8_lcase)` == 'aaa'
+);
+
+-- Implicit alias reference in Sort
+select lower(`concat_ws(' ' collate UTF8_LCASE, utf8_lcase, utf8_lcase)`) from (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5
+ group by 1
+ order by 1
+);
+
+-- Implciit alias from aggregate in Sort
+select lower(`concat_ws(' ' collate UTF8_LCASE, utf8_lcase, utf8_lcase)`) from (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5
+ group by 1
+ order by max(concat_ws(' ', utf8_lcase, utf8_lcase))
+);
+
+-- Implicit alias in view schema
+create temporary view v1 as (
+ select concat_ws(' ', utf8_lcase, utf8_lcase) from t5
+);
+
+select * from v1;
+
+select `concat_ws(' ' collate UTF8_LCASE, utf8_lcase, utf8_lcase)` from v1;
+
+drop view v1;
+
+drop table t5;
+drop table t6;
+drop table t7;
+drop table t8;
+drop table t9;
+drop table t10;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/column-resolution-aggregate.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/column-resolution-aggregate.sql
new file mode 100644
index 000000000000..4f879fc809d9
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/column-resolution-aggregate.sql
@@ -0,0 +1,33 @@
+-- Tests covering column resolution priority in Aggregate.
+
+CREATE TEMPORARY VIEW v1 AS VALUES (1, 1, 1), (2, 2, 1) AS t(a, b, k);
+CREATE TEMPORARY VIEW v2 AS VALUES (1, 1, 1), (2, 2, 1) AS t(x, y, all);
+
+-- Relation output columns have higher priority than lateral column alias. This query
+-- should fail as `b` is not in GROUP BY.
+SELECT max(a) AS b, b FROM v1 GROUP BY k;
+
+-- Lateral column alias has higher priority than outer reference.
+SELECT a FROM v1 WHERE (12, 13) IN (SELECT max(x + 10) AS a, a + 1 FROM v2);
+
+-- Relation output columns have higher priority than GROUP BY alias. This query should
+-- fail as `a` is not in GROUP BY.
+SELECT a AS k FROM v1 GROUP BY k;
+
+-- Relation output columns have higher priority than GROUP BY ALL. This query should
+-- fail as `x` is not in GROUP BY.
+SELECT x FROM v2 GROUP BY all;
+
+-- GROUP BY alias has higher priority than GROUP BY ALL, this query fails as `b` is not in GROUP BY.
+SELECT a AS all, b FROM v1 GROUP BY all;
+
+-- GROUP BY alias/ALL does not support lateral column alias.
+SELECT k AS lca, lca + 1 AS col FROM v1 GROUP BY k, col;
+SELECT k AS lca, lca + 1 AS col FROM v1 GROUP BY all;
+
+-- GROUP BY alias still works if it does not directly reference lateral column alias.
+SELECT k AS lca, lca + 1 AS col FROM v1 GROUP BY lca;
+
+-- GROUP BY ALL has higher priority than outer reference. This query should run as `a` and `b` are
+-- in GROUP BY due to the GROUP BY ALL resolution.
+SELECT * FROM v2 WHERE EXISTS (SELECT a, b FROM v1 GROUP BY all);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/column-resolution-sort.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/column-resolution-sort.sql
new file mode 100644
index 000000000000..2c5b9f9e9dfc
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/column-resolution-sort.sql
@@ -0,0 +1,20 @@
+--SET spark.sql.leafNodeDefaultParallelism=1
+-- Tests covering column resolution priority in Sort.
+
+CREATE TEMPORARY VIEW v1 AS VALUES (1, 2, 2), (2, 1, 1) AS t(a, b, k);
+CREATE TEMPORARY VIEW v2 AS VALUES (1, 2, 2), (2, 1, 1) AS t(a, b, all);
+
+-- Relation output columns have higher priority than missing reference.
+-- Query will fail if we order by the column `v1.b`, as it's not in GROUP BY.
+-- Actually results are [1, 2] as we order by `max(a) AS b`.
+SELECT max(a) AS b FROM v1 GROUP BY k ORDER BY b;
+
+-- Missing reference has higher priority than ORDER BY ALL.
+-- Results will be [1, 2] if we order by `max(a)`.
+-- Actually results are [2, 1] as we order by the grouping column `v2.all`.
+SELECT max(a) FROM v2 GROUP BY all ORDER BY all;
+
+-- ORDER BY ALL has higher priority than outer reference.
+-- Results will be [1, 1] if we order by outer reference 'v2.all'.
+-- Actually results are [2, 2] as we order by column `v1.b`
+SELECT (SELECT b FROM v1 ORDER BY all LIMIT 1) FROM v2;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/columnresolution-negative.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/columnresolution-negative.sql
new file mode 100644
index 000000000000..d100023b4ee1
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/columnresolution-negative.sql
@@ -0,0 +1,50 @@
+-- Negative testcases for column resolution
+CREATE DATABASE mydb1;
+USE mydb1;
+CREATE TABLE t1 USING parquet AS SELECT 1 AS i1;
+
+CREATE DATABASE mydb2;
+USE mydb2;
+CREATE TABLE t1 USING parquet AS SELECT 20 AS i1;
+
+-- Negative tests: column resolution scenarios with ambiguous cases in join queries
+SET spark.sql.crossJoin.enabled = true;
+USE mydb1;
+SELECT i1 FROM t1, mydb1.t1;
+SELECT t1.i1 FROM t1, mydb1.t1;
+SELECT mydb1.t1.i1 FROM t1, mydb1.t1;
+SELECT i1 FROM t1, mydb2.t1;
+SELECT t1.i1 FROM t1, mydb2.t1;
+USE mydb2;
+SELECT i1 FROM t1, mydb1.t1;
+SELECT t1.i1 FROM t1, mydb1.t1;
+SELECT i1 FROM t1, mydb2.t1;
+SELECT t1.i1 FROM t1, mydb2.t1;
+SELECT db1.t1.i1 FROM t1, mydb2.t1;
+SET spark.sql.crossJoin.enabled = false;
+
+-- Negative tests
+USE mydb1;
+SELECT mydb1.t1 FROM t1;
+SELECT t1.x.y.* FROM t1;
+SELECT t1 FROM mydb1.t1;
+USE mydb2;
+SELECT mydb1.t1.i1 FROM t1;
+
+-- Negative tests: view cannot resolve column after incompatible schema change
+USE mydb1;
+CREATE VIEW v1 AS SELECT * FROM t1;
+DROP TABLE t1;
+CREATE TABLE t1 USING parquet AS SELECT 1 AS i2;
+SELECT * FROM v1;
+
+-- Negative tests: temp view cannot resolve column after incompatible schema change
+USE mydb2;
+CREATE TEMP VIEW v2 AS SELECT * FROM t1;
+DROP TABLE t1;
+CREATE TABLE t1 USING parquet AS SELECT 1 AS i2;
+SELECT * FROM v2;
+
+-- reset
+DROP DATABASE mydb1 CASCADE;
+DROP DATABASE mydb2 CASCADE;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/columnresolution-views.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/columnresolution-views.sql
new file mode 100644
index 000000000000..83c32a5bf243
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/columnresolution-views.sql
@@ -0,0 +1,23 @@
+-- Tests for qualified column names for the view code-path
+-- Test scenario with Temporary view
+CREATE OR REPLACE TEMPORARY VIEW view1 AS SELECT 2 AS i1;
+SELECT view1.* FROM view1;
+SELECT * FROM view1;
+SELECT view1.i1 FROM view1;
+SELECT i1 FROM view1;
+SELECT a.i1 FROM view1 AS a;
+SELECT i1 FROM view1 AS a;
+-- cleanup
+DROP VIEW view1;
+
+-- Test scenario with Global Temp view
+CREATE OR REPLACE GLOBAL TEMPORARY VIEW view1 as SELECT 1 as i1;
+SELECT * FROM global_temp.view1;
+SELECT global_temp.view1.* FROM global_temp.view1;
+SELECT i1 FROM global_temp.view1;
+SELECT global_temp.view1.i1 FROM global_temp.view1;
+SELECT view1.i1 FROM global_temp.view1;
+SELECT a.i1 FROM global_temp.view1 AS a;
+SELECT i1 FROM global_temp.view1 AS a;
+-- cleanup
+DROP VIEW global_temp.view1;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/columnresolution.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/columnresolution.sql
new file mode 100644
index 000000000000..d001185a7393
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/columnresolution.sql
@@ -0,0 +1,78 @@
+-- Tests covering different scenarios with qualified column names
+-- Scenario: column resolution scenarios with datasource table
+CREATE DATABASE mydb1;
+USE mydb1;
+CREATE TABLE t1 USING parquet AS SELECT 1 AS i1;
+
+CREATE DATABASE mydb2;
+USE mydb2;
+CREATE TABLE t1 USING parquet AS SELECT 20 AS i1;
+
+USE mydb1;
+SELECT i1 FROM t1;
+SELECT i1 FROM mydb1.t1;
+SELECT t1.i1 FROM t1;
+SELECT t1.i1 FROM mydb1.t1;
+
+SELECT mydb1.t1.i1 FROM t1;
+SELECT mydb1.t1.i1 FROM mydb1.t1;
+
+USE mydb2;
+SELECT i1 FROM t1;
+SELECT i1 FROM mydb1.t1;
+SELECT t1.i1 FROM t1;
+SELECT t1.i1 FROM mydb1.t1;
+SELECT mydb1.t1.i1 FROM mydb1.t1;
+
+-- Scenario: resolve fully qualified table name in star expansion
+USE mydb1;
+SELECT t1.* FROM t1;
+SELECT mydb1.t1.* FROM mydb1.t1;
+SELECT t1.* FROM mydb1.t1;
+USE mydb2;
+SELECT t1.* FROM t1;
+SELECT mydb1.t1.* FROM mydb1.t1;
+SELECT t1.* FROM mydb1.t1;
+SELECT a.* FROM mydb1.t1 AS a;
+
+-- Scenario: resolve in case of subquery
+
+USE mydb1;
+CREATE TABLE t3 USING parquet AS SELECT * FROM VALUES (4,1), (3,1) AS t3(c1, c2);
+CREATE TABLE t4 USING parquet AS SELECT * FROM VALUES (4,1), (2,1) AS t4(c2, c3);
+
+SELECT * FROM t3 WHERE c1 IN (SELECT c2 FROM t4 WHERE t4.c3 = t3.c2);
+
+SELECT * FROM mydb1.t3 WHERE c1 IN
+ (SELECT mydb1.t4.c2 FROM mydb1.t4 WHERE mydb1.t4.c3 = mydb1.t3.c2);
+
+-- Scenario: column resolution scenarios in join queries
+SET spark.sql.crossJoin.enabled = true;
+
+SELECT mydb1.t1.i1 FROM t1, mydb2.t1;
+
+SELECT mydb1.t1.i1 FROM mydb1.t1, mydb2.t1;
+
+USE mydb2;
+SELECT mydb1.t1.i1 FROM t1, mydb1.t1;
+SET spark.sql.crossJoin.enabled = false;
+
+-- Scenario: Table with struct column
+USE mydb1;
+CREATE TABLE t5(i1 INT, t5 STRUCT) USING parquet;
+INSERT INTO t5 VALUES(1, (2, 3));
+SELECT t5.i1 FROM t5;
+SELECT t5.t5.i1 FROM t5;
+SELECT t5.t5.i1 FROM mydb1.t5;
+SELECT t5.i1 FROM mydb1.t5;
+SELECT t5.* FROM mydb1.t5;
+SELECT t5.t5.* FROM mydb1.t5;
+SELECT mydb1.t5.t5.i1 FROM mydb1.t5;
+SELECT mydb1.t5.t5.i2 FROM mydb1.t5;
+SELECT mydb1.t5.* FROM mydb1.t5;
+SELECT mydb1.t5.* FROM t5;
+
+-- Cleanup and Reset
+USE default;
+DROP DATABASE mydb1 CASCADE;
+DROP DATABASE mydb2 CASCADE;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/comments.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/comments.sql
new file mode 100644
index 000000000000..da5e57a94292
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/comments.sql
@@ -0,0 +1,119 @@
+-- Test comments.
+
+-- the first case of bracketed comment
+--QUERY-DELIMITER-START
+/* This is the first example of bracketed comment.
+SELECT 'ommented out content' AS first;
+*/
+SELECT 'selected content' AS first;
+--QUERY-DELIMITER-END
+
+-- the second case of bracketed comment
+--QUERY-DELIMITER-START
+/* This is the second example of bracketed comment.
+SELECT '/', 'ommented out content' AS second;
+*/
+SELECT '/', 'selected content' AS second;
+--QUERY-DELIMITER-END
+
+-- the third case of bracketed comment
+--QUERY-DELIMITER-START
+/* This is the third example of bracketed comment.
+ *SELECT '*', 'ommented out content' AS third;
+ */
+SELECT '*', 'selected content' AS third;
+--QUERY-DELIMITER-END
+
+-- the first case of empty bracketed comment
+--QUERY-DELIMITER-START
+/**/
+SELECT 'selected content' AS fourth;
+--QUERY-DELIMITER-END
+
+-- the first case of nested bracketed comment
+--QUERY-DELIMITER-START
+/* This is the first example of nested bracketed comment.
+/* I am a nested bracketed comment.*/
+*/
+SELECT 'selected content' AS fifth;
+--QUERY-DELIMITER-END
+
+-- the second case of nested bracketed comment
+--QUERY-DELIMITER-START
+/* This is the second example of nested bracketed comment.
+/* I am a nested bracketed comment.
+ */
+ */
+SELECT 'selected content' AS sixth;
+--QUERY-DELIMITER-END
+
+-- the third case of nested bracketed comment
+--QUERY-DELIMITER-START
+/*
+ * This is the third example of nested bracketed comment.
+ /*
+ * I am a nested bracketed comment.
+ */
+ */
+SELECT 'selected content' AS seventh;
+--QUERY-DELIMITER-END
+
+-- the fourth case of nested bracketed comment
+--QUERY-DELIMITER-START
+/*
+ * This is the fourth example of nested bracketed comment.
+SELECT /* I am a nested bracketed comment.*/ * FROM testData;
+ */
+SELECT 'selected content' AS eighth;
+--QUERY-DELIMITER-END
+
+-- the fifth case of nested bracketed comment
+--QUERY-DELIMITER-START
+SELECT /*
+ * This is the fifth example of nested bracketed comment.
+/* I am a second level of nested bracketed comment.
+/* I am a third level of nested bracketed comment.
+Other information of third level.
+SELECT 'ommented out content' AS ninth;
+*/
+Other information of second level.
+*/
+Other information of first level.
+*/
+'selected content' AS ninth;
+--QUERY-DELIMITER-END
+
+-- the first case of empty nested bracketed comment
+--QUERY-DELIMITER-START
+/*/**/*/
+SELECT 'selected content' AS tenth;
+--QUERY-DELIMITER-END
+
+-- the first case of unclosed bracketed comment
+--QUERY-DELIMITER-START
+/*abc*/
+select 1 as a
+/*
+
+2 as b
+/*abc*/
+, 3 as c
+
+/**/
+;
+--QUERY-DELIMITER-END
+
+-- the second case of unclosed bracketed comment
+--QUERY-DELIMITER-START
+/*abc*/
+select 1 as a
+/*
+
+2 as b
+/*abc*/
+, 3 as c
+
+/**/
+select 4 as d
+;
+--QUERY-DELIMITER-END
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/comparator.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/comparator.sql
new file mode 100644
index 000000000000..70af4f75ac43
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/comparator.sql
@@ -0,0 +1,13 @@
+-- binary type
+select x'00' < x'0f';
+select x'00' < x'ff';
+
+-- trim string to numeric
+select '1 ' = 1Y;
+select '\t1 ' = 1Y;
+select '1 ' = 1S;
+select '1 ' = 1;
+select ' 1' = 1L;
+select ' 1' = cast(1.0 as float);
+select ' 1.0 ' = 1.0D;
+select ' 1.0 ' = 1.0BD;
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/conditional-functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/conditional-functions.sql
new file mode 100644
index 000000000000..c7a4b055f024
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/conditional-functions.sql
@@ -0,0 +1,38 @@
+-- Tests for conditional functions
+
+CREATE TABLE conditional_t USING PARQUET AS SELECT c1, c2 FROM VALUES(1d, 0),(2d, 1),(null, 1),(CAST('NaN' AS DOUBLE), 0) AS t(c1, c2);
+
+SELECT nanvl(c2, c1/c2 + c1/c2) FROM conditional_t;
+SELECT nanvl(c2, 1/0) FROM conditional_t;
+SELECT nanvl(1-0, 1/0) FROM conditional_t;
+
+SELECT if(c2 >= 0, 1-0, 1/0) from conditional_t;
+SELECT if(1 == 1, 1, 1/0);
+SELECT if(1 != 1, 1/0, 1);
+
+SELECT coalesce(c2, 1/0) from conditional_t;
+SELECT coalesce(1, 1/0);
+SELECT coalesce(null, 1, 1/0);
+
+SELECT case when c2 >= 0 then 1 else 1/0 end from conditional_t;
+SELECT case when 1 < 2 then 1 else 1/0 end;
+SELECT case when 1 > 2 then 1/0 else 1 end;
+
+SELECT nullifzero(0),
+ nullifzero(cast(0 as tinyint)),
+ nullifzero(cast(0 as bigint)),
+ nullifzero('0'),
+ nullifzero(0.0),
+ nullifzero(1),
+ nullifzero(null);
+
+SELECT nullifzero('abc');
+
+SELECT zeroifnull(null),
+ zeroifnull(1),
+ zeroifnull(cast(1 as tinyint)),
+ zeroifnull(cast(1 as bigint));
+
+SELECT zeroifnull('abc');
+
+DROP TABLE conditional_t;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/count.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/count.sql
new file mode 100644
index 000000000000..644e808cc04c
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/count.sql
@@ -0,0 +1,55 @@
+-- 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/spark41/src/test/resources/backends-velox/sql-tests/inputs/cross-join.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cross-join.sql
new file mode 100644
index 000000000000..b64197e2bc70
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cross-join.sql
@@ -0,0 +1,36 @@
+-- Cross join detection and error checking is done in JoinSuite since explain output is
+-- used in the error message and the ids are not stable. Only positive cases are checked here.
+
+create temporary view nt1 as select * from values
+ ("one", 1),
+ ("two", 2),
+ ("three", 3)
+ as nt1(k, v1);
+
+create temporary view nt2 as select * from values
+ ("one", 1),
+ ("two", 22),
+ ("one", 5)
+ as nt2(k, v2);
+
+-- Cross joins with and without predicates
+SELECT * FROM nt1 cross join nt2;
+SELECT * FROM nt1 cross join nt2 where nt1.k = nt2.k;
+SELECT * FROM nt1 cross join nt2 on (nt1.k = nt2.k);
+SELECT * FROM nt1 cross join nt2 where nt1.v1 = 1 and nt2.v2 = 22;
+
+SELECT a.key, b.key FROM
+(SELECT k key FROM nt1 WHERE v1 < 2) a
+CROSS JOIN
+(SELECT k key FROM nt2 WHERE v2 = 22) b;
+
+-- Join reordering
+create temporary view A(a, va) as select * from nt1;
+create temporary view B(b, vb) as select * from nt1;
+create temporary view C(c, vc) as select * from nt1;
+create temporary view D(d, vd) as select * from nt1;
+
+-- Allowed since cross join with C is explicit
+select * from ((A join B on (a = b)) cross join C) join D on (a = d);
+-- Cross joins with non-equal predicates
+SELECT * FROM nt1 CROSS JOIN nt2 ON (nt1.k > nt2.k);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/csv-functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/csv-functions.sql
new file mode 100644
index 000000000000..01d436534a10
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/csv-functions.sql
@@ -0,0 +1,24 @@
+-- from_csv
+select from_csv('1, 3.14', 'a INT, f FLOAT');
+select from_csv('26/08/2015', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
+-- Check if errors handled
+select from_csv('1', 1);
+select from_csv('1', 'a InvalidType');
+select from_csv('1', 'Array');
+select from_csv('1', 'a INT', named_struct('mode', 'PERMISSIVE'));
+select from_csv('1', 'a INT', map('mode', 1));
+select from_csv();
+-- infer schema of json literal
+select from_csv('1,abc', schema_of_csv('1,abc'));
+select schema_of_csv('1|abc', map('delimiter', '|'));
+select schema_of_csv(null);
+CREATE TEMPORARY VIEW csvTable(csvField, a) AS SELECT * FROM VALUES ('1,abc', 'a');
+SELECT schema_of_csv(csvField) FROM csvTable;
+-- Clean up
+DROP VIEW IF EXISTS csvTable;
+-- to_csv
+select to_csv(named_struct('a', 1, 'b', 2));
+select to_csv(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
+-- Check if errors handled
+select to_csv(named_struct('a', 1, 'b', 2), named_struct('mode', 'PERMISSIVE'));
+select to_csv(named_struct('a', 1, 'b', 2), map('mode', 1));
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-command.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-command.sql
new file mode 100644
index 000000000000..ee90c2de49eb
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-command.sql
@@ -0,0 +1,33 @@
+-- WITH inside CTE
+CREATE TABLE cte_tbl USING csv AS WITH s AS (SELECT 42 AS col) SELECT * FROM s;
+
+SELECT * FROM cte_tbl;
+
+-- WITH inside CREATE VIEW
+CREATE TEMPORARY VIEW cte_view AS WITH s AS (SELECT 42 AS col) SELECT * FROM s;
+
+SELECT * FROM cte_view;
+
+-- INSERT inside WITH
+WITH s AS (SELECT 43 AS col)
+INSERT INTO cte_tbl SELECT * FROM S;
+
+SELECT * FROM cte_tbl;
+
+-- WITH inside INSERT
+INSERT INTO cte_tbl WITH s AS (SELECT 44 AS col) SELECT * FROM s;
+
+SELECT * FROM cte_tbl;
+
+CREATE TABLE cte_tbl2 (col INT) USING csv;
+-- Multi-INSERT
+WITH s AS (SELECT 45 AS col)
+FROM s
+INSERT INTO cte_tbl SELECT col
+INSERT INTO cte_tbl2 SELECT col;
+
+SELECT * FROM cte_tbl;
+SELECT * FROM cte_tbl2;
+
+DROP TABLE cte_tbl;
+DROP TABLE cte_tbl2;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-legacy.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-legacy.sql
new file mode 100644
index 000000000000..29dee1a3afd3
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-legacy.sql
@@ -0,0 +1,2 @@
+--SET spark.sql.legacy.ctePrecedencePolicy = legacy
+--IMPORT cte-nested.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-nested.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-nested.sql
new file mode 100644
index 000000000000..3b2ba1fcdd66
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-nested.sql
@@ -0,0 +1,228 @@
+-- CTE in CTE definition
+WITH t as (
+ WITH t2 AS (SELECT 1)
+ SELECT * FROM t2
+)
+SELECT * FROM t;
+
+-- CTE in subquery
+SELECT max(c) FROM (
+ WITH t(c) AS (SELECT 1)
+ SELECT * FROM t
+);
+
+-- CTE in subquery expression
+SELECT (
+ WITH t AS (SELECT 1)
+ SELECT * FROM t
+);
+
+-- un-referenced CTE in subquery expression: outer reference in CTE relation
+SELECT (
+ WITH unreferenced AS (SELECT id)
+ SELECT 1
+) FROM range(1);
+
+-- un-referenced CTE in subquery expression: outer reference in CTE main query
+SELECT (
+ WITH unreferenced AS (SELECT 1)
+ SELECT id
+) FROM range(1);
+
+-- Make sure CTE in subquery is scoped to that subquery rather than global
+-- the 2nd half of the union should fail because the cte is scoped to the first half
+SELECT * FROM
+ (
+ WITH cte AS (SELECT * FROM range(10))
+ SELECT * FROM cte WHERE id = 8
+ ) a
+UNION
+SELECT * FROM cte;
+
+-- CTE in CTE definition shadows outer
+WITH
+ t AS (SELECT 1),
+ t2 AS (
+ WITH t AS (SELECT 2)
+ SELECT * FROM t
+ )
+SELECT * FROM t2;
+
+-- CTE in CTE definition shadows outer 2
+WITH
+ t(c) AS (SELECT 1),
+ t2 AS (
+ SELECT (
+ SELECT max(c) FROM (
+ WITH t(c) AS (SELECT 2)
+ SELECT * FROM t
+ )
+ )
+ )
+SELECT * FROM t2;
+
+-- CTE in CTE definition shadows outer 3
+WITH
+ t AS (SELECT 1),
+ t2 AS (
+ WITH t AS (SELECT 2),
+ t2 AS (
+ WITH t AS (SELECT 3)
+ SELECT * FROM t
+ )
+ SELECT * FROM t2
+ )
+SELECT * FROM t2;
+
+-- CTE in subquery shadows outer
+WITH t(c) AS (SELECT 1)
+SELECT max(c) FROM (
+ WITH t(c) AS (SELECT 2)
+ SELECT * FROM t
+);
+
+-- CTE in subquery shadows outer 2
+WITH t(c) AS (SELECT 1)
+SELECT sum(c) FROM (
+ SELECT max(c) AS c FROM (
+ WITH t(c) AS (SELECT 2)
+ SELECT * FROM t
+ )
+);
+
+-- CTE in subquery shadows outer 3
+WITH t(c) AS (SELECT 1)
+SELECT sum(c) FROM (
+ WITH t(c) AS (SELECT 2)
+ SELECT max(c) AS c FROM (
+ WITH t(c) AS (SELECT 3)
+ SELECT * FROM t
+ )
+);
+
+-- CTE in subquery expression shadows outer
+WITH t AS (SELECT 1)
+SELECT (
+ WITH t AS (SELECT 2)
+ SELECT * FROM t
+);
+
+-- CTE in subquery expression shadows outer 2
+WITH t AS (SELECT 1)
+SELECT (
+ SELECT (
+ WITH t AS (SELECT 2)
+ SELECT * FROM t
+ )
+);
+
+-- CTE in subquery expression shadows outer 3
+WITH t AS (SELECT 1)
+SELECT (
+ WITH t AS (SELECT 2)
+ SELECT (
+ WITH t AS (SELECT 3)
+ SELECT * FROM t
+ )
+);
+
+-- CTE in subquery expression shadows outer 4
+WITH t(c) AS (SELECT 1)
+SELECT * FROM t
+WHERE c IN (
+ WITH t(c) AS (SELECT 2)
+ SELECT * FROM t
+);
+
+-- forward name conflict is not a real conflict
+WITH
+ t AS (
+ WITH t2 AS (SELECT 1)
+ SELECT * FROM t2
+ ),
+ t2 AS (SELECT 2)
+SELECT * FROM t;
+
+-- case insensitive name conflicts: in other CTE relations
+WITH
+ abc AS (SELECT 1),
+ t AS (
+ WITH aBc AS (SELECT 2)
+ SELECT * FROM aBC
+ )
+SELECT * FROM t;
+
+-- case insensitive name conflicts: in subquery expressions
+WITH abc AS (SELECT 1)
+SELECT (
+ WITH aBc AS (SELECT 2)
+ SELECT * FROM aBC
+);
+
+-- SPARK-38404: CTE in CTE definition references outer
+WITH
+ t1 AS (SELECT 1),
+ t2 AS (
+ WITH t3 AS (
+ SELECT * FROM t1
+ )
+ SELECT * FROM t3
+ )
+SELECT * FROM t2;
+
+-- CTE nested in CTE main body FROM clause references outer CTE def
+WITH cte_outer AS (
+ SELECT 1
+)
+SELECT * FROM (
+ WITH cte_inner AS (
+ SELECT * FROM cte_outer
+ )
+ SELECT * FROM cte_inner
+);
+
+-- CTE double nested in CTE main body FROM clause references outer CTE def
+WITH cte_outer AS (
+ SELECT 1
+)
+SELECT * FROM (
+ WITH cte_inner AS (
+ SELECT * FROM (
+ WITH cte_inner_inner AS (
+ SELECT * FROM cte_outer
+ )
+ SELECT * FROM cte_inner_inner
+ )
+ )
+ SELECT * FROM cte_inner
+);
+
+-- Invalid reference to invisible CTE def nested CTE def
+WITH cte_outer AS (
+ WITH cte_invisible_inner AS (
+ SELECT 1
+ )
+ SELECT * FROM cte_invisible_inner
+)
+SELECT * FROM (
+ WITH cte_inner AS (
+ SELECT * FROM cte_invisible_inner
+ )
+ SELECT * FROM cte_inner
+);
+
+-- Invalid reference to invisible CTE def nested CTE def (in FROM)
+WITH cte_outer AS (
+ SELECT * FROM (
+ WITH cte_invisible_inner AS (
+ SELECT 1
+ )
+ SELECT * FROM cte_invisible_inner
+ )
+)
+SELECT * FROM (
+ WITH cte_inner AS (
+ SELECT * FROM cte_invisible_inner
+ )
+ SELECT * FROM cte_inner
+);
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-nonlegacy.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-nonlegacy.sql
new file mode 100644
index 000000000000..3316f6740281
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte-nonlegacy.sql
@@ -0,0 +1,2 @@
+--SET spark.sql.legacy.ctePrecedencePolicy = EXCEPTION
+--IMPORT cte-nested.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte.sql
new file mode 100644
index 000000000000..ecf760ecac70
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/cte.sql
@@ -0,0 +1,184 @@
+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);
+create temporary view t3 as select * from t;
+
+-- 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;
+
+-- Table `t` referenced by a view should take precedence over the top CTE `t`
+WITH t AS (SELECT 1) SELECT * FROM t3;
+
+-- 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;
+DROP VIEW IF EXISTS t3;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/current_database_catalog.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/current_database_catalog.sql
new file mode 100644
index 000000000000..d7aed6afaa17
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/current_database_catalog.sql
@@ -0,0 +1,2 @@
+-- get current_database/current_schema and current_catalog
+select current_database(), current_schema(), current_catalog();
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/date.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/date.sql
new file mode 100644
index 000000000000..c1ae432d6316
--- /dev/null
+++ b/gluten-ut/spark41/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/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-formatting-invalid.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-formatting-invalid.sql
new file mode 100644
index 000000000000..11bba00e91ab
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-formatting-invalid.sql
@@ -0,0 +1,53 @@
+--- TESTS FOR DATETIME FORMATTING FUNCTIONS WITH INVALID PATTERNS ---
+
+-- separating this from datetime-formatting.sql, because the text form
+-- for patterns with 5 letters in SimpleDateFormat varies from different JDKs
+select date_format('2018-11-17 13:33:33.333', 'GGGGG');
+-- pattern letter count can not be greater than 6
+select date_format('2018-11-17 13:33:33.333', 'yyyyyyy');
+-- q/L in JDK 8 will fail when the count is more than 2
+select date_format('2018-11-17 13:33:33.333', 'qqqqq');
+select date_format('2018-11-17 13:33:33.333', 'QQQQQ');
+select date_format('2018-11-17 13:33:33.333', 'MMMMM');
+select date_format('2018-11-17 13:33:33.333', 'LLLLL');
+
+select date_format('2018-11-17 13:33:33.333', 'EEEEE');
+select date_format('2018-11-17 13:33:33.333', 'FF');
+select date_format('2018-11-17 13:33:33.333', 'ddd');
+-- DD is invalid if the day-of-year exceeds 100, but it becomes valid in Java 11
+-- select date_format('2018-11-17 13:33:33.333', 'DD');
+select date_format('2018-11-17 13:33:33.333', 'DDDD');
+select date_format('2018-11-17 13:33:33.333', 'HHH');
+select date_format('2018-11-17 13:33:33.333', 'hhh');
+select date_format('2018-11-17 13:33:33.333', 'kkk');
+select date_format('2018-11-17 13:33:33.333', 'KKK');
+select date_format('2018-11-17 13:33:33.333', 'mmm');
+select date_format('2018-11-17 13:33:33.333', 'sss');
+select date_format('2018-11-17 13:33:33.333', 'SSSSSSSSSS');
+select date_format('2018-11-17 13:33:33.333', 'aa');
+select date_format('2018-11-17 13:33:33.333', 'V');
+select date_format('2018-11-17 13:33:33.333', 'zzzzz');
+select date_format('2018-11-17 13:33:33.333', 'XXXXXX');
+select date_format('2018-11-17 13:33:33.333', 'ZZZZZZ');
+select date_format('2018-11-17 13:33:33.333', 'OO');
+select date_format('2018-11-17 13:33:33.333', 'xxxxxx');
+
+select date_format('2018-11-17 13:33:33.333', 'A');
+select date_format('2018-11-17 13:33:33.333', 'n');
+select date_format('2018-11-17 13:33:33.333', 'N');
+select date_format('2018-11-17 13:33:33.333', 'p');
+
+-- disabled week-based patterns
+select date_format('2018-11-17 13:33:33.333', 'Y');
+select date_format('2018-11-17 13:33:33.333', 'w');
+select date_format('2018-11-17 13:33:33.333', 'W');
+select date_format('2018-11-17 13:33:33.333', 'u');
+select date_format('2018-11-17 13:33:33.333', 'e');
+select date_format('2018-11-17 13:33:33.333', 'c');
+
+-- others
+select date_format('2018-11-17 13:33:33.333', 'B');
+select date_format('2018-11-17 13:33:33.333', 'C');
+select date_format('2018-11-17 13:33:33.333', 'I');
+
+
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-formatting-legacy.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-formatting-legacy.sql
new file mode 100644
index 000000000000..19cab61a7ee5
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-formatting-legacy.sql
@@ -0,0 +1,2 @@
+--SET spark.sql.legacy.timeParserPolicy=LEGACY
+--IMPORT datetime-formatting.sql
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-formatting.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-formatting.sql
new file mode 100644
index 000000000000..3618bb5c399f
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-formatting.sql
@@ -0,0 +1,73 @@
+--- TESTS FOR DATETIME FORMATTING FUNCTIONS ---
+
+create temporary view v as select col from values
+ (timestamp '1582-06-01 11:33:33.123UTC+080000'),
+ (timestamp '1970-01-01 00:00:00.000Europe/Paris'),
+ (timestamp '1970-12-31 23:59:59.999Asia/Srednekolymsk'),
+ (timestamp '1996-04-01 00:33:33.123Australia/Darwin'),
+ (timestamp '2018-11-17 13:33:33.123Z'),
+ (timestamp '2020-01-01 01:33:33.123Asia/Shanghai'),
+ (timestamp '2100-01-01 01:33:33.123America/Los_Angeles') t(col);
+
+select col, date_format(col, 'G GG GGG GGGG'), to_char(col, 'G GG GGG GGGG'), to_varchar(col, 'G GG GGG GGGG') from v;
+
+select col, date_format(col, 'y yy yyy yyyy yyyyy yyyyyy'), to_char(col, 'y yy yyy yyyy yyyyy yyyyyy'), to_varchar(col, 'y yy yyy yyyy yyyyy yyyyyy') from v;
+
+select col, date_format(col, 'q qq'), to_char(col, 'q qq'), to_varchar(col, 'q qq') from v;
+
+select col, date_format(col, 'Q QQ QQQ QQQQ'), to_char(col, 'Q QQ QQQ QQQQ'), to_varchar(col, 'Q QQ QQQ QQQQ') from v;
+
+select col, date_format(col, 'M MM MMM MMMM'), to_char(col, 'M MM MMM MMMM'), to_varchar(col, 'M MM MMM MMMM') from v;
+
+select col, date_format(col, 'L LL'), to_char(col, 'L LL'), to_varchar(col, 'L LL') from v;
+
+select col, date_format(col, 'E EE EEE EEEE'), to_char(col, 'E EE EEE EEEE'), to_varchar(col, 'E EE EEE EEEE') from v;
+
+select col, date_format(col, 'F'), to_char(col, 'F'), to_varchar(col, 'F') from v;
+
+select col, date_format(col, 'd dd'), to_char(col, 'd dd'), to_varchar(col, 'd dd') from v;
+
+select col, date_format(col, 'DD'), to_char(col, 'DD'), to_varchar(col, 'DD') from v where col = timestamp '2100-01-01 01:33:33.123America/Los_Angeles';
+select col, date_format(col, 'D DDD'), to_char(col, 'D DDD'), to_varchar(col, 'D DDD') from v;
+
+select col, date_format(col, 'H HH'), to_char(col, 'H HH'), to_varchar(col, 'H HH') from v;
+
+select col, date_format(col, 'h hh'), to_char(col, 'h hh'), to_varchar(col, 'h hh') from v;
+
+select col, date_format(col, 'k kk'), to_char(col, 'k kk'), to_varchar(col, 'k kk') from v;
+
+select col, date_format(col, 'K KK'), to_char(col, 'K KK'), to_varchar(col, 'K KK') from v;
+
+select col, date_format(col, 'm mm'), to_char(col, 'm mm'), to_varchar(col, 'm mm') from v;
+
+select col, date_format(col, 's ss'), to_char(col, 's ss'), to_varchar(col, 's ss') from v;
+
+select col, date_format(col, 'S SS SSS SSSS SSSSS SSSSSS SSSSSSS SSSSSSSS SSSSSSSSS'), to_char(col, 'S SS SSS SSSS SSSSS SSSSSS SSSSSSS SSSSSSSS SSSSSSSSS'), to_varchar(col, 'S SS SSS SSSS SSSSS SSSSSS SSSSSSS SSSSSSSS SSSSSSSSS') from v;
+
+select col, date_format(col, 'a'), to_char(col, 'a'), to_varchar(col, 'a') from v;
+
+select col, date_format(col, 'VV'), to_char(col, 'VV'), to_varchar(col, 'VV') from v;
+
+select col, date_format(col, 'z zz zzz zzzz'), to_char(col, 'z zz zzz zzzz'), to_varchar(col, 'z zz zzz zzzz') from v;
+
+select col, date_format(col, 'X XX XXX'), to_char(col, 'X XX XXX'), to_varchar(col, 'X XX XXX') from v;
+select col, date_format(col, 'XXXX XXXXX'), to_char(col, 'XXXX XXXXX'), to_varchar(col, 'XXXX XXXXX') from v;
+
+select col, date_format(col, 'Z ZZ ZZZ ZZZZ ZZZZZ'), to_char(col, 'Z ZZ ZZZ ZZZZ ZZZZZ'), to_varchar(col, 'Z ZZ ZZZ ZZZZ ZZZZZ') from v;
+
+select col, date_format(col, 'O OOOO'), to_char(col, 'O OOOO'), to_varchar(col, 'O OOOO') from v;
+
+select col, date_format(col, 'x xx xxx xxxx xxxx xxxxx'), to_char(col, 'x xx xxx xxxx xxxx xxxxx'), to_varchar(col, 'x xx xxx xxxx xxxx xxxxx') from v;
+
+-- optional pattern, but the results won't be optional for formatting
+select col, date_format(col, '[yyyy-MM-dd HH:mm:ss]'), to_char(col, '[yyyy-MM-dd HH:mm:ss]'), to_varchar(col, '[yyyy-MM-dd HH:mm:ss]') from v;
+
+-- literals
+select col, date_format(col, "姚123'GyYqQMLwWuEFDdhHmsSaVzZxXOV'"), to_char(col, "姚123'GyYqQMLwWuEFDdhHmsSaVzZxXOV'"), to_varchar(col, "姚123'GyYqQMLwWuEFDdhHmsSaVzZxXOV'") from v;
+select col, date_format(col, "''"), to_char(col, "''"), to_varchar(col, "''") from v;
+select col, date_format(col, ''), to_char(col, ''), to_varchar(col, '') from v;
+
+-- different datetime types
+select date_format(date'2023-08-18', 'yyyy-MM-dd'), to_char(date'2023-08-18', 'yyyy-MM-dd'), to_varchar(date'2023-08-18', 'yyyy-MM-dd');
+select date_format(timestamp_ltz'2023-08-18 09:13:14.123456Z', 'yyyy-MM-dd HH:mm:ss.SSSSSSZ'), to_char(timestamp_ltz'2023-08-18 09:13:14.123456Z', 'yyyy-MM-dd HH:mm:ss.SSSSSSZ'), to_varchar(timestamp_ltz'2023-08-18 09:13:14.123456Z', 'yyyy-MM-dd HH:mm:ss.SSSSSSZ');
+select date_format(timestamp_ntz'2023-08-18 09:13:14.123456', 'yyyy-MM-dd HH:mm:ss.SSSSSS'), to_char(timestamp_ntz'2023-08-18 09:13:14.123456', 'yyyy-MM-dd HH:mm:ss.SSSSSS'), to_varchar(timestamp_ntz'2023-08-18 09:13:14.123456', 'yyyy-MM-dd HH:mm:ss.SSSSSS');
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-legacy.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-legacy.sql
new file mode 100644
index 000000000000..22b29f3451ff
--- /dev/null
+++ b/gluten-ut/spark41/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/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-invalid.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-invalid.sql
new file mode 100644
index 000000000000..1f5a9b117ca2
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-invalid.sql
@@ -0,0 +1,39 @@
+--- 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('1', 'yy'); -- the number of digits must be 2 for 'yy'.
+select to_timestamp('-12', 'yy'); -- out of year value range [0, 99] for reduced two digit form
+select to_timestamp('123', 'yy'); -- the number of digits must be 2 for 'yy'.
+select to_timestamp('1', 'yyy'); -- the number of digits must be in [3, 6] for 'yyy'
+
+select to_timestamp('1234567', 'yyyyyyy'); -- the length of 'y' pattern must be less than 7
+
+-- parsing invalid values with pattern 'D'
+select to_timestamp('366', 'D');
+select to_timestamp('9', 'DD');
+select to_timestamp('366', 'DD');
+select to_timestamp('9', 'DDD');
+select to_timestamp('99', 'DDD');
+select to_timestamp('30-365', 'dd-DDD');
+select to_timestamp('11-365', 'MM-DDD');
+select to_timestamp('2019-366', 'yyyy-DDD');
+select to_timestamp('12-30-365', 'MM-dd-DDD');
+select to_timestamp('2020-01-365', 'yyyy-dd-DDD');
+select to_timestamp('2020-10-350', 'yyyy-MM-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/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-legacy.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing-legacy.sql
new file mode 100644
index 000000000000..ee1afe502ab7
--- /dev/null
+++ b/gluten-ut/spark41/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/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing.sql
new file mode 100644
index 000000000000..f87ae556867b
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-parsing.sql
@@ -0,0 +1,45 @@
+--- 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');
+select to_timestamp('009999', 'y');
+
+-- reduced two digit form is used, the range of valid year is 20-[01, 99]
+select to_timestamp('00', 'yy');
+select to_timestamp('99', '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');
+select to_timestamp('009999', 'yyy');
+
+-- the range of valid year is [-9999, 9999], the number of digits must be 4 for 'yyyy'.
+select to_timestamp('0001', 'yyyy');
+select to_timestamp('9999', 'yyyy');
+
+-- the range of valid year is [-99999, 99999], the number of digits must be 5 for 'yyyyy'.
+select to_timestamp('00001', 'yyyyy');
+select to_timestamp('09999', 'yyyyy');
+
+-- the range of valid year is [-290307, 294247], the number of digits must be 6 for 'yyyyyy'.
+select to_timestamp('000001', 'yyyyyy');
+select to_timestamp('009999', 'yyyyyy');
+
+-- parsing with pattern 'D'
+select to_timestamp('9', 'D');
+select to_timestamp('300', 'D');
+select to_timestamp('09', 'DD');
+select to_timestamp('99', 'DD');
+select to_timestamp('100', 'DD');
+select to_timestamp('009', 'DDD');
+select to_timestamp('365', 'DDD');
+select to_timestamp('31-365', 'dd-DDD');
+select to_timestamp('12-365', 'MM-DDD');
+select to_timestamp('2020-365', 'yyyy-DDD');
+select to_timestamp('12-31-365', 'MM-dd-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/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-special.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-special.sql
new file mode 100644
index 000000000000..2699274bb7c9
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/datetime-special.sql
@@ -0,0 +1,10 @@
+-- special date and timestamp values that are not allowed in the SQL standard
+-- these tests are put in this separated file because they don't work in JDBC environment
+
+-- date with year outside [0000-9999]
+select date'999999-03-18', date'-0001-1-28', date'0015';
+select make_date(999999, 3, 18), make_date(-1, 1, 28);
+
+-- timestamp with year outside [0000-9999]
+select timestamp'-1969-12-31 16:00:00', timestamp'-0015-03-18 16:00:00', timestamp'-000001', timestamp'99999-03-18T12:03:17';
+select make_timestamp(-1969, 12, 31, 16, 0, 0.0), make_timestamp(-15, 3, 18, 16, 0, 0.0), make_timestamp(99999, 3, 18, 12, 3, 17.0);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/decimalArithmeticOperations.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/decimalArithmeticOperations.sql
new file mode 100644
index 000000000000..13bbd9d81b79
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/decimalArithmeticOperations.sql
@@ -0,0 +1,125 @@
+--
+-- 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 1.0 as a, 0.0 as b;
+
+-- division, remainder and pmod by 0 return NULL
+select a / b from t;
+select a % b from t;
+select pmod(a, b) from t;
+
+-- tests for decimals handling in operations
+create table decimals_test(id int, a decimal(38,18), b decimal(38,18)) using parquet;
+
+insert into decimals_test values(1, 100.0, 999.0), (2, 12345.123, 12345.123),
+ (3, 0.1234567891011, 1234.1), (4, 123456789123456789.0, 1.123456789123456789);
+
+-- test decimal operations
+select id, a+b, a-b, a*b, a/b from decimals_test order by id;
+
+-- test operations between decimals and constants
+select id, a*10, b/10 from decimals_test order by id;
+
+-- test operations on constants
+select 10.3 * 3.0;
+select 10.3000 * 3.0;
+select 10.30000 * 30.0;
+select 10.300000000000000000 * 3.000000000000000000;
+select 10.300000000000000000 * 3.0000000000000000000;
+select 2.35E10 * 1.0;
+
+-- arithmetic operations causing an overflow return NULL
+select (5e36BD + 0.1) + 5e36BD;
+select (-4e36BD - 0.1) - 7e36BD;
+select 12345678901234567890.0 * 12345678901234567890.0;
+select 1e35BD / 0.1;
+select 1.2345678901234567890E30BD * 1.2345678901234567890E25BD;
+
+-- arithmetic operations causing a precision loss are truncated
+select 12345678912345678912345678912.1234567 + 9999999999999999999999999999999.12345;
+select 123456789123456789.1234567890 * 1.123456789123456789;
+select 12345678912345.123456789123 / 0.000000012345678;
+
+-- union decimal type
+
+SELECT CAST(20 AS DECIMAL(4, 1))
+UNION ALL
+SELECT CAST(10 AS DECIMAL(3, 1)) + CAST(90 AS DECIMAL(3, 1));
+
+SELECT CAST(20 AS DECIMAL(4, 1))
+UNION ALL
+SELECT CAST(10 AS DECIMAL(3, 1)) - CAST(-90 AS DECIMAL(3, 1));
+
+SELECT CAST(20 AS DECIMAL(4, 1))
+UNION ALL
+SELECT CAST(10 AS DECIMAL(3, 1)) * CAST(10 AS DECIMAL(3, 1));
+
+SELECT CAST(20 AS DECIMAL(4, 1))
+UNION ALL
+SELECT CAST(10 AS DECIMAL(3, 1)) / CAST(10 AS DECIMAL(3, 1));
+
+SELECT CAST(20 AS DECIMAL(4, 1))
+UNION ALL
+SELECT CAST(10 AS DECIMAL(10, 2)) % CAST(3 AS DECIMAL(5, 1));
+
+SELECT CAST(20 AS DECIMAL(4, 1))
+UNION ALL
+SELECT pmod(CAST(10 AS DECIMAL(10, 2)), CAST(3 AS DECIMAL(5, 1)));
+
+SELECT CAST(20 AS DECIMAL(4, 1))
+UNION ALL
+SELECT CAST(10 AS DECIMAL(10, 2)) div CAST(3 AS DECIMAL(5, 1));
+
+-- return NULL instead of rounding, according to old Spark versions' behavior
+set spark.sql.decimalOperations.allowPrecisionLoss=false;
+
+-- test decimal operations
+select /*+ COALESCE(1) */ id, a+b, a-b, a*b, a/b from decimals_test order by id;
+
+-- test operations between decimals and constants
+select id, a*10, b/10 from decimals_test order by id;
+
+-- test operations on constants
+select 10.3 * 3.0;
+select 10.3000 * 3.0;
+select 10.30000 * 30.0;
+select 10.300000000000000000 * 3.000000000000000000;
+select 10.300000000000000000 * 3.0000000000000000000;
+select 2.35E10 * 1.0;
+
+-- arithmetic operations causing an overflow return NULL
+select (5e36BD + 0.1) + 5e36BD;
+select (-4e36BD - 0.1) - 7e36BD;
+select 12345678901234567890.0 * 12345678901234567890.0;
+select 1e35BD / 0.1;
+select 1.2345678901234567890E30BD * 1.2345678901234567890E25BD;
+
+-- arithmetic operations causing a precision loss return NULL
+select 12345678912345678912345678912.1234567 + 9999999999999999999999999999999.12345;
+select 123456789123456789.1234567890 * 1.123456789123456789;
+select 12345678912345.123456789123 / 0.000000012345678;
+
+select 1.0123456789012345678901234567890123456e36BD / 0.1;
+select 1.0123456789012345678901234567890123456e35BD / 1.0;
+select 1.0123456789012345678901234567890123456e34BD / 1.0;
+select 1.0123456789012345678901234567890123456e33BD / 1.0;
+select 1.0123456789012345678901234567890123456e32BD / 1.0;
+select 1.0123456789012345678901234567890123456e31BD / 1.0;
+select 1.0123456789012345678901234567890123456e31BD / 0.1;
+select 1.0123456789012345678901234567890123456e31BD / 10.0;
+
+drop table decimals_test;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe-part-after-analyze.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe-part-after-analyze.sql
new file mode 100644
index 000000000000..f4239da90627
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe-part-after-analyze.sql
@@ -0,0 +1,34 @@
+CREATE TABLE t (key STRING, value STRING, ds STRING, hr INT) USING parquet
+ PARTITIONED BY (ds, hr);
+
+INSERT INTO TABLE t PARTITION (ds='2017-08-01', hr=10)
+VALUES ('k1', 100), ('k2', 200), ('k3', 300);
+
+INSERT INTO TABLE t PARTITION (ds='2017-08-01', hr=11)
+VALUES ('k1', 101), ('k2', 201), ('k3', 301), ('k4', 401);
+
+INSERT INTO TABLE t PARTITION (ds='2017-09-01', hr=5)
+VALUES ('k1', 102), ('k2', 202);
+
+DESC EXTENDED t PARTITION (ds='2017-08-01', hr=10);
+
+-- Collect stats for a single partition
+ANALYZE TABLE t PARTITION (ds='2017-08-01', hr=10) COMPUTE STATISTICS;
+
+DESC EXTENDED t PARTITION (ds='2017-08-01', hr=10);
+
+-- Collect stats for 2 partitions
+ANALYZE TABLE t PARTITION (ds='2017-08-01') COMPUTE STATISTICS;
+
+DESC EXTENDED t PARTITION (ds='2017-08-01', hr=10);
+DESC EXTENDED t PARTITION (ds='2017-08-01', hr=11);
+
+-- Collect stats for all partitions
+ANALYZE TABLE t PARTITION (ds, hr) COMPUTE STATISTICS;
+
+DESC EXTENDED t PARTITION (ds='2017-08-01', hr=10);
+DESC EXTENDED t PARTITION (ds='2017-08-01', hr=11);
+DESC EXTENDED t PARTITION (ds='2017-09-01', hr=5);
+
+-- DROP TEST TABLES/VIEWS
+DROP TABLE t;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe-query.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe-query.sql
new file mode 100644
index 000000000000..f8fbb43ba2f8
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe-query.sql
@@ -0,0 +1,31 @@
+-- Test tables
+CREATE table desc_temp1 (key int COMMENT 'column_comment', val string) USING PARQUET;
+CREATE table desc_temp2 (key int, val string) USING PARQUET;
+
+-- Simple Describe query
+DESC SELECT key, key + 1 as plusone FROM desc_temp1;
+DESC QUERY SELECT * FROM desc_temp2;
+DESC SELECT key, COUNT(*) as count FROM desc_temp1 group by key;
+DESC SELECT 10.00D as col1;
+DESC QUERY SELECT key FROM desc_temp1 UNION ALL select CAST(1 AS DOUBLE);
+DESC QUERY VALUES(1.00D, 'hello') as tab1(col1, col2);
+DESC QUERY FROM desc_temp1 a SELECT *;
+DESC WITH s AS (SELECT 'hello' as col1) SELECT * FROM s;
+DESCRIBE QUERY WITH s AS (SELECT * from desc_temp1) SELECT * FROM s;
+DESCRIBE SELECT * FROM (FROM desc_temp2 select * select *);
+
+-- Error cases.
+DESCRIBE INSERT INTO desc_temp1 values (1, 'val1');
+DESCRIBE INSERT INTO desc_temp1 SELECT * FROM desc_temp2;
+DESCRIBE
+ FROM desc_temp1 a
+ insert into desc_temp1 select *
+ insert into desc_temp2 select *;
+
+-- Explain
+EXPLAIN DESC QUERY SELECT * FROM desc_temp2 WHERE key > 0;
+EXPLAIN EXTENDED DESC WITH s AS (SELECT 'hello' as col1) SELECT * FROM s;
+
+-- cleanup
+DROP TABLE desc_temp1;
+DROP TABLE desc_temp2;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe-table-after-alter-table.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe-table-after-alter-table.sql
new file mode 100644
index 000000000000..69bff6656c43
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe-table-after-alter-table.sql
@@ -0,0 +1,29 @@
+CREATE TABLE table_with_comment (a STRING, b INT, c STRING, d STRING) USING parquet COMMENT 'added';
+
+DESC FORMATTED table_with_comment;
+
+-- ALTER TABLE BY MODIFYING COMMENT
+ALTER TABLE table_with_comment SET TBLPROPERTIES("comment"= "modified comment", "type"= "parquet");
+
+DESC FORMATTED table_with_comment;
+
+-- DROP TEST TABLE
+DROP TABLE table_with_comment;
+
+-- CREATE TABLE WITHOUT COMMENT
+CREATE TABLE table_comment (a STRING, b INT) USING parquet;
+
+DESC FORMATTED table_comment;
+
+-- ALTER TABLE BY ADDING COMMENT
+ALTER TABLE table_comment SET TBLPROPERTIES(comment = "added comment");
+
+DESC formatted table_comment;
+
+-- ALTER UNSET PROPERTIES COMMENT
+ALTER TABLE table_comment UNSET TBLPROPERTIES IF EXISTS ('comment');
+
+DESC FORMATTED table_comment;
+
+-- DROP TEST TABLE
+DROP TABLE table_comment;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe.sql
new file mode 100644
index 000000000000..dbe5bc840bce
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/describe.sql
@@ -0,0 +1,145 @@
+CREATE TABLE t (a STRING, b INT, c STRING, d STRING) USING parquet
+ OPTIONS (a '1', b '2', password 'password')
+ PARTITIONED BY (c, d) CLUSTERED BY (a) SORTED BY (b ASC) INTO 2 BUCKETS
+ COMMENT 'table_comment'
+ TBLPROPERTIES (t 'test', password 'password');
+
+CREATE TEMPORARY VIEW temp_v AS SELECT * FROM t;
+
+CREATE TEMPORARY VIEW temp_Data_Source_View
+ USING org.apache.spark.sql.sources.DDLScanSource
+ OPTIONS (
+ From '1',
+ To '10',
+ Table 'test1');
+
+CREATE VIEW v AS SELECT * FROM t;
+
+ALTER TABLE t SET TBLPROPERTIES (e = '3');
+
+ALTER TABLE t ADD PARTITION (c='Us', d=1);
+
+DESCRIBE t;
+
+DESCRIBE EXTENDED t AS JSON;
+
+-- AnalysisException: describe table as json must be extended
+DESCRIBE t AS JSON;
+
+-- AnalysisException: describe col as json unsupported
+DESC FORMATTED t a AS JSON;
+
+DESC default.t;
+
+DESC TABLE t;
+
+DESC FORMATTED t;
+
+DESC EXTENDED t;
+
+ALTER TABLE t UNSET TBLPROPERTIES (e);
+
+DESC EXTENDED t;
+
+ALTER TABLE t UNSET TBLPROPERTIES (comment);
+
+DESC EXTENDED t;
+
+DESC t PARTITION (c='Us', d=1);
+
+DESC EXTENDED t PARTITION (c='Us', d=1) AS JSON;
+
+DESC EXTENDED t PARTITION (c='Us', d=1);
+
+DESC FORMATTED t PARTITION (c='Us', d=1);
+
+DESC EXTENDED t PARTITION (C='Us', D=1);
+
+-- NoSuchPartitionException: Partition not found in table
+DESC t PARTITION (c='Us', d=2);
+
+-- AnalysisException: Partition spec is invalid
+DESC t PARTITION (c='Us');
+
+-- ParseException: PARTITION specification is incomplete
+DESC t PARTITION (c='Us', d);
+
+-- DESC Temp View
+
+DESC temp_v;
+
+DESC TABLE temp_v;
+
+DESC FORMATTED temp_v;
+
+DESC EXTENDED temp_v;
+
+DESC temp_Data_Source_View;
+
+-- AnalysisException DESC PARTITION is not allowed on a temporary view
+DESC temp_v PARTITION (c='Us', d=1);
+
+-- DESC Persistent View
+
+DESC v;
+
+DESC TABLE v;
+
+DESC FORMATTED v;
+
+DESC EXTENDED v;
+
+-- AnalysisException DESC PARTITION is not allowed on a view
+DESC v PARTITION (c='Us', d=1);
+
+-- Explain Describe Table
+EXPLAIN DESC t;
+EXPLAIN DESC EXTENDED t;
+EXPLAIN EXTENDED DESC t;
+EXPLAIN DESCRIBE t b;
+EXPLAIN DESCRIBE t PARTITION (c='Us', d=2);
+EXPLAIN DESCRIBE EXTENDED t PARTITION (c='Us', d=2) AS JSON;
+
+-- Show column default values
+CREATE TABLE d (a STRING DEFAULT 'default-value', b INT DEFAULT 42) USING parquet COMMENT 'table_comment';
+
+DESC d;
+
+DESC EXTENDED d;
+
+DESC TABLE EXTENDED d;
+
+DESC FORMATTED d;
+
+-- Show column default values with newlines in the string
+CREATE TABLE e (a STRING DEFAULT CONCAT('a\n b\n ', 'c\n d'), b INT DEFAULT 42) USING parquet COMMENT 'table_comment';
+
+DESC e;
+
+DESC EXTENDED e;
+
+DESC TABLE EXTENDED e;
+
+DESC FORMATTED e;
+
+CREATE TABLE f USING json PARTITIONED BY (B, C) AS SELECT 'APACHE' A, CAST('SPARK' AS BINARY) B, TIMESTAMP'2018-11-17 13:33:33' C;
+
+DESC FORMATTED f PARTITION (B='SPARK', C=TIMESTAMP'2018-11-17 13:33:33');
+
+DESC TABLE EXTENDED f PARTITION (B='SPARK', C=TIMESTAMP'2018-11-17 13:33:33') AS JSON;
+
+-- DROP TEST TABLES/VIEWS
+
+DROP VIEW temp_v;
+
+DROP VIEW temp_Data_Source_View;
+
+DROP VIEW v;
+
+DROP TABLE t;
+
+DROP TABLE d;
+
+DROP TABLE e;
+
+DROP TABLE f;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/double-quoted-identifiers-enabled.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/double-quoted-identifiers-enabled.sql
new file mode 100644
index 000000000000..9547d011c76e
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/double-quoted-identifiers-enabled.sql
@@ -0,0 +1,3 @@
+--SET spark.sql.ansi.doubleQuotedIdentifiers=true
+--IMPORT double-quoted-identifiers.sql
+
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/double-quoted-identifiers.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/double-quoted-identifiers.sql
new file mode 100644
index 000000000000..ffb52b403346
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/double-quoted-identifiers.sql
@@ -0,0 +1,57 @@
+-- All these should error out in the parser
+SELECT 1 FROM "not_exist";
+
+USE SCHEMA "not_exist";
+
+ALTER TABLE "not_exist" ADD COLUMN not_exist int;
+
+ALTER TABLE not_exist ADD COLUMN "not_exist" int;
+
+SELECT 1 AS "not_exist" FROM not_exist;
+
+SELECT 1 FROM not_exist AS X("hello");
+
+SELECT "not_exist"();
+
+SELECT "not_exist".not_exist();
+
+-- All these should error out in analysis
+SELECT 1 FROM `hello`;
+
+USE SCHEMA `not_exist`;
+
+ALTER TABLE `not_exist` ADD COLUMN not_exist int;
+
+ALTER TABLE not_exist ADD COLUMN `not_exist` int;
+
+SELECT 1 AS `not_exist` FROM `not_exist`;
+
+SELECT 1 FROM not_exist AS X(`hello`);
+
+SELECT `not_exist`();
+
+SELECT `not_exist`.not_exist();
+
+-- Strings in various situations all work
+SELECT "hello";
+
+CREATE TEMPORARY VIEW v(c1 COMMENT "hello") AS SELECT 1;
+DROP VIEW v;
+
+SELECT INTERVAL "1" YEAR;
+
+-- Single ticks still work
+SELECT 'hello';
+
+CREATE TEMPORARY VIEW v(c1 COMMENT 'hello') AS SELECT 1;
+DROP VIEW v;
+
+SELECT INTERVAL '1' YEAR;
+
+-- A whole scenario
+CREATE SCHEMA "myschema";
+CREATE TEMPORARY VIEW "myview"("c1") AS
+ WITH "v"("a") AS (SELECT 1) SELECT "a" FROM "v";
+SELECT "a1" AS "a2" FROM "myview" AS "atab"("a1");
+DROP TABLE "myview";
+DROP SCHEMA "myschema";
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/except-all.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/except-all.sql
new file mode 100644
index 000000000000..e28f0721a644
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/except-all.sql
@@ -0,0 +1,160 @@
+CREATE TEMPORARY VIEW tab1 AS SELECT * FROM VALUES
+ (0), (1), (2), (2), (2), (2), (3), (null), (null) AS tab1(c1);
+CREATE TEMPORARY VIEW tab2 AS SELECT * FROM VALUES
+ (1), (2), (2), (3), (5), (5), (null) AS tab2(c1);
+CREATE TEMPORARY VIEW tab3 AS SELECT * FROM VALUES
+ (1, 2),
+ (1, 2),
+ (1, 3),
+ (2, 3),
+ (2, 2)
+ AS tab3(k, v);
+CREATE TEMPORARY VIEW tab4 AS SELECT * FROM VALUES
+ (1, 2),
+ (2, 3),
+ (2, 2),
+ (2, 2),
+ (2, 20)
+ AS tab4(k, v);
+
+-- Basic EXCEPT ALL
+SELECT * FROM tab1
+EXCEPT ALL
+SELECT * FROM tab2;
+
+-- MINUS ALL (synonym for EXCEPT)
+SELECT * FROM tab1
+MINUS ALL
+SELECT * FROM tab2;
+
+-- EXCEPT ALL same table in both branches
+SELECT * FROM tab1
+EXCEPT ALL
+SELECT * FROM tab2 WHERE c1 IS NOT NULL;
+
+-- Empty left relation
+SELECT * FROM tab1 WHERE c1 > 5
+EXCEPT ALL
+SELECT * FROM tab2;
+
+-- Empty right relation
+SELECT * FROM tab1
+EXCEPT ALL
+SELECT * FROM tab2 WHERE c1 > 6;
+
+-- Type Coerced ExceptAll
+SELECT * FROM tab1
+EXCEPT ALL
+SELECT CAST(1 AS BIGINT);
+
+-- Error as types of two side are not compatible
+SELECT * FROM tab1
+EXCEPT ALL
+SELECT array(1);
+
+-- Basic
+SELECT * FROM tab3
+EXCEPT ALL
+SELECT * FROM tab4;
+
+-- Basic
+SELECT * FROM tab4
+EXCEPT ALL
+SELECT * FROM tab3;
+
+-- EXCEPT ALL + INTERSECT
+SELECT * FROM tab4
+EXCEPT ALL
+SELECT * FROM tab3
+INTERSECT DISTINCT
+SELECT * FROM tab4;
+
+-- EXCEPT ALL + EXCEPT
+SELECT * FROM tab4
+EXCEPT ALL
+SELECT * FROM tab3
+EXCEPT DISTINCT
+SELECT * FROM tab4;
+
+-- Chain of set operations
+SELECT * FROM tab3
+EXCEPT ALL
+SELECT * FROM tab4
+UNION ALL
+SELECT * FROM tab3
+EXCEPT DISTINCT
+SELECT * FROM tab4;
+
+-- Mismatch on number of columns across both branches
+SELECT k FROM tab3
+EXCEPT ALL
+SELECT k, v FROM tab4;
+
+-- Chain of set operations
+SELECT * FROM tab3
+EXCEPT ALL
+SELECT * FROM tab4
+UNION
+SELECT * FROM tab3
+EXCEPT DISTINCT
+SELECT * FROM tab4;
+
+-- Using MINUS ALL
+SELECT * FROM tab3
+MINUS ALL
+SELECT * FROM tab4
+UNION
+SELECT * FROM tab3
+MINUS DISTINCT
+SELECT * FROM tab4;
+
+-- Chain of set operations
+SELECT * FROM tab3
+EXCEPT ALL
+SELECT * FROM tab4
+EXCEPT DISTINCT
+SELECT * FROM tab3
+EXCEPT DISTINCT
+SELECT * FROM tab4;
+
+-- Join under except all. Should produce empty resultset since both left and right sets
+-- are same.
+SELECT *
+FROM (SELECT tab3.k,
+ tab4.v
+ FROM tab3
+ JOIN tab4
+ ON tab3.k = tab4.k)
+EXCEPT ALL
+SELECT *
+FROM (SELECT tab3.k,
+ tab4.v
+ FROM tab3
+ JOIN tab4
+ ON tab3.k = tab4.k);
+
+-- Join under except all (2)
+SELECT *
+FROM (SELECT tab3.k,
+ tab4.v
+ FROM tab3
+ JOIN tab4
+ ON tab3.k = tab4.k)
+EXCEPT ALL
+SELECT *
+FROM (SELECT tab4.v AS k,
+ tab3.k AS v
+ FROM tab3
+ JOIN tab4
+ ON tab3.k = tab4.k);
+
+-- Group by under ExceptAll
+SELECT v FROM tab3 GROUP BY v
+EXCEPT ALL
+SELECT k FROM tab4 GROUP BY k;
+
+-- Clean-up
+DROP VIEW IF EXISTS tab1;
+DROP VIEW IF EXISTS tab2;
+DROP VIEW IF EXISTS tab3;
+DROP VIEW IF EXISTS tab4;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/except.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/except.sql
new file mode 100644
index 000000000000..ffdf1f4f3d24
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/except.sql
@@ -0,0 +1,76 @@
+-- Tests different scenarios of except operation
+create temporary view t1 as select * from values
+ ("one", 1),
+ ("two", 2),
+ ("three", 3),
+ ("one", NULL)
+ as t1(k, v);
+
+create temporary view t2 as select * from values
+ ("one", 1),
+ ("two", 22),
+ ("one", 5),
+ ("one", NULL),
+ (NULL, 5)
+ as t2(k, v);
+
+
+-- Except operation that will be replaced by left anti join
+SELECT * FROM t1 EXCEPT SELECT * FROM t2;
+
+
+-- Except operation that will be replaced by Filter: SPARK-22181
+SELECT * FROM t1 EXCEPT SELECT * FROM t1 where v <> 1 and v <> 2;
+
+
+-- Except operation that will be replaced by Filter: SPARK-22181
+SELECT * FROM t1 where v <> 1 and v <> 22 EXCEPT SELECT * FROM t1 where v <> 2 and v >= 3;
+
+
+-- Except operation that will be replaced by Filter: SPARK-22181
+SELECT t1.* FROM t1, t2 where t1.k = t2.k
+EXCEPT
+SELECT t1.* FROM t1, t2 where t1.k = t2.k and t1.k != 'one';
+
+
+-- Except operation that will be replaced by left anti join
+SELECT * FROM t2 where v >= 1 and v <> 22 EXCEPT SELECT * FROM t1;
+
+
+-- Except operation that will be replaced by left anti join
+SELECT (SELECT min(k) FROM t2 WHERE t2.k = t1.k) min_t2 FROM t1
+MINUS
+SELECT (SELECT min(k) FROM t2) abs_min_t2 FROM t1 WHERE t1.k = 'one';
+
+
+-- Except operation that will be replaced by left anti join
+SELECT t1.k
+FROM t1
+WHERE t1.v <= (SELECT max(t2.v)
+ FROM t2
+ WHERE t2.k = t1.k)
+MINUS
+SELECT t1.k
+FROM t1
+WHERE t1.v >= (SELECT min(t2.v)
+ FROM t2
+ WHERE t2.k = t1.k);
+
+-- SPARK-32638: corrects references when adding aliases in WidenSetOperationTypes
+CREATE OR REPLACE TEMPORARY VIEW t3 AS VALUES (decimal(1)) tbl(v);
+SELECT t.v FROM (
+ SELECT v FROM t3
+ EXCEPT
+ SELECT v + v AS v FROM t3
+) t;
+
+SELECT SUM(t.v) FROM (
+ SELECT v FROM t3
+ EXCEPT
+ SELECT v + v AS v FROM t3
+) t;
+
+-- Clean-up
+DROP VIEW IF EXISTS t1;
+DROP VIEW IF EXISTS t2;
+DROP VIEW IF EXISTS t3;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/execute-immediate.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/execute-immediate.sql
new file mode 100644
index 000000000000..f7d27c6c0b03
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/execute-immediate.sql
@@ -0,0 +1,149 @@
+-- Automatically generated by SQLQueryTestSuite
+-- !query
+CREATE TEMPORARY VIEW tbl_view AS SELECT * FROM VALUES
+ (10, 'name1', named_struct('f1', 1, 's2', named_struct('f2', 101, 'f3', 'a'))),
+ (20, 'name2', named_struct('f1', 2, 's2', named_struct('f2', 202, 'f3', 'b'))),
+ (30, 'name3', named_struct('f1', 3, 's2', named_struct('f2', 303, 'f3', 'c'))),
+ (40, 'name4', named_struct('f1', 4, 's2', named_struct('f2', 404, 'f3', 'd'))),
+ (50, 'name5', named_struct('f1', 5, 's2', named_struct('f2', 505, 'f3', 'e'))),
+ (60, 'name6', named_struct('f1', 6, 's2', named_struct('f2', 606, 'f3', 'f'))),
+ (70, 'name7', named_struct('f1', 7, 's2', named_struct('f2', 707, 'f3', 'g')))
+AS tbl_view(id, name, data);
+CREATE TABLE x (id INT) USING csv;
+
+DECLARE sql_string STRING;
+SET VAR sql_string = 'SELECT * from tbl_view where name = \'name1\'';
+
+-- test commands
+EXECUTE IMMEDIATE 'SET spark.sql.ansi.enabled=true';
+EXECUTE IMMEDIATE 'CREATE TEMPORARY VIEW IDENTIFIER(:tblName) AS SELECT id, name FROM tbl_view' USING 'tbl_view_tmp' as tblName;
+EXECUTE IMMEDIATE 'SELECT * FROM tbl_view_tmp';
+
+EXECUTE IMMEDIATE 'REFRESH TABLE IDENTIFIER(:tblName)' USING 'x' as tblName;
+
+-- test execute immediate without parameters
+EXECUTE IMMEDIATE sql_string;
+EXECUTE IMMEDIATE 'SELECT * from tbl_view where name = \'name1\'';
+
+-- test positional parameters
+SET VAR sql_string = 'SELECT * from tbl_view where name = ? or name = ?';
+DECLARE a STRING;
+SET VAR a = 'name1';
+EXECUTE IMMEDIATE sql_string USING 'name1', 'name3';
+EXECUTE IMMEDIATE sql_string USING a, 'name2';
+EXECUTE IMMEDIATE 'SELECT * from tbl_view where name = ? or name = ?' USING 'name1', 'name3';
+EXECUTE IMMEDIATE 'SELECT * from tbl_view where name = ? or name = ?' USING a, 'name2';
+EXECUTE IMMEDIATE 'SELECT * from tbl_view where name = ? or name = ?' USING (a, 'name2');
+-- test positional command
+EXECUTE IMMEDIATE 'INSERT INTO x VALUES(?)' USING 1;
+SELECT * from x;
+
+-- test named parameters
+SET VAR sql_string = 'SELECT * from tbl_view where name = :first or id = :second';
+DECLARE b INT;
+SET VAR b = 40;
+EXECUTE IMMEDIATE sql_string USING 40 as second, 'name7' as first;
+EXECUTE IMMEDIATE sql_string USING b as second, 'name7' as first;
+EXECUTE IMMEDIATE 'SELECT * from tbl_view where name = :first or id = :second' USING 40 as second, 'name7' as first;
+EXECUTE IMMEDIATE 'SELECT * from tbl_view where name = :first or id = :second' USING 'name7' as first, b as second;
+-- named parameter used multiple times
+EXECUTE IMMEDIATE 'SELECT tbl_view.*, :first as p FROM tbl_view WHERE name = :first' USING 'name7' as first;
+
+-- test named command and setup for next test
+EXECUTE IMMEDIATE 'SET VAR sql_string = ?' USING 'SELECT id from tbl_view where name = :first';
+SELECT sql_string;
+
+-- test into
+DECLARE res_id INT;
+EXECUTE IMMEDIATE sql_string INTO res_id USING 'name7' as first;
+SELECT res_id;
+EXECUTE IMMEDIATE sql_string INTO res_id USING a as first;
+SELECT res_id;
+
+-- test into without using
+SET VAR sql_string = 'SELECT * from tbl_view where name = :first or id = :second';
+EXECUTE IMMEDIATE 'SELECT 42' INTO res_id;
+SELECT res_id;
+
+-- multiple INTOs
+EXECUTE IMMEDIATE 'SELECT id, name FROM tbl_view WHERE id = ?' INTO b, a USING 10;
+SELECT b, a;
+
+-- use AS for using positional params
+EXECUTE IMMEDIATE 'SELECT * FROM tbl_view where id = ? AND name = ?' USING b as first, a;
+
+-- empty query
+EXECUTE IMMEDIATE 'SELECT 42 WHERE 2 = 1' INTO res_id;
+SELECT res_id;
+
+-- implicit casting
+EXECUTE IMMEDIATE 'SELECT \'1707\'' INTO res_id;
+SELECT res_id;
+
+-- test errors
+-- string to int error
+EXECUTE IMMEDIATE 'SELECT \'invalid_cast_error_expected\'' INTO res_id;
+
+-- require query when using INTO
+EXECUTE IMMEDIATE 'INSERT INTO x VALUES (?)' INTO res_id USING 1;
+
+-- use column in using - should fail as we expect variable here
+EXECUTE IMMEDIATE 'SELECT * FROM tbl_view WHERE ? = id' USING id;
+
+-- either positional or named parameters must be used
+EXECUTE IMMEDIATE 'SELECT * FROM tbl_view where ? = id and :first = name' USING 1, 'name2' as first;
+
+-- all paramerers must be named
+EXECUTE IMMEDIATE 'SELECT * FROM tbl_view where :first = name' USING 1, 'name2' as first;
+
+-- internal syntax error
+EXECUTE IMMEDIATE 'SELCT Fa';
+
+-- internal syntax error - test that both parseQuery and parsePlan fail
+EXECUTE IMMEDIATE 'SELCT Fa' INTO res_id;
+
+-- Parameter passed must be STRING
+EXECUTE IMMEDIATE b;
+
+-- test expressions should fail with parser error
+SET VAR sql_string = 'SELECT * from tbl_view where name = :first or id = :second';
+SET VAR a = 'na';
+
+-- expressions not supported - feature not supported
+EXECUTE IMMEDIATE 'SELECT * from tbl_view where name = :first' USING CONCAT(a , "me1") as first;
+EXECUTE IMMEDIATE 'SELECT * from tbl_view where name = :first' USING (SELECT 42) as first, 'name2' as second;
+
+-- INTO variables not matching scalar types
+EXECUTE IMMEDIATE 'SELECT id, name FROM tbl_view WHERE id = ?' INTO a, b USING 10;
+
+-- INTO does not support braces - parser error
+EXECUTE IMMEDIATE 'SELECT id, name FROM tbl_view WHERE id = ?' INTO (a, b) USING 10;
+
+-- Error too many rows
+EXECUTE IMMEDIATE 'SELECT id FROM tbl_view' INTO res_id;
+
+-- Error mismatch cardinality
+EXECUTE IMMEDIATE 'SELECT id, data.f1 FROM tbl_view' INTO res_id;
+EXECUTE IMMEDIATE 'SELECT id FROM tbl_view' INTO res_id, b;
+
+-- duplicate aliases
+EXECUTE IMMEDIATE 'SELECT id FROM tbl_view WHERE id = :first' USING 10 as first, 20 as first;
+
+-- no alias
+DECLARE p = 10;
+EXECUTE IMMEDIATE 'SELECT id FROM tbl_view WHERE id = :p' USING p;
+
+-- mixing literals and named parameters
+EXECUTE IMMEDIATE 'SELECT id FROM tbl_view WHERE id = :p' USING p, 'p';
+
+-- duplicate into entry
+EXECUTE IMMEDIATE 'SELECT id, data.f1 FROM tbl_view WHERE id = 10' INTO res_id, res_id;
+
+-- nested execute immediate
+EXECUTE IMMEDIATE 'EXECUTE IMMEDIATE \'SELECT id FROM tbl_view WHERE id = ? USING 10\'';
+
+-- sqlString is null
+SET VAR sql_string = null;
+EXECUTE IMMEDIATE sql_string;
+
+DROP TABLE x;
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/explain-aqe.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/explain-aqe.sql
new file mode 100644
index 000000000000..7aef901da4fb
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/explain-aqe.sql
@@ -0,0 +1,4 @@
+--IMPORT explain.sql
+
+--SET spark.sql.adaptive.enabled=true
+--SET spark.sql.maxMetadataStringLength = 500
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/explain-cbo.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/explain-cbo.sql
new file mode 100644
index 000000000000..eeb2180f7a54
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/explain-cbo.sql
@@ -0,0 +1,27 @@
+--SET spark.sql.cbo.enabled=true
+--SET spark.sql.maxMetadataStringLength = 500
+
+CREATE TABLE explain_temp1(a INT, b INT) USING PARQUET;
+CREATE TABLE explain_temp2(c INT, d INT) USING PARQUET;
+
+ANALYZE TABLE explain_temp1 COMPUTE STATISTICS FOR ALL COLUMNS;
+ANALYZE TABLE explain_temp2 COMPUTE STATISTICS FOR ALL COLUMNS;
+
+EXPLAIN COST WITH max_store_sales AS
+(
+ SELECT max(csales) tpcds_cmax
+ FROM (
+ SELECT sum(b) csales
+ FROM explain_temp1 WHERE a < 100
+ ) x
+),
+best_ss_customer AS
+(
+ SELECT c
+ FROM explain_temp2
+ WHERE d > (SELECT * FROM max_store_sales)
+)
+SELECT c FROM best_ss_customer;
+
+DROP TABLE explain_temp1;
+DROP TABLE explain_temp2;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/explain.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/explain.sql
new file mode 100644
index 000000000000..698ca009b4ff
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/explain.sql
@@ -0,0 +1,136 @@
+--SET spark.sql.codegen.wholeStage = true
+--SET spark.sql.adaptive.enabled = false
+--SET spark.sql.maxMetadataStringLength = 500
+
+-- Test tables
+CREATE table explain_temp1 (key int, val int) USING PARQUET;
+CREATE table explain_temp2 (key int, val int) USING PARQUET;
+CREATE table explain_temp3 (key int, val int) USING PARQUET;
+CREATE table explain_temp4 (key int, val string) USING PARQUET;
+CREATE table explain_temp5 (key int) USING PARQUET PARTITIONED BY(val string);
+
+SET spark.sql.codegen.wholeStage = true;
+
+-- distinct func
+EXPLAIN EXTENDED
+ SELECT sum(distinct val)
+ FROM explain_temp1;
+
+-- single table
+EXPLAIN FORMATTED
+ SELECT key, max(val)
+ FROM explain_temp1
+ WHERE key > 0
+ GROUP BY key
+ ORDER BY key;
+
+EXPLAIN FORMATTED
+ SELECT key, max(val)
+ FROM explain_temp1
+ WHERE key > 0
+ GROUP BY key
+ HAVING max(val) > 0;
+
+-- simple union
+EXPLAIN FORMATTED
+ SELECT key, val FROM explain_temp1 WHERE key > 0
+ UNION
+ SELECT key, val FROM explain_temp1 WHERE key > 1;
+
+-- Join
+EXPLAIN FORMATTED
+ SELECT *
+ FROM explain_temp1 a,
+ explain_temp2 b
+ WHERE a.key = b.key;
+
+EXPLAIN FORMATTED
+ SELECT *
+ FROM explain_temp1 a
+ LEFT OUTER JOIN explain_temp2 b
+ ON a.key = b.key;
+
+-- Subqueries nested.
+EXPLAIN FORMATTED
+ SELECT *
+ FROM explain_temp1
+ WHERE key = (SELECT max(key)
+ FROM explain_temp2
+ WHERE key = (SELECT max(key)
+ FROM explain_temp3
+ WHERE val > 0)
+ AND val = 2)
+ AND val > 3;
+
+EXPLAIN FORMATTED
+ SELECT *
+ FROM explain_temp1
+ WHERE key = (SELECT max(key)
+ FROM explain_temp2
+ WHERE val > 0)
+ OR
+ key = (SELECT avg(key)
+ FROM explain_temp3
+ WHERE val > 0);
+
+-- Reuse subquery
+EXPLAIN FORMATTED
+ SELECT (SELECT Avg(key) FROM explain_temp1) + (SELECT Avg(key) FROM explain_temp1)
+ FROM explain_temp1;
+
+-- CTE + ReuseExchange
+EXPLAIN FORMATTED
+ WITH cte1 AS (
+ SELECT *
+ FROM explain_temp1
+ WHERE key > 10
+ )
+ SELECT * FROM cte1 a, cte1 b WHERE a.key = b.key;
+
+EXPLAIN FORMATTED
+ WITH cte1 AS (
+ SELECT key, max(val)
+ FROM explain_temp1
+ WHERE key > 10
+ GROUP BY key
+ )
+ SELECT * FROM cte1 a, cte1 b WHERE a.key = b.key;
+
+-- A spark plan which has innerChildren other than subquery
+EXPLAIN FORMATTED
+ CREATE VIEW explain_view AS
+ SELECT key, val FROM explain_temp1;
+
+-- HashAggregate
+EXPLAIN FORMATTED
+ SELECT
+ COUNT(val) + SUM(key) as TOTAL,
+ COUNT(key) FILTER (WHERE val > 1)
+ FROM explain_temp1;
+
+-- ObjectHashAggregate
+EXPLAIN FORMATTED
+ SELECT key, sort_array(collect_set(val))[0]
+ FROM explain_temp4
+ GROUP BY key;
+
+-- SortAggregate
+EXPLAIN FORMATTED
+ SELECT key, MIN(val)
+ FROM explain_temp4
+ GROUP BY key;
+
+-- V1 Write
+EXPLAIN EXTENDED INSERT INTO TABLE explain_temp5 SELECT * FROM explain_temp4;
+
+-- cleanup
+DROP TABLE explain_temp1;
+DROP TABLE explain_temp2;
+DROP TABLE explain_temp3;
+DROP TABLE explain_temp4;
+DROP TABLE explain_temp5;
+
+-- SPARK-35479: Format PartitionFilters IN strings in scan nodes
+CREATE table t(v array) USING PARQUET;
+EXPLAIN SELECT * FROM t WHERE v IN (array('a'), null);
+DROP TABLE t;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/extract.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/extract.sql
new file mode 100644
index 000000000000..5fd3362c6964
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/extract.sql
@@ -0,0 +1,167 @@
+CREATE TEMPORARY VIEW t AS select '2011-05-06 07:08:09.1234567' as c, to_timestamp_ntz('2011-05-06 07:08:09.1234567') as ntz, interval 10 year 20 month as i, interval 30 day 40 hour 50 minute 6.7890 second as j;
+
+select extract(year from c), extract(year from ntz), extract(year from i) from t;
+select extract(y from c), extract(y from ntz), extract(y from i) from t;
+select extract(years from c), extract(years from ntz), extract(years from i) from t;
+select extract(yr from c), extract(yr from ntz), extract(yr from i) from t;
+select extract(yrs from c), extract(yrs from ntz), extract(yrs from i) from t;
+
+select extract(yearofweek from c), extract(yearofweek from ntz) from t;
+
+select extract(quarter from c), extract(quarter from ntz) from t;
+select extract(qtr from c), extract(qtr from ntz) from t;
+
+select extract(month from c), extract(month from ntz), extract(month from i) from t;
+select extract(mon from c), extract(mon from ntz), extract(mon from i) from t;
+select extract(mons from c), extract(mons from ntz), extract(mons from i) from t;
+select extract(months from c), extract(months from ntz), extract(months from i) from t;
+
+select extract(week from c), extract(week from ntz) from t;
+select extract(w from c), extract(w from ntz) from t;
+select extract(weeks from c), extract(weeks from ntz) from t;
+
+select extract(day from c), extract(day from ntz), extract(day from j) from t;
+select extract(d from c), extract(d from ntz), extract(d from j) from t;
+select extract(days from c), extract(days from ntz), extract(days from j) from t;
+
+select extract(dayofweek from c), extract(dayofweek from ntz) from t;
+select extract(dow from c), extract(dow from ntz) from t;
+
+select extract(dayofweek_iso from c), extract(dayofweek_iso from ntz) from t;
+select extract(dow_iso from c), extract(dow_iso from ntz) from t;
+
+select extract(doy from c), extract(doy from ntz) from t;
+
+select extract(hour from c), extract(hour from ntz), extract(hour from j) from t;
+select extract(h from c), extract(h from ntz), extract(h from j) from t;
+select extract(hours from c), extract(hours from ntz), extract(hours from j) from t;
+select extract(hr from c), extract(hr from ntz), extract(hr from j) from t;
+select extract(hrs from c), extract(hrs from ntz), extract(hrs from j) from t;
+
+select extract(minute from c), extract(minute from ntz), extract(minute from j) from t;
+select extract(m from c), extract(m from ntz), extract(m from j) from t;
+select extract(min from c), extract(min from ntz), extract(min from j) from t;
+select extract(mins from c), extract(mins from ntz), extract(mins from j) from t;
+select extract(minutes from c), extract(minutes from ntz), extract(minutes from j) from t;
+
+select extract(second from c), extract(second from ntz), extract(second from j) from t;
+select extract(s from c), extract(s from ntz), extract(s from j) from t;
+select extract(sec from c), extract(sec from ntz), extract(sec from j) from t;
+select extract(seconds from c), extract(seconds from ntz), extract(seconds from j) from t;
+select extract(secs from c), extract(secs from ntz), extract(secs from j) from t;
+
+select extract(not_supported from c) from t;
+select extract(not_supported from i) from t;
+select extract(not_supported from j) from t;
+
+select date_part('year', c), date_part('year', ntz), date_part('year', i) from t;
+select date_part('y', c), date_part('y', ntz), date_part('y', i) from t;
+select date_part('years', c), date_part('years', ntz), date_part('years', i) from t;
+select date_part('yr', c), date_part('yr', ntz), date_part('yr', i) from t;
+select date_part('yrs', c), date_part('yrs', ntz), date_part('yrs', i) from t;
+
+select date_part('yearofweek', c), date_part('yearofweek', ntz) from t;
+
+select date_part('quarter', c), date_part('quarter', ntz) from t;
+select date_part('qtr', c), date_part('qtr', ntz) from t;
+
+select date_part('month', c), date_part('month', ntz), date_part('month', i) from t;
+select date_part('mon', c), date_part('mon', ntz), date_part('mon', i) from t;
+select date_part('mons', c), date_part('mons', ntz), date_part('mons', i) from t;
+select date_part('months', c), date_part('months', ntz), date_part('months', i) from t;
+
+select date_part('week', c), date_part('week', ntz) from t;
+select date_part('w', c), date_part('w', ntz) from t;
+select date_part('weeks', c), date_part('weeks', ntz) from t;
+
+select date_part('day', c), date_part('day', ntz), date_part('day', j) from t;
+select date_part('d', c), date_part('d', ntz), date_part('d', j) from t;
+select date_part('days', c), date_part('days', ntz), date_part('days', j) from t;
+
+select date_part('dayofweek', c), date_part('dayofweek', ntz) from t;
+select date_part('dow', c), date_part('dow', ntz) from t;
+
+select date_part('dayofweek_iso', c), date_part('dayofweek_iso', ntz) from t;
+select date_part('dow_iso', c), date_part('dow_iso', ntz) from t;
+
+select date_part('doy', c), date_part('doy', ntz) from t;
+
+select date_part('hour', c), date_part('hour', ntz), date_part('hour', j) from t;
+select date_part('h', c), date_part('h', ntz), date_part('h', j) from t;
+select date_part('hours', c), date_part('hours', ntz), date_part('hours', j) from t;
+select date_part('hr', c), date_part('hr', ntz), date_part('hr', j) from t;
+select date_part('hrs', c), date_part('hrs', ntz), date_part('hrs', j) from t;
+
+select date_part('minute', c), date_part('minute', ntz), date_part('minute', j) from t;
+select date_part('m', c), date_part('m', ntz), date_part('m', j) from t;
+select date_part('min', c), date_part('min', ntz), date_part('min', j) from t;
+select date_part('mins', c), date_part('mins', ntz), date_part('mins', j) from t;
+select date_part('minutes', c), date_part('minutes', ntz), date_part('minutes', j) from t;
+
+select date_part('second', c), date_part('second', ntz), date_part('second', j) from t;
+select date_part('s', c), date_part('s', ntz), date_part('s', j) from t;
+select date_part('sec', c), date_part('sec', ntz), date_part('sec', j) from t;
+select date_part('seconds', c), date_part('seconds', ntz), date_part('seconds', j) from t;
+select date_part('secs', c), date_part('secs', ntz), date_part('secs', j) from t;
+
+select date_part('not_supported', c) from t;
+select date_part(c, c) from t;
+select date_part(null, c) from t;
+
+select date_part(i, i) from t;
+select date_part(null, i) from t;
+
+-- In SPARK-31476, we've supported extract('field', source), too
+select extract('year', c) from t;
+select extract('quarter', c) from t;
+select extract('month', c) from t;
+select extract('week', c) from t;
+select extract('day', c) from t;
+select extract('days', c) from t;
+select extract('dayofweek', c) from t;
+select extract('dow', c) from t;
+select extract('doy', c) from t;
+select extract('hour', c) from t;
+select extract('minute', c) from t;
+select extract('second', c) from t;
+
+select c - j from t;
+select day(c - j) from t;
+select extract(day from c - j) from t;
+select extract(month from to_timestamp(c) - i) from t;
+select extract(second from to_timestamp(c) - j) from t;
+
+-- extract fields from year-month/day-time intervals
+select extract(YEAR from interval '2-1' YEAR TO MONTH);
+select date_part('YEAR', interval '2-1' YEAR TO MONTH);
+select extract(YEAR from -interval '2-1' YEAR TO MONTH);
+select extract(MONTH from interval '2-1' YEAR TO MONTH);
+select date_part('MONTH', interval '2-1' YEAR TO MONTH);
+select extract(MONTH from -interval '2-1' YEAR TO MONTH);
+select date_part(NULL, interval '2-1' YEAR TO MONTH);
+
+-- invalid
+select extract(DAY from interval '2-1' YEAR TO MONTH);
+select date_part('DAY', interval '2-1' YEAR TO MONTH);
+select date_part('not_supported', interval '2-1' YEAR TO MONTH);
+
+select extract(DAY from interval '123 12:34:56.789123123' DAY TO SECOND);
+select date_part('DAY', interval '123 12:34:56.789123123' DAY TO SECOND);
+select extract(DAY from -interval '123 12:34:56.789123123' DAY TO SECOND);
+select extract(HOUR from interval '123 12:34:56.789123123' DAY TO SECOND);
+select date_part('HOUR', interval '123 12:34:56.789123123' DAY TO SECOND);
+select extract(HOUR from -interval '123 12:34:56.789123123' DAY TO SECOND);
+select extract(MINUTE from interval '123 12:34:56.789123123' DAY TO SECOND);
+select date_part('MINUTE', interval '123 12:34:56.789123123' DAY TO SECOND);
+select extract(MINUTE from -interval '123 12:34:56.789123123' DAY TO SECOND);
+select extract(SECOND from interval '123 12:34:56.789123123' DAY TO SECOND);
+select date_part('SECOND', interval '123 12:34:56.789123123' DAY TO SECOND);
+select extract(SECOND from -interval '123 12:34:56.789123123' DAY TO SECOND);
+select date_part(NULL, interval '123 12:34:56.789123123' DAY TO SECOND);
+
+select extract(MONTH from interval '123 12:34:56.789123123' DAY TO SECOND);
+select date_part('not_supported', interval '123 12:34:56.789123123' DAY TO SECOND);
+
+-- alias for date_part
+select datepart('year', c), datepart('year', ntz), datepart('year', i) from t;
+select datepart('DAY', interval '123 12:34:56.789123123' DAY TO SECOND);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-analytics.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-analytics.sql
new file mode 100644
index 000000000000..d6381e59e0d8
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-analytics.sql
@@ -0,0 +1,93 @@
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2)
+AS testData(a, b);
+
+-- CUBE on overlapping columns
+SELECT a + b, b, SUM(a - b) FROM testData GROUP BY a + b, b WITH CUBE;
+
+SELECT a, b, SUM(b) FROM testData GROUP BY a, b WITH CUBE;
+
+-- ROLLUP on overlapping columns
+SELECT a + b, b, SUM(a - b) FROM testData GROUP BY a + b, b WITH ROLLUP;
+
+SELECT a, b, SUM(b) FROM testData GROUP BY a, b WITH ROLLUP;
+
+CREATE OR REPLACE TEMPORARY VIEW courseSales AS SELECT * FROM VALUES
+("dotNET", 2012, 10000), ("Java", 2012, 20000), ("dotNET", 2012, 5000), ("dotNET", 2013, 48000), ("Java", 2013, 30000)
+AS courseSales(course, year, earnings);
+
+-- ROLLUP
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY ROLLUP(course, year) ORDER BY course, year;
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY ROLLUP(course, year, (course, year)) ORDER BY course, year;
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY ROLLUP(course, year, (course, year), ()) ORDER BY course, year;
+
+-- CUBE
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY CUBE(course, year) ORDER BY course, year;
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY CUBE(course, year, (course, year)) ORDER BY course, year;
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY CUBE(course, year, (course, year), ()) ORDER BY course, year;
+
+-- GROUPING SETS
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY course, year GROUPING SETS(course, year);
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY course, year GROUPING SETS(course, year, ());
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY course, year GROUPING SETS(course);
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY course, year GROUPING SETS(year);
+
+-- Partial ROLLUP/CUBE/GROUPING SETS
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY course, CUBE(course, year) ORDER BY course, year;
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY CUBE(course, year), ROLLUP(course, year) ORDER BY course, year;
+SELECT course, year, SUM(earnings) FROM courseSales GROUP BY CUBE(course, year), ROLLUP(course, year), GROUPING SETS(course, year) ORDER BY course, year;
+
+-- GROUPING SETS with aggregate functions containing groupBy columns
+SELECT course, SUM(earnings) AS sum FROM courseSales
+GROUP BY course, earnings GROUPING SETS((), (course), (course, earnings)) ORDER BY course, sum;
+SELECT course, SUM(earnings) AS sum, GROUPING_ID(course, earnings) FROM courseSales
+GROUP BY course, earnings GROUPING SETS((), (course), (course, earnings)) ORDER BY course, sum;
+
+-- GROUPING/GROUPING_ID
+SELECT course, year, GROUPING(course), GROUPING(year), GROUPING_ID(course, year) FROM courseSales
+GROUP BY CUBE(course, year);
+SELECT course, year, GROUPING(course) FROM courseSales GROUP BY course, year;
+SELECT course, year, GROUPING_ID(course, year) FROM courseSales GROUP BY course, year;
+SELECT course, year, grouping__id FROM courseSales GROUP BY CUBE(course, year) ORDER BY grouping__id, course, year;
+
+-- GROUPING/GROUPING_ID in having clause
+SELECT course, year FROM courseSales GROUP BY CUBE(course, year)
+HAVING GROUPING(year) = 1 AND GROUPING_ID(course, year) > 0 ORDER BY course, year;
+SELECT course, year FROM courseSales GROUP BY course, year HAVING GROUPING(course) > 0;
+SELECT course, year FROM courseSales GROUP BY course, year HAVING GROUPING_ID(course) > 0;
+SELECT course, year FROM courseSales GROUP BY CUBE(course, year) HAVING grouping__id > 0;
+
+-- GROUPING/GROUPING_ID in orderBy clause
+SELECT course, year, GROUPING(course), GROUPING(year) FROM courseSales GROUP BY CUBE(course, year)
+ORDER BY GROUPING(course), GROUPING(year), course, year;
+SELECT course, year, GROUPING_ID(course, year) FROM courseSales GROUP BY CUBE(course, year)
+ORDER BY GROUPING(course), GROUPING(year), course, year;
+SELECT course, year FROM courseSales GROUP BY course, year ORDER BY GROUPING(course);
+SELECT course, year FROM courseSales GROUP BY course, year ORDER BY GROUPING_ID(course);
+SELECT course, year FROM courseSales GROUP BY CUBE(course, year) ORDER BY grouping__id, course, year;
+
+-- Aliases in SELECT could be used in ROLLUP/CUBE/GROUPING SETS
+SELECT a + b AS k1, b AS k2, SUM(a - b) FROM testData GROUP BY CUBE(k1, k2);
+SELECT a + b AS k, b, SUM(a - b) FROM testData GROUP BY ROLLUP(k, b);
+SELECT a + b, b AS k, SUM(a - b) FROM testData GROUP BY a + b, k GROUPING SETS(k);
+
+-- GROUP BY use mixed Separate columns and CUBE/ROLLUP/Gr
+SELECT a, b, count(1) FROM testData GROUP BY a, b, CUBE(a, b);
+SELECT a, b, count(1) FROM testData GROUP BY a, b, ROLLUP(a, b);
+SELECT a, b, count(1) FROM testData GROUP BY CUBE(a, b), ROLLUP(a, b);
+SELECT a, b, count(1) FROM testData GROUP BY a, CUBE(a, b), ROLLUP(b);
+SELECT a, b, count(1) FROM testData GROUP BY a, GROUPING SETS((a, b), (a), ());
+SELECT a, b, count(1) FROM testData GROUP BY a, CUBE(a, b), GROUPING SETS((a, b), (a), ());
+SELECT a, b, count(1) FROM testData GROUP BY a, CUBE(a, b), ROLLUP(a, b), GROUPING SETS((a, b), (a), ());
+
+-- Support nested CUBE/ROLLUP/GROUPING SETS in GROUPING SETS
+SELECT a, b, count(1) FROM testData GROUP BY a, GROUPING SETS(ROLLUP(a, b));
+SELECT a, b, count(1) FROM testData GROUP BY a, GROUPING SETS(GROUPING SETS((a, b), (a), ()));
+
+SELECT a, b, count(1) FROM testData GROUP BY a, GROUPING SETS((a, b), GROUPING SETS(ROLLUP(a, b)));
+SELECT a, b, count(1) FROM testData GROUP BY a, GROUPING SETS((a, b, a, b), (a, b, a), (a, b));
+SELECT a, b, count(1) FROM testData GROUP BY a, GROUPING SETS(GROUPING SETS((a, b, a, b), (a, b, a), (a, b)));
+
+SELECT a, b, count(1) FROM testData GROUP BY a, GROUPING SETS(ROLLUP(a, b), CUBE(a, b));
+SELECT a, b, count(1) FROM testData GROUP BY a, GROUPING SETS(GROUPING SETS((a, b), (a), ()), GROUPING SETS((a, b), (a), (b), ()));
+SELECT a, b, count(1) FROM testData GROUP BY a, GROUPING SETS((a, b), (a), (), (a, b), (a), (b), ());
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-alias.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-alias.sql
new file mode 100644
index 000000000000..75afc82f998d
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-alias.sql
@@ -0,0 +1,58 @@
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (null, 1), (3, null), (null, null)
+AS testData(a, b);
+
+-- GROUP BY alias should work with case insensitive names
+SELECT a from testData GROUP BY A;
+
+-- Aliases in SELECT could be used in GROUP BY
+SELECT a AS k, COUNT(b) FROM testData GROUP BY k;
+SELECT a AS k, COUNT(b) FROM testData GROUP BY k HAVING k > 1;
+SELECT col1 AS k, SUM(col2) FROM testData AS t(col1, col2) GROUP BY k;
+SELECT a as alias FROM testData GROUP BY ALIAS;
+
+-- GROUP BY literal
+SELECT a AS k FROM testData GROUP BY 'k';
+SELECT 1 AS k FROM testData GROUP BY 'k';
+
+-- GROUP BY alias with the function name
+SELECT concat_ws(' ', a, b) FROM testData GROUP BY `concat_ws( , a, b)`;
+
+-- GROUP BY column with name same as an alias used in the project list
+SELECT 1 AS a FROM testData GROUP BY a;
+SELECT 1 AS a FROM testData GROUP BY `a`;
+
+-- GROUP BY implicit alias
+SELECT 1 GROUP BY `1`;
+
+-- GROUP BY alias with the subquery name
+SELECT (SELECT a FROM testData) + (SELECT b FROM testData) group by `(scalarsubquery() + scalarsubquery())`;
+
+-- GROUP BY with expression subqueries
+SELECT a, count(*) FROM testData GROUP BY (SELECT b FROM testData);
+SELECT a, count(*) FROM testData GROUP BY a, (SELECT b FROM testData);
+SELECT a, count(*) FROM testData GROUP BY a, (SELECT b FROM testData LIMIT 1);
+SELECT a, count(*) FROM testData GROUP BY a, b IN (SELECT a FROM testData);
+SELECT a, count(*) FROM testData GROUP BY a, a IN (SELECT b FROM testData);
+SELECT a, count(*) FROM testData GROUP BY a, EXISTS(SELECT b FROM testData);
+
+-- GROUP BY alias with invalid col in SELECT list
+SELECT a AS k, COUNT(non_existing) FROM testData GROUP BY k;
+
+-- Aggregate functions cannot be used in GROUP BY
+SELECT COUNT(b) AS k FROM testData GROUP BY k;
+
+-- Ordinal is replaced correctly when grouping by alias of a literal
+SELECT MAX(col1), 3 as abc FROM VALUES(1),(2),(3),(4) GROUP BY col1 % abc;
+
+-- turn off group by aliases
+set spark.sql.groupByAliases=false;
+
+-- Check analysis exceptions
+SELECT a AS k, COUNT(b) FROM testData GROUP BY k;
+SELECT 1 GROUP BY `1`;
+SELECT 1 AS col FROM testData GROUP BY `col`;
+
+-- GROUP BY attribute takes precedence over alias
+SELECT 1 AS a FROM testData GROUP BY `a`;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-all-duckdb.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-all-duckdb.sql
new file mode 100644
index 000000000000..ac6d425a956f
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-all-duckdb.sql
@@ -0,0 +1,29 @@
+-- group by all
+-- additional test cases from DuckDB, given to us by Mosha
+
+create temporary view integers as select * from values
+ (0, 1),
+ (0, 2),
+ (1, 3),
+ (1, NULL)
+ as integers(g, i);
+
+
+SELECT g, SUM(i) FROM integers GROUP BY ALL ORDER BY 1;
+
+SELECT g, SUM(i), COUNT(*), COUNT(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1;
+
+SELECT i%2, SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1;
+
+SELECT (g+i)%2, SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1;
+
+SELECT (g+i)%2 + SUM(i), SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1;
+
+SELECT g, i, g%2, SUM(i), SUM(g) FROM integers GROUP BY ALL ORDER BY 1, 2, 3, 4;
+
+SELECT c0 FROM (SELECT 1 c0) t0 GROUP BY ALL HAVING c0>0;
+
+SELECT c0 FROM (SELECT 1 c0, 1 c1 UNION ALL SELECT 1, 2) t0 GROUP BY ALL ORDER BY c0;
+
+SELECT c0 FROM (SELECT 1 c0, 1 c1 UNION ALL SELECT 1, 2) t0 GROUP BY ALL HAVING c1>0 ORDER BY c0;
+
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-all-mosha.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-all-mosha.sql
new file mode 100644
index 000000000000..451f745a97ee
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-all-mosha.sql
@@ -0,0 +1,32 @@
+-- group by all
+-- additional group by star test cases from Mosha
+create temporary view stuff as select * from values
+ (42, 9.75, 'hello world', '1970-08-07', '13.37', array(1,20,300)),
+ (1337, 1.2345, 'oh no', '2000-01-01', '42.0', array(4000,50000,600000)),
+ (42, 13.37, 'test', '1970-08-07', '1234567890', array(7000000,80000000,900000000))
+ as stuff(i, f, s, t, d, a);
+
+SELECT 100 * SUM(i) + SUM(f) / COUNT(s) AS f1, i AS f2 FROM stuff GROUP BY ALL ORDER BY f2;
+
+SELECT i + 1 AS i1, COUNT(i - 2) ci, f / i AS fi, SUM(i + f) sif FROM stuff GROUP BY ALL ORDER BY 1, 3;
+
+SELECT i AS i, COUNT(i) ci, f AS f, SUM(i + f) sif FROM stuff GROUP BY ALL ORDER BY 1, i, 2, ci, 3, f, 4, sif;
+
+SELECT i + 1, f / i, substring(s, 2, 3), extract(year from t), octet_length(d), size(a) FROM stuff
+GROUP BY ALL ORDER BY 1, 3, 4, 5, 6, 2;
+
+-- unlike Mosha, I'm failing this case because IMO it is too implicit to automatically group by i.
+SELECT i + SUM(f) FROM stuff GROUP BY ALL;
+
+SELECT s AS s, COUNT(*) c FROM stuff GROUP BY ALL HAVING SUM(f) > 0 ORDER BY s;
+
+SELECT SUM(i) si FROM stuff GROUP BY ALL HAVING si > 2;
+
+SELECT SUM(i) si FROM stuff GROUP BY ALL HAVING si < 2;
+
+-- negative test, i shouldn't propagate through the aggregate so the having should fail
+SELECT SUM(i) si FROM stuff GROUP BY ALL HAVING i > 2;
+
+-- negative test, i shouldn't propagate through the aggregate so the order by should fail
+SELECT SUM(i) si FROM stuff GROUP BY ALL ORDER BY i DESC;
+
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-all.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-all.sql
new file mode 100644
index 000000000000..4400c0b57866
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-all.sql
@@ -0,0 +1,85 @@
+-- group by all
+-- see https://www.linkedin.com/posts/mosha_duckdb-firebolt-snowflake-activity-7009615821006131200-VQ0o
+
+create temporary view data as select * from values
+ ("USA", "San Francisco", "Reynold", 1, 11.0),
+ ("USA", "San Francisco", "Matei", 2, 12.0),
+ ("USA", "Berkeley", "Xiao", 3, 13.0),
+ ("China", "Hangzhou", "Wenchen", 4, 14.0),
+ ("China", "Shanghai", "Shanghaiese", 5, 15.0),
+ ("Korea", "Seoul", "Hyukjin", 6, 16.0),
+ ("UK", "London", "Sean", 7, 17.0)
+ as data(country, city, name, id, power);
+
+-- basic
+select country, count(*) from data group by ALL;
+
+-- different case
+select country, count(*) from data group by aLl;
+
+-- a column named "all" would still work
+select all, city, count(*) from (select country as all, city, id from data) group by all, city;
+
+-- a column named "all" should take precedence over the normal group by all expansion
+-- if all refers to the column, then the following should return 3 rows.
+-- if all refers to the global aggregate, then 1 row.
+SELECT count(1) FROM VALUES(1), (2), (3) AS T(all) GROUP BY all;
+
+-- two grouping columns and two aggregates
+select country, city, count(*), sum(power) from data group by all;
+
+-- different ordering
+select count(*), country, city, sum(power) from data group by all;
+
+-- alias in grouping column
+select country as con, count(*) from data group by all;
+
+
+-- alias in aggregate column
+select country, count(*) as cnt from data group by all;
+
+-- scalar expression in grouping column
+select upper(country), count(*) as powerup from data group by all;
+
+-- scalar expression in aggregate column
+select country, sum(power) + 10 as powerup from data group by all;
+
+-- group by all without aggregate, which should just become a distinct
+select country, city from data group by all;
+
+-- make sure aliases are propagated through correctly
+select con, powerup from
+ (select country as con, sum(power) + 10 as powerup from data group by all);
+
+-- having
+select country, count(id) as cnt from data group by all having cnt > 1;
+
+-- no grouping column
+select count(id) from data group by all;
+
+-- a more complex no grouping column case
+select count(id + power / 2) * 3 from data group by all;
+
+-- no grouping column on an empty relation
+-- this should still return one row because we rewrite this to a global aggregate, as opposed to
+-- returning zero row (grouping by a constant).
+select count(*) from (select * from data where country = "DNS") group by all;
+
+-- complex cases that we choose not to infer; fail with a useful error message
+select id + count(*) from data group by all;
+
+-- an even more complex case that we choose not to infer; fail with a useful error message
+select (id + id) / 2 + count(*) * 2 from data group by all;
+
+-- uncorrelated subquery should work
+select country, (select count(*) from data) as cnt, count(id) as cnt_id from data group by all;
+
+-- correlated subquery should also work
+select country, (select count(*) from data d1 where d1.country = d2.country), count(id) from data d2 group by all;
+
+-- correlated subquery together with aggregate function doesn't work.
+-- make sure we report the right error UNRESOLVED_ALL_IN_GROUP_BY, rather than some random subquery error.
+select (select count(*) from data d1 where d1.country = d2.country) + count(id) from data d2 group by all;
+
+-- SELECT list contains unresolved column, should not report UNRESOLVED_ALL_IN_GROUP_BY
+select non_exist from data group by all;
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-filter.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-filter.sql
new file mode 100644
index 000000000000..6d8d0790ec8e
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-filter.sql
@@ -0,0 +1,179 @@
+-- Test filter clause for aggregate expression 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_DIM1 spark.sql.optimizeNullAwareAntiJoin=true
+--CONFIG_DIM1 spark.sql.optimizeNullAwareAntiJoin=false
+
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (null, 1), (3, null), (null, null)
+AS testData(a, b);
+
+CREATE OR REPLACE TEMPORARY VIEW EMP AS SELECT * FROM VALUES
+ (100, "emp 1", date "2005-01-01", 100.00D, 10),
+ (100, "emp 1", date "2005-01-01", 100.00D, 10),
+ (200, "emp 2", date "2003-01-01", 200.00D, 10),
+ (300, "emp 3", date "2002-01-01", 300.00D, 20),
+ (400, "emp 4", date "2005-01-01", 400.00D, 30),
+ (500, "emp 5", date "2001-01-01", 400.00D, NULL),
+ (600, "emp 6 - no dept", date "2001-01-01", 400.00D, 100),
+ (700, "emp 7", date "2010-01-01", 400.00D, 100),
+ (800, "emp 8", date "2016-01-01", 150.00D, 70)
+AS EMP(id, emp_name, hiredate, salary, dept_id);
+
+CREATE OR REPLACE TEMPORARY VIEW DEPT AS SELECT * FROM VALUES
+ (10, "dept 1", "CA"),
+ (20, "dept 2", "NY"),
+ (30, "dept 3", "TX"),
+ (40, "dept 4 - unassigned", "OR"),
+ (50, "dept 5 - unassigned", "NJ"),
+ (70, "dept 7", "FL")
+AS DEPT(dept_id, dept_name, state);
+
+CREATE OR REPLACE TEMPORARY VIEW FilterExpressionTestData AS SELECT * FROM VALUES
+ (1, 2, "asd"),
+ (3, 4, "fgh"),
+ (5, 6, "jkl")
+AS FilterExpressionTestData(num1, num2, str);
+
+-- Aggregate with filter and empty GroupBy expressions.
+SELECT a, COUNT(b) FILTER (WHERE a >= 2) FROM testData;
+SELECT COUNT(a) FILTER (WHERE a = 1), COUNT(b) FILTER (WHERE a > 1) FROM testData;
+SELECT COUNT(id) FILTER (WHERE hiredate = date "2001-01-01") FROM emp;
+SELECT COUNT(id) FILTER (WHERE hiredate = to_date('2001-01-01 00:00:00')) FROM emp;
+SELECT COUNT(id) FILTER (WHERE hiredate = to_timestamp("2001-01-01 00:00:00")) FROM emp;
+SELECT COUNT(id) FILTER (WHERE date_format(hiredate, "yyyy-MM-dd") = "2001-01-01") FROM emp;
+SELECT COUNT(DISTINCT id) FILTER (WHERE date_format(hiredate, "yyyy-MM-dd HH:mm:ss") = "2001-01-01 00:00:00") FROM emp;
+SELECT COUNT(DISTINCT id), COUNT(DISTINCT id) FILTER (WHERE date_format(hiredate, "yyyy-MM-dd HH:mm:ss") = "2001-01-01 00:00:00") FROM emp;
+SELECT COUNT(DISTINCT id) FILTER (WHERE hiredate = to_timestamp("2001-01-01 00:00:00")), COUNT(DISTINCT id) FILTER (WHERE hiredate = to_date('2001-01-01 00:00:00')) FROM emp;
+SELECT SUM(salary), COUNT(DISTINCT id), COUNT(DISTINCT id) FILTER (WHERE hiredate = date "2001-01-01") FROM emp;
+SELECT COUNT(DISTINCT 1) FILTER (WHERE a = 1) FROM testData;
+SELECT COUNT(DISTINCT id) FILTER (WHERE true) FROM emp;
+SELECT COUNT(DISTINCT id) FILTER (WHERE false) FROM emp;
+SELECT COUNT(DISTINCT 2), COUNT(DISTINCT 2,3) FILTER (WHERE dept_id = 40) FROM emp;
+SELECT COUNT(DISTINCT 2), COUNT(DISTINCT 3,2) FILTER (WHERE dept_id = 40) FROM emp;
+SELECT COUNT(DISTINCT 2), COUNT(DISTINCT 2,3) FILTER (WHERE dept_id > 0) FROM emp;
+SELECT COUNT(DISTINCT 2), COUNT(DISTINCT 3,2) FILTER (WHERE dept_id > 0) FROM emp;
+SELECT COUNT(DISTINCT id), COUNT(DISTINCT 2,3) FILTER (WHERE dept_id = 40) FROM emp;
+SELECT COUNT(DISTINCT id), COUNT(DISTINCT 3,2) FILTER (WHERE dept_id = 40) FROM emp;
+SELECT COUNT(DISTINCT id), COUNT(DISTINCT 2,3) FILTER (WHERE dept_id > 0) FROM emp;
+SELECT COUNT(DISTINCT id), COUNT(DISTINCT 3,2) FILTER (WHERE dept_id > 0) FROM emp;
+
+-- Aggregate with filter and non-empty GroupBy expressions.
+SELECT a, COUNT(b) FILTER (WHERE a >= 2) FROM testData GROUP BY a;
+SELECT a, COUNT(b) FILTER (WHERE a != 2) FROM testData GROUP BY b;
+SELECT COUNT(a) FILTER (WHERE a >= 0), COUNT(b) FILTER (WHERE a >= 3) FROM testData GROUP BY a;
+SELECT dept_id, SUM(salary) FILTER (WHERE hiredate > date "2003-01-01") FROM emp GROUP BY dept_id;
+SELECT dept_id, SUM(salary) FILTER (WHERE hiredate > to_date("2003-01-01")) FROM emp GROUP BY dept_id;
+SELECT dept_id, SUM(salary) FILTER (WHERE hiredate > to_timestamp("2003-01-01 00:00:00")) FROM emp GROUP BY dept_id;
+SELECT dept_id, SUM(salary) FILTER (WHERE date_format(hiredate, "yyyy-MM-dd") > "2003-01-01") FROM emp GROUP BY dept_id;
+SELECT dept_id, SUM(DISTINCT salary) FILTER (WHERE date_format(hiredate, "yyyy-MM-dd HH:mm:ss") > "2001-01-01 00:00:00") FROM emp GROUP BY dept_id;
+SELECT dept_id, SUM(DISTINCT salary), SUM(DISTINCT salary) FILTER (WHERE date_format(hiredate, "yyyy-MM-dd HH:mm:ss") > "2001-01-01 00:00:00") FROM emp GROUP BY dept_id;
+SELECT dept_id, SUM(DISTINCT salary) FILTER (WHERE hiredate > date "2001-01-01"), SUM(DISTINCT salary) FILTER (WHERE date_format(hiredate, "yyyy-MM-dd HH:mm:ss") > "2001-01-01 00:00:00") FROM emp GROUP BY dept_id;
+SELECT dept_id, COUNT(id), SUM(DISTINCT salary), SUM(DISTINCT salary) FILTER (WHERE date_format(hiredate, "yyyy-MM-dd") > "2001-01-01") FROM emp GROUP BY dept_id;
+SELECT b, COUNT(DISTINCT 1) FILTER (WHERE a = 1) FROM testData GROUP BY b;
+
+-- Aggregate with filter and grouped by literals.
+SELECT 'foo', COUNT(a) FILTER (WHERE b <= 2) FROM testData GROUP BY 1;
+SELECT 'foo', SUM(salary) FILTER (WHERE hiredate >= date "2003-01-01") FROM emp GROUP BY 1;
+SELECT 'foo', SUM(salary) FILTER (WHERE hiredate >= to_date("2003-01-01")) FROM emp GROUP BY 1;
+SELECT 'foo', SUM(salary) FILTER (WHERE hiredate >= to_timestamp("2003-01-01")) FROM emp GROUP BY 1;
+
+-- Aggregate with filter, more than one aggregate function goes with distinct.
+select dept_id, count(distinct emp_name), count(distinct hiredate), sum(salary), sum(salary) filter (where id > 200) from emp group by dept_id;
+select dept_id, count(distinct emp_name), count(distinct hiredate), sum(salary), sum(salary) filter (where id + dept_id > 500) from emp group by dept_id;
+select dept_id, count(distinct emp_name), count(distinct hiredate), sum(salary) filter (where salary < 400.00D), sum(salary) filter (where id > 200) from emp group by dept_id;
+select dept_id, count(distinct emp_name), count(distinct hiredate), sum(salary) filter (where salary < 400.00D), sum(salary) filter (where id + dept_id > 500) from emp group by dept_id;
+select dept_id, count(distinct emp_name) filter (where id > 200), sum(salary) from emp group by dept_id;
+select dept_id, count(distinct emp_name) filter (where id + dept_id > 500), sum(salary) from emp group by dept_id;
+select dept_id, count(distinct emp_name), count(distinct emp_name) filter (where id > 200), sum(salary) from emp group by dept_id;
+select dept_id, count(distinct emp_name), count(distinct emp_name) filter (where id + dept_id > 500), sum(salary) from emp group by dept_id;
+select dept_id, count(distinct emp_name), count(distinct emp_name) filter (where id > 200), sum(salary), sum(salary) filter (where id > 200) from emp group by dept_id;
+select dept_id, count(distinct emp_name), count(distinct emp_name) filter (where id + dept_id > 500), sum(salary), sum(salary) filter (where id > 200) from emp group by dept_id;
+select dept_id, count(distinct emp_name) filter (where id > 200), count(distinct hiredate), sum(salary) from emp group by dept_id;
+select dept_id, count(distinct emp_name) filter (where id > 200), count(distinct hiredate) filter (where hiredate > date "2003-01-01"), sum(salary) from emp group by dept_id;
+select dept_id, count(distinct emp_name) filter (where id > 200), count(distinct hiredate) filter (where hiredate > date "2003-01-01"), sum(salary) filter (where salary < 400.00D) from emp group by dept_id;
+select dept_id, count(distinct emp_name) filter (where id > 200), count(distinct hiredate) filter (where hiredate > date "2003-01-01"), sum(salary) filter (where salary < 400.00D), sum(salary) filter (where id > 200) from emp group by dept_id;
+select dept_id, count(distinct emp_name) filter (where id > 200), count(distinct emp_name), sum(salary) from emp group by dept_id;
+select dept_id, count(distinct emp_name) filter (where id > 200), count(distinct emp_name) filter (where hiredate > date "2003-01-01"), sum(salary) from emp group by dept_id;
+select dept_id, sum(distinct (id + dept_id)) filter (where id > 200), count(distinct hiredate), sum(salary) from emp group by dept_id;
+select dept_id, sum(distinct (id + dept_id)) filter (where id > 200), count(distinct hiredate) filter (where hiredate > date "2003-01-01"), sum(salary) from emp group by dept_id;
+select dept_id, avg(distinct (id + dept_id)) filter (where id > 200), count(distinct hiredate) filter (where hiredate > date "2003-01-01"), sum(salary) filter (where salary < 400.00D) from emp group by dept_id;
+select dept_id, count(distinct emp_name, hiredate) filter (where id > 200), sum(salary) from emp group by dept_id;
+select dept_id, count(distinct emp_name, hiredate) filter (where id > 0), sum(salary) from emp group by dept_id;
+select dept_id, count(distinct 1), count(distinct 1) filter (where id > 200), sum(salary) from emp group by dept_id;
+
+-- Aggregate with filter and grouped by literals (hash aggregate), here the input table is filtered using WHERE.
+SELECT 'foo', APPROX_COUNT_DISTINCT(a) FILTER (WHERE b >= 0) FROM testData WHERE a = 0 GROUP BY 1;
+
+-- Aggregate with filter and grouped by literals (sort aggregate), here the input table is filtered using WHERE.
+SELECT 'foo', MAX(STRUCT(a)) FILTER (WHERE b >= 1) FROM testData WHERE a = 0 GROUP BY 1;
+
+-- Aggregate with filter and complex GroupBy expressions.
+SELECT a + b, COUNT(b) FILTER (WHERE b >= 2) FROM testData GROUP BY a + b;
+SELECT a + 2, COUNT(b) FILTER (WHERE b IN (1, 2)) FROM testData GROUP BY a + 1;
+SELECT a + 1 + 1, COUNT(b) FILTER (WHERE b > 0) FROM testData GROUP BY a + 1;
+
+-- Aggregate with filter, foldable input and multiple distinct groups.
+SELECT COUNT(DISTINCT b) FILTER (WHERE b > 0), COUNT(DISTINCT b, c) FILTER (WHERE b > 0 AND c > 2)
+FROM (SELECT 1 AS a, 2 AS b, 3 AS c) GROUP BY a;
+
+-- Check analysis exceptions
+SELECT a AS k, COUNT(b) FILTER (WHERE b > 0) FROM testData GROUP BY k;
+
+-- Aggregate with filter contains exists subquery
+SELECT emp.dept_id,
+ avg(salary),
+ avg(salary) FILTER (WHERE id > (SELECT 200))
+FROM emp
+GROUP BY dept_id;
+
+SELECT emp.dept_id,
+ avg(salary),
+ avg(salary) FILTER (WHERE emp.dept_id = (SELECT dept_id FROM dept LIMIT 1))
+FROM emp
+GROUP BY dept_id;
+
+-- [SPARK-30220] Support Filter expression uses IN/EXISTS predicate sub-queries
+SELECT emp.dept_id,
+ avg(salary),
+ avg(salary) FILTER (WHERE EXISTS (SELECT state
+ FROM dept
+ WHERE dept.dept_id = emp.dept_id))
+FROM emp
+GROUP BY dept_id;
+
+SELECT emp.dept_id,
+ Sum(salary),
+ Sum(salary) FILTER (WHERE NOT EXISTS (SELECT state
+ FROM dept
+ WHERE dept.dept_id = emp.dept_id))
+FROM emp
+GROUP BY dept_id;
+
+SELECT emp.dept_id,
+ avg(salary),
+ avg(salary) FILTER (WHERE emp.dept_id IN (SELECT DISTINCT dept_id
+ FROM dept))
+FROM emp
+GROUP BY dept_id;
+SELECT emp.dept_id,
+ Sum(salary),
+ Sum(salary) FILTER (WHERE emp.dept_id NOT IN (SELECT DISTINCT dept_id
+ FROM dept))
+FROM emp
+GROUP BY dept_id;
+
+-- Aggregate with filter is subquery
+SELECT t1.b FROM (SELECT COUNT(b) FILTER (WHERE a >= 2) AS b FROM testData) t1;
+
+-- SPARK-47256: Wrong use of FILTER expression in aggregate functions
+SELECT count(num1) FILTER (WHERE rand(int(num2)) > 1) FROM FilterExpressionTestData;
+
+SELECT sum(num1) FILTER (WHERE str) FROM FilterExpressionTestData;
+
+SELECT sum(num1) FILTER (WHERE max(num2) > 1) FROM FilterExpressionTestData;
+
+SELECT sum(num1) FILTER (WHERE nth_value(num2, 2) OVER(ORDER BY num2) > 1) FROM FilterExpressionTestData;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-ordinal.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-ordinal.sql
new file mode 100644
index 000000000000..b773396c050d
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by-ordinal.sql
@@ -0,0 +1,96 @@
+-- group by ordinal positions
+
+create temporary view data as select * from values
+ (1, 1),
+ (1, 2),
+ (2, 1),
+ (2, 2),
+ (3, 1),
+ (3, 2)
+ as data(a, b);
+
+-- basic case
+select a, sum(b) from data group by 1;
+
+-- constant case
+select 1, 2, sum(b) from data group by 1, 2;
+
+-- duplicate group by column
+select a, 1, sum(b) from data group by a, 1;
+select a, 1, sum(b) from data group by 1, 2;
+
+-- group by a non-aggregate expression's ordinal
+select a, b + 2, count(2) from data group by a, 2;
+
+-- with alias
+select a as aa, b + 2 as bb, count(2) from data group by 1, 2;
+
+-- foldable non-literal: this should be the same as no grouping.
+select sum(b) from data group by 1 + 0;
+
+-- negative cases: ordinal out of range
+select a, b from data group by -1;
+select a, b from data group by 0;
+select a, b from data group by 3;
+
+-- negative case: position is an aggregate expression
+select a, b, sum(b) from data group by 3;
+select a, b, sum(b) + 2 from data group by 3;
+
+-- negative case: nondeterministic expression
+select a, rand(0), sum(b)
+from
+(select /*+ REPARTITION(1) */ a, b from data) group by a, 2;
+
+-- negative case: star
+select * from data group by a, b, 1;
+
+-- group by ordinal followed by order by
+select a, count(a) from (select 1 as a) tmp group by 1 order by 1;
+
+-- group by ordinal followed by having
+select count(a), a from (select 1 as a) tmp group by 2 having a > 0;
+
+-- mixed cases: group-by ordinals and aliases
+select a, a AS k, count(b) from data group by k, 1;
+
+-- can use ordinal in CUBE
+select a, b, count(1) from data group by cube(1, 2);
+
+-- mixed cases: can use ordinal in CUBE
+select a, b, count(1) from data group by cube(1, b);
+
+-- can use ordinal with cube
+select a, b, count(1) from data group by 1, 2 with cube;
+
+-- can use ordinal in ROLLUP
+select a, b, count(1) from data group by rollup(1, 2);
+
+-- mixed cases: can use ordinal in ROLLUP
+select a, b, count(1) from data group by rollup(1, b);
+
+-- can use ordinal with rollup
+select a, b, count(1) from data group by 1, 2 with rollup;
+
+-- can use ordinal in GROUPING SETS
+select a, b, count(1) from data group by grouping sets((1), (2), (1, 2));
+
+-- mixed cases: can use ordinal in GROUPING SETS
+select a, b, count(1) from data group by grouping sets((1), (b), (a, 2));
+
+select a, b, count(1) from data group by a, 2 grouping sets((1), (b), (a, 2));
+
+-- range error
+select a, b, count(1) from data group by a, -1;
+
+select a, b, count(1) from data group by a, 3;
+
+select a, b, count(1) from data group by cube(-1, 2);
+
+select a, b, count(1) from data group by cube(1, 3);
+
+-- turn off group by ordinal
+set spark.sql.groupByOrdinal=false;
+
+-- can now group by negative literal
+select sum(b) from data group by -1;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by.sql
new file mode 100644
index 000000000000..c1b5e88c43f2
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/group-by.sql
@@ -0,0 +1,329 @@
+-- Test aggregate 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
+
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (null, 1), (3, null), (null, null)
+AS testData(a, b);
+
+-- Aggregate with empty GroupBy expressions.
+SELECT a, COUNT(b) FROM testData;
+SELECT COUNT(a), COUNT(b) FROM testData;
+
+-- Aggregate with non-empty GroupBy expressions.
+SELECT a, COUNT(b) FROM testData GROUP BY a;
+SELECT a, COUNT(b) FROM testData GROUP BY b;
+SELECT COUNT(a), COUNT(b) FROM testData GROUP BY a;
+
+-- Aggregate grouped by literals.
+SELECT 'foo', COUNT(a) FROM testData GROUP BY 1;
+
+-- Aggregate grouped by literals (whole stage code generation).
+SELECT 'foo' FROM testData WHERE a = 0 GROUP BY 1;
+
+-- Aggregate grouped by literals (hash aggregate).
+SELECT 'foo', APPROX_COUNT_DISTINCT(a) FROM testData WHERE a = 0 GROUP BY 1;
+
+-- Aggregate grouped by literals (sort aggregate).
+SELECT 'foo', MAX(STRUCT(a)) FROM testData WHERE a = 0 GROUP BY 1;
+
+-- Aggregate with complex GroupBy expressions.
+SELECT a + b, COUNT(b) FROM testData GROUP BY a + b;
+SELECT a + 2, COUNT(b) FROM testData GROUP BY a + 1;
+SELECT a + 1 + 1, COUNT(b) FROM testData GROUP BY a + 1;
+
+-- struct() in group by
+SELECT count(1) FROM testData GROUP BY struct(a + 0.1 AS aa);
+
+-- Aggregate with nulls.
+SELECT SKEWNESS(a), KURTOSIS(a), MIN(a), MAX(a), AVG(a), VARIANCE(a), STDDEV(a), SUM(a), COUNT(a)
+FROM testData;
+
+-- Aggregate with foldable input and multiple distinct groups.
+SELECT COUNT(DISTINCT b), COUNT(DISTINCT b, c) FROM (SELECT 1 AS a, 2 AS b, 3 AS c) GROUP BY a;
+
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testDataHasSameNameWithAlias AS SELECT * FROM VALUES
+(1, 1, 3), (1, 2, 1) AS testDataHasSameNameWithAlias(k, a, v);
+SELECT k AS a, COUNT(v) FROM testDataHasSameNameWithAlias GROUP BY a;
+
+-- turn off group by aliases
+set spark.sql.groupByAliases=false;
+
+-- Aggregate with empty input and non-empty GroupBy expressions.
+SELECT a, COUNT(1) FROM testData WHERE false GROUP BY a;
+
+-- Aggregate with empty input and empty GroupBy expressions.
+SELECT COUNT(1) FROM testData WHERE false;
+SELECT 1 FROM (SELECT COUNT(1) FROM testData WHERE false) t;
+
+-- Aggregate with empty GroupBy expressions and filter on top
+SELECT 1 from (
+ SELECT 1 AS z,
+ MIN(a.x)
+ FROM (select 1 as x) a
+ WHERE false
+) b
+where b.z != b.z;
+
+-- SPARK-24369 multiple distinct aggregations having the same argument set
+SELECT corr(DISTINCT x, y), corr(DISTINCT y, x), count(*)
+ FROM (VALUES (1, 1), (2, 2), (2, 2)) t(x, y);
+
+-- SPARK-25708 HAVING without GROUP BY means global aggregate
+SELECT 1 FROM range(10) HAVING true;
+
+SELECT 1 FROM range(10) HAVING MAX(id) > 0;
+
+SELECT id FROM range(10) HAVING id > 0;
+
+SET spark.sql.legacy.parser.havingWithoutGroupByAsWhere=true;
+
+SELECT 1 FROM range(10) HAVING true;
+
+SELECT 1 FROM range(10) HAVING MAX(id) > 0;
+
+SELECT id FROM range(10) HAVING id > 0;
+
+SET spark.sql.legacy.parser.havingWithoutGroupByAsWhere=false;
+
+-- Test data
+CREATE OR REPLACE TEMPORARY VIEW test_agg AS SELECT * FROM VALUES
+ (1, true), (1, false),
+ (2, true),
+ (3, false), (3, null),
+ (4, null), (4, null),
+ (5, null), (5, true), (5, false) AS test_agg(k, v);
+
+-- empty table
+SELECT every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg WHERE 1 = 0;
+
+-- all null values
+SELECT every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg WHERE k = 4;
+
+-- aggregates are null Filtering
+SELECT every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg WHERE k = 5;
+
+-- group by
+SELECT k, every(v), some(v), any(v), bool_and(v), bool_or(v) FROM test_agg GROUP BY k;
+
+-- having
+SELECT k, every(v) FROM test_agg GROUP BY k HAVING every(v) = false;
+SELECT k, every(v) FROM test_agg GROUP BY k HAVING every(v) IS NULL;
+
+-- basic subquery path to make sure rewrite happens in both parent and child plans.
+SELECT k,
+ Every(v) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Any(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY k;
+
+-- basic subquery path to make sure rewrite happens in both parent and child plans.
+SELECT k,
+ Every(v) AS every
+FROM test_agg
+WHERE k = 2
+ AND v IN (SELECT Every(v)
+ FROM test_agg
+ WHERE k = 1)
+GROUP BY k;
+
+-- input type checking Int
+SELECT every(1);
+
+-- input type checking Short
+SELECT some(1S);
+
+-- input type checking Long
+SELECT any(1L);
+
+-- input type checking String
+SELECT every("true");
+
+-- input type checking Decimal
+SELECT bool_and(1.0);
+
+-- input type checking double
+SELECT bool_or(1.0D);
+
+-- every/some/any aggregates/bool_and/bool_or are supported as windows expression.
+SELECT k, v, every(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT k, v, some(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT k, v, any(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT k, v, bool_and(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+SELECT k, v, bool_or(v) OVER (PARTITION BY k ORDER BY v) FROM test_agg;
+
+-- Having referencing aggregate expressions is ok.
+SELECT count(*) FROM test_agg HAVING count(*) > 1L;
+SELECT k, max(v) FROM test_agg GROUP BY k HAVING max(v) = true;
+
+-- Aggrgate expressions can be referenced through an alias
+SELECT * FROM (SELECT COUNT(*) AS cnt FROM test_agg) WHERE cnt > 1L;
+
+-- Error when aggregate expressions are in where clause directly
+SELECT count(*) FROM test_agg WHERE count(*) > 1L;
+SELECT count(*) FROM test_agg WHERE count(*) + 1L > 1L;
+SELECT count(*) FROM test_agg WHERE k = 1 or k = 2 or count(*) + 1L > 1L or max(k) > 1;
+
+-- Aggregate with multiple distinct decimal columns
+SELECT AVG(DISTINCT decimal_col), SUM(DISTINCT decimal_col) FROM VALUES (CAST(1 AS DECIMAL(9, 0))) t(decimal_col);
+
+-- SPARK-34581: Don't optimize out grouping expressions from aggregate expressions without aggregate function
+SELECT not(a IS NULL), count(*) AS c
+FROM testData
+GROUP BY a IS NULL;
+
+SELECT if(not(a IS NULL), rand(0), 1), count(*) AS c
+FROM testData
+GROUP BY a IS NULL;
+
+
+-- Histogram aggregates with different numeric input types
+SELECT
+ histogram_numeric(col, 2) as histogram_2,
+ histogram_numeric(col, 3) as histogram_3,
+ histogram_numeric(col, 5) as histogram_5,
+ histogram_numeric(col, 10) as histogram_10
+FROM VALUES
+ (1), (2), (3), (4), (5), (6), (7), (8), (9), (10),
+ (11), (12), (13), (14), (15), (16), (17), (18), (19), (20),
+ (21), (22), (23), (24), (25), (26), (27), (28), (29), (30),
+ (31), (32), (33), (34), (35), (3), (37), (38), (39), (40),
+ (41), (42), (43), (44), (45), (46), (47), (48), (49), (50) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1), (2), (3) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1L), (2L), (3L) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1F), (2F), (3F) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1D), (2D), (3D) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (1S), (2S), (3S) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS BYTE)), (CAST(2 AS BYTE)), (CAST(3 AS BYTE)) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS TINYINT)), (CAST(2 AS TINYINT)), (CAST(3 AS TINYINT)) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS SMALLINT)), (CAST(2 AS SMALLINT)), (CAST(3 AS SMALLINT)) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS BIGINT)), (CAST(2 AS BIGINT)), (CAST(3 AS BIGINT)) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES
+ (CAST(1 AS DECIMAL(4, 2))), (CAST(2 AS DECIMAL(4, 2))), (CAST(3 AS DECIMAL(4, 2))) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (TIMESTAMP '2017-03-01 00:00:00'),
+ (TIMESTAMP '2017-04-01 00:00:00'), (TIMESTAMP '2017-05-01 00:00:00') AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (INTERVAL '100-00' YEAR TO MONTH),
+ (INTERVAL '110-00' YEAR TO MONTH), (INTERVAL '120-00' YEAR TO MONTH) AS tab(col);
+SELECT histogram_numeric(col, 3) FROM VALUES (INTERVAL '12 20:4:0' DAY TO SECOND),
+ (INTERVAL '12 21:4:0' DAY TO SECOND), (INTERVAL '12 22:4:0' DAY TO SECOND) AS tab(col);
+SELECT histogram_numeric(col, 3)
+FROM VALUES (NULL), (NULL), (NULL) AS tab(col);
+SELECT histogram_numeric(col, 3)
+FROM VALUES (CAST(NULL AS DOUBLE)), (CAST(NULL AS DOUBLE)), (CAST(NULL AS DOUBLE)) AS tab(col);
+SELECT histogram_numeric(col, 3)
+FROM VALUES (CAST(NULL AS INT)), (CAST(NULL AS INT)), (CAST(NULL AS INT)) AS tab(col);
+
+-- SPARK-27974: Support ANSI Aggregate Function: array_agg
+SELECT
+ collect_list(col),
+ array_agg(col)
+FROM VALUES
+ (1), (2), (1) AS tab(col);
+SELECT
+ a,
+ collect_list(b),
+ array_agg(b)
+FROM VALUES
+ (1,4),(2,3),(1,4),(2,4) AS v(a,b)
+GROUP BY a;
+
+-- SPARK-44846: PushFoldableIntoBranches in complex grouping expressions cause bindReference error
+SELECT c * 2 AS d
+FROM (
+ SELECT if(b > 1, 1, b) AS c
+ FROM (
+ SELECT if(a < 0, 0, a) AS b
+ FROM VALUES (-1), (1), (2) AS t1(a)
+ ) t2
+ 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
+;
+
+-- SC-170296: Verify that group by works when MapType is inside complex type for column type
+-- ARRAY>
+SELECT count(*)
+FROM VALUES (ARRAY(MAP(1, 2, 2, 3), MAP(1, 3))), (ARRAY(MAP(2, 3), MAP(1, 3))), (ARRAY(MAP(2, 3, 1, 2), MAP(1, 3))) as t(a)
+GROUP BY a;
+
+-- STRUCT>
+SELECT count(*)
+FROM VALUES (named_struct('b', map(1, 2, 2, 3))), (named_struct('b', map(1, 3))), (named_struct('b', map(2, 3, 1, 2))) as t(a)
+GROUP BY a;
+
+SELECT count(*)
+FROM VALUES (named_struct('b', map(1, 2, 2, 3))), (named_struct('b', map(1, 3))), (named_struct('b', map(2, 3, 1, 2))) as t(a)
+GROUP BY a.b;
+
+-- STRUCT>>
+SELECT count(*)
+FROM VALUES (named_struct('b', array(map(1, 2, 2, 3), map(1, 3)))), (named_struct('b', array(map(2, 3), map(1, 3)))), (named_struct('b', array(map(2, 3, 1, 2), map(1, 3)))) as t(a)
+GROUP BY a;
+
+-- ARRAY>>
+SELECT count(*)
+FROM VALUES (ARRAY(named_struct('b', map(1, 2, 2, 3)), named_struct('b', map(1, 3)))), (ARRAY(named_struct('b', map(2, 3)), named_struct('b', map(1, 3)))), (ARRAY(named_struct('b', map(2, 3, 1, 2)), named_struct('b', map(1, 3)))) as t(a)
+group BY a;
+
+-- MAP,INT>
+SELECT count(*)
+FROM VALUES (map(array(1, 2), 2, array(2, 3), 3)), (map(array(1, 3), 3)), (map(array(2, 3), 3, array(1, 2), 2)) as t(a)
+group BY a;
+
+SELECT count(*)
+FROM VALUES (map(array(1, 2, 3), 3)), (map(array(3, 2, 1), 3)) as t(a)
+group BY a;
+
+-- ARRAY,INT>>
+SELECT count(*)
+FROM VALUES (ARRAY(map(array(1, 2), 2, array(2, 3), 3))), (ARRAY(MAP(ARRAY(1, 3), 3))), (ARRAY(map(array(2, 3), 3, array(1, 2), 2))) as t(a)
+group BY a;
+
+-- MAP,INT>
+SELECT count(*)
+FROM VALUES (map(named_struct('b', 1), 2, named_struct('b', 2), 3)), (map(named_struct('b', 1), 3)), (map(named_struct('b', 2), 3, named_struct('b', 1), 2)) as t(a)
+group BY a;
+
+-- STRUCT,INT>>
+SELECT count(*)
+FROM VALUES (named_struct('b', map(named_struct('c', 1), 2, named_struct('c', 2), 3))), (named_struct('b', map(named_struct('c', 1), 3))), (named_struct('b', map(named_struct('c', 2), 3, named_struct('c', 1), 2))) as t(a)
+group BY a;
+
+SELECT count(*)
+FROM VALUES (named_struct('b', map(named_struct('c', 1), 2, named_struct('c', 2), 3))), (named_struct('b', map(named_struct('c', 1), 3))), (named_struct('b', map(named_struct('c', 2), 3, named_struct('c', 1), 2))) as t(a)
+group BY a.b;
+
+-- Map valueType contains MapType (possibly nested)
+-- MAP>
+SELECT count(*)
+FROM VALUES (Map(1, Map(1,2), 2, Map(2, 3, 1, 2))), (Map(2, Map(1, 2, 2,3), 1, Map(1, 2))), (Map(1, Map(1,2), 2, Map(2, 4))) as t(a)
+GROUP BY a;
+
+-- MAP>>
+SELECT count(*)
+FROM VALUES (Map(1, Array(Map(1,2)), 2, Array(Map(2, 3, 1, 2)))), (Map(2, Array(Map(1, 2, 2,3)), 1, Array(Map(1, 2)))), (Map(1, Array(Map(1,2)), 2, Array(Map(2, 4)))) as t(a)
+GROUP BY a;
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/grouping_set.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/grouping_set.sql
new file mode 100644
index 000000000000..909c36c926c1
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/grouping_set.sql
@@ -0,0 +1,66 @@
+CREATE TEMPORARY VIEW grouping AS SELECT * FROM VALUES
+ ("1", "2", "3", 1),
+ ("4", "5", "6", 1),
+ ("7", "8", "9", 1)
+ as grouping(a, b, c, d);
+
+-- SPARK-17849: grouping set throws NPE #1
+SELECT a, b, c, count(d) FROM grouping GROUP BY a, b, c GROUPING SETS (());
+
+-- SPARK-17849: grouping set throws NPE #2
+SELECT a, b, c, count(d) FROM grouping GROUP BY a, b, c GROUPING SETS ((a));
+
+-- SPARK-17849: grouping set throws NPE #3
+SELECT a, b, c, count(d) FROM grouping GROUP BY a, b, c GROUPING SETS ((c));
+
+-- Group sets without explicit group by
+SELECT c1, sum(c2) FROM (VALUES ('x', 10, 0), ('y', 20, 0)) AS t (c1, c2, c3) GROUP BY GROUPING SETS (c1);
+
+-- Group sets without group by and with grouping
+SELECT c1, sum(c2), grouping(c1) FROM (VALUES ('x', 10, 0), ('y', 20, 0)) AS t (c1, c2, c3) GROUP BY GROUPING SETS (c1);
+
+-- Mutiple grouping within a grouping set
+SELECT c1, c2, Sum(c3), grouping__id
+FROM (VALUES ('x', 'a', 10), ('y', 'b', 20) ) AS t (c1, c2, c3)
+GROUP BY GROUPING SETS ( ( c1 ), ( c2 ) )
+HAVING GROUPING__ID > 1;
+
+-- Group sets without explicit group by
+SELECT grouping(c1) FROM (VALUES ('x', 'a', 10), ('y', 'b', 20)) AS t (c1, c2, c3) GROUP BY GROUPING SETS (c1,c2);
+
+-- Mutiple grouping within a grouping set
+SELECT -c1 AS c1 FROM (values (1,2), (3,2)) t(c1, c2) GROUP BY GROUPING SETS ((c1), (c1, c2));
+
+-- complex expression in grouping sets
+SELECT a + b, b, sum(c) FROM (VALUES (1,1,1),(2,2,2)) AS t(a,b,c) GROUP BY GROUPING SETS ( (a + b), (b));
+
+-- complex expression in grouping sets
+SELECT a + b, b, sum(c) FROM (VALUES (1,1,1),(2,2,2)) AS t(a,b,c) GROUP BY GROUPING SETS ( (a + b), (b + a), (b));
+
+-- more query constructs with grouping sets
+SELECT c1 AS col1, c2 AS col2
+FROM (VALUES (1, 2), (3, 2)) t(c1, c2)
+GROUP BY GROUPING SETS ( ( c1 ), ( c1, c2 ) )
+HAVING col2 IS NOT NULL
+ORDER BY -col1;
+
+-- negative tests - must have at least one grouping expression
+SELECT a, b, c, count(d) FROM grouping GROUP BY WITH ROLLUP;
+
+SELECT a, b, c, count(d) FROM grouping GROUP BY WITH CUBE;
+
+SELECT c1 FROM (values (1,2), (3,2)) t(c1, c2) GROUP BY GROUPING SETS (());
+
+-- duplicate entries in grouping sets
+SELECT k1, k2, avg(v) FROM (VALUES (1,1,1),(2,2,2)) AS t(k1,k2,v) GROUP BY GROUPING SETS ((k1),(k1,k2),(k2,k1));
+
+SELECT grouping__id, k1, k2, avg(v) FROM (VALUES (1,1,1),(2,2,2)) AS t(k1,k2,v) GROUP BY GROUPING SETS ((k1),(k1,k2),(k2,k1));
+
+SELECT grouping(k1), k1, k2, avg(v) FROM (VALUES (1,1,1),(2,2,2)) AS t(k1,k2,v) GROUP BY GROUPING SETS ((k1),(k1,k2),(k2,k1));
+
+-- grouping_id function
+SELECT grouping_id(k1, k2), avg(v) from (VALUES (1,1,1),(2,2,2)) AS t(k1,k2,v) GROUP BY k1, k2 GROUPING SETS ((k2, k1), k1);
+
+SELECT CASE WHEN a IS NULL THEN count(b) WHEN b IS NULL THEN count(c) END
+FROM grouping
+GROUP BY GROUPING SETS (a, b, c);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/having.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/having.sql
new file mode 100644
index 000000000000..4c25a60c8abb
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/having.sql
@@ -0,0 +1,41 @@
+create temporary view hav as select * from values
+ ("one", 1),
+ ("two", 2),
+ ("three", 3),
+ ("one", 5)
+ as hav(k, v);
+
+-- having clause
+SELECT k, sum(v) FROM hav GROUP BY k HAVING sum(v) > 2;
+
+-- having condition contains grouping column
+SELECT count(k) FROM hav GROUP BY v + 1 HAVING v + 1 = 2;
+
+-- invalid having condition contains grouping column
+SELECT count(k) FROM hav GROUP BY v HAVING v = array(1);
+
+-- SPARK-11032: resolve having correctly
+SELECT MIN(t.v) FROM (SELECT * FROM hav WHERE v > 0) t HAVING(COUNT(1) > 0);
+
+-- SPARK-20329: make sure we handle timezones correctly
+SELECT a + b FROM VALUES (1L, 2), (3L, 4) AS T(a, b) GROUP BY a + b HAVING a + b > 1;
+
+-- SPARK-31519: Cast in having aggregate expressions returns the wrong result
+SELECT SUM(a) AS b, CAST('2020-01-01' AS DATE) AS fake FROM VALUES (1, 10), (2, 20) AS T(a, b) GROUP BY b HAVING b > 10;
+
+-- SPARK-31663: Grouping sets with having clause returns the wrong result
+SELECT SUM(a) AS b FROM VALUES (1, 10), (2, 20) AS T(a, b) GROUP BY GROUPING SETS ((b), (a, b)) HAVING b > 10;
+SELECT SUM(a) AS b FROM VALUES (1, 10), (2, 20) AS T(a, b) GROUP BY CUBE(a, b) HAVING b > 10;
+SELECT SUM(a) AS b FROM VALUES (1, 10), (2, 20) AS T(a, b) GROUP BY ROLLUP(a, b) HAVING b > 10;
+
+-- SPARK-33131: Grouping sets with having clause can not resolve qualified col name.
+SELECT c1 FROM VALUES (1, 2) as t(c1, c2) GROUP BY GROUPING SETS(t.c1) HAVING t.c1 = 1;
+SELECT c1 FROM VALUES (1, 2) as t(c1, c2) GROUP BY CUBE(t.c1) HAVING t.c1 = 1;
+SELECT c1 FROM VALUES (1, 2) as t(c1, c2) GROUP BY ROLLUP(t.c1) HAVING t.c1 = 1;
+SELECT c1 FROM VALUES (1, 2) as t(c1, c2) GROUP BY t.c1 HAVING t.c1 = 1;
+
+-- SPARK-28386: Resolve ORDER BY agg function with HAVING clause, while the agg function presents on SELECT list
+SELECT k, sum(v) FROM hav GROUP BY k HAVING sum(v) > 2 ORDER BY sum(v);
+
+-- SPARK-28386: Resolve ORDER BY agg function with HAVING clause, while the agg function does not present on SELECT list
+SELECT k, sum(v) FROM hav GROUP BY k HAVING sum(v) > 2 ORDER BY avg(v);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/higher-order-functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/higher-order-functions.sql
new file mode 100644
index 000000000000..37081de012e9
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/higher-order-functions.sql
@@ -0,0 +1,105 @@
+-- Test higher order functions 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 or replace temporary view nested as values
+ (1, array(32, 97), array(array(12, 99), array(123, 42), array(1))),
+ (2, array(77, -76), array(array(6, 96, 65), array(-1, -2))),
+ (3, array(12), array(array(17)))
+ as t(x, ys, zs);
+
+-- Only allow lambda's in higher order functions.
+select upper(x -> x) as v;
+-- Also test functions registered with `ExpressionBuilder`.
+select ceil(x -> x) as v;
+
+-- Identity transform an array
+select transform(zs, z -> z) as v from nested;
+
+-- Transform an array
+select transform(ys, y -> y * y) as v from nested;
+
+-- Transform an array with index
+select transform(ys, (y, i) -> y + i) as v from nested;
+
+-- Transform an array with reference
+select transform(zs, z -> concat(ys, z)) as v from nested;
+
+-- Transform an array to an array of 0's
+select transform(ys, 0) as v from nested;
+
+-- Transform a null array
+select transform(cast(null as array), x -> x + 1) as v;
+
+-- Filter.
+select filter(ys, y -> y > 30) as v from nested;
+
+-- Filter a null array
+select filter(cast(null as array), y -> true) as v;
+
+-- Filter nested arrays
+select transform(zs, z -> filter(z, zz -> zz > 50)) as v from nested;
+
+-- Aggregate.
+select aggregate(ys, 0, (y, a) -> y + a + x) as v from nested;
+
+-- Aggregate average.
+select aggregate(ys, (0 as sum, 0 as n), (acc, x) -> (acc.sum + x, acc.n + 1), acc -> acc.sum / acc.n) as v from nested;
+
+-- Aggregate nested arrays
+select transform(zs, z -> aggregate(z, 1, (acc, val) -> acc * val * size(z))) as v from nested;
+
+-- Aggregate a null array
+select aggregate(cast(null as array), 0, (a, y) -> a + y + 1, a -> a + 2) as v;
+
+-- alias for Aggregate.
+select reduce(ys, 0, (y, a) -> y + a + x) as v from nested;
+select reduce(ys, (0 as sum, 0 as n), (acc, x) -> (acc.sum + x, acc.n + 1), acc -> acc.sum / acc.n) as v from nested;
+select transform(zs, z -> reduce(z, 1, (acc, val) -> acc * val * size(z))) as v from nested;
+select reduce(cast(null as array), 0, (a, y) -> a + y + 1, a -> a + 2) as v;
+
+-- Check for element existence
+select exists(ys, y -> y > 30) as v from nested;
+
+-- Check for element existence in a null array
+select exists(cast(null as array), y -> y > 30) as v;
+
+-- Zip with array
+select zip_with(ys, zs, (a, b) -> a + size(b)) as v from nested;
+
+-- Zip with array with concat
+select zip_with(array('a', 'b', 'c'), array('d', 'e', 'f'), (x, y) -> concat(x, y)) as v;
+
+-- Zip with array coalesce
+select zip_with(array('a'), array('d', null, 'f'), (x, y) -> coalesce(x, y)) as v;
+
+create or replace temporary view nested as values
+ (1, map(1, 1, 2, 2, 3, 3)),
+ (2, map(4, 4, 5, 5, 6, 6))
+ as t(x, ys);
+
+-- Identity Transform Keys in a map
+select transform_keys(ys, (k, v) -> k) as v from nested;
+
+-- Transform Keys in a map by adding constant
+select transform_keys(ys, (k, v) -> k + 1) as v from nested;
+
+-- Transform Keys in a map using values
+select transform_keys(ys, (k, v) -> k + v) as v from nested;
+
+-- Identity Transform values in a map
+select transform_values(ys, (k, v) -> v) as v from nested;
+
+-- Transform values in a map by adding constant
+select transform_values(ys, (k, v) -> v + 1) as v from nested;
+
+-- Transform values in a map using values
+select transform_values(ys, (k, v) -> k + v) as v from nested;
+
+-- use non reversed keywords: all is non reversed only if !ansi
+select transform(ys, all -> all * all) as v from values (array(32, 97)) as t(ys);
+select transform(ys, (all, i) -> all + i) as v from values (array(32, 97)) as t(ys);
+
+-- SPARK-32819: Aggregate on nested string arrays
+select aggregate(split('abcdefgh',''), array(array('')), (acc, x) -> array(array(x)));
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/hll.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/hll.sql
new file mode 100644
index 000000000000..a0c29cb25a5b
--- /dev/null
+++ b/gluten-ut/spark41/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/spark41/src/test/resources/backends-velox/sql-tests/inputs/identifier-clause.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/identifier-clause.sql
new file mode 100644
index 000000000000..4aa8019097fd
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/identifier-clause.sql
@@ -0,0 +1,177 @@
+-------------------------------------------------------------------------------------------------
+-- Ths testfile tests the ability to templatize identifiers such as table and column names in SQL
+-- Common patterns are to to use variable substitution or parameter markers (test in another file)
+--------------------------------------------------------------------------------------------------
+
+-- Sanity test variable substitution
+SET hivevar:colname = 'c';
+SELECT IDENTIFIER(${colname} || '_1') FROM VALUES(1) AS T(c_1);
+
+-- Column references
+SELECT IDENTIFIER('c1') FROM VALUES(1) AS T(c1);
+SELECT IDENTIFIER('t.c1') FROM VALUES(1) AS T(c1);
+SELECT IDENTIFIER('`t`.c1') FROM VALUES(1) AS T(c1);
+SELECT IDENTIFIER('`c 1`') FROM VALUES(1) AS T(`c 1`);
+SELECT IDENTIFIER('``') FROM VALUES(1) AS T(``);
+SELECT IDENTIFIER('c' || '1') FROM VALUES(1) AS T(c1);
+
+-- Table references
+CREATE SCHEMA IF NOT EXISTS s;
+CREATE TABLE s.tab(c1 INT) USING CSV;
+USE SCHEMA s;
+
+INSERT INTO IDENTIFIER('ta' || 'b') VALUES(1);
+DELETE FROM IDENTIFIER('ta' || 'b') WHERE 1=0;
+UPDATE IDENTIFIER('ta' || 'b') SET c1 = 2;
+MERGE INTO IDENTIFIER('ta' || 'b') AS t USING IDENTIFIER('ta' || 'b') AS s ON s.c1 = t.c1
+ WHEN MATCHED THEN UPDATE SET c1 = 3;
+SELECT * FROM IDENTIFIER('tab');
+SELECT * FROM IDENTIFIER('s.tab');
+SELECT * FROM IDENTIFIER('`s`.`tab`');
+SELECT * FROM IDENTIFIER('t' || 'a' || 'b');
+
+USE SCHEMA default;
+DROP TABLE s.tab;
+DROP SCHEMA s;
+
+-- Function reference
+SELECT IDENTIFIER('COAL' || 'ESCE')(NULL, 1);
+SELECT IDENTIFIER('abs')(c1) FROM VALUES(-1) AS T(c1);
+SELECT * FROM IDENTIFIER('ra' || 'nge')(0, 1);
+
+-- Table DDL
+CREATE TABLE IDENTIFIER('tab')(c1 INT) USING CSV;
+DROP TABLE IF EXISTS IDENTIFIER('ta' || 'b');
+
+CREATE SCHEMA identifier_clauses;
+USE identifier_clauses;
+CREATE TABLE IDENTIFIER('ta' || 'b')(c1 INT) USING CSV;
+DROP TABLE IF EXISTS IDENTIFIER('identifier_clauses.' || 'tab');
+CREATE TABLE IDENTIFIER('identifier_clauses.' || 'tab')(c1 INT) USING CSV;
+REPLACE TABLE IDENTIFIER('identifier_clauses.' || 'tab')(c1 INT) USING CSV;
+CACHE TABLE IDENTIFIER('ta' || 'b');
+UNCACHE TABLE IDENTIFIER('ta' || 'b');
+DROP TABLE IF EXISTS IDENTIFIER('ta' || 'b');
+USE default;
+DROP SCHEMA identifier_clauses;
+
+CREATE TABLE tab(c1 INT) USING CSV;
+INSERT INTO tab VALUES (1);
+SELECT c1 FROM tab;
+DESCRIBE IDENTIFIER('ta' || 'b');
+ANALYZE TABLE IDENTIFIER('ta' || 'b') COMPUTE STATISTICS;
+ALTER TABLE IDENTIFIER('ta' || 'b') ADD COLUMN c2 INT;
+SHOW TBLPROPERTIES IDENTIFIER('ta' || 'b');
+SHOW COLUMNS FROM IDENTIFIER('ta' || 'b');
+COMMENT ON TABLE IDENTIFIER('ta' || 'b') IS 'hello';
+REFRESH TABLE IDENTIFIER('ta' || 'b');
+REPAIR TABLE IDENTIFIER('ta' || 'b');
+TRUNCATE TABLE IDENTIFIER('ta' || 'b');
+DROP TABLE IF EXISTS tab;
+
+-- View
+CREATE OR REPLACE VIEW IDENTIFIER('v')(c1) AS VALUES(1);
+SELECT * FROM v;
+ALTER VIEW IDENTIFIER('v') AS VALUES(2);
+DROP VIEW IDENTIFIER('v');
+CREATE TEMPORARY VIEW IDENTIFIER('v')(c1) AS VALUES(1);
+DROP VIEW IDENTIFIER('v');
+
+-- Schema
+CREATE SCHEMA IDENTIFIER('id' || 'ent');
+ALTER SCHEMA IDENTIFIER('id' || 'ent') SET PROPERTIES (somekey = 'somevalue');
+ALTER SCHEMA IDENTIFIER('id' || 'ent') SET LOCATION 'someloc';
+COMMENT ON SCHEMA IDENTIFIER('id' || 'ent') IS 'some comment';
+DESCRIBE SCHEMA IDENTIFIER('id' || 'ent');
+SHOW TABLES IN IDENTIFIER('id' || 'ent');
+SHOW TABLE EXTENDED IN IDENTIFIER('id' || 'ent') LIKE 'hello';
+USE IDENTIFIER('id' || 'ent');
+SHOW CURRENT SCHEMA;
+USE SCHEMA IDENTIFIER('id' || 'ent');
+USE SCHEMA default;
+DROP SCHEMA IDENTIFIER('id' || 'ent');
+
+-- Function
+CREATE SCHEMA ident;
+CREATE FUNCTION IDENTIFIER('ident.' || 'myDoubleAvg') AS 'test.org.apache.spark.sql.MyDoubleAvg';
+DESCRIBE FUNCTION IDENTIFIER('ident.' || 'myDoubleAvg');
+REFRESH FUNCTION IDENTIFIER('ident.' || 'myDoubleAvg');
+DROP FUNCTION IDENTIFIER('ident.' || 'myDoubleAvg');
+DROP SCHEMA ident;
+CREATE TEMPORARY FUNCTION IDENTIFIER('my' || 'DoubleAvg') AS 'test.org.apache.spark.sql.MyDoubleAvg';
+DROP TEMPORARY FUNCTION IDENTIFIER('my' || 'DoubleAvg');
+
+-- IDENTIFIER + variable
+DECLARE var = 'sometable';
+CREATE TABLE IDENTIFIER(var)(c1 INT) USING CSV;
+
+SET VAR var = 'c1';
+SELECT IDENTIFIER(var) FROM VALUES(1) AS T(c1);
+
+SET VAR var = 'some';
+DROP TABLE IDENTIFIER(var || 'table');
+
+-- Error conditions
+SELECT IDENTIFIER('c 1') FROM VALUES(1) AS T(`c 1`);
+SELECT IDENTIFIER('') FROM VALUES(1) AS T(``);
+VALUES(IDENTIFIER(CAST(NULL AS STRING)));
+VALUES(IDENTIFIER(1));
+VALUES(IDENTIFIER(SUBSTR('HELLO', 1, RAND() + 1)));
+SELECT `IDENTIFIER`('abs')(c1) FROM VALUES(-1) AS T(c1);
+
+CREATE TABLE IDENTIFIER(1)(c1 INT) USING csv;
+CREATE TABLE IDENTIFIER('a.b.c')(c1 INT) USING csv;
+CREATE VIEW IDENTIFIER('a.b.c')(c1) AS VALUES(1);
+DROP TABLE IDENTIFIER('a.b.c');
+DROP VIEW IDENTIFIER('a.b.c');
+COMMENT ON TABLE IDENTIFIER('a.b.c.d') IS 'hello';
+VALUES(IDENTIFIER(1)());
+VALUES(IDENTIFIER('a.b.c.d')());
+
+CREATE TEMPORARY FUNCTION IDENTIFIER('default.my' || 'DoubleAvg') AS 'test.org.apache.spark.sql.MyDoubleAvg';
+DROP TEMPORARY FUNCTION IDENTIFIER('default.my' || 'DoubleAvg');
+CREATE TEMPORARY VIEW IDENTIFIER('default.v')(c1) AS VALUES(1);
+
+-- SPARK-48273: Aggregation operation in statements using identifier clause for table name
+create temporary view identifier('v1') as (select my_col from (values (1), (2), (1) as (my_col)) group by 1);
+cache table identifier('t1') as (select my_col from (values (1), (2), (1) as (my_col)) group by 1);
+create table identifier('t2') using csv as (select my_col from (values (1), (2), (1) as (my_col)) group by 1);
+insert into identifier('t2') select my_col from (values (3) as (my_col)) group by 1;
+drop view v1;
+drop table t1;
+drop table t2;
+
+-- SPARK-46625: CTE reference with identifier clause and session variables
+DECLARE agg = 'max';
+DECLARE col = 'c1';
+DECLARE tab = 'T';
+
+WITH S(c1, c2) AS (VALUES(1, 2), (2, 3)),
+ T(c1, c2) AS (VALUES ('a', 'b'), ('c', 'd'))
+SELECT IDENTIFIER(agg)(IDENTIFIER(col)) FROM IDENTIFIER(tab);
+
+WITH S(c1, c2) AS (VALUES(1, 2), (2, 3)),
+ T(c1, c2) AS (VALUES ('a', 'b'), ('c', 'd'))
+SELECT IDENTIFIER('max')(IDENTIFIER('c1')) FROM IDENTIFIER('T');
+
+WITH ABC(c1, c2) AS (VALUES(1, 2), (2, 3))
+SELECT IDENTIFIER('max')(IDENTIFIER('c1')) FROM IDENTIFIER('A' || 'BC');
+
+-- Not supported
+SELECT row_number() OVER IDENTIFIER('x.win') FROM VALUES(1) AS T(c1) WINDOW win AS (ORDER BY c1);
+SELECT T1.c1 FROM VALUES(1) AS T1(c1) JOIN VALUES(1) AS T2(c1) USING (IDENTIFIER('c1'));
+SELECT IDENTIFIER('t').c1 FROM VALUES(1) AS T(c1);
+SELECT map('a', 1).IDENTIFIER('a') FROM VALUES(1) AS T(c1);
+SELECT named_struct('a', 1).IDENTIFIER('a') FROM VALUES(1) AS T(c1);
+SELECT * FROM s.IDENTIFIER('tab');
+SELECT * FROM IDENTIFIER('s').IDENTIFIER('tab');
+SELECT * FROM IDENTIFIER('s').tab;
+SELECT row_number() OVER IDENTIFIER('win') FROM VALUES(1) AS T(c1) WINDOW win AS (ORDER BY c1);
+SELECT row_number() OVER win FROM VALUES(1) AS T(c1) WINDOW IDENTIFIER('win') AS (ORDER BY c1);
+WITH identifier('v')(identifier('c1')) AS (VALUES(1)) (SELECT c1 FROM v);
+INSERT INTO tab(IDENTIFIER('c1')) VALUES(1);
+CREATE OR REPLACE VIEW v(IDENTIFIER('c1')) AS VALUES(1);
+CREATE TABLE tab(IDENTIFIER('c1') INT) USING CSV;
+
+
+
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ignored.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ignored.sql
new file mode 100644
index 000000000000..0b5331a1d022
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ignored.sql
@@ -0,0 +1,4 @@
+-- This is a query file that has been ignored.
+-- It includes a query that should crash Spark.
+-- If the test case is run, the whole suite would fail.
+some random not working query that should crash Spark.
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ilike-all.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ilike-all.sql
new file mode 100644
index 000000000000..747cf1c3acab
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ilike-all.sql
@@ -0,0 +1,41 @@
+-- test cases for ilike all
+
+CREATE OR REPLACE TEMPORARY VIEW ilike_all_table AS SELECT * FROM (VALUES
+ ('gOOgle', '%oo%'),
+ ('facebook', '%OO%'),
+ ('liNkedin', '%In'))
+ as t1(company, pat);
+
+SELECT company FROM ilike_all_table WHERE company ILIKE ALL ('%oO%', '%Go%');
+
+SELECT company FROM ilike_all_table WHERE company ILIKE ALL ('microsoft', '%yoo%');
+
+SELECT
+ company,
+ CASE
+ WHEN company ILIKE ALL ('%oo%', '%GO%') THEN 'Y'
+ ELSE 'N'
+ END AS is_available,
+ CASE
+ WHEN company ILIKE ALL ('%OO%', 'go%') OR company ILIKE ALL ('%IN', 'ms%') THEN 'Y'
+ ELSE 'N'
+ END AS mix
+FROM ilike_all_table ;
+
+-- Mix test with constant pattern and column value
+SELECT company FROM ilike_all_table WHERE company ILIKE ALL ('%oo%', pat);
+
+-- not ilike all test
+SELECT company FROM ilike_all_table WHERE company NOT ILIKE ALL ('%oo%', '%In', 'Fa%');
+SELECT company FROM ilike_all_table WHERE company NOT ILIKE ALL ('microsoft', '%yoo%');
+SELECT company FROM ilike_all_table WHERE company NOT ILIKE ALL ('%oo%', 'fA%');
+SELECT company FROM ilike_all_table WHERE NOT company ILIKE ALL ('%oO%', 'fa%');
+
+-- null test
+SELECT company FROM ilike_all_table WHERE company ILIKE ALL ('%OO%', NULL);
+SELECT company FROM ilike_all_table WHERE company NOT ILIKE ALL ('%Oo%', NULL);
+SELECT company FROM ilike_all_table WHERE company ILIKE ALL (NULL, NULL);
+SELECT company FROM ilike_all_table WHERE company NOT ILIKE ALL (NULL, NULL);
+
+-- negative case
+SELECT company FROM ilike_any_table WHERE company ILIKE ALL ();
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ilike-any.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ilike-any.sql
new file mode 100644
index 000000000000..615b9fcc70bf
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ilike-any.sql
@@ -0,0 +1,41 @@
+-- test cases for ilike any
+
+CREATE OR REPLACE TEMPORARY VIEW ilike_any_table AS SELECT * FROM (VALUES
+ ('Google', '%Oo%'),
+ ('FaceBook', '%oO%'),
+ ('linkedIn', '%IN'))
+ as t1(company, pat);
+
+SELECT company FROM ilike_any_table WHERE company ILIKE ANY ('%oo%', '%IN', 'fA%');
+
+SELECT company FROM ilike_any_table WHERE company ILIKE ANY ('microsoft', '%yoo%');
+
+select
+ company,
+ CASE
+ WHEN company ILIKE ANY ('%oO%', '%IN', 'Fa%') THEN 'Y'
+ ELSE 'N'
+ END AS is_available,
+ CASE
+ WHEN company ILIKE ANY ('%OO%', 'fa%') OR company ILIKE ANY ('%in', 'MS%') THEN 'Y'
+ ELSE 'N'
+ END AS mix
+FROM ilike_any_table;
+
+-- Mix test with constant pattern and column value
+SELECT company FROM ilike_any_table WHERE company ILIKE ANY ('%zZ%', pat);
+
+-- not ilike any test
+SELECT company FROM ilike_any_table WHERE company NOT ILIKE ANY ('%oO%', '%iN', 'fa%');
+SELECT company FROM ilike_any_table WHERE company NOT ILIKE ANY ('microsoft', '%yOo%');
+SELECT company FROM ilike_any_table WHERE company NOT ILIKE ANY ('%oo%', 'Fa%');
+SELECT company FROM ilike_any_table WHERE NOT company ILIKE ANY ('%OO%', 'fa%');
+
+-- null test
+SELECT company FROM ilike_any_table WHERE company ILIKE ANY ('%oO%', NULL);
+SELECT company FROM ilike_any_table WHERE company NOT ILIKE ANY ('%oo%', NULL);
+SELECT company FROM ilike_any_table WHERE company ILIKE ANY (NULL, NULL);
+SELECT company FROM ilike_any_table WHERE company NOT ILIKE ANY (NULL, NULL);
+
+-- negative case
+SELECT company FROM ilike_any_table WHERE company ILIKE ANY ();
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ilike.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ilike.sql
new file mode 100644
index 000000000000..701685982df8
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/ilike.sql
@@ -0,0 +1,39 @@
+-- test cases for ilike
+
+-- null handling
+select null ilike 'a';
+select 'a' ilike null;
+select null ilike null;
+
+-- simple patterns
+select 'a' ilike 'a';
+select 'a' ilike 'b';
+select 'A' ilike 'a';
+select 'a' ilike 'A';
+select 'abdef' ilike 'aBdef';
+select 'a_%b' ilike 'a\\__b';
+select 'addb' ilike 'A_%b';
+select 'abC' ilike 'a%';
+select 'a\nb' ilike 'a_B';
+
+-- empty input
+select '' ilike '';
+select 'A' ilike '';
+select '' ilike 'a';
+
+-- double-escaping backslash
+select ilike('\__', '\\\__');
+select ilike('\\\__', '%\\%\%');
+
+-- unicode
+select 'a\u20ACA' ilike '_\u20AC_';
+select 'A€a' ilike '_€_';
+select 'a€AA' ilike '_\u20AC_a';
+select 'a\u20ACaz' ilike '_€_Z';
+select 'ЀЁЂѺΏỀ' ilike 'ѐёђѻώề';
+
+-- escape char
+select 'Addb' ilike 'a%#%b' escape '#';
+select 'a_%b' ilike 'a%#%B' escape '#';
+select 'Addb' ilike 'A%$%b' escape '$';
+select 'a_%b' ilike 'a%+%B' escape '+';
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/inline-table.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/inline-table.sql
new file mode 100644
index 000000000000..8f65dc77c960
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/inline-table.sql
@@ -0,0 +1,68 @@
+
+-- single row, without table and column alias
+select * from values ("one", 1);
+
+-- single row, without column alias
+select * from values ("one", 1) as data;
+
+-- single row
+select * from values ("one", 1) as data(a, b);
+
+-- single column multiple rows
+select * from values 1, 2, 3 as data(a);
+
+-- three rows
+select * from values ("one", 1), ("two", 2), ("three", null) as data(a, b);
+
+-- null type
+select * from values ("one", null), ("two", null) as data(a, b);
+
+-- int and long coercion
+select * from values ("one", 1), ("two", 2L) as data(a, b);
+
+-- foldable expressions
+select * from values ("one", 1 + 0), ("two", 1 + 3L) as data(a, b);
+
+-- expressions with alias
+select * from values ("one", 1 as one) as data(a, b);
+
+-- literal functions
+select a from values ("one", current_timestamp) as data(a, b);
+
+-- complex types
+select * from values ("one", array(0, 1)), ("two", array(2, 3)) as data(a, b);
+
+-- decimal and double coercion
+select * from values ("one", 2.0), ("two", 3.0D) as data(a, b);
+
+-- error reporting: nondeterministic function rand
+select * from values ("one", rand(5)), ("two", 3.0D) as data(a, b);
+
+-- error reporting: different number of columns
+select * from values ("one", 2.0), ("two") as data(a, b);
+
+-- error reporting: types that are incompatible
+select * from values ("one", array(0, 1)), ("two", struct(1, 2)) as data(a, b);
+
+-- error reporting: number aliases different from number data values
+select * from values ("one"), ("two") as data(a, b);
+
+-- error reporting: unresolved expression
+select * from values ("one", random_not_exist_func(1)), ("two", 2) as data(a, b);
+
+-- error reporting: aggregate expression
+select * from values ("one", count(1)), ("two", 2) as data(a, b);
+
+-- string to timestamp
+select * from values (timestamp('1991-12-06 00:00:00.0'), array(timestamp('1991-12-06 01:00:00.0'), timestamp('1991-12-06 12:00:00.0'))) as data(a, b);
+
+-- ReplaceExpressions as row
+select * from values (try_add(5, 0));
+select * from values (try_divide(5, 0));
+select * from values (10 + try_divide(5, 0));
+
+-- now() should be kept as tempResolved inline expression.
+select count(distinct ct) from values now(), now(), now() as data(ct);
+
+-- current_timestamp() should be kept as tempResolved inline expression.
+select count(distinct ct) from values current_timestamp(), current_timestamp() as data(ct);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/inner-join.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/inner-join.sql
new file mode 100644
index 000000000000..6a761ad5a74e
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/inner-join.sql
@@ -0,0 +1,29 @@
+-- There are 2 dimensions we want to test
+-- 1. run with broadcast hash join, sort merge join or shuffle hash join.
+-- 2. run with whole-stage-codegen, operator codegen or no codegen.
+
+--CONFIG_DIM1 spark.sql.autoBroadcastJoinThreshold=10485760
+--CONFIG_DIM1 spark.sql.autoBroadcastJoinThreshold=-1,spark.sql.join.preferSortMergeJoin=true
+--CONFIG_DIM1 spark.sql.autoBroadcastJoinThreshold=-1,spark.sql.join.forceApplyShuffledHashJoin=true
+
+--CONFIG_DIM2 spark.sql.codegen.wholeStage=true
+--CONFIG_DIM2 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=CODEGEN_ONLY
+--CONFIG_DIM2 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=NO_CODEGEN
+
+CREATE TEMPORARY VIEW t1 AS SELECT * FROM VALUES (1) AS GROUPING(a);
+CREATE TEMPORARY VIEW t2 AS SELECT * FROM VALUES (1) AS GROUPING(a);
+CREATE TEMPORARY VIEW t3 AS SELECT * FROM VALUES (1), (1) AS GROUPING(a);
+CREATE TEMPORARY VIEW t4 AS SELECT * FROM VALUES (1), (1) AS GROUPING(a);
+
+CREATE TEMPORARY VIEW ta AS
+SELECT a, 'a' AS tag FROM t1
+UNION ALL
+SELECT a, 'b' AS tag FROM t2;
+
+CREATE TEMPORARY VIEW tb AS
+SELECT a, 'a' AS tag FROM t3
+UNION ALL
+SELECT a, 'b' AS tag FROM t4;
+
+-- SPARK-19766 Constant alias columns in INNER JOIN should not be folded by FoldablePropagation rule
+SELECT tb.* FROM ta INNER JOIN tb ON ta.a = tb.a AND ta.tag = tb.tag;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/intersect-all.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/intersect-all.sql
new file mode 100644
index 000000000000..077caa5dd44a
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/intersect-all.sql
@@ -0,0 +1,175 @@
+CREATE TEMPORARY VIEW tab1 AS SELECT * FROM VALUES
+ (1, 2),
+ (1, 2),
+ (1, 3),
+ (1, 3),
+ (2, 3),
+ (null, null),
+ (null, null)
+ AS tab1(k, v);
+CREATE TEMPORARY VIEW tab2 AS SELECT * FROM VALUES
+ (1, 2),
+ (1, 2),
+ (2, 3),
+ (3, 4),
+ (null, null),
+ (null, null)
+ AS tab2(k, v);
+
+-- Basic INTERSECT ALL
+SELECT * FROM tab1
+INTERSECT ALL
+SELECT * FROM tab2;
+
+-- INTERSECT ALL same table in both branches
+SELECT * FROM tab1
+INTERSECT ALL
+SELECT * FROM tab1 WHERE k = 1;
+
+-- Empty left relation
+SELECT * FROM tab1 WHERE k > 2
+INTERSECT ALL
+SELECT * FROM tab2;
+
+-- Empty right relation
+SELECT * FROM tab1
+INTERSECT ALL
+SELECT * FROM tab2 WHERE k > 3;
+
+-- Type Coerced INTERSECT ALL
+SELECT * FROM tab1
+INTERSECT ALL
+SELECT CAST(1 AS BIGINT), CAST(2 AS BIGINT);
+
+-- Error as types of two side are not compatible
+SELECT * FROM tab1
+INTERSECT ALL
+SELECT array(1), 2;
+
+-- Mismatch on number of columns across both branches
+SELECT k FROM tab1
+INTERSECT ALL
+SELECT k, v FROM tab2;
+
+-- Basic
+SELECT * FROM tab2
+INTERSECT ALL
+SELECT * FROM tab1
+INTERSECT ALL
+SELECT * FROM tab2;
+
+-- Chain of different `set operations
+SELECT * FROM tab1
+EXCEPT
+SELECT * FROM tab2
+UNION ALL
+SELECT * FROM tab1
+INTERSECT ALL
+SELECT * FROM tab2
+;
+
+-- Chain of different `set operations
+SELECT * FROM tab1
+EXCEPT
+SELECT * FROM tab2
+EXCEPT
+SELECT * FROM tab1
+INTERSECT ALL
+SELECT * FROM tab2
+;
+
+-- test use parenthesis to control order of evaluation
+(
+ (
+ (
+ SELECT * FROM tab1
+ EXCEPT
+ SELECT * FROM tab2
+ )
+ EXCEPT
+ SELECT * FROM tab1
+ )
+ INTERSECT ALL
+ SELECT * FROM tab2
+)
+;
+
+-- Join under intersect all
+SELECT *
+FROM (SELECT tab1.k,
+ tab2.v
+ FROM tab1
+ JOIN tab2
+ ON tab1.k = tab2.k)
+INTERSECT ALL
+SELECT *
+FROM (SELECT tab1.k,
+ tab2.v
+ FROM tab1
+ JOIN tab2
+ ON tab1.k = tab2.k);
+
+-- Join under intersect all (2)
+SELECT *
+FROM (SELECT tab1.k,
+ tab2.v
+ FROM tab1
+ JOIN tab2
+ ON tab1.k = tab2.k)
+INTERSECT ALL
+SELECT *
+FROM (SELECT tab2.v AS k,
+ tab1.k AS v
+ FROM tab1
+ JOIN tab2
+ ON tab1.k = tab2.k);
+
+-- Group by under intersect all
+SELECT v FROM tab1 GROUP BY v
+INTERSECT ALL
+SELECT k FROM tab2 GROUP BY k;
+
+-- Test pre spark2.4 behaviour of set operation precedence
+-- All the set operators are given equal precedence and are evaluated
+-- from left to right as they appear in the query.
+
+-- Set the property
+SET spark.sql.legacy.setopsPrecedence.enabled= true;
+
+SELECT * FROM tab1
+EXCEPT
+SELECT * FROM tab2
+UNION ALL
+SELECT * FROM tab1
+INTERSECT ALL
+SELECT * FROM tab2;
+
+SELECT * FROM tab1
+EXCEPT
+SELECT * FROM tab2
+UNION ALL
+SELECT * FROM tab1
+INTERSECT
+SELECT * FROM tab2;
+
+-- Restore the property
+SET spark.sql.legacy.setopsPrecedence.enabled = false;
+
+-- SPARK-32638: corrects references when adding aliases in WidenSetOperationTypes
+CREATE OR REPLACE TEMPORARY VIEW tab3 AS VALUES (decimal(1)), (decimal(2)) tbl3(v);
+SELECT t.v FROM (
+ SELECT v FROM tab3
+ INTERSECT
+ SELECT v + v AS v FROM tab3
+) t;
+
+SELECT SUM(t.v) FROM (
+ SELECT v FROM tab3
+ INTERSECT
+ SELECT v + v AS v FROM tab3
+) t;
+
+-- Clean-up
+DROP VIEW IF EXISTS tab1;
+DROP VIEW IF EXISTS tab2;
+DROP VIEW IF EXISTS tab3;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/interval.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/interval.sql
new file mode 100644
index 000000000000..e4da28c2e758
--- /dev/null
+++ b/gluten-ut/spark41/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/spark41/src/test/resources/backends-velox/sql-tests/inputs/join-empty-relation.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/join-empty-relation.sql
new file mode 100644
index 000000000000..8afa3270f4de
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/join-empty-relation.sql
@@ -0,0 +1,28 @@
+CREATE TEMPORARY VIEW t1 AS SELECT * FROM VALUES (1) AS GROUPING(a);
+CREATE TEMPORARY VIEW t2 AS SELECT * FROM VALUES (1) AS GROUPING(a);
+
+CREATE TEMPORARY VIEW empty_table as SELECT a FROM t2 WHERE false;
+
+SELECT * FROM t1 INNER JOIN empty_table;
+SELECT * FROM t1 CROSS JOIN empty_table;
+SELECT * FROM t1 LEFT OUTER JOIN empty_table;
+SELECT * FROM t1 RIGHT OUTER JOIN empty_table;
+SELECT * FROM t1 FULL OUTER JOIN empty_table;
+SELECT * FROM t1 LEFT SEMI JOIN empty_table;
+SELECT * FROM t1 LEFT ANTI JOIN empty_table;
+
+SELECT * FROM empty_table INNER JOIN t1;
+SELECT * FROM empty_table CROSS JOIN t1;
+SELECT * FROM empty_table LEFT OUTER JOIN t1;
+SELECT * FROM empty_table RIGHT OUTER JOIN t1;
+SELECT * FROM empty_table FULL OUTER JOIN t1;
+SELECT * FROM empty_table LEFT SEMI JOIN t1;
+SELECT * FROM empty_table LEFT ANTI JOIN t1;
+
+SELECT * FROM empty_table INNER JOIN empty_table;
+SELECT * FROM empty_table CROSS JOIN empty_table;
+SELECT * FROM empty_table LEFT OUTER JOIN empty_table;
+SELECT * FROM empty_table RIGHT OUTER JOIN empty_table;
+SELECT * FROM empty_table FULL OUTER JOIN empty_table;
+SELECT * FROM empty_table LEFT SEMI JOIN empty_table;
+SELECT * FROM empty_table LEFT ANTI JOIN empty_table;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/join-lateral.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/join-lateral.sql
new file mode 100644
index 000000000000..e3cef9207d20
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/join-lateral.sql
@@ -0,0 +1,559 @@
+-- Test cases for lateral join
+
+CREATE VIEW t1(c1, c2) AS VALUES (0, 1), (1, 2);
+CREATE VIEW t2(c1, c2) AS VALUES (0, 2), (0, 3);
+CREATE VIEW t3(c1, c2) AS VALUES (0, ARRAY(0, 1)), (1, ARRAY(2)), (2, ARRAY()), (null, ARRAY(4));
+CREATE VIEW t4(c1, c2) AS VALUES (0, 1), (0, 2), (1, 1), (1, 3);
+
+-- lateral join with single column select
+SELECT * FROM t1, LATERAL (SELECT c1);
+SELECT * FROM t1, LATERAL (SELECT c1 FROM t2);
+SELECT * FROM t1, LATERAL (SELECT t1.c1 FROM t2);
+SELECT * FROM t1, LATERAL (SELECT t1.c1 + t2.c1 FROM t2);
+
+-- lateral join with star expansion
+SELECT * FROM t1, LATERAL (SELECT *);
+SELECT * FROM t1, LATERAL (SELECT * FROM t2);
+SELECT * FROM t1, LATERAL (SELECT t1.*);
+SELECT * FROM t1, LATERAL (SELECT t1.*, t2.* FROM t2);
+SELECT * FROM t1, LATERAL (SELECT t1.* FROM t2 AS t1);
+-- expect error: cannot resolve 't1.*'
+-- TODO: Currently we don't allow deep correlation so t1.* cannot be resolved using the outermost query.
+SELECT * FROM t1, LATERAL (SELECT t1.*, t2.* FROM t2, LATERAL (SELECT t1.*, t2.*, t3.* FROM t2 AS t3));
+
+-- lateral join with different join types
+SELECT * FROM t1 JOIN LATERAL (SELECT c1 + c2 AS c3) ON c2 = c3;
+SELECT * FROM t1 LEFT JOIN LATERAL (SELECT c1 + c2 AS c3) ON c2 = c3;
+SELECT * FROM t1 CROSS JOIN LATERAL (SELECT c1 + c2 AS c3);
+SELECT * FROM t1 NATURAL JOIN LATERAL (SELECT c1 + c2 AS c2);
+SELECT * FROM t1 JOIN LATERAL (SELECT c1 + c2 AS c2) USING (c2);
+
+-- lateral join without outer column references
+SELECT * FROM LATERAL (SELECT * FROM t1);
+SELECT * FROM t1, LATERAL (SELECT * FROM t2);
+SELECT * FROM LATERAL (SELECT * FROM t1), LATERAL (SELECT * FROM t2);
+SELECT * FROM LATERAL (SELECT * FROM t1) JOIN LATERAL (SELECT * FROM t2);
+
+-- lateral join with subquery alias
+SELECT a, b FROM t1, LATERAL (SELECT c1, c2) s(a, b);
+
+-- lateral join with foldable outer query references
+SELECT * FROM (SELECT 1 AS c1, 2 AS c2), LATERAL (SELECT c1, c2);
+
+-- lateral join with correlated equality predicates
+SELECT * FROM t1, LATERAL (SELECT c2 FROM t2 WHERE t1.c1 = t2.c1);
+
+-- lateral join with correlated non-equality predicates
+SELECT * FROM t1, LATERAL (SELECT c2 FROM t2 WHERE t1.c2 < t2.c2);
+
+-- SPARK-36114: lateral join with aggregation and correlated non-equality predicates
+SELECT * FROM t1, LATERAL (SELECT max(c2) AS m FROM t2 WHERE t1.c2 < t2.c2);
+
+-- lateral join can reference preceding FROM clause items
+SELECT * FROM t1 JOIN t2 JOIN LATERAL (SELECT t1.c2 + t2.c2);
+-- expect error: cannot resolve `t2.c1`
+SELECT * FROM t1 JOIN LATERAL (SELECT t1.c1 AS a, t2.c1 AS b) s JOIN t2 ON s.b = t2.c1;
+
+-- SPARK-37716: lateral join with non-deterministic expressions.
+-- non-deterministic lateral subquery with single row relation.
+SELECT x FROM VALUES (0) t(x) JOIN LATERAL (SELECT x + rand(0) AS y);
+SELECT x FROM (SELECT SUM(c1) AS x FROM t1), LATERAL (SELECT x + rand(0) AS y);
+-- expect error: lateral subquery must be deterministic when joining with a multi-row relation.
+SELECT * FROM t1, LATERAL (SELECT c1 + c2 + rand(0) AS c3);
+SELECT * FROM t1, LATERAL (SELECT rand(0) FROM t2);
+-- expect error: lateral join cannot have non-deterministic join condition.
+SELECT * FROM t1 JOIN LATERAL (SELECT * FROM t2) s ON t1.c1 + rand(0) = s.c1;
+
+-- multiple lateral joins
+SELECT * FROM t1,
+LATERAL (SELECT c1 + c2 AS a),
+LATERAL (SELECT c1 - c2 AS b),
+LATERAL (SELECT a * b AS c);
+
+-- lateral join in between regular joins
+SELECT * FROM t1
+LEFT OUTER JOIN LATERAL (SELECT c2 FROM t2 WHERE t1.c1 = t2.c1) s
+LEFT OUTER JOIN t1 t3 ON s.c2 = t3.c2;
+
+-- nested lateral joins
+SELECT * FROM t1, LATERAL (SELECT * FROM t2, LATERAL (SELECT c1));
+SELECT * FROM t1, LATERAL (SELECT * FROM (SELECT c1 + 1 AS c1), LATERAL (SELECT c1));
+SELECT * FROM t1, LATERAL (
+ SELECT * FROM (SELECT c1, MIN(c2) m FROM t2 WHERE t1.c1 = t2.c1 GROUP BY c1) s,
+ LATERAL (SELECT m WHERE m > c1)
+);
+-- expect error: cannot resolve `t1.c1`
+SELECT * FROM t1, LATERAL (SELECT * FROM t2, LATERAL (SELECT t1.c1 + t2.c1));
+-- expect error: cannot resolve `c2`
+SELECT * FROM t1, LATERAL (SELECT * FROM (SELECT c1), LATERAL (SELECT c2));
+
+-- uncorrelated scalar subquery inside lateral join
+SELECT * FROM t1, LATERAL (SELECT c2, (SELECT MIN(c2) FROM t2));
+
+-- correlated scalar subquery inside lateral join
+SELECT * FROM t1, LATERAL (SELECT (SELECT SUM(c2) FROM t2 WHERE c1 = a) FROM (SELECT c1 AS a));
+-- expect error: cannot resolve `t1.c1`
+SELECT * FROM t1, LATERAL (SELECT c1, (SELECT SUM(c2) FROM t2 WHERE c1 = t1.c1));
+
+-- lateral join inside uncorrelated subquery
+SELECT * FROM t1 WHERE c1 = (SELECT MIN(a) FROM t2, LATERAL (SELECT c1 AS a));
+
+-- lateral join inside correlated subquery
+SELECT * FROM t1 WHERE c1 = (SELECT MIN(a) FROM t2, LATERAL (SELECT c1 AS a) WHERE c1 = t1.c1);
+
+-- join condition has a correlated reference to the left side of the lateral join
+SELECT * FROM t1 JOIN lateral (SELECT * FROM t2 JOIN t4 ON t2.c1 = t4.c1 AND t2.c1 = t1.c1);
+SELECT * FROM t1 JOIN lateral (SELECT * FROM t2 JOIN t4 ON t2.c1 != t4.c1 AND t2.c1 != t1.c1);
+SELECT * FROM t1 LEFT JOIN lateral (SELECT * FROM t4 LEFT JOIN t2 ON t2.c1 = t4.c1 AND t2.c1 = t1.c1);
+
+-- COUNT bug with a single aggregate expression
+SELECT * FROM t1, LATERAL (SELECT COUNT(*) cnt FROM t2 WHERE c1 = t1.c1);
+
+-- COUNT bug with multiple aggregate expressions
+SELECT * FROM t1, LATERAL (SELECT COUNT(*) cnt, SUM(c2) sum FROM t2 WHERE c1 = t1.c1);
+
+-- COUNT bug without count aggregate
+SELECT * FROM t1, LATERAL (SELECT SUM(c2) IS NULL FROM t2 WHERE t1.c1 = t2.c1);
+
+-- COUNT bug with complex aggregate expressions
+SELECT * FROM t1, LATERAL (SELECT COUNT(*) + CASE WHEN sum(c2) IS NULL THEN 0 ELSE sum(c2) END FROM t2 WHERE t1.c1 = t2.c1);
+
+-- COUNT bug with non-empty group by columns (should not handle the count bug)
+SELECT * FROM t1, LATERAL (SELECT c1, COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1 GROUP BY c1);
+SELECT * FROM t1, LATERAL (SELECT c2, COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1 GROUP BY c2);
+
+-- COUNT bug with different join types
+SELECT * FROM t1 JOIN LATERAL (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1);
+SELECT * FROM t1 LEFT JOIN LATERAL (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1);
+SELECT * FROM t1 CROSS JOIN LATERAL (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1);
+
+-- COUNT bug with group by columns and different join types
+SELECT * FROM t1 LEFT JOIN LATERAL (SELECT c1, COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1 GROUP BY c1);
+SELECT * FROM t1 CROSS JOIN LATERAL (SELECT c1, COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1 GROUP BY c1);
+
+-- COUNT bug with non-empty join conditions
+SELECT * FROM t1 JOIN LATERAL (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1) ON cnt + 1 = c1;
+
+-- COUNT bug with self join
+SELECT * FROM t1, LATERAL (SELECT COUNT(*) cnt FROM t1 t2 WHERE t1.c1 = t2.c1);
+SELECT * FROM t1, LATERAL (SELECT COUNT(*) cnt FROM t1 t2 WHERE t1.c1 = t2.c1 HAVING cnt > 0);
+
+-- COUNT bug with multiple aggregates
+SELECT * FROM t1, LATERAL (SELECT SUM(cnt) FROM (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1));
+SELECT * FROM t1, LATERAL (SELECT COUNT(cnt) FROM (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1));
+SELECT * FROM t1, LATERAL (SELECT SUM(cnt) FROM (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1 GROUP BY c1));
+SELECT * FROM t1, LATERAL (
+ SELECT COUNT(*) FROM (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1)
+ JOIN t2 ON cnt = t2.c1
+);
+
+-- COUNT bug with correlated predicates above the left outer join
+SELECT * FROM t1, LATERAL (SELECT * FROM (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1) WHERE cnt = c1 - 1);
+SELECT * FROM t1, LATERAL (SELECT COUNT(*) FROM (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1) WHERE cnt = c1 - 1);
+SELECT * FROM t1, LATERAL (
+ SELECT COUNT(*) FROM (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1)
+ WHERE cnt = c1 - 1 GROUP BY cnt
+);
+
+-- COUNT bug with joins in the subquery
+SELECT * FROM t1, LATERAL (
+ SELECT * FROM (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1)
+ JOIN t2 ON cnt = t2.c1
+);
+SELECT * FROM t1, LATERAL (
+ SELECT l.cnt + r.cnt
+ FROM (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1) l
+ JOIN (SELECT COUNT(*) cnt FROM t2 WHERE t1.c1 = t2.c1) r
+);
+
+-- lateral subquery with group by
+SELECT * FROM t1 LEFT JOIN LATERAL (SELECT MIN(c2) FROM t2 WHERE c1 = t1.c1 GROUP BY c1);
+
+-- lateral join inside CTE
+WITH cte1 AS (
+ SELECT c1 FROM t1
+), cte2 AS (
+ SELECT s.* FROM cte1, LATERAL (SELECT * FROM t2 WHERE c1 = cte1.c1) s
+)
+SELECT * FROM cte2;
+
+-- SPARK-41441: lateral join with outer references in Generate
+SELECT * FROM t3 JOIN LATERAL (SELECT EXPLODE(c2));
+SELECT * FROM t3 JOIN LATERAL (SELECT EXPLODE_OUTER(c2));
+SELECT * FROM t3 JOIN LATERAL (SELECT EXPLODE(c2)) t(c3) ON c1 = c3;
+SELECT * FROM t3 LEFT JOIN LATERAL (SELECT EXPLODE(c2)) t(c3) ON c1 = c3;
+
+-- Window func
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT sum(t2.c2) over (order by t2.c1)
+ FROM t2
+ WHERE t2.c1 >= t1.c1);
+
+-- lateral join with union
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ UNION ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 = t1.c1);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ UNION DISTINCT
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 > t1.c2);
+
+-- INTERSECT
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ INTERSECT ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 = t1.c1);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ INTERSECT DISTINCT
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 > t1.c2);
+
+-- EXCEPT
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ EXCEPT ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 = t1.c1);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ EXCEPT DISTINCT
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 > t1.c2);
+
+-- COUNT bug with UNION in subquery
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT COUNT(t2.c2)
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ UNION DISTINCT
+ SELECT COUNT(t4.c2)
+ FROM t4
+ WHERE t4.c1 > t1.c2);
+
+-- Both correlated and uncorrelated children
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c1, t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ UNION ALL
+ SELECT t4.c2, t4.c1
+ FROM t4
+ WHERE t4.c1 = t1.c1);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1 and t2.c2 >= t1.c2
+ UNION ALL
+ SELECT t4.c2
+ FROM t4);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ UNION ALL
+ SELECT t4.c2
+ FROM t4);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1 and t2.c2 >= t1.c2
+ UNION DISTINCT
+ SELECT t4.c2
+ FROM t4);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1 and t2.c2 >= t1.c2
+ INTERSECT ALL
+ SELECT t4.c2
+ FROM t4);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1 and t2.c2 >= t1.c2
+ INTERSECT DISTINCT
+ SELECT t4.c2
+ FROM t4);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1 and t2.c2 >= t1.c2
+ EXCEPT ALL
+ SELECT t4.c2
+ FROM t4);
+
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1 and t2.c2 >= t1.c2
+ EXCEPT DISTINCT
+ SELECT t4.c2
+ FROM t4);
+
+-- Correlation under group by
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ GROUP BY t2.c2
+ UNION ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 > t1.c2
+ GROUP BY t4.c2);
+
+-- Correlation in group by
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c1 - t1.c1
+ FROM t2
+ GROUP BY t2.c1 - t1.c1
+ UNION ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 > t1.c2
+ GROUP BY t4.c2);
+
+-- Window func - unsupported
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT sum(t2.c2) over (order by t2.c1)
+ FROM t2
+ WHERE t2.c1 >= t1.c1
+ UNION ALL
+ SELECT t4.c2
+ FROM t4);
+
+-- lateral join under union
+SELECT * FROM t1 JOIN LATERAL (SELECT * FROM t2 WHERE t2.c1 = t1.c1)
+UNION ALL
+SELECT * FROM t1 JOIN t4;
+
+-- union above and below lateral join
+SELECT * FROM t1 JOIN LATERAL
+ (SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ UNION ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 = t1.c1)
+UNION ALL
+SELECT * FROM t2 JOIN LATERAL
+ (SELECT t1.c2
+ FROM t1
+ WHERE t2.c1 <= t1.c1
+ UNION ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 < t2.c1);
+
+-- Combinations of set ops
+SELECT * FROM t1 JOIN LATERAL
+ ((SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ EXCEPT DISTINCT
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 > t1.c2)
+ UNION DISTINCT
+ (SELECT t4.c1
+ FROM t4
+ WHERE t4.c1 <= t1.c2
+ INTERSECT ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 <> t1.c1)
+);
+
+SELECT * FROM t1 JOIN LATERAL
+ ((SELECT t2.c2
+ FROM t2
+ WHERE t2.c1 = t1.c1
+ UNION ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 > t1.c2)
+ INTERSECT DISTINCT
+ (SELECT t4.c1
+ FROM t4
+ WHERE t4.c1 <= t1.c2
+ EXCEPT ALL
+ SELECT t4.c2
+ FROM t4
+ WHERE t4.c1 <> t1.c1)
+);
+
+-- Semi join with correlation on left side - supported
+SELECT * FROM t1 JOIN LATERAL (SELECT sum(c1) FROM
+ (SELECT *
+ FROM t2
+ WHERE t2.c1 <= t1.c1) lhs
+ LEFT SEMI JOIN
+ (SELECT *
+ FROM t4) rhs
+ ON lhs.c1 <=> rhs.c1 and lhs.c2 <=> rhs.c2
+);
+
+-- Semi join with correlation on right side - unsupported
+SELECT * FROM t1 JOIN LATERAL (SELECT sum(c1) FROM
+ (SELECT *
+ FROM t2
+ WHERE t2.c1 <= t1.c1) lhs
+ LEFT SEMI JOIN
+ (SELECT *
+ FROM t4
+ WHERE t4.c1 > t1.c2) rhs
+ ON lhs.c1 <=> rhs.c1 and lhs.c2 <=> rhs.c2
+);
+
+-- SPARK-41961: lateral join with table-valued functions
+SELECT * FROM LATERAL EXPLODE(ARRAY(1, 2));
+SELECT * FROM t1, LATERAL RANGE(3);
+SELECT * FROM t1, LATERAL EXPLODE(ARRAY(c1, c2)) t2(c3);
+SELECT * FROM t3, LATERAL EXPLODE(c2) t2(v);
+SELECT * FROM t3, LATERAL EXPLODE_OUTER(c2) t2(v);
+SELECT * FROM EXPLODE(ARRAY(1, 2)) t(v), LATERAL (SELECT v + 1);
+
+-- lateral join with table-valued functions and join conditions
+SELECT * FROM t1 JOIN LATERAL EXPLODE(ARRAY(c1, c2)) t(c3) ON t1.c1 = c3;
+SELECT * FROM t3 JOIN LATERAL EXPLODE(c2) t(c3) ON t3.c1 = c3;
+SELECT * FROM t3 LEFT JOIN LATERAL EXPLODE(c2) t(c3) ON t3.c1 = c3;
+
+-- lateral join with table-valued functions in lateral subqueries
+SELECT * FROM t1, LATERAL (SELECT * FROM EXPLODE(ARRAY(c1, c2)));
+SELECT * FROM t1, LATERAL (SELECT t1.c1 + c3 FROM EXPLODE(ARRAY(c1, c2)) t(c3));
+SELECT * FROM t1, LATERAL (SELECT t1.c1 + c3 FROM EXPLODE(ARRAY(c1, c2)) t(c3) WHERE t1.c2 > 1);
+SELECT * FROM t1, LATERAL (SELECT * FROM EXPLODE(ARRAY(c1, c2)) l(x) JOIN EXPLODE(ARRAY(c2, c1)) r(y) ON x = y);
+
+-- SPARK-42119: lateral join with table-valued functions inline and inline_outer;
+CREATE OR REPLACE TEMPORARY VIEW array_struct(id, arr) AS VALUES
+ (1, ARRAY(STRUCT(1, 'a'), STRUCT(2, 'b'))),
+ (2, ARRAY()),
+ (3, ARRAY(STRUCT(3, 'c')));
+SELECT * FROM t1, LATERAL INLINE(ARRAY(STRUCT(1, 'a'), STRUCT(2, 'b')));
+SELECT c1, t.* FROM t1, LATERAL INLINE(ARRAY(STRUCT(1, 'a'), STRUCT(2, 'b'))) t(x, y);
+SELECT * FROM array_struct JOIN LATERAL INLINE(arr);
+SELECT * FROM array_struct LEFT JOIN LATERAL INLINE(arr) t(k, v) ON id = k;
+SELECT * FROM array_struct JOIN LATERAL INLINE_OUTER(arr);
+DROP VIEW array_struct;
+
+-- lateral join with table-valued functions posexplode and posexplode_outer
+SELECT * FROM LATERAL posexplode(ARRAY(1, 2));
+SELECT * FROM t1, LATERAL posexplode(ARRAY(c1, c2)) t2(pos, c3);
+SELECT * FROM t1 JOIN LATERAL posexplode(ARRAY(c1, c2)) t(pos, c3) ON t1.c1 = c3;
+SELECT * FROM t3, LATERAL posexplode(c2) t2(pos, v);
+SELECT * FROM t3 JOIN LATERAL posexplode(c2) t(pos, c3) ON t3.c1 = c3;
+SELECT * FROM t3, LATERAL posexplode_outer(c2) t2(pos, v);
+SELECT * FROM t3 LEFT JOIN LATERAL posexplode(c2) t(pos, c3) ON t3.c1 = c3;
+SELECT * FROM t3 LEFT JOIN LATERAL posexplode_outer(c2) t(pos, c3) ON t3.c1 = c3;
+
+-- lateral join with table-valued function json_tuple
+CREATE OR REPLACE TEMP VIEW json_table(key, jstring) AS VALUES
+ ('1', '{"f1": "1", "f2": "2", "f3": 3, "f5": 5.23}'),
+ ('2', '{"f1": "1", "f3": "3", "f2": 2, "f4": 4.01}'),
+ ('3', '{"f1": 3, "f4": "4", "f3": "3", "f2": 2, "f5": 5.01}'),
+ ('4', cast(null as string)),
+ ('5', '{"f1": null, "f5": ""}'),
+ ('6', '[invalid JSON string]');
+SELECT t1.key, t2.* FROM json_table t1, LATERAL json_tuple(t1.jstring, 'f1', 'f2', 'f3', 'f4', 'f5') t2;
+SELECT t1.key, t2.* FROM json_table t1, LATERAL json_tuple(t1.jstring, 'f1', 'f2', 'f3', 'f4', 'f5') t2 WHERE t2.c0 IS NOT NULL;
+SELECT t1.key, t2.* FROM json_table t1
+ JOIN LATERAL json_tuple(t1.jstring, 'f1', 'f2', 'f3', 'f4', 'f5') t2(f1, f2, f3, f4, f5)
+ ON t1.key = t2.f1;
+SELECT t1.key, t2.* FROM json_table t1
+ LEFT JOIN LATERAL json_tuple(t1.jstring, 'f1', 'f2', 'f3', 'f4', 'f5') t2(f1, f2, f3, f4, f5)
+ ON t1.key = t2.f1;
+DROP VIEW json_table;
+
+-- lateral join with table-valued function stack
+SELECT t.* FROM t1, LATERAL stack(2, 'Key', c1, 'Value', c2) t;
+SELECT t.* FROM t1 JOIN LATERAL stack(1, c1, c2) t(x, y);
+SELECT t.* FROM t1 JOIN t3 ON t1.c1 = t3.c1 JOIN LATERAL stack(1, t1.c2, t3.c2) t;
+-- expect error
+SELECT t.* FROM t1, LATERAL stack(c1, c2);
+
+-- SPARK-36191: ORDER BY/LIMIT in the correlated subquery
+select * from t1 join lateral (select * from t2 where t1.c1 = t2.c1 and t1.c2 < t2.c2 limit 1);
+
+select * from t1 join lateral (select * from t4 where t1.c1 <= t4.c1 order by t4.c2 limit 10);
+
+select * from t1 join lateral (select c1, min(c2) as m
+ from t2 where t1.c1 = t2.c1 and t1.c2 < t2.c2
+ group by t2.c1
+ order by m);
+
+select * from t1 join lateral (select c1, min(c2) as m
+ from t4 where t1.c1 = t4.c1
+ group by t4.c1
+ limit 1);
+
+select * from t1 join lateral
+ ((select t4.c2 from t4 where t1.c1 <= t4.c1 order by t4.c2 limit 1)
+ union all
+ (select t4.c1 from t4 where t1.c1 = t4.c1 order by t4.c1 limit 3));
+
+select * from t1 join lateral
+ (select * from
+ ((select t4.c2 as t from t4 where t1.c1 <= t4.c1)
+ union all
+ (select t4.c1 as t from t4 where t1.c1 = t4.c1)) as foo
+ order by foo.t limit 5);
+
+
+select 1
+from t1 as t_outer
+left join
+ lateral(
+ select b1,b2
+ from
+ (
+ select
+ t2.c1 as b1,
+ 1 as b2
+ from t2
+ union
+ select t_outer.c1 as b1,
+ null as b2
+ ) as t_inner
+ where (t_inner.b1 < t_outer.c2 or t_inner.b1 is null)
+ and t_inner.b1 = t_outer.c1
+ order by t_inner.b1,t_inner.b2 desc limit 1
+ ) as lateral_table;
+
+-- clean up
+DROP VIEW t1;
+DROP VIEW t2;
+DROP VIEW t3;
+DROP VIEW t4;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/json-functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/json-functions.sql
new file mode 100644
index 000000000000..245a6a6dfa7c
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/json-functions.sql
@@ -0,0 +1,111 @@
+-- to_json
+select to_json(named_struct('a', 1, 'b', 2));
+select to_json(named_struct('time', to_timestamp('2015-08-26', 'yyyy-MM-dd')), map('timestampFormat', 'dd/MM/yyyy'));
+select to_json(array(named_struct('a', 1, 'b', 2)));
+select to_json(map(named_struct('a', 1, 'b', 2), named_struct('a', 1, 'b', 2)));
+select to_json(map('a', named_struct('a', 1, 'b', 2)));
+select to_json(map('a', 1));
+select to_json(array(map('a',1)));
+select to_json(array(map('a',1), map('b',2)));
+-- Check if errors handled
+select to_json(named_struct('a', 1, 'b', 2), named_struct('mode', 'PERMISSIVE'));
+select to_json(named_struct('a', 1, 'b', 2), map('mode', 1));
+select to_json();
+
+-- from_json
+select from_json('{"a":1}', 'a INT');
+select from_json('{"time":"26/08/2015"}', 'time Timestamp', map('timestampFormat', 'dd/MM/yyyy'));
+-- Check if errors handled
+select from_json('{"a":1}', 1);
+select from_json('{"a":1}', 'a InvalidType');
+select from_json('{"a":1}', 'a INT', named_struct('mode', 'PERMISSIVE'));
+select from_json('{"a":1}', 'a INT', map('mode', 1));
+select from_json();
+-- json_tuple
+SELECT json_tuple('{"a" : 1, "b" : 2}', CAST(NULL AS STRING), 'b', CAST(NULL AS STRING), 'a');
+CREATE TEMPORARY VIEW jsonTable(jsonField, a) AS SELECT * FROM VALUES ('{"a": 1, "b": 2}', 'a');
+SELECT json_tuple(jsonField, 'b', CAST(NULL AS STRING), a) FROM jsonTable;
+-- json_tuple exists no foldable null field
+SELECT json_tuple('{"a":"1"}', if(c1 < 1, null, 'a')) FROM ( SELECT rand() AS c1 );
+SELECT json_tuple('{"a":"1"}', if(c1 < 1, null, 'a'), if(c2 < 1, null, 'a')) FROM ( SELECT 0 AS c1, rand() AS c2 );
+
+-- Clean up
+DROP VIEW IF EXISTS jsonTable;
+
+-- from_json - complex types
+select from_json('{"a":1, "b":2}', 'map');
+select from_json('{"a":1, "b":"2"}', 'struct');
+
+-- infer schema of json literal
+select schema_of_json('{"c1":0, "c2":[1]}');
+select from_json('{"c1":[1, 2, 3]}', schema_of_json('{"c1":[0]}'));
+
+-- from_json - array type
+select from_json('[1, 2, 3]', 'array');
+select from_json('[1, "2", 3]', 'array');
+select from_json('[1, 2, null]', 'array');
+
+select from_json('[{"a": 1}, {"a":2}]', 'array>');
+select from_json('{"a": 1}', 'array>');
+select from_json('[null, {"a":2}]', 'array>');
+
+select from_json('[{"a": 1}, {"b":2}]', 'array>');
+select from_json('[{"a": 1}, 2]', 'array>');
+
+-- from_json - datetime type
+select from_json('{"d": "2012-12-15", "t": "2012-12-15 15:15:15"}', 'd date, t timestamp');
+select from_json(
+ '{"d": "12/15 2012", "t": "12/15 2012 15:15:15"}',
+ 'd date, t timestamp',
+ map('dateFormat', 'MM/dd yyyy', 'timestampFormat', 'MM/dd yyyy HH:mm:ss'));
+select from_json(
+ '{"d": "02-29"}',
+ 'd date',
+ map('dateFormat', 'MM-dd'));
+select from_json(
+ '{"t": "02-29"}',
+ 't timestamp',
+ map('timestampFormat', 'MM-dd'));
+
+-- to_json - array type
+select to_json(array('1', '2', '3'));
+select to_json(array(array(1, 2, 3), array(4)));
+
+-- infer schema of json literal using options
+select schema_of_json('{"c1":1}', map('primitivesAsString', 'true'));
+select schema_of_json('{"c1":01, "c2":0.1}', map('allowNumericLeadingZeros', 'true', 'prefersDecimal', 'true'));
+select schema_of_json(null);
+CREATE TEMPORARY VIEW jsonTable(jsonField, a) AS SELECT * FROM VALUES ('{"a": 1, "b": 2}', 'a');
+SELECT schema_of_json(jsonField) FROM jsonTable;
+
+-- json_array_length
+select json_array_length(null);
+select json_array_length(2);
+select json_array_length();
+select json_array_length('');
+select json_array_length('[]');
+select json_array_length('[1,2,3]');
+select json_array_length('[[1,2],[5,6,7]]');
+select json_array_length('[{"a":123},{"b":"hello"}]');
+select json_array_length('[1,2,3,[33,44],{"key":[2,3,4]}]');
+select json_array_length('{"key":"not a json array"}');
+select json_array_length('[1,2,3,4,5');
+
+-- json_object_keys
+select json_object_keys();
+select json_object_keys(null);
+select json_object_keys(200);
+select json_object_keys('');
+select json_object_keys('{}');
+select json_object_keys('{"key": 1}');
+select json_object_keys('{"key": "value", "key2": 2}');
+select json_object_keys('{"arrayKey": [1, 2, 3]}');
+select json_object_keys('{"key":[1,2,3,{"key":"value"},[1,2,3]]}');
+select json_object_keys('{"f1":"abc","f2":{"f3":"a", "f4":"b"}}');
+select json_object_keys('{"k1": [1, 2, {"key": 5}], "k2": {"key2": [1, 2]}}');
+select json_object_keys('{[1,2]}');
+select json_object_keys('{"key": 45, "random_string"}');
+select json_object_keys('[1, 2, 3]');
+
+-- Clean up
+DROP VIEW IF EXISTS jsonTable;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/keywords-enforced.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/keywords-enforced.sql
new file mode 100644
index 000000000000..b0c6e5929b18
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/keywords-enforced.sql
@@ -0,0 +1,2 @@
+--SET spark.sql.ansi.enforceReservedKeywords = true
+--IMPORT keywords.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/keywords.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/keywords.sql
new file mode 100644
index 000000000000..d6b96b784c2a
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/keywords.sql
@@ -0,0 +1,3 @@
+SELECT * from SQL_KEYWORDS();
+
+SELECT keyword from SQL_KEYWORDS() WHERE reserved;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/like-all.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/like-all.sql
new file mode 100644
index 000000000000..0304e772e28e
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/like-all.sql
@@ -0,0 +1,41 @@
+-- test cases for like all
+
+CREATE OR REPLACE TEMPORARY VIEW like_all_table AS SELECT * FROM (VALUES
+ ('google', '%oo%'),
+ ('facebook', '%oo%'),
+ ('linkedin', '%in'))
+ as t1(company, pat);
+
+SELECT company FROM like_all_table WHERE company LIKE ALL ('%oo%', '%go%');
+
+SELECT company FROM like_all_table WHERE company LIKE ALL ('microsoft', '%yoo%');
+
+SELECT
+ company,
+ CASE
+ WHEN company LIKE ALL ('%oo%', '%go%') THEN 'Y'
+ ELSE 'N'
+ END AS is_available,
+ CASE
+ WHEN company LIKE ALL ('%oo%', 'go%') OR company LIKE ALL ('%in', 'ms%') THEN 'Y'
+ ELSE 'N'
+ END AS mix
+FROM like_all_table ;
+
+-- Mix test with constant pattern and column value
+SELECT company FROM like_all_table WHERE company LIKE ALL ('%oo%', pat);
+
+-- not like all test
+SELECT company FROM like_all_table WHERE company NOT LIKE ALL ('%oo%', '%in', 'fa%');
+SELECT company FROM like_all_table WHERE company NOT LIKE ALL ('microsoft', '%yoo%');
+SELECT company FROM like_all_table WHERE company NOT LIKE ALL ('%oo%', 'fa%');
+SELECT company FROM like_all_table WHERE NOT company LIKE ALL ('%oo%', 'fa%');
+
+-- null test
+SELECT company FROM like_all_table WHERE company LIKE ALL ('%oo%', NULL);
+SELECT company FROM like_all_table WHERE company NOT LIKE ALL ('%oo%', NULL);
+SELECT company FROM like_all_table WHERE company LIKE ALL (NULL, NULL);
+SELECT company FROM like_all_table WHERE company NOT LIKE ALL (NULL, NULL);
+
+-- negative case
+SELECT company FROM like_all_table WHERE company LIKE ALL ();
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/like-any.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/like-any.sql
new file mode 100644
index 000000000000..a6e9827d58d9
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/like-any.sql
@@ -0,0 +1,41 @@
+-- test cases for like any
+
+CREATE OR REPLACE TEMPORARY VIEW like_any_table AS SELECT * FROM (VALUES
+ ('google', '%oo%'),
+ ('facebook', '%oo%'),
+ ('linkedin', '%in'))
+ as t1(company, pat);
+
+SELECT company FROM like_any_table WHERE company LIKE ANY ('%oo%', '%in', 'fa%');
+
+SELECT company FROM like_any_table WHERE company LIKE ANY ('microsoft', '%yoo%');
+
+select
+ company,
+ CASE
+ WHEN company LIKE ANY ('%oo%', '%in', 'fa%') THEN 'Y'
+ ELSE 'N'
+ END AS is_available,
+ CASE
+ WHEN company LIKE ANY ('%oo%', 'fa%') OR company LIKE ANY ('%in', 'ms%') THEN 'Y'
+ ELSE 'N'
+ END AS mix
+FROM like_any_table;
+
+-- Mix test with constant pattern and column value
+SELECT company FROM like_any_table WHERE company LIKE ANY ('%zz%', pat);
+
+-- not like any test
+SELECT company FROM like_any_table WHERE company NOT LIKE ANY ('%oo%', '%in', 'fa%');
+SELECT company FROM like_any_table WHERE company NOT LIKE ANY ('microsoft', '%yoo%');
+SELECT company FROM like_any_table WHERE company NOT LIKE ANY ('%oo%', 'fa%');
+SELECT company FROM like_any_table WHERE NOT company LIKE ANY ('%oo%', 'fa%');
+
+-- null test
+SELECT company FROM like_any_table WHERE company LIKE ANY ('%oo%', NULL);
+SELECT company FROM like_any_table WHERE company NOT LIKE ANY ('%oo%', NULL);
+SELECT company FROM like_any_table WHERE company LIKE ANY (NULL, NULL);
+SELECT company FROM like_any_table WHERE company NOT LIKE ANY (NULL, NULL);
+
+-- negative case
+SELECT company FROM like_any_table WHERE company LIKE ANY ();
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/limit.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/limit.sql
new file mode 100644
index 000000000000..b4c73cf33e53
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/limit.sql
@@ -0,0 +1,32 @@
+
+-- limit on various data types
+SELECT * FROM testdata LIMIT 2;
+SELECT * FROM arraydata LIMIT 2;
+SELECT * FROM mapdata LIMIT 2;
+
+-- foldable non-literal in limit
+SELECT * FROM testdata LIMIT 2 + 1;
+
+SELECT * FROM testdata LIMIT CAST(1 AS int);
+
+-- limit must be non-negative
+SELECT * FROM testdata LIMIT -1;
+SELECT * FROM testData TABLESAMPLE (-1 ROWS);
+
+
+SELECT * FROM testdata LIMIT CAST(1 AS INT);
+-- evaluated limit must not be null
+SELECT * FROM testdata LIMIT CAST(NULL AS INT);
+
+-- limit must be foldable
+SELECT * FROM testdata LIMIT key > 3;
+
+-- limit must be integer
+SELECT * FROM testdata LIMIT true;
+SELECT * FROM testdata LIMIT 'a';
+
+-- limit within a subquery
+SELECT * FROM (SELECT * FROM range(10) LIMIT 5) WHERE id > 3;
+
+-- limit ALL
+SELECT * FROM testdata WHERE key < 3 LIMIT ALL;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/linear-regression.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/linear-regression.sql
new file mode 100644
index 000000000000..df286d2a9b0a
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/linear-regression.sql
@@ -0,0 +1,52 @@
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testRegression AS SELECT * FROM VALUES
+(1, 10, null), (2, 10, 11), (2, 20, 22), (2, 25, null), (2, 30, 35), (2, null, 40)
+AS testRegression(k, y, x);
+
+-- SPARK-37613: Support ANSI Aggregate Function: regr_count
+SELECT regr_count(y, x) FROM testRegression;
+SELECT regr_count(y, x) FROM testRegression WHERE x IS NOT NULL;
+SELECT k, count(*), regr_count(y, x) FROM testRegression GROUP BY k;
+SELECT k, count(*) FILTER (WHERE x IS NOT NULL), regr_count(y, x) FROM testRegression GROUP BY k;
+
+-- SPARK-37613: Support ANSI Aggregate Function: regr_r2
+SELECT regr_r2(y, x) FROM testRegression;
+SELECT regr_r2(y, x) FROM testRegression WHERE x IS NOT NULL;
+SELECT k, corr(y, x), regr_r2(y, x) FROM testRegression GROUP BY k;
+SELECT k, corr(y, x) FILTER (WHERE x IS NOT NULL), regr_r2(y, x) FROM testRegression GROUP BY k;
+
+-- SPARK-37614: Support ANSI Aggregate Function: regr_avgx & regr_avgy
+SELECT regr_avgx(y, x), regr_avgy(y, x) FROM testRegression;
+SELECT regr_avgx(y, x), regr_avgy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, avg(x), avg(y), regr_avgx(y, x), regr_avgy(y, x) FROM testRegression GROUP BY k;
+SELECT k, avg(x) FILTER (WHERE x IS NOT NULL AND y IS NOT NULL), avg(y) FILTER (WHERE x IS NOT NULL AND y IS NOT NULL), regr_avgx(y, x), regr_avgy(y, x) FROM testRegression GROUP BY k;
+
+-- SPARK-37672: Support ANSI Aggregate Function: regr_sxx
+SELECT regr_sxx(y, x) FROM testRegression;
+SELECT regr_sxx(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_sxx(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_sxx(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
+
+-- SPARK-37681: Support ANSI Aggregate Function: regr_sxy
+SELECT regr_sxy(y, x) FROM testRegression;
+SELECT regr_sxy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_sxy(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_sxy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
+
+-- SPARK-37702: Support ANSI Aggregate Function: regr_syy
+SELECT regr_syy(y, x) FROM testRegression;
+SELECT regr_syy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_syy(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_syy(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
+
+-- SPARK-39230: Support ANSI Aggregate Function: regr_slope
+SELECT regr_slope(y, x) FROM testRegression;
+SELECT regr_slope(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_slope(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_slope(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
+
+-- SPARK-37623: Support ANSI Aggregate Function: regr_intercept
+SELECT regr_intercept(y, x) FROM testRegression;
+SELECT regr_intercept(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL;
+SELECT k, regr_intercept(y, x) FROM testRegression GROUP BY k;
+SELECT k, regr_intercept(y, x) FROM testRegression WHERE x IS NOT NULL AND y IS NOT NULL GROUP BY k;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/listagg-collations.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/listagg-collations.sql
new file mode 100644
index 000000000000..aa3d02dc2fb6
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/listagg-collations.sql
@@ -0,0 +1,14 @@
+-- Test cases with utf8_binary
+SELECT listagg(c1) WITHIN GROUP (ORDER BY c1 COLLATE utf8_binary) FROM (VALUES ('a'), ('A'), ('b'), ('B')) AS t(c1);
+WITH t(c1) AS (SELECT listagg(DISTINCT col1 COLLATE utf8_binary) FROM (VALUES ('a'), ('A'), ('b'), ('B'))) SELECT len(c1), regexp_count(c1, 'a'), regexp_count(c1, 'b'), regexp_count(c1, 'A'), regexp_count(c1, 'B') FROM t;
+WITH t(c1) AS (SELECT listagg(col1) WITHIN GROUP (ORDER BY col1) FROM (VALUES ('abc '), ('abc '), ('abc\n'), ('abc'), ('x'))) SELECT replace(replace(c1, ' ', ''), '\n', '$') FROM t;
+-- Test cases with utf8_lcase. Lower expression added for determinism
+SELECT lower(listagg(c1) WITHIN GROUP (ORDER BY c1 COLLATE utf8_lcase)) FROM (VALUES ('a'), ('A'), ('b'), ('B')) AS t(c1);
+WITH t(c1) AS (SELECT lower(listagg(DISTINCT col1 COLLATE utf8_lcase)) FROM (VALUES ('a'), ('A'), ('b'), ('B'))) SELECT len(c1), regexp_count(c1, 'a'), regexp_count(c1, 'b') FROM t;
+SELECT lower(listagg(DISTINCT c1 COLLATE utf8_lcase) WITHIN GROUP (ORDER BY c1 COLLATE utf8_lcase)) FROM (VALUES ('a'), ('B'), ('b'), ('A')) AS t(c1);
+-- Test cases with unicode_rtrim.
+WITH t(c1) AS (SELECT replace(listagg(DISTINCT col1 COLLATE unicode_rtrim) COLLATE utf8_binary, ' ', '') FROM (VALUES ('xbc '), ('xbc '), ('a'), ('xbc'))) SELECT len(c1), regexp_count(c1, 'a'), regexp_count(c1, 'xbc') FROM t;
+WITH t(c1) AS (SELECT listagg(col1) WITHIN GROUP (ORDER BY col1 COLLATE unicode_rtrim) FROM (VALUES ('abc '), ('abc\n'), ('abc'), ('x'))) SELECT replace(replace(c1, ' ', ''), '\n', '$') FROM t;
+
+-- Error case with collations
+SELECT listagg(DISTINCT c1 COLLATE utf8_lcase) WITHIN GROUP (ORDER BY c1 COLLATE utf8_binary) FROM (VALUES ('a'), ('b'), ('A'), ('B')) AS t(c1);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/listagg.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/listagg.sql
new file mode 100644
index 000000000000..021de9975d30
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/listagg.sql
@@ -0,0 +1,41 @@
+--SET spark.sql.binaryOutputStyle=HEX
+
+-- Create temporary views
+CREATE TEMP VIEW df AS
+SELECT * FROM (VALUES ('a', 'b'), ('a', 'c'), ('b', 'c'), ('b', 'd'), (NULL, NULL));
+
+CREATE TEMP VIEW df2 AS
+SELECT * FROM (VALUES (1, true), (2, false), (3, false));
+
+-- Test cases for listagg function
+WITH t(col) AS (SELECT listagg(col2) FROM df GROUP BY col1) SELECT len(col), regexp_count(col, 'a'), regexp_count(col, 'b'), regexp_count(col, 'c'), regexp_count(col, 'd') FROM t;
+WITH t(col) AS (SELECT string_agg(col2) FROM df GROUP BY col1) SELECT len(col), regexp_count(col, 'a'), regexp_count(col, 'b'), regexp_count(col, 'c'), regexp_count(col, 'd') FROM t;
+WITH t(col) AS (SELECT listagg(col2, NULL) FROM df GROUP BY col1) SELECT len(col), regexp_count(col, 'a'), regexp_count(col, 'b'), regexp_count(col, 'c'), regexp_count(col, 'd') FROM t;
+SELECT listagg(col2) FROM df WHERE 1 != 1;
+WITH t(col) AS (SELECT listagg(col2, '|') FROM df GROUP BY col1) SELECT len(col), regexp_count(col, 'a'), regexp_count(col, 'b'), regexp_count(col, 'c'), regexp_count(col, 'd') FROM t;
+WITH t(col) AS (SELECT listagg(col1) FROM df) SELECT len(col), regexp_count(col, 'a'), regexp_count(col, 'b') FROM t;
+WITH t(col) AS (SELECT listagg(DISTINCT col1) FROM df) SELECT len(col), regexp_count(col, 'a'), regexp_count(col, 'b') FROM t;
+SELECT listagg(col1) WITHIN GROUP (ORDER BY col1) FROM df;
+SELECT listagg(col1) WITHIN GROUP (ORDER BY col1 DESC) FROM df;
+SELECT listagg(col1) WITHIN GROUP (ORDER BY col1 DESC) OVER (PARTITION BY col2) FROM df;
+SELECT listagg(col1) WITHIN GROUP (ORDER BY col2) FROM df;
+WITH t(col) AS (SELECT listagg(col1) WITHIN GROUP (ORDER BY col2 DESC) FROM df) SELECT (col == 'baba') || (col == 'bbaa') FROM t;
+WITH t(col) AS (SELECT listagg(col1, '|') WITHIN GROUP (ORDER BY col2 DESC) FROM df) SELECT (col == 'b|a|b|a') || (col == 'b|b|a|a') FROM t;
+SELECT listagg(col1, '|') WITHIN GROUP (ORDER BY col2 DESC) FROM df;
+SELECT listagg(col1) WITHIN GROUP (ORDER BY col2 DESC, col1 ASC) FROM df;
+SELECT listagg(col1) WITHIN GROUP (ORDER BY col2 DESC, col1 DESC) FROM df;
+WITH t(col) AS (SELECT listagg(col1) FROM (VALUES (X'DEAD'), (X'BEEF'))) SELECT len(col), regexp_count(col, X'DEAD'), regexp_count(col, X'BEEF') FROM t;
+WITH t(col) AS (SELECT listagg(col1, NULL) FROM (VALUES (X'DEAD'), (X'BEEF'))) SELECT len(col), regexp_count(col, X'DEAD'), regexp_count(col, X'BEEF') FROM t;
+WITH t(col) AS (SELECT listagg(col1, X'42') FROM (VALUES (X'DEAD'), (X'BEEF'))) SELECT len(col), regexp_count(col, X'42'), regexp_count(col, X'DEAD'), regexp_count(col, X'BEEF') FROM t;
+WITH t(col1, col2) AS (SELECT listagg(col1), listagg(col2, ',') FROM df2) SELECT len(col1), regexp_count(col1, '1'), regexp_count(col1, '2'), regexp_count(col1, '3'), len(col2), regexp_count(col2, 'true'), regexp_count(col1, 'false') FROM t;
+
+-- Error cases
+SELECT listagg(c1) FROM (VALUES (ARRAY('a', 'b'))) AS t(c1);
+SELECT listagg(c1, ', ') FROM (VALUES (X'DEAD'), (X'BEEF')) AS t(c1);
+SELECT listagg(col2, col1) FROM df GROUP BY col1;
+SELECT listagg(col1) OVER (ORDER BY col1) FROM df;
+SELECT listagg(col1) WITHIN GROUP (ORDER BY col1) OVER (ORDER BY col1) FROM df;
+SELECT string_agg(col1) WITHIN GROUP (ORDER BY col1) OVER (ORDER BY col1) FROM df;
+SELECT listagg(DISTINCT col1) OVER (ORDER BY col1) FROM df;
+SELECT listagg(DISTINCT col1) WITHIN GROUP (ORDER BY col2) FROM df;
+SELECT listagg(DISTINCT col1) WITHIN GROUP (ORDER BY col1, col2) FROM df;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/literals.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/literals.sql
new file mode 100644
index 000000000000..e1e4a370bffd
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/literals.sql
@@ -0,0 +1,123 @@
+-- Literal parsing
+
+-- null
+select null, Null, nUll;
+
+-- boolean
+select true, tRue, false, fALse;
+
+-- byte (tinyint)
+select 1Y;
+select 127Y, -128Y;
+
+-- out of range byte
+select 128Y;
+
+-- short (smallint)
+select 1S;
+select 32767S, -32768S;
+
+-- out of range short
+select 32768S;
+
+-- long (bigint)
+select 1L, 2147483648L;
+select 9223372036854775807L, -9223372036854775808L;
+
+-- out of range long
+select 9223372036854775808L;
+
+-- integral parsing
+
+-- parse int
+select 1, -1;
+
+-- parse int max and min value as int
+select 2147483647, -2147483648;
+
+-- parse long max and min value as long
+select 9223372036854775807, -9223372036854775808;
+
+-- parse as decimals (Long.MaxValue + 1, and Long.MinValue - 1)
+select 9223372036854775808, -9223372036854775809;
+
+-- out of range decimal numbers
+select 1234567890123456789012345678901234567890;
+select 1234567890123456789012345678901234567890.0;
+
+-- float
+select 1F, 1.2F, .10f, 0.10f;
+select -1F, -1.2F, -.10F, -0.10F;
+select -3.4028235E39f;
+
+-- double
+select 1D, 1.2D, 1e10, 1.5e5, .10D, 0.10D, .1e5, .9e+2, 0.9e+2, 900e-1, 9.e+1;
+select -1D, -1.2D, -1e10, -1.5e5, -.10D, -0.10D, -.1e5;
+-- negative double
+select .e3;
+-- very large decimals (overflowing double).
+select 1E309, -1E309;
+
+-- decimal parsing
+select 0.3, -0.8, .5, -.18, 0.1111, .1111;
+select 0.3 F, 0.4 D, 0.5 BD;
+
+-- super large scientific notation double literals should still be valid doubles
+select 123456789012345678901234567890123456789e10d, 123456789012345678901234567890123456789.1e10d;
+
+-- string
+select "Hello Peter!", 'hello lee!';
+-- multi string
+select 'hello' 'world', 'hello' " " 'lee';
+-- single quote within double quotes
+select "hello 'peter'";
+select 'pattern%', 'no-pattern\%', 'pattern\\%', 'pattern\\\%';
+select '\'', '"', '\n', '\r', '\t', 'Z';
+-- "Hello!" in octals
+select '\110\145\154\154\157\041';
+-- "World :)" in unicode
+select '\u0057\u006F\u0072\u006C\u0064\u0020\u003A\u0029';
+
+-- date
+select dAte '2016-03-12';
+-- invalid date
+select date 'mar 11 2016';
+
+-- timestamp
+select tImEstAmp '2016-03-11 20:54:00.000';
+-- invalid timestamp
+select timestamp '2016-33-11 20:54:00.000';
+
+-- unsupported data type
+select GEO '(10,-6)';
+
+-- big decimal parsing
+select 90912830918230182310293801923652346786BD, 123.0E-28BD, 123.08BD;
+
+-- out of range big decimal
+select 1.20E-38BD;
+
+-- hexadecimal binary literal
+select x'2379ACFe';
+
+-- invalid hexadecimal binary literal
+select X'XuZ';
+
+-- Hive literal_double test.
+SELECT 3.14, -3.14, 3.14e8, 3.14e-8, -3.14e8, -3.14e-8, 3.14e+8, 3.14E8, 3.14E-8;
+
+-- awareness of the negative/positive sign before type
+select +date '1999-01-01';
+select +timestamp '1999-01-01';
+select +interval '1 day';
+select +map(1, 2);
+select +array(1,2);
+select +named_struct('a', 1, 'b', 'spark');
+select +X'1';
+-- can't negate date/timestamp/binary
+select -date '1999-01-01';
+select -timestamp '1999-01-01';
+select -x'2379ACFe';
+
+-- normalize -0 and -0.0
+select -0, -0.0;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/map.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/map.sql
new file mode 100644
index 000000000000..bff2f7a9ae28
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/map.sql
@@ -0,0 +1,17 @@
+-- test cases for map functions
+
+-- key does not exist
+select element_at(map(1, 'a', 2, 'b'), 5);
+select map(1, 'a', 2, 'b')[5];
+
+
+-- map_contains_key
+select map_contains_key(map(1, 'a', 2, 'b'), 5);
+select map_contains_key(map(1, 'a', 2, 'b'), 1);
+-- map_contains_key: input type is different from the key type
+select map_contains_key(map(1, 'a', 2, 'b'), 5.0);
+select map_contains_key(map(1, 'a', 2, 'b'), 1.0);
+select map_contains_key(map(1.0, 'a', 2, 'b'), 5);
+select map_contains_key(map(1.0, 'a', 2, 'b'), 1);
+select map_contains_key(map('1', 'a', '2', 'b'), 1);
+select map_contains_key(map(1, 'a', 2, 'b'), '1');
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/mask-functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/mask-functions.sql
new file mode 100644
index 000000000000..b4dc8f183036
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/mask-functions.sql
@@ -0,0 +1,58 @@
+-- mask function
+SELECT mask('AbCD123-@$#');
+SELECT mask('AbCD123-@$#', 'Q');
+SELECT mask('AbCD123-@$#', 'Q', 'q');
+SELECT mask('AbCD123-@$#', 'Q', 'q', 'd');
+SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o');
+SELECT mask('AbCD123-@$#', 'Qa', 'qa', 'da', 'oa');
+SELECT mask('AbCD123-@$#', NULL, 'q', 'd', 'o');
+SELECT mask('AbCD123-@$#', NULL, NULL, 'd', 'o');
+SELECT mask('AbCD123-@$#', NULL, NULL, NULL, 'o');
+SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL);
+SELECT mask(NULL);
+SELECT mask(NULL, NULL, 'q', 'd', 'o');
+SELECT mask(NULL, NULL, NULL, 'd', 'o');
+SELECT mask(NULL, NULL, NULL, NULL, 'o');
+SELECT mask('AbCD123-@$#', NULL, NULL, NULL, NULL);
+SELECT mask(c1) from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, 'Q') from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, 'Q', 'q')from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, 'Q', 'q', 'd') from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, 'Q', 'q', 'd', 'o') from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, NULL, 'q', 'd', 'o') from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, NULL, NULL, 'd', 'o') from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, NULL, NULL, NULL, 'o') from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, NULL, NULL, NULL, NULL) from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, NULL, 'q', 'd', 'o') from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, 'Q', NULL, 'd', 'o') from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, 'Q', 'q', NULL, 'o') from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(c1, 'Q', 'q', 'd', NULL) from values ('AbCD123-@$#') as tab(c1);
+SELECT mask(NULL, 'Q', 'q', 'd', NULL) from values ('AbCD123-@$#') as tab(c1);
+SELECT mask('abcd-EFGH-8765-4321');
+SELECT mask('abcd-EFGH-8765-4321', 'Q');
+SELECT mask('abcd-EFGH-8765-4321', 'Q', 'q');
+SELECT mask('abcd-EFGH-8765-4321', 'Q', 'q', 'd');
+SELECT mask('abcd-EFGH-8765-4321', 'Q', 'q', 'd', '*');
+SELECT mask('abcd-EFGH-8765-4321', NULL, 'q', 'd', '*');
+SELECT mask('abcd-EFGH-8765-4321', NULL, NULL, 'd', '*');
+SELECT mask('abcd-EFGH-8765-4321', NULL, NULL, NULL, '*');
+SELECT mask('abcd-EFGH-8765-4321', NULL, NULL, NULL, NULL);
+SELECT mask(NULL);
+SELECT mask(NULL, NULL, 'q', 'd', '*');
+SELECT mask(NULL, NULL, NULL, 'd', '*');
+SELECT mask(NULL, NULL, NULL, NULL, '*');
+SELECT mask(NULL, NULL, NULL, NULL, NULL);
+SELECT mask(c1) from values ('abcd-EFGH-8765-4321') as tab(c1);
+SELECT mask(c1, 'Q') from values ('abcd-EFGH-8765-4321') as tab(c1);
+SELECT mask(c1, 'Q', 'q')from values ('abcd-EFGH-8765-4321') as tab(c1);
+SELECT mask(c1, 'Q', 'q', 'd') from values ('abcd-EFGH-8765-4321') as tab(c1);
+SELECT mask(c1, 'Q', 'q', 'd', '*') from values ('abcd-EFGH-8765-4321') as tab(c1);
+SELECT mask(c1, NULL, 'q', 'd', '*') from values ('abcd-EFGH-8765-4321') as tab(c1);
+SELECT mask(c1, NULL, NULL, 'd', '*') from values ('abcd-EFGH-8765-4321') as tab(c1);
+SELECT mask(c1, NULL, NULL, NULL, '*') from values ('abcd-EFGH-8765-4321') as tab(c1);
+SELECT mask(c1, NULL, NULL, NULL, NULL) from values ('abcd-EFGH-8765-4321') as tab(c1);
+SELECT mask(c1, replaceArg) from values('abcd-EFGH-8765-4321', 'a') as t(c1, replaceArg);
+SELECT mask(c1, replaceArg) from values('abcd-EFGH-8765-4321', 'ABC') as t(c1, replaceArg);
+SELECT mask(c1, replaceArg) from values('abcd-EFGH-8765-4321', 123) as t(c1, replaceArg);
+SELECT mask('abcd-EFGH-8765-4321', 'A', 'w', '');
+SELECT mask('abcd-EFGH-8765-4321', 'A', 'abc');
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/math.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/math.sql
new file mode 100644
index 000000000000..14a647a610cc
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/math.sql
@@ -0,0 +1,92 @@
+-- Round with Byte input
+SELECT round(25y, 1);
+SELECT round(25y, 0);
+SELECT round(25y, -1);
+SELECT round(25y, -2);
+SELECT round(25y, -3);
+SELECT round(127y, -1);
+SELECT round(-128y, -1);
+
+-- Round with short integer input
+SELECT round(525s, 1);
+SELECT round(525s, 0);
+SELECT round(525s, -1);
+SELECT round(525s, -2);
+SELECT round(525s, -3);
+SELECT round(32767s, -1);
+SELECT round(-32768s, -1);
+
+-- Round with integer input
+SELECT round(525, 1);
+SELECT round(525, 0);
+SELECT round(525, -1);
+SELECT round(525, -2);
+SELECT round(525, -3);
+SELECT round(2147483647, -1);
+SELECT round(-2147483647, -1);
+
+-- Round with big integer input
+SELECT round(525L, 1);
+SELECT round(525L, 0);
+SELECT round(525L, -1);
+SELECT round(525L, -2);
+SELECT round(525L, -3);
+SELECT round(9223372036854775807L, -1);
+SELECT round(-9223372036854775808L, -1);
+
+-- Bround with byte input
+SELECT bround(25y, 1);
+SELECT bround(25y, 0);
+SELECT bround(25y, -1);
+SELECT bround(25y, -2);
+SELECT bround(25y, -3);
+SELECT bround(127y, -1);
+SELECT bround(-128y, -1);
+
+-- Bround with Short input
+SELECT bround(525s, 1);
+SELECT bround(525s, 0);
+SELECT bround(525s, -1);
+SELECT bround(525s, -2);
+SELECT bround(525s, -3);
+SELECT bround(32767s, -1);
+SELECT bround(-32768s, -1);
+
+-- Bround with integer input
+SELECT bround(525, 1);
+SELECT bround(525, 0);
+SELECT bround(525, -1);
+SELECT bround(525, -2);
+SELECT bround(525, -3);
+SELECT bround(2147483647, -1);
+SELECT bround(-2147483647, -1);
+
+-- Bround with big integer input
+SELECT bround(525L, 1);
+SELECT bround(525L, 0);
+SELECT bround(525L, -1);
+SELECT bround(525L, -2);
+SELECT bround(525L, -3);
+SELECT bround(9223372036854775807L, -1);
+SELECT bround(-9223372036854775808L, -1);
+
+-- Conv
+SELECT conv('100', 2, 10);
+SELECT conv(-10, 16, -10);
+SELECT conv('9223372036854775808', 10, 16);
+SELECT conv('92233720368547758070', 10, 16);
+SELECT conv('9223372036854775807', 36, 10);
+SELECT conv('-9223372036854775807', 36, 10);
+
+SELECT BIN(0);
+SELECT BIN(25);
+SELECT BIN(25L);
+SELECT BIN(25.5);
+
+SELECT POSITIVE(0Y);
+SELECT POSITIVE(25);
+SELECT POSITIVE(-25L);
+SELECT POSITIVE(25.5);
+SELECT POSITIVE("25.5");
+SELECT POSITIVE("invalid");
+SELECT POSITIVE(null);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/misc-functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/misc-functions.sql
new file mode 100644
index 000000000000..e178f69c7d51
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/misc-functions.sql
@@ -0,0 +1,45 @@
+-- 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);
+select typeof(true);
+select typeof(1Y), typeof(1S), typeof(1), typeof(1L);
+select typeof(cast(1.0 as float)), typeof(1.0D), typeof(1.2);
+select typeof(date '1986-05-23'), typeof(timestamp '1986-05-23'), typeof(interval '23 days');
+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);
+SELECT assert_true(boolean(0));
+SELECT assert_true(null);
+SELECT assert_true(boolean(null));
+SELECT assert_true(false, 'custom error message');
+
+CREATE TEMPORARY VIEW tbl_misc AS SELECT * FROM (VALUES (1), (8), (2)) AS T(v);
+SELECT raise_error('error message');
+SELECT if(v > 5, raise_error('too big: ' || v), v + 1) FROM tbl_misc;
+
+-- Too many parameters
+SELECT raise_error('error message', Map());
+
+-- Too many parameters
+SELECT raise_error('error message', 'some args');
+
+-- Too few parameters
+SELECT raise_error();
+
+-- Passing null as message
+SELECT raise_error(NULL);
+
+-- Passing non-string type
+SELECT raise_error(1);
+
+-- Check legacy config disables printing of [USER_RAISED_EXCEPTION]
+SET spark.sql.legacy.raiseErrorWithoutErrorClass=true;
+SELECT assert_true(false);
+SELECT raise_error('hello');
+SET spark.sql.legacy.raiseErrorWithoutErrorClass=false;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/mode.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/mode.sql
new file mode 100644
index 000000000000..85035da7ad3f
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/mode.sql
@@ -0,0 +1,139 @@
+-- Test data.
+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 mode(department), mode(salary) FROM basic_pays;
+SELECT department, mode(salary) FROM basic_pays GROUP BY department ORDER BY department;
+SELECT department, mode(DISTINCT salary) FROM basic_pays GROUP BY department ORDER BY department;
+
+-- SPARK-45034: Support deterministic mode function
+SELECT mode(col) FROM VALUES (-10), (0), (10) AS tab(col);
+SELECT mode(col, false) FROM VALUES (-10), (0), (10) AS tab(col);
+SELECT mode(col, true) FROM VALUES (-10), (0), (10) AS tab(col);
+SELECT mode(col, 'true') FROM VALUES (-10), (0), (10) AS tab(col);
+SELECT mode(col, null) FROM VALUES (-10), (0), (10) AS tab(col);
+SELECT mode(col, b) FROM VALUES (-10, false), (0, false), (10, false) AS tab(col, b);
+SELECT mode(col) FROM VALUES (map(1, 'a')) AS tab(col);
+SELECT mode(col, false) FROM VALUES (map(1, 'a')) AS tab(col);
+SELECT mode(col, true) FROM VALUES (map(1, 'a')) AS tab(col);
+
+SELECT
+ mode() WITHIN GROUP (ORDER BY col),
+ mode() WITHIN GROUP (ORDER BY col DESC)
+FROM VALUES (null), (null), (null) AS tab(col);
+
+SELECT
+ mode() WITHIN GROUP (ORDER BY salary),
+ mode() WITHIN GROUP (ORDER BY salary DESC)
+FROM basic_pays
+WHERE salary > 20000;
+
+SELECT
+ mode() WITHIN GROUP (ORDER BY salary),
+ mode() WITHIN GROUP (ORDER BY salary DESC)
+FROM basic_pays;
+
+SELECT
+ mode() WITHIN GROUP (ORDER BY salary),
+ mode() WITHIN GROUP (ORDER BY salary) FILTER (WHERE salary > 10000)
+FROM basic_pays;
+
+SELECT
+ department,
+ mode() WITHIN GROUP (ORDER BY salary),
+ mode() WITHIN GROUP (ORDER BY salary) FILTER (WHERE salary > 10000)
+FROM basic_pays
+GROUP BY department
+ORDER BY department;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ mode() WITHIN GROUP (ORDER BY salary) OVER (PARTITION BY department)
+FROM basic_pays
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ mode() WITHIN GROUP (ORDER BY salary) OVER (PARTITION BY department ORDER BY salary)
+FROM basic_pays
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ mode() WITHIN GROUP (ORDER BY salary) OVER (PARTITION BY department ROWS BETWEEN UNBOUNDED PRECEDING AND 1 FOLLOWING)
+FROM basic_pays
+ORDER BY salary;
+
+SELECT
+ employee_name,
+ department,
+ salary,
+ mode() WITHIN GROUP (ORDER BY salary) OVER w
+FROM basic_pays
+WHERE salary > 8900
+WINDOW w AS (PARTITION BY department)
+ORDER BY salary;
+
+SELECT
+ mode(DISTINCT salary) WITHIN GROUP (ORDER BY salary)
+FROM basic_pays;
+
+SELECT
+ mode()
+FROM basic_pays;
+
+SELECT
+ mode(salary) WITHIN GROUP (ORDER BY salary)
+FROM basic_pays;
+
+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
+ mode() WITHIN GROUP (ORDER BY dt),
+ mode() WITHIN GROUP (ORDER BY dt DESC)
+FROM intervals;
+
+SELECT
+ k,
+ mode() WITHIN GROUP (ORDER BY ym),
+ mode() WITHIN GROUP (ORDER BY dt DESC)
+FROM intervals
+GROUP BY k
+ORDER BY k;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/named-function-arguments.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/named-function-arguments.sql
new file mode 100644
index 000000000000..a795a19828c1
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/named-function-arguments.sql
@@ -0,0 +1,74 @@
+-- Test for named arguments for Mask
+SELECT mask('AbCD123-@$#', lowerChar => 'q', upperChar => 'Q', otherChar => 'o', digitChar => 'd');
+SELECT mask(lowerChar => 'q', upperChar => 'Q', otherChar => 'o', digitChar => 'd', str => 'AbCD123-@$#');
+SELECT mask('AbCD123-@$#', lowerChar => 'q', upperChar => 'Q', digitChar => 'd');
+SELECT mask(lowerChar => 'q', upperChar => 'Q', digitChar => 'd', str => 'AbCD123-@$#');
+
+-- Test for named arguments for CountMinSketchAgg
+create temporary view t2 as select * from values
+ ('val2a', 6S, 12, 14L, float(15), 20D, 20E2, timestamp '2014-04-04 01:01:00.000', date '2014-04-04'),
+ ('val1b', 10S, 12, 19L, float(17), 25D, 26E2, timestamp '2014-05-04 01:01:00.000', date '2014-05-04'),
+ ('val1b', 8S, 16, 119L, float(17), 25D, 26E2, timestamp '2015-05-04 01:01:00.000', date '2015-05-04'),
+ ('val1c', 12S, 16, 219L, float(17), 25D, 26E2, timestamp '2016-05-04 01:01:00.000', date '2016-05-04'),
+ ('val1b', null, 16, 319L, float(17), 25D, 26E2, timestamp '2017-05-04 01:01:00.000', null),
+ ('val2e', 8S, null, 419L, float(17), 25D, 26E2, timestamp '2014-06-04 01:01:00.000', date '2014-06-04'),
+ ('val1f', 19S, null, 519L, float(17), 25D, 26E2, timestamp '2014-05-04 01:01:00.000', date '2014-05-04'),
+ ('val1b', 10S, 12, 19L, float(17), 25D, 26E2, timestamp '2014-06-04 01:01:00.000', date '2014-06-04'),
+ ('val1b', 8S, 16, 19L, float(17), 25D, 26E2, timestamp '2014-07-04 01:01:00.000', date '2014-07-04'),
+ ('val1c', 12S, 16, 19L, float(17), 25D, 26E2, timestamp '2014-08-04 01:01:00.000', date '2014-08-05'),
+ ('val1e', 8S, null, 19L, float(17), 25D, 26E2, timestamp '2014-09-04 01:01:00.000', date '2014-09-04'),
+ ('val1f', 19S, null, 19L, float(17), 25D, 26E2, timestamp '2014-10-04 01:01:00.000', date '2014-10-04'),
+ ('val1b', null, 16, 19L, float(17), 25D, 26E2, timestamp '2014-05-04 01:01:00.000', null)
+ as t2(t2a, t2b, t2c, t2d, t2e, t2f, t2g, t2h, t2i);
+
+SELECT hex(count_min_sketch(t2d, seed => 1, epsilon => 0.5d, confidence => 0.5d)) FROM t2;
+SELECT hex(count_min_sketch(seed => 1, epsilon => 0.5d, confidence => 0.5d, column => t2d)) FROM t2;
+SELECT hex(count_min_sketch(t2d, 0.5d, seed => 1, confidence => 0.5d)) FROM t2;
+
+-- Test for tabled value functions explode and explode_outer
+SELECT * FROM explode(collection => array(1, 2));
+SELECT * FROM explode_outer(collection => map('a', 1, 'b', 2));
+SELECT * FROM explode(array(1, 2)), explode(array(3, 4));
+SELECT * FROM explode(array(1, 2)) AS t, LATERAL explode(array(3 * t.col, 4 * t.col));
+SELECT num, val, 'Spark' FROM explode(map(1, 'a', 2, 'b')) AS t(num, val);
+
+-- Test for tabled value functions posexplode and posexplode_outer
+SELECT * FROM posexplode(collection => array(1, 2));
+SELECT * FROM posexplode_outer(collection => map('a', 1, 'b', 2));
+SELECT * FROM posexplode(array(1, 2)), posexplode(array(3, 4));
+SELECT * FROM posexplode(array(1, 2)) AS t, LATERAL posexplode(array(3 * t.col, 4 * t.col));
+SELECT pos, num, val, 'Spark' FROM posexplode(map(1, 'a', 2, 'b')) AS t(pos, num, val);
+
+-- Test for tabled value functions inline and inline_outer
+SELECT * FROM inline(input => array(struct(1, 'a'), struct(2, 'b')));
+SELECT * FROM inline_outer(input => array(struct(1, 'a'), struct(2, 'b')));
+SELECT * FROM inline(array(struct(1, 'a'), struct(2, 'b'))), inline(array(struct(3, 'c'), struct(4, 'd')));
+SELECT * FROM inline(array(struct(1, 'a'), struct(2, 'b'))) AS t, LATERAL inline(array(struct(3 * t.col1, 4 * t.col1)));
+SELECT num, val, 'Spark' FROM inline(array(struct(1, 'a'), struct(2, 'b'))) AS t(num, val);
+
+-- Test for wrapped EXPLODE call to check error preservation
+SELECT * FROM explode(collection => explode(array(1)));
+SELECT * FROM explode(collection => explode(collection => array(1)));
+
+-- Test with TABLE parser rule
+CREATE OR REPLACE TEMPORARY VIEW v AS SELECT id FROM range(0, 8);
+SELECT * FROM explode(collection => TABLE(v));
+
+-- Unexpected positional argument
+SELECT mask(lowerChar => 'q', 'AbCD123-@$#', upperChar => 'Q', otherChar => 'o', digitChar => 'd');
+
+-- Duplicate parameter assignment
+SELECT mask('AbCD123-@$#', lowerChar => 'q', upperChar => 'Q', otherChar => 'o', digitChar => 'd', digitChar => 'e');
+SELECT mask('AbCD123-@$#', lowerChar => 'q', upperChar => 'Q', otherChar => 'o', digitChar => 'd', str => 'AbC');
+
+-- Required parameter not found
+SELECT mask(lowerChar => 'q', upperChar => 'Q', otherChar => 'o', digitChar => 'd');
+
+-- Unrecognized parameter name
+SELECT mask('AbCD123-@$#', lowerChar => 'q', upperChar => 'Q', otherChar => 'o', digitChar => 'd', cellular => 'automata');
+
+-- Named arguments not supported
+SELECT encode(str => 'a', charset => 'utf-8');
+
+-- Wrong number of arguments
+SELECT mask('AbCD123-@$#', 'Q', 'q', 'd', 'o', 'k');
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/natural-join.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/natural-join.sql
new file mode 100644
index 000000000000..5815eee2d9e4
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/natural-join.sql
@@ -0,0 +1,77 @@
+create temporary view nt1 as select * from values
+ ("one", 1),
+ ("two", 2),
+ ("three", 3)
+ as nt1(k, v1);
+
+create temporary view nt2 as select * from values
+ ("one", 1),
+ ("two", 22),
+ ("one", 5)
+ as nt2(k, v2);
+
+create temporary view nt3 as select * from values
+ ("one", 4),
+ ("two", 5),
+ ("one", 6)
+ as nt3(k, v3);
+
+create temporary view nt4 as select * from values
+ ("one", 7),
+ ("two", 8),
+ ("one", 9)
+ as nt4(k, v4);
+
+SELECT * FROM nt1 natural join nt2;
+
+SELECT * FROM nt1 natural join nt2 where k = "one";
+
+SELECT * FROM nt1 natural left join nt2 order by v1, v2;
+
+SELECT * FROM nt1 natural right join nt2 order by v1, v2;
+
+SELECT count(*) FROM nt1 natural full outer join nt2;
+
+SELECT k FROM nt1 natural join nt2;
+
+SELECT k FROM nt1 natural join nt2 where k = "one";
+
+SELECT nt1.* FROM nt1 natural join nt2;
+
+SELECT nt2.* FROM nt1 natural join nt2;
+
+SELECT sbq.* from (SELECT * FROM nt1 natural join nt2) sbq;
+
+SELECT sbq.k from (SELECT * FROM nt1 natural join nt2) sbq;
+
+SELECT nt1.*, nt2.* FROM nt1 natural join nt2;
+
+SELECT *, nt2.k FROM nt1 natural join nt2;
+
+SELECT nt1.k, nt2.k FROM nt1 natural join nt2;
+
+SELECT k FROM (SELECT nt2.k FROM nt1 natural join nt2);
+
+SELECT nt2.k AS key FROM nt1 natural join nt2 ORDER BY key;
+
+SELECT nt1.k, nt2.k FROM nt1 natural join nt2 where k = "one";
+
+SELECT * FROM (SELECT * FROM nt1 natural join nt2);
+
+SELECT * FROM (SELECT nt1.*, nt2.* FROM nt1 natural join nt2);
+
+SELECT * FROM (SELECT nt1.v1, nt2.k FROM nt1 natural join nt2);
+
+SELECT nt2.k FROM (SELECT * FROM nt1 natural join nt2);
+
+SELECT * FROM nt1 natural join nt2 natural join nt3;
+
+SELECT nt1.*, nt2.*, nt3.* FROM nt1 natural join nt2 natural join nt3;
+
+SELECT nt1.*, nt2.*, nt3.* FROM nt1 natural join nt2 join nt3 on nt2.k = nt3.k;
+
+SELECT * FROM nt1 natural join nt2 join nt3 on nt1.k = nt3.k;
+
+SELECT * FROM nt1 natural join nt2 join nt3 on nt2.k = nt3.k;
+
+SELECT nt1.*, nt2.*, nt3.*, nt4.* FROM nt1 natural join nt2 natural join nt3 natural join nt4;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/non-excludable-rule.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/non-excludable-rule.sql
new file mode 100644
index 000000000000..c02bc8c6063f
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/non-excludable-rule.sql
@@ -0,0 +1,19 @@
+-- SPARK-39448
+SET spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.ReplaceCTERefWithRepartition;
+SELECT
+ (SELECT min(id) FROM range(10)),
+ (SELECT sum(id) FROM range(10)),
+ (SELECT count(distinct id) FROM range(10));
+
+-- SPARK-39444
+SET spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.Optimizer$OptimizeSubqueries;
+WITH tmp AS (
+ SELECT id FROM range(2)
+ INTERSECT
+ SELECT id FROM range(4)
+)
+SELECT id FROM range(3) WHERE id > (SELECT max(id) FROM tmp);
+
+-- SPARK-36979
+SET spark.sql.optimizer.excludedRules=org.apache.spark.sql.catalyst.optimizer.RewriteLateralSubquery;
+SELECT * FROM testData, LATERAL (SELECT * FROM testData) LIMIT 1;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/array.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/array.sql
new file mode 100644
index 000000000000..b04abe57cb86
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/array.sql
@@ -0,0 +1 @@
+--IMPORT array.sql
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/cast.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/cast.sql
new file mode 100644
index 000000000000..b16ee89ac67e
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/cast.sql
@@ -0,0 +1 @@
+--IMPORT cast.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/conditional-functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/conditional-functions.sql
new file mode 100644
index 000000000000..c4b3418cc6d8
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/conditional-functions.sql
@@ -0,0 +1 @@
+--IMPORT conditional-functions.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/date.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/date.sql
new file mode 100644
index 000000000000..1f6e366eba94
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/date.sql
@@ -0,0 +1 @@
+--IMPORT date.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/datetime-parsing-invalid.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/datetime-parsing-invalid.sql
new file mode 100644
index 000000000000..70022f33337d
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/datetime-parsing-invalid.sql
@@ -0,0 +1,2 @@
+--IMPORT datetime-parsing-invalid.sql
+
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/datetime-special.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/datetime-special.sql
new file mode 100644
index 000000000000..87a5986ae9a9
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/datetime-special.sql
@@ -0,0 +1 @@
+--IMPORT datetime-special.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/decimalArithmeticOperations.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/decimalArithmeticOperations.sql
new file mode 100644
index 000000000000..7d6c336df452
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/decimalArithmeticOperations.sql
@@ -0,0 +1 @@
+--IMPORT decimalArithmeticOperations.sql
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/double-quoted-identifiers.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/double-quoted-identifiers.sql
new file mode 100644
index 000000000000..7ccd294e709b
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/double-quoted-identifiers.sql
@@ -0,0 +1 @@
+--IMPORT double-quoted-identifiers.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/higher-order-functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/higher-order-functions.sql
new file mode 100644
index 000000000000..1e2424fe47ca
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/higher-order-functions.sql
@@ -0,0 +1 @@
+--IMPORT higher-order-functions.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/interval.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/interval.sql
new file mode 100644
index 000000000000..215ce9658e1a
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/interval.sql
@@ -0,0 +1 @@
+--IMPORT interval.sql
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/keywords.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/keywords.sql
new file mode 100644
index 000000000000..ebc9345c3a73
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/keywords.sql
@@ -0,0 +1 @@
+--IMPORT keywords.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/literals.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/literals.sql
new file mode 100644
index 000000000000..698e8fa88630
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/literals.sql
@@ -0,0 +1,2 @@
+--- malformed interval literal with ansi mode
+--IMPORT literals.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/map.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/map.sql
new file mode 100644
index 000000000000..23e5b9562973
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/map.sql
@@ -0,0 +1 @@
+--IMPORT map.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/math.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/math.sql
new file mode 100644
index 000000000000..5ee19c28ca6b
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/math.sql
@@ -0,0 +1 @@
+--IMPORT math.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/parse-schema-string.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/parse-schema-string.sql
new file mode 100644
index 000000000000..42775102e650
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/parse-schema-string.sql
@@ -0,0 +1 @@
+--IMPORT parse-schema-string.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/string-functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/string-functions.sql
new file mode 100644
index 000000000000..dd28e9b97fb2
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/string-functions.sql
@@ -0,0 +1 @@
+--IMPORT string-functions.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/timestamp.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/timestamp.sql
new file mode 100644
index 000000000000..79193c900d04
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/timestamp.sql
@@ -0,0 +1 @@
+--IMPORT timestamp.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_aggregates.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_aggregates.sql
new file mode 100644
index 000000000000..f5b44d2b2aa7
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_aggregates.sql
@@ -0,0 +1 @@
+--IMPORT try_aggregates.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_arithmetic.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_arithmetic.sql
new file mode 100644
index 000000000000..a0165b9784ae
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_arithmetic.sql
@@ -0,0 +1 @@
+--IMPORT try_arithmetic.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_datetime_functions.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_datetime_functions.sql
new file mode 100644
index 000000000000..ede47f3eecb9
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_datetime_functions.sql
@@ -0,0 +1 @@
+--IMPORT try_datetime_functions.sql
\ No newline at end of file
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_element_at.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_element_at.sql
new file mode 100644
index 000000000000..64d6197fa205
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/nonansi/try_element_at.sql
@@ -0,0 +1 @@
+--IMPORT try_element_at.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/null-handling.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/null-handling.sql
new file mode 100644
index 000000000000..dcdf241df73d
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/null-handling.sql
@@ -0,0 +1,53 @@
+-- Create a test table with data
+create table t1(a int, b int, c int) using parquet;
+insert into t1 values(1,0,0);
+insert into t1 values(2,0,1);
+insert into t1 values(3,1,0);
+insert into t1 values(4,1,1);
+insert into t1 values(5,null,0);
+insert into t1 values(6,null,1);
+insert into t1 values(7,null,null);
+
+-- Adding anything to null gives null
+select a, b+c from t1;
+select b + 0 from t1 where a = 5;
+select -100 + b + 100 from t1 where a = 5;
+
+-- Multiplying null by zero gives null
+select a+10, b*0 from t1;
+
+-- nulls are NOT distinct in SELECT DISTINCT
+select distinct b from t1;
+
+-- nulls are NOT distinct in UNION
+select b from t1 union select b from t1;
+
+-- CASE WHEN null THEN 1 ELSE 0 END is 0
+select a+20, case b when c then 1 else 0 end from t1;
+select a+30, case c when b then 1 else 0 end from t1;
+select a+40, case when b<>0 then 1 else 0 end from t1;
+select a+50, case when not b<>0 then 1 else 0 end from t1;
+select a+60, case when b<>0 and c<>0 then 1 else 0 end from t1;
+
+-- "not (null AND false)" is true
+select a+70, case when not (b<>0 and c<>0) then 1 else 0 end from t1;
+
+-- "null OR true" is true
+select a+80, case when b<>0 or c<>0 then 1 else 0 end from t1;
+select a+90, case when not (b<>0 or c<>0) then 1 else 0 end from t1;
+
+-- null with aggregate operators
+select count(*), count(b), sum(b), avg(b), min(b), max(b) from t1;
+
+-- Check the behavior of NULLs in WHERE clauses
+select a+100 from t1 where b<10;
+select a+110 from t1 where not b>10;
+select a+120 from t1 where b<10 OR c=1;
+select a+130 from t1 where b<10 AND c=1;
+select a+140 from t1 where not (b<10 AND c=1);
+select a+150 from t1 where not (c=1 AND b<10);
+
+-- null-safe comparisons
+select b, c, equal_null(b, c), equal_null(c, b) from t1;
+
+drop table t1;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/null-propagation.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/null-propagation.sql
new file mode 100644
index 000000000000..66549da7971d
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/null-propagation.sql
@@ -0,0 +1,9 @@
+
+-- count(null) should be 0
+SELECT COUNT(NULL) FROM VALUES 1, 2, 3;
+SELECT COUNT(1 + NULL) FROM VALUES 1, 2, 3;
+
+-- count(null) on window should be 0
+SELECT COUNT(NULL) OVER () FROM VALUES 1, 2, 3;
+SELECT COUNT(1 + NULL) OVER () FROM VALUES 1, 2, 3;
+
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/operators.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/operators.sql
new file mode 100644
index 000000000000..33274665f55c
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/operators.sql
@@ -0,0 +1,105 @@
+
+-- unary minus and plus
+select -100;
+select +230;
+select -5.2;
+select +6.8e0;
+select -key, +key from testdata where key = 2;
+select -(key + 1), - key + 1, +(key + 5) from testdata where key = 1;
+select -max(key), +max(key) from testdata;
+select - (-10);
+select + (-key) from testdata where key = 32;
+select - (+max(key)) from testdata;
+select - - 3;
+select - + 20;
+select + + 100;
+select - - max(key) from testdata;
+select + - key from testdata where key = 33;
+
+-- division
+select 5 / 2;
+select 5 / 0;
+select 5 / null;
+select null / 5;
+
+-- integral div
+select 5 div 2;
+select 5 div 0;
+select 5 div null;
+select null div 5;
+select cast(51 as decimal(10, 0)) div cast(2 as decimal(2, 0));
+select cast(5 as decimal(1, 0)) div cast(0 as decimal(2, 0));
+select cast(5 as decimal(1, 0)) div cast(null as decimal(2, 0));
+select cast(null as decimal(1, 0)) div cast(5 as decimal(2, 0));
+
+-- other arithmetics
+select 1 + 2;
+select 1 - 2;
+select 2 * 5;
+select 5 % 3;
+select pmod(-7, 3);
+
+-- math functions
+select sec(1);
+select sec(null);
+select sec(0);
+select sec(-1);
+select csc(1);
+select csc(null);
+select csc(0);
+select csc(-1);
+select cot(1);
+select cot(null);
+select cot(0);
+select cot(-1);
+
+-- ceil and ceiling
+select ceiling(0);
+select ceiling(1);
+select ceil(1234567890123456);
+select ceiling(1234567890123456);
+select ceil(0.01);
+select ceiling(-0.10);
+
+-- floor
+select floor(0);
+select floor(1);
+select floor(1234567890123456);
+select floor(0.01);
+select floor(-0.10);
+
+-- comparison operator
+select 1 > 0.00001;
+
+-- mod
+select mod(7, 2), mod(7, 0), mod(0, 2), mod(7, null), mod(null, 2), mod(null, null);
+
+-- length
+select BIT_LENGTH('abc');
+select CHAR_LENGTH('abc');
+select CHARACTER_LENGTH('abc');
+select OCTET_LENGTH('abc');
+
+-- abs
+select abs(-3.13), abs('-2.19');
+
+-- positive/negative
+select positive('-1.11'), positive(-1.11), negative('-1.11'), negative(-1.11);
+
+-- pmod
+select pmod(-7, 2), pmod(0, 2), pmod(7, 0), pmod(7, null), pmod(null, 2), pmod(null, null);
+select pmod(cast(3.13 as decimal), cast(0 as decimal)), pmod(cast(2 as smallint), cast(0 as smallint));
+
+-- width_bucket
+select width_bucket(5.35, 0.024, 10.06, 5);
+select width_bucket(5.35, 0.024, 10.06, 3 + 2);
+select width_bucket('5.35', '0.024', '10.06', '5');
+select width_bucket(5.35, 0.024, 10.06, 2.5);
+select width_bucket(5.35, 0.024, 10.06, 0.5);
+select width_bucket(null, 0.024, 10.06, 5);
+select width_bucket(5.35, null, 10.06, 5);
+select width_bucket(5.35, 0.024, null, -5);
+select width_bucket(5.35, 0.024, 10.06, null);
+select width_bucket(5.35, 0.024, 10.06, -5);
+select width_bucket(5.35, 0.024, 10.06, 9223372036854775807L); -- long max value
+select width_bucket(5.35, 0.024, 10.06, 9223372036854775807L - 1);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by-all.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by-all.sql
new file mode 100644
index 000000000000..56472cad7644
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by-all.sql
@@ -0,0 +1,47 @@
+create temporary view data as select * from values
+ (0, 1),
+ (0, 2),
+ (1, 3),
+ (1, NULL)
+ as data(g, i);
+
+-- most basic test with only 1 column
+select g from data order by all;
+
+-- two columns
+select * from data order by all;
+
+-- test case insensitive
+select * from data order by aLl;
+
+-- asc/desc
+select * from data order by all asc;
+select * from data order by all desc;
+
+-- nulls first / last
+select * from data order by all nulls first;
+select * from data order by all nulls last;
+
+-- combining nulls first/last/asc/desc
+select * from data order by all asc nulls first;
+select * from data order by all desc nulls first;
+select * from data order by all asc nulls last;
+select * from data order by all desc nulls last;
+
+-- set operations from duckdb
+select * from data union all select * from data order by all;
+select * from data union select * from data order by all;
+
+-- limit
+select * from data order by all limit 2;
+
+-- precedence: if there's a column already named all, reference that, instead of expanding.
+-- result should be 1, 2, 3, and not 3, 2, 1
+select * from values("z", 1), ("y", 2), ("x", 3) AS T(col1, all) order by all;
+
+-- shouldn't work in window functions
+select name, dept, rank() over (partition by dept order by all) as rank
+from values('Lisa', 'Sales', 10000, 35) as T(name, dept, salary, age);
+
+-- ORDER BY column can't reference an outer scope
+SELECT all, (SELECT col2 FROM VALUES (2, 2) ORDER BY ALL) FROM VALUES (1) AS t1 (all)
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by-nulls-ordering.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by-nulls-ordering.sql
new file mode 100644
index 000000000000..ad3977465c83
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by-nulls-ordering.sql
@@ -0,0 +1,88 @@
+-- Test sort 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
+
+-- Q1. testing window functions with order by
+create table spark_10747(col1 int, col2 int, col3 int) using parquet;
+
+-- Q2. insert to tables
+INSERT INTO spark_10747 VALUES (6, 12, 10), (6, 11, 4), (6, 9, 10), (6, 15, 8),
+(6, 15, 8), (6, 7, 4), (6, 7, 8), (6, 13, null), (6, 10, null);
+
+-- Q3. windowing with order by DESC NULLS LAST
+select col1, col2, col3, sum(col2)
+ over (partition by col1
+ order by col3 desc nulls last, col2
+ rows between 2 preceding and 2 following ) as sum_col2
+from spark_10747 where col1 = 6 order by sum_col2;
+
+-- Q4. windowing with order by DESC NULLS FIRST
+select col1, col2, col3, sum(col2)
+ over (partition by col1
+ order by col3 desc nulls first, col2
+ rows between 2 preceding and 2 following ) as sum_col2
+from spark_10747 where col1 = 6 order by sum_col2;
+
+-- Q5. windowing with order by ASC NULLS LAST
+select col1, col2, col3, sum(col2)
+ over (partition by col1
+ order by col3 asc nulls last, col2
+ rows between 2 preceding and 2 following ) as sum_col2
+from spark_10747 where col1 = 6 order by sum_col2;
+
+-- Q6. windowing with order by ASC NULLS FIRST
+select col1, col2, col3, sum(col2)
+ over (partition by col1
+ order by col3 asc nulls first, col2
+ rows between 2 preceding and 2 following ) as sum_col2
+from spark_10747 where col1 = 6 order by sum_col2;
+
+-- Q7. Regular query with ORDER BY ASC NULLS FIRST
+SELECT COL1, COL2, COL3 FROM spark_10747 ORDER BY COL3 ASC NULLS FIRST, COL2;
+
+-- Q8. Regular query with ORDER BY ASC NULLS LAST
+SELECT COL1, COL2, COL3 FROM spark_10747 ORDER BY COL3 NULLS LAST, COL2;
+
+-- Q9. Regular query with ORDER BY DESC NULLS FIRST
+SELECT COL1, COL2, COL3 FROM spark_10747 ORDER BY COL3 DESC NULLS FIRST, COL2;
+
+-- Q10. Regular query with ORDER BY DESC NULLS LAST
+SELECT COL1, COL2, COL3 FROM spark_10747 ORDER BY COL3 DESC NULLS LAST, COL2;
+
+-- drop the test table
+drop table spark_10747;
+
+-- Q11. mix datatype for ORDER BY NULLS FIRST|LAST
+create table spark_10747_mix(
+col1 string,
+col2 int,
+col3 double,
+col4 decimal(10,2),
+col5 decimal(20,1))
+using parquet;
+
+-- Q12. Insert to the table
+INSERT INTO spark_10747_mix VALUES
+('b', 2, 1.0, 1.00, 10.0),
+('d', 3, 2.0, 3.00, 0.0),
+('c', 3, 2.0, 2.00, 15.1),
+('d', 3, 0.0, 3.00, 1.0),
+(null, 3, 0.0, 3.00, 1.0),
+('d', 3, null, 4.00, 1.0),
+('a', 1, 1.0, 1.00, null),
+('c', 3, 2.0, 2.00, null);
+
+-- Q13. Regular query with 2 NULLS LAST columns
+select * from spark_10747_mix order by col1 nulls last, col5 nulls last;
+
+-- Q14. Regular query with 2 NULLS FIRST columns
+select * from spark_10747_mix order by col1 desc nulls first, col5 desc nulls first;
+
+-- Q15. Regular query with mixed NULLS FIRST|LAST
+select * from spark_10747_mix order by col5 desc nulls first, col3 desc nulls last;
+
+-- drop the test table
+drop table spark_10747_mix;
+
+
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by-ordinal.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by-ordinal.sql
new file mode 100644
index 000000000000..8d733e77fa8d
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by-ordinal.sql
@@ -0,0 +1,36 @@
+-- order by and sort by ordinal positions
+
+create temporary view data as select * from values
+ (1, 1),
+ (1, 2),
+ (2, 1),
+ (2, 2),
+ (3, 1),
+ (3, 2)
+ as data(a, b);
+
+select * from data order by 1 desc;
+
+-- mix ordinal and column name
+select * from data order by 1 desc, b desc;
+
+-- order by multiple ordinals
+select * from data order by 1 desc, 2 desc;
+
+-- 1 + 0 is considered a constant (not an ordinal) and thus ignored
+select * from data order by 1 + 0 desc, b desc;
+
+-- negative cases: ordinal position out of range
+select * from data order by 0;
+select * from data order by -1;
+select * from data order by 3;
+
+-- sort by ordinal
+select * from data sort by 1 desc;
+
+-- turn off order by ordinal
+set spark.sql.orderByOrdinal=false;
+
+-- 0 is now a valid literal
+select * from data order by 0;
+select * from data sort by 0;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by.sql
new file mode 100644
index 000000000000..d67987bcb51c
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/order-by.sql
@@ -0,0 +1,34 @@
+-- Test data.
+CREATE OR REPLACE TEMPORARY VIEW testData AS SELECT * FROM VALUES
+(1, 1), (1, 2), (2, 1), (2, 2), (3, 1), (3, 2), (null, 1), (3, null), (null, null)
+AS testData(a, b);
+
+-- ORDER BY a column from a child's output
+SELECT a FROM testData ORDER BY a;
+SELECT a FROM testData GROUP BY a, b ORDER BY a;
+
+-- ORDER BY a column from an output below a child's one
+SELECT b FROM testData WHERE a > 1 ORDER BY a;
+
+-- ORDER BY a column from grouping expressions list
+SELECT b FROM testData GROUP BY a, b ORDER BY a;
+
+-- ORDER BY a nested column from an output below a child's one
+SELECT col1 FROM VALUES (1, named_struct('f1', 1)) ORDER BY col2.f1;
+SELECT col1 FROM VALUES (1, named_struct('f1', named_struct('f2', 1))) ORDER BY col2.f1.f2;
+
+-- ORDER BY column can't reference an outer scope
+SELECT a, (SELECT b FROM testData GROUP BY b HAVING b > 1 ORDER BY a) FROM testData;
+
+-- Column resolution from the child's output takes the precedence over `ORDER BY ALL`
+SELECT a, (SELECT b FROM VALUES (1, 2) AS innerTestData (all, b) ORDER BY ALL) FROM testData;
+
+-- ORDER BY with scalar subqueries
+SELECT * FROM testData ORDER BY (SELECT a FROM testData ORDER BY b);
+SELECT * FROM testData ORDER BY (SELECT * FROM testData ORDER BY (SELECT a FROM testData ORDER BY b));
+
+-- Fails because correlation is not allowed in ORDER BY
+SELECT * FROM testData ORDER BY (SELECT a FROM VALUES (1));
+
+-- Clean up
+DROP VIEW IF EXISTS testData;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/outer-join.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/outer-join.sql
new file mode 100644
index 000000000000..a43b0eadf2b4
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/outer-join.sql
@@ -0,0 +1,45 @@
+-- There are 2 dimensions we want to test
+-- 1. run with broadcast hash join, sort merge join or shuffle hash join.
+-- 2. run with whole-stage-codegen, operator codegen or no codegen.
+
+--CONFIG_DIM1 spark.sql.autoBroadcastJoinThreshold=10485760
+--CONFIG_DIM1 spark.sql.autoBroadcastJoinThreshold=-1,spark.sql.join.preferSortMergeJoin=true
+--CONFIG_DIM1 spark.sql.autoBroadcastJoinThreshold=-1,spark.sql.join.forceApplyShuffledHashJoin=true
+
+--CONFIG_DIM2 spark.sql.codegen.wholeStage=true
+--CONFIG_DIM2 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=CODEGEN_ONLY
+--CONFIG_DIM2 spark.sql.codegen.wholeStage=false,spark.sql.codegen.factoryMode=NO_CODEGEN
+
+-- SPARK-17099: Incorrect result when HAVING clause is added to group by query
+CREATE OR REPLACE TEMPORARY VIEW t1 AS SELECT * FROM VALUES
+(-234), (145), (367), (975), (298)
+as t1(int_col1);
+
+CREATE OR REPLACE TEMPORARY VIEW t2 AS SELECT * FROM VALUES
+(-769, -244), (-800, -409), (940, 86), (-507, 304), (-367, 158)
+as t2(int_col0, int_col1);
+
+SELECT
+ (SUM(COALESCE(t1.int_col1, t2.int_col0))),
+ ((COALESCE(t1.int_col1, t2.int_col0)) * 2)
+FROM t1
+RIGHT JOIN t2
+ ON (t2.int_col0) = (t1.int_col1)
+GROUP BY GREATEST(COALESCE(t2.int_col1, 109), COALESCE(t1.int_col1, -449)),
+ COALESCE(t1.int_col1, t2.int_col0)
+HAVING (SUM(COALESCE(t1.int_col1, t2.int_col0)))
+ > ((COALESCE(t1.int_col1, t2.int_col0)) * 2);
+
+
+-- SPARK-17120: Analyzer incorrectly optimizes plan to empty LocalRelation
+CREATE OR REPLACE TEMPORARY VIEW t1 AS SELECT * FROM VALUES (97) as t1(int_col1);
+
+CREATE OR REPLACE TEMPORARY VIEW t2 AS SELECT * FROM VALUES (0) as t2(int_col1);
+
+SELECT *
+FROM (
+SELECT
+ COALESCE(t2.int_col1, t1.int_col1) AS int_col
+ FROM t1
+ LEFT JOIN t2 ON false
+) t where (t.int_col) is not null;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/parse-query-correctness-old-behavior.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/parse-query-correctness-old-behavior.sql
new file mode 100644
index 000000000000..bece56f575cb
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/parse-query-correctness-old-behavior.sql
@@ -0,0 +1,2 @@
+--SET spark.sql.legacy.parseQueryWithoutEof=true
+--IMPORT parse-query-correctness.sql
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/parse-query-correctness.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/parse-query-correctness.sql
new file mode 100644
index 000000000000..8884e51f052e
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/parse-query-correctness.sql
@@ -0,0 +1,286 @@
+-- This test suite checks the correctness of AbstractSqlParser.parseQuery
+
+-- SPARK-51113, view read path
+
+-- UNION
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1 AS num
+ UNION
+ SELECT 2
+ UNION
+ SELECT 3
+ UNION
+ SELECT 4
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1
+ UNION
+ SELECT 2
+ UNION
+ SELECT 3
+ UNION
+ SELECT 4
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1, 'a'
+ UNION
+ SELECT 2, 'b'
+ UNION
+ SELECT 3, 'c'
+ UNION
+ SELECT 4, 'd'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1 AS num, 'a'
+ UNION
+ SELECT 2, 'b'
+ UNION
+ SELECT 3, 'c'
+ UNION
+ SELECT 4, 'd'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1, 'a' AS a
+ UNION
+ SELECT 2, 'b'
+ UNION
+ SELECT 3, 'c'
+ UNION
+ SELECT 4, 'd'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1 AS num, 'a' AS a
+ UNION
+ SELECT 2, 'b'
+ UNION
+ SELECT 3, 'c'
+ UNION
+ SELECT 4, 'd'
+;
+SELECT * FROM v1;
+
+-- EXCEPT
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1 AS num
+ EXCEPT
+ SELECT 2
+ EXCEPT
+ SELECT 1
+ EXCEPT
+ SELECT 2
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1
+ EXCEPT
+ SELECT 2
+ EXCEPT
+ SELECT 1
+ EXCEPT
+ SELECT 2
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1, 'a'
+ EXCEPT
+ SELECT 2, 'b'
+ EXCEPT
+ SELECT 1, 'a'
+ EXCEPT
+ SELECT 2, 'b'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1 AS num, 'a'
+ EXCEPT
+ SELECT 2, 'b'
+ EXCEPT
+ SELECT 1, 'a'
+ EXCEPT
+ SELECT 2, 'b'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1, 'a' AS a
+ EXCEPT
+ SELECT 2, 'b'
+ EXCEPT
+ SELECT 1, 'a'
+ EXCEPT
+ SELECT 2, 'b'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1 AS num, 'a' AS a
+ EXCEPT
+ SELECT 2, 'b'
+ EXCEPT
+ SELECT 1, 'a'
+ EXCEPT
+ SELECT 2, 'b'
+;
+SELECT * FROM v1;
+
+-- INTERSECT
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1 AS num
+ INTERSECT
+ SELECT 1
+ INTERSECT
+ SELECT 2
+ INTERSECT
+ SELECT 2
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1
+ INTERSECT
+ SELECT 1
+ INTERSECT
+ SELECT 2
+ INTERSECT
+ SELECT 2
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1, 'a'
+ INTERSECT
+ SELECT 1, 'a'
+ INTERSECT
+ SELECT 2, 'b'
+ INTERSECT
+ SELECT 2, 'b'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1 AS num, 'a'
+ INTERSECT
+ SELECT 1, 'a'
+ INTERSECT
+ SELECT 2, 'b'
+ INTERSECT
+ SELECT 2, 'b'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1, 'a' AS a
+ INTERSECT
+ SELECT 1, 'a'
+ INTERSECT
+ SELECT 2, 'b'
+ INTERSECT
+ SELECT 2, 'b'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE TEMPORARY VIEW v1 AS
+ SELECT 1 AS num, 'a' AS a
+ INTERSECT
+ SELECT 1, 'a'
+ INTERSECT
+ SELECT 2, 'b'
+ INTERSECT
+ SELECT 2, 'b'
+;
+SELECT * FROM v1;
+
+DROP VIEW v1;
+
+-- Views with schema evolution would give incorrect result.
+-- The last column would be named 'UNION' on read, but schema evolution
+-- would allow the 'a' -> 'UNION' rename on read.
+
+CREATE OR REPLACE VIEW v1 WITH SCHEMA EVOLUTION AS
+ SELECT 1, 'a'
+ UNION
+ SELECT 2, 'b'
+ UNION
+ SELECT 3, 'c'
+ UNION
+ SELECT 4, 'd'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE VIEW v1 WITH SCHEMA EVOLUTION AS
+ SELECT 1 AS num, 'a'
+ UNION
+ SELECT 2, 'b'
+ UNION
+ SELECT 3, 'c'
+ UNION
+ SELECT 4, 'd'
+;
+SELECT * FROM v1;
+
+CREATE OR REPLACE VIEW v1 WITH SCHEMA EVOLUTION AS
+ SELECT 1 AS num, 'a' AS a
+ UNION
+ SELECT 2, 'b'
+ UNION
+ SELECT 3, 'c'
+ UNION
+ SELECT 4, 'd'
+;
+SELECT * FROM v1;
+
+DROP VIEW v1;
+
+-- SPARK-51113, EXECUTE IMMEDIATE ... INTO
+
+DECLARE v1 INT;
+
+EXECUTE IMMEDIATE 'SELECT 1 UNION SELECT 2 UNION SELECT 3' INTO v1;
+SELECT v1;
+
+EXECUTE IMMEDIATE 'SELECT 1 UNION SELECT 1 UNION SELECT 1' INTO v1;
+SELECT v1;
+
+EXECUTE IMMEDIATE 'SELECT 1 EXCEPT SELECT 2 EXCEPT SELECT 3' INTO v1;
+SELECT v1;
+
+EXECUTE IMMEDIATE 'SELECT 1 EXCEPT SELECT 1 EXCEPT SELECT 1' INTO v1;
+SELECT v1;
+
+EXECUTE IMMEDIATE 'SELECT 1 INTERSECT SELECT 2 INTERSECT SELECT 3' INTO v1;
+SELECT v1;
+
+EXECUTE IMMEDIATE 'SELECT 1 INTERSECT SELECT 1 INTERSECT SELECT 1' INTO v1;
+SELECT v1;
+
+-- Garbage queries
+
+EXECUTE IMMEDIATE 'SELECT 1 JOIN SELECT 2' INTO v1;
+SELECT v1;
+
+EXECUTE IMMEDIATE 'SELECT 1 VALUES (1)' INTO v1;
+SELECT v1;
+
+EXECUTE IMMEDIATE 'SELECT 1 alias garbage garbage garbage' INTO v1;
+SELECT v1;
+
+EXECUTE IMMEDIATE 'SELECT 1 WITH abc' INTO v1;
+SELECT v1;
+
+DROP TEMPORARY VARIABLE v1;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/parse-schema-string.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/parse-schema-string.sql
new file mode 100644
index 000000000000..c67d45139fd6
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/parse-schema-string.sql
@@ -0,0 +1,5 @@
+-- Use keywords as attribute names
+select from_csv('1', 'create INT');
+select from_csv('1', 'cube INT');
+select from_json('{"create":1}', 'create INT');
+select from_json('{"cube":1}', 'cube INT');
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/percentiles.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/percentiles.sql
new file mode 100644
index 000000000000..4b3e8708222a
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/percentiles.sql
@@ -0,0 +1,429 @@
+-- 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
+ round(v, 0) WITHIN GROUP (ORDER BY v)
+FROM aggr;
+
+SELECT
+ round(v, 0) WITHIN GROUP (ORDER BY v) OVER (PARTITION BY k)
+FROM aggr;
+
+SELECT
+ percentile(v, 0.5) WITHIN GROUP (ORDER BY v)
+FROM aggr;
+
+SELECT
+ percentile(v, 0.5) WITHIN GROUP (ORDER BY v) OVER (PARTITION BY k)
+FROM aggr;
+
+SELECT
+ percentile_cont(DISTINCT 0.5) WITHIN GROUP (ORDER BY v)
+FROM aggr;
+
+SELECT
+ percentile_cont(DISTINCT 0.5) WITHIN GROUP (ORDER BY v) OVER (PARTITION BY k)
+FROM aggr;
+
+SELECT
+ percentile_cont() WITHIN GROUP (ORDER BY v)
+FROM aggr;
+
+SELECT
+ percentile_cont() WITHIN GROUP (ORDER BY v) OVER (PARTITION BY k)
+FROM aggr;
+
+SELECT
+ percentile_cont(0.5)
+FROM aggr;
+
+SELECT
+ percentile_cont(0.5) OVER (PARTITION BY k)
+FROM aggr;
+
+SELECT
+ percentile_cont(0.5) WITHIN GROUP (ORDER BY k, v)
+FROM aggr;
+
+SELECT
+ percentile_cont(k, 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;
+
+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;
+
+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;
+
+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;
+
+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/spark41/src/test/resources/backends-velox/sql-tests/inputs/pipe-operators.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/pipe-operators.sql
new file mode 100644
index 000000000000..ce70cea0e6e0
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/pipe-operators.sql
@@ -0,0 +1,1763 @@
+-- Prepare some test data.
+--------------------------
+drop table if exists t;
+create table t(x int, y string) using csv;
+insert into t values (0, 'abc'), (1, 'def');
+
+drop table if exists other;
+create table other(a int, b int) using json;
+insert into other values (1, 1), (1, 2), (2, 4);
+
+drop table if exists st;
+create table st(x int, col struct) using parquet;
+insert into st values (1, (2, 3));
+
+create temporary view courseSales as select * from values
+ ("dotNET", 2012, 10000),
+ ("Java", 2012, 20000),
+ ("dotNET", 2012, 5000),
+ ("dotNET", 2013, 48000),
+ ("Java", 2013, 30000)
+ as courseSales(course, year, earnings);
+
+create temporary view courseEarnings as select * from values
+ ("dotNET", 15000, 48000, 22500),
+ ("Java", 20000, 30000, NULL)
+ as courseEarnings(course, `2012`, `2013`, `2014`);
+
+create temporary view courseEarningsAndSales as select * from values
+ ("dotNET", 15000, NULL, 48000, 1, 22500, 1),
+ ("Java", 20000, 1, 30000, 2, NULL, NULL)
+ as courseEarningsAndSales(
+ course, earnings2012, sales2012, earnings2013, sales2013, earnings2014, sales2014);
+
+create temporary view yearsWithComplexTypes as select * from values
+ (2012, array(1, 1), map('1', 1), struct(1, 'a')),
+ (2013, array(2, 2), map('2', 2), struct(2, 'b'))
+ as yearsWithComplexTypes(y, a, m, s);
+
+create temporary view join_test_t1 as select * from values (1) as grouping(a);
+create temporary view join_test_t2 as select * from values (1) as grouping(a);
+create temporary view join_test_t3 as select * from values (1) as grouping(a);
+create temporary view join_test_empty_table as select a from join_test_t2 where false;
+
+create temporary view lateral_test_t1(c1, c2)
+ as values (0, 1), (1, 2);
+create temporary view lateral_test_t2(c1, c2)
+ as values (0, 2), (0, 3);
+create temporary view lateral_test_t3(c1, c2)
+ as values (0, array(0, 1)), (1, array(2)), (2, array()), (null, array(4));
+create temporary view lateral_test_t4(c1, c2)
+ as values (0, 1), (0, 2), (1, 1), (1, 3);
+
+create temporary view natural_join_test_t1 as select * from values
+ ("one", 1), ("two", 2), ("three", 3) as natural_join_test_t1(k, v1);
+
+create temporary view natural_join_test_t2 as select * from values
+ ("one", 1), ("two", 22), ("one", 5) as natural_join_test_t2(k, v2);
+
+create temporary view natural_join_test_t3 as select * from values
+ ("one", 4), ("two", 5), ("one", 6) as natural_join_test_t3(k, v3);
+
+create temporary view windowTestData 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);
+
+-- FROM operators: positive tests.
+----------------------------------
+
+-- FromClause alone.
+from t;
+
+-- Table alone.
+table t;
+
+-- Selecting from a constant.
+from t
+|> select 1 as x;
+
+-- Selecting using a table alias.
+from t as t_alias
+|> select t_alias.x;
+
+-- Selecting using a table alias.
+from t as t_alias
+|> select t_alias.x as tx, t_alias.y as ty
+|> where ty = 'def'
+|> select tx;
+
+-- Selecting from multiple relations.
+from t, other
+|> select t.x + other.a as z;
+
+-- Selecting from multiple relations with join.
+from t join other on (t.x = other.a)
+|> select t.x + other.a as z;
+
+-- Selecting from lateral view.
+from t lateral view explode(array(100, 101)) as ly
+|> select t.x + ly as z;
+
+-- Selecting struct fields.
+from st
+|> select col.i1;
+
+-- Selecting struct fields using a table alias.
+from st as st_alias
+|> select st_alias.col.i1;
+
+-- Selecting from a VALUES list.
+from values (0), (1) tab(col)
+|> select col as x;
+
+-- FROM operators: negative tests.
+----------------------------------
+
+-- It is not possible to use the FROM operator accepting an input relation.
+from t
+|> from t;
+
+-- SELECT operators: positive tests.
+---------------------------------------
+
+-- Selecting a constant.
+table t
+|> select 1 as x;
+
+-- Selecting attributes.
+table t
+|> select x, y;
+
+-- Chained pipe SELECT operators.
+table t
+|> select x, y
+|> select x + length(y) as z;
+
+-- Using the VALUES list as the source relation.
+values (0), (1) tab(col)
+|> select col * 2 as result;
+
+-- Using a table subquery as the source relation.
+(select * from t union all select * from t)
+|> select x + length(y) as result;
+
+-- Enclosing the result of a pipe SELECT operation in a table subquery.
+(table t
+ |> select x, y
+ |> select x)
+union all
+select x from t where x < 1;
+
+-- Selecting struct fields.
+(select col from st)
+|> select col.i1;
+
+table st
+|> select st.col.i1;
+
+-- Expression subqueries in the pipe operator SELECT list.
+table t
+|> select (select a from other where x = a limit 1) as result;
+
+-- Pipe operator SELECT inside expression subqueries.
+select (values (0) tab(col) |> select col) as result;
+
+-- Aggregations are allowed within expression subqueries in the pipe operator SELECT list as long as
+-- no aggregate functions exist in the top-level select list.
+table t
+|> select (select any_value(a) from other where x = a limit 1) as result;
+
+-- Lateral column aliases in the pipe operator SELECT list.
+table t
+|> select x + length(x) as z, z + 1 as plus_one;
+
+-- Window functions are allowed in the pipe operator SELECT list.
+table t
+|> select first_value(x) over (partition by y) as result;
+
+select 1 x, 2 y, 3 z
+|> select 1 + sum(x) over (),
+ avg(y) over (),
+ x,
+ avg(x+1) over (partition by y order by z) AS a2
+|> select a2;
+
+table t
+|> select x, count(*) over ()
+|> select x;
+
+-- DISTINCT is supported.
+table t
+|> select distinct x, y;
+
+-- SELECT * is supported.
+table t
+|> select *;
+
+table t
+|> select * except (y);
+
+-- Hints are supported.
+table t
+|> select /*+ repartition(3) */ *;
+
+table t
+|> select /*+ repartition(3) */ distinct x;
+
+table t
+|> select /*+ repartition(3) */ all x;
+
+-- SELECT operators: negative tests.
+---------------------------------------
+
+-- Aggregate functions are not allowed in the pipe operator SELECT list.
+table t
+|> select sum(x) as result;
+
+table t
+|> select y, length(y) + sum(x) as result;
+
+from t
+|> select sum(x);
+
+from t as t_alias
+|> select y, sum(x);
+
+from t as t_alias
+|> select y, sum(x) group by y;
+
+-- EXTEND operators: positive tests.
+------------------------------------
+
+-- Extending with a constant.
+table t
+|> extend 1 as z;
+
+-- Extending without an explicit alias.
+table t
+|> extend 1;
+
+-- Extending with an attribute.
+table t
+|> extend x as z;
+
+-- Extending with an expression.
+table t
+|> extend x + length(y) as z;
+
+-- Extending two times.
+table t
+|> extend x + length(y) as z, x + 1 as zz;
+
+-- Extending two times in sequence.
+table t
+|> extend x + length(y) as z
+|> extend z + 1 as zz;
+
+-- Extending with a struct field.
+select col from st
+|> extend col.i1 as z;
+
+-- Extending with a subquery.
+table t
+|> extend (select a from other where x = a limit 1) as z;
+
+-- Extending with a correlated reference.
+table t
+|> where exists (
+ table other
+ |> extend t.x
+ |> select * except (a, b));
+
+-- Extending with a column name that already exists in the input relation.
+table t
+|> extend 1 as x;
+
+-- Window functions are allowed in the pipe operator EXTEND list.
+table t
+|> extend first_value(x) over (partition by y) as result;
+
+-- Lateral column aliases in the pipe operator EXTEND list.
+table t
+|> extend x + length(y) as z, z + 1 as plus_one;
+
+-- EXTEND operators: negative tests.
+------------------------------------
+
+-- Aggregations are not allowed.
+table t
+|> extend sum(x) as z;
+
+-- DISTINCT is not supported.
+table t
+|> extend distinct x as z;
+
+-- EXTEND * is not supported.
+table t
+|> extend *;
+
+-- SET operators: positive tests.
+---------------------------------
+
+-- Setting with a constant.
+-- The indicated column is not the last column in the table, and the SET operator will replace it
+-- with the new value in its existing position.
+table t
+|> set x = 1;
+
+-- Setting with an attribute.
+table t
+|> set y = x;
+
+-- Setting with an expression.
+table t
+|> extend 1 as z
+|> set z = x + length(y);
+
+-- Setting two times.
+table t
+|> extend 1 as z
+|> extend 2 as zz
+|> set z = x + length(y), zz = x + 1;
+
+table other
+|> extend 3 as c
+|> set a = b, b = c;
+
+-- Setting two times with a lateral reference.
+table t
+|> extend 1 as z
+|> extend 2 as zz
+|> set z = x + length(y), zz = z + 1;
+
+-- Setting two times in sequence.
+table t
+|> extend 1 as z
+|> set z = x + length(y)
+|> set z = z + 1;
+
+-- SET assignments with duplicate keys. This is supported, and we can update the column as we go.
+table t
+|> extend 1 as z
+|> set z = x + length(y), z = z + 1;
+
+-- Setting with a struct field.
+select col from st
+|> extend 1 as z
+|> set z = col.i1;
+
+-- Setting with a subquery.
+table t
+|> set y = (select a from other where x = a limit 1);
+
+-- Setting with a backquoted column name with a dot inside.
+table t
+|> extend 1 as `x.y.z`
+|> set `x.y.z` = x + length(y);
+
+-- Window functions are allowed in the pipe operator SET list.
+table t
+|> extend 1 as z
+|> set z = first_value(x) over (partition by y);
+
+-- Any prior table aliases remain visible after a SET operator.
+values (0), (1) lhs(a)
+|> inner join values (1), (2) rhs(a) using (a)
+|> extend lhs.a + rhs.a as z1
+|> extend lhs.a - rhs.a as z2
+|> drop z1
+|> where z2 = 0
+|> order by lhs.a, rhs.a, z2
+|> set z2 = 4
+|> limit 2
+|> select lhs.a, rhs.a, z2;
+
+-- SET operators: negative tests.
+---------------------------------
+
+-- SET with a column name that does not exist in the input relation.
+table t
+|> set z = 1;
+
+-- SET with an alias.
+table t
+|> set x = 1 as z;
+
+-- Setting nested fields in structs is not supported.
+select col from st
+|> set col.i1 = 42;
+
+-- DROP operators: positive tests.
+------------------------------------
+
+-- Dropping a column.
+table t
+|> drop y;
+
+-- Dropping two times.
+select 1 as x, 2 as y, 3 as z
+|> drop z, y;
+
+-- Dropping two times in sequence.
+select 1 as x, 2 as y, 3 as z
+|> drop z
+|> drop y;
+
+-- Dropping all columns in the input relation.
+select x from t
+|> drop x;
+
+-- Dropping a backquoted column name with a dot inside.
+table t
+|> extend 1 as `x.y.z`
+|> drop `x.y.z`;
+
+-- DROP operators: negative tests.
+----------------------------------
+
+-- Dropping a column that is not present in the input relation.
+table t
+|> drop z;
+
+-- Attempting to drop a struct field.
+table st
+|> drop col.i1;
+
+table st
+|> drop `col.i1`;
+
+-- Duplicate fields in the drop list.
+select 1 as x, 2 as y, 3 as z
+|> drop z, y, z;
+
+-- AS operators: positive tests.
+--------------------------------
+
+-- Renaming a table.
+table t
+|> as u
+|> select u.x, u.y;
+
+-- Renaming an input relation that is not a table.
+select 1 as x, 2 as y
+|> as u
+|> select u.x, u.y;
+
+-- Renaming as a backquoted name including a period.
+table t
+|> as `u.v`
+|> select `u.v`.x, `u.v`.y;
+
+-- Renaming two times.
+table t
+|> as u
+|> as v
+|> select v.x, v.y;
+
+-- Filtering by referring to the table or table subquery alias.
+table t
+|> as u
+|> where u.x = 1;
+
+-- AS operators: negative tests.
+--------------------------------
+
+-- Multiple aliases are not supported.
+table t
+|> as u, v;
+
+-- Expressions are not supported.
+table t
+|> as 1 + 2;
+
+-- Renaming as an invalid name.
+table t
+|> as u-v;
+
+table t
+|> as u@v;
+
+table t
+|> as u#######v;
+
+-- WHERE operators: positive tests.
+-----------------------------------
+
+-- Filtering with a constant predicate.
+table t
+|> where true;
+
+-- Filtering with a predicate based on attributes from the input relation.
+table t
+|> where x + length(y) < 4;
+
+-- Two consecutive filters are allowed.
+table t
+|> where x + length(y) < 4
+|> where x + length(y) < 3;
+
+-- It is possible to use the WHERE operator instead of the HAVING clause when processing the result
+-- of aggregations. For example, this WHERE operator is equivalent to the normal SQL "HAVING x = 1".
+(select x, sum(length(y)) as sum_len from t group by x)
+|> where x = 1;
+
+-- Filtering by referring to the table or table subquery alias.
+table t
+|> where t.x = 1;
+
+table t
+|> where spark_catalog.default.t.x = 1;
+
+-- Filtering using struct fields.
+(select col from st)
+|> where col.i1 = 1;
+
+table st
+|> where st.col.i1 = 2;
+
+-- Expression subqueries in the WHERE clause.
+table t
+|> where exists (select a from other where x = a limit 1);
+
+-- Aggregations are allowed within expression subqueries in the pipe operator WHERE clause as long
+-- no aggregate functions exist in the top-level expression predicate.
+table t
+|> where (select any_value(a) from other where x = a limit 1) = 1;
+
+-- WHERE operators: negative tests.
+-----------------------------------
+
+-- Aggregate functions are not allowed in the top-level WHERE predicate.
+-- (Note: to implement this behavior, perform the aggregation first separately and then add a
+-- pipe-operator WHERE clause referring to the result of aggregate expression(s) therein).
+table t
+|> where sum(x) = 1;
+
+table t
+|> where y = 'abc' or length(y) + sum(x) = 1;
+
+-- Window functions are not allowed in the WHERE clause (pipe operators or otherwise).
+-- (Note: to implement this behavior, perform the window function first separately in a SELECT
+-- clause and then add a pipe-operator WHERE clause referring to the result of the window function
+-- expression(s) therein).
+table t
+|> where sum(x) over (partition by y) = 1;
+
+table t
+|> where sum(x) over w = 1
+ window w as (partition by y);
+
+select * from t where sum(x) over (partition by y) = 1;
+
+-- Pipe operators may only refer to attributes produced as output from the directly-preceding
+-- pipe operator, not from earlier ones.
+table t
+|> select x, length(y) as z
+|> where x + length(y) < 4;
+
+table t
+|> select x, length(y) as z
+|> limit 1000
+|> where x + length(y) < 4;
+
+table t
+|> select x, length(y) as z
+|> limit 1000 offset 1
+|> where x + length(y) < 4;
+
+table t
+|> select x, length(y) as z
+|> order by x, y
+|> where x + length(y) < 4;
+
+-- If the WHERE clause wants to filter rows produced by an aggregation, it is not valid to try to
+-- refer to the aggregate functions directly; it is necessary to use aliases instead.
+(select x, sum(length(y)) as sum_len from t group by x)
+|> where sum(length(y)) = 3;
+
+-- Pivot and unpivot operators: positive tests.
+-----------------------------------------------
+
+table courseSales
+|> select `year`, course, earnings
+|> pivot (
+ sum(earnings)
+ for course in ('dotNET', 'Java')
+ );
+
+table courseSales
+|> select `year` as y, course as c, earnings as e
+|> pivot (
+ sum(e) as s, avg(e) as a
+ for y in (2012 as firstYear, 2013 as secondYear)
+ );
+
+-- Pivot on multiple pivot columns with aggregate columns of complex data types.
+select course, `year`, y, a
+from courseSales
+join yearsWithComplexTypes on `year` = y
+|> pivot (
+ max(a)
+ for (y, course) in ((2012, 'dotNET'), (2013, 'Java'))
+ );
+
+-- Pivot on pivot column of struct type.
+select earnings, `year`, s
+from courseSales
+join yearsWithComplexTypes on `year` = y
+|> pivot (
+ sum(earnings)
+ for s in ((1, 'a'), (2, 'b'))
+ );
+
+table courseEarnings
+|> unpivot (
+ earningsYear for `year` in (`2012`, `2013`, `2014`)
+ );
+
+table courseEarnings
+|> unpivot include nulls (
+ earningsYear for `year` in (`2012`, `2013`, `2014`)
+ );
+
+table courseEarningsAndSales
+|> unpivot include nulls (
+ (earnings, sales) for `year` in (
+ (earnings2012, sales2012) as `2012`,
+ (earnings2013, sales2013) as `2013`,
+ (earnings2014, sales2014) as `2014`)
+ );
+
+-- Pivot and unpivot operators: negative tests.
+-----------------------------------------------
+
+-- The PIVOT operator refers to a column 'year' is not available in the input relation.
+table courseSales
+|> select course, earnings
+|> pivot (
+ sum(earnings)
+ for `year` in (2012, 2013)
+ );
+
+-- Non-literal PIVOT values are not supported.
+table courseSales
+|> pivot (
+ sum(earnings)
+ for `year` in (course, 2013)
+ );
+
+-- The PIVOT and UNPIVOT clauses are mutually exclusive.
+table courseSales
+|> select course, earnings
+|> pivot (
+ sum(earnings)
+ for `year` in (2012, 2013)
+ )
+ unpivot (
+ earningsYear for `year` in (`2012`, `2013`, `2014`)
+ );
+
+table courseSales
+|> select course, earnings
+|> unpivot (
+ earningsYear for `year` in (`2012`, `2013`, `2014`)
+ )
+ pivot (
+ sum(earnings)
+ for `year` in (2012, 2013)
+ );
+
+-- Multiple PIVOT and/or UNPIVOT clauses are not supported in the same pipe operator.
+table courseSales
+|> select course, earnings
+|> pivot (
+ sum(earnings)
+ for `year` in (2012, 2013)
+ )
+ pivot (
+ sum(earnings)
+ for `year` in (2012, 2013)
+ );
+
+table courseSales
+|> select course, earnings
+|> unpivot (
+ earningsYear for `year` in (`2012`, `2013`, `2014`)
+ )
+ unpivot (
+ earningsYear for `year` in (`2012`, `2013`, `2014`)
+ )
+ pivot (
+ sum(earnings)
+ for `year` in (2012, 2013)
+ );
+
+-- Sampling operators: positive tests.
+--------------------------------------
+
+-- We will use the REPEATABLE clause and/or adjust the sampling options to either remove no rows or
+-- all rows to help keep the tests deterministic.
+table t
+|> tablesample (100 percent) repeatable (0);
+
+table t
+|> tablesample (2 rows) repeatable (0);
+
+table t
+|> tablesample (bucket 1 out of 1) repeatable (0);
+
+table t
+|> tablesample (100 percent) repeatable (0)
+|> tablesample (5 rows) repeatable (0)
+|> tablesample (bucket 1 out of 1) repeatable (0);
+
+-- Sampling operators: negative tests.
+--------------------------------------
+
+-- The sampling method is required.
+table t
+|> tablesample ();
+
+-- Negative sampling options are not supported.
+table t
+|> tablesample (-100 percent) repeatable (0);
+
+table t
+|> tablesample (-5 rows);
+
+-- The sampling method may not refer to attribute names from the input relation.
+table t
+|> tablesample (x rows);
+
+-- The bucket number is invalid.
+table t
+|> tablesample (bucket 2 out of 1);
+
+-- Byte literals are not supported.
+table t
+|> tablesample (200b) repeatable (0);
+
+-- Invalid byte literal syntax.
+table t
+|> tablesample (200) repeatable (0);
+
+-- JOIN operators: positive tests.
+----------------------------------
+
+table join_test_t1
+|> inner join join_test_empty_table;
+
+table join_test_t1
+|> cross join join_test_empty_table;
+
+table join_test_t1
+|> left outer join join_test_empty_table;
+
+table join_test_t1
+|> right outer join join_test_empty_table;
+
+table join_test_t1
+|> full outer join join_test_empty_table using (a);
+
+table join_test_t1
+|> full outer join join_test_empty_table on (join_test_t1.a = join_test_empty_table.a);
+
+table join_test_t1
+|> left semi join join_test_empty_table;
+
+table join_test_t1
+|> left anti join join_test_empty_table;
+
+select * from join_test_t1 where true
+|> inner join join_test_empty_table;
+
+select 1 as x, 2 as y
+|> inner join (select 1 as x, 4 as y) using (x);
+
+table join_test_t1
+|> inner join (join_test_t2 jt2 inner join join_test_t3 jt3 using (a)) using (a)
+|> select a, join_test_t1.a, jt2.a, jt3.a;
+
+table join_test_t1
+|> inner join join_test_t2 tablesample (100 percent) repeatable (0) jt2 using (a);
+
+table join_test_t1
+|> inner join (select 1 as a) tablesample (100 percent) repeatable (0) jt2 using (a);
+
+table join_test_t1
+|> join join_test_t1 using (a);
+
+-- Lateral joins.
+table lateral_test_t1
+|> join lateral (select c1);
+
+table lateral_test_t1
+|> join lateral (select c1 from lateral_test_t2);
+
+table lateral_test_t1
+|> join lateral (select lateral_test_t1.c1 from lateral_test_t2);
+
+table lateral_test_t1
+|> join lateral (select lateral_test_t1.c1 + t2.c1 from lateral_test_t2 t2);
+
+table lateral_test_t1
+|> join lateral (select *);
+
+table lateral_test_t1
+|> join lateral (select * from lateral_test_t2);
+
+table lateral_test_t1
+|> join lateral (select lateral_test_t1.* from lateral_test_t2);
+
+table lateral_test_t1
+|> join lateral (select lateral_test_t1.*, t2.* from lateral_test_t2 t2);
+
+table lateral_test_t1
+|> join lateral_test_t2
+|> join lateral (select lateral_test_t1.c2 + lateral_test_t2.c2);
+
+-- Natural joins.
+table natural_join_test_t1
+|> natural join natural_join_test_t2
+|> where k = "one";
+
+table natural_join_test_t1
+|> natural join natural_join_test_t2 nt2
+|> select natural_join_test_t1.*;
+
+table natural_join_test_t1
+|> natural join natural_join_test_t2 nt2
+|> natural join natural_join_test_t3 nt3
+|> select natural_join_test_t1.*, nt2.*, nt3.*;
+
+-- JOIN operators: negative tests.
+----------------------------------
+
+-- Multiple joins within the same pipe operator are not supported without parentheses.
+table join_test_t1
+|> inner join join_test_empty_table
+ inner join join_test_empty_table;
+
+-- The join pipe operator can only refer to column names from the previous relation.
+table join_test_t1
+|> select 1 + 2 as result
+|> full outer join join_test_empty_table on (join_test_t1.a = join_test_empty_table.a);
+
+-- The table from the pipe input is not visible as a table name in the right side.
+table join_test_t1 jt
+|> cross join (select * from jt);
+
+-- Set operations: positive tests.
+----------------------------------
+
+-- Union all.
+table t
+|> union all table t;
+
+-- Union distinct.
+table t
+|> union table t;
+
+-- Union all with a table subquery.
+(select * from t)
+|> union all table t;
+
+-- Union distinct with a table subquery.
+(select * from t)
+|> union table t;
+
+-- Union all with a VALUES list.
+values (0, 'abc') tab(x, y)
+|> union all table t;
+
+-- Union distinct with a VALUES list.
+-- The |> WHERE operator applies to the result of the |> UNION operator, not to the "table t" input.
+values (2, 'xyz') tab(x, y)
+|> union table t
+|> where x = 0;
+
+-- Union distinct with a VALUES list.
+-- The |> DROP operator applies to the result of the |> UNION operator, not to the "table t" input.
+values (2, 'xyz') tab(x, y)
+|> union table t
+|> drop x;
+
+-- Union all with a table subquery on both the source and target sides.
+(select * from t)
+|> union all (select * from t);
+
+-- Except all.
+table t
+|> except all table t;
+
+-- Except distinct.
+table t
+|> except table t;
+
+-- Intersect all.
+table t
+|> intersect all table t;
+
+-- Intersect distinct.
+table t
+|> intersect table t;
+
+-- Minus all.
+table t
+|> minus all table t;
+
+-- Minus distinct.
+table t
+|> minus table t;
+
+-- Set operations: negative tests.
+----------------------------------
+
+-- The UNION operator requires the same number of columns in the input relations.
+table t
+|> select x
+|> union all table t;
+
+-- The UNION operator requires the column types to be compatible.
+table t
+|> union all table st;
+
+-- Sorting and repartitioning operators: positive tests.
+--------------------------------------------------------
+
+-- Order by.
+table t
+|> order by x;
+
+-- Order by with a table subquery.
+(select * from t)
+|> order by x;
+
+-- Order by with a VALUES list.
+values (0, 'abc') tab(x, y)
+|> order by x;
+
+-- Limit.
+table t
+|> order by x
+|> limit 1;
+
+-- Limit with offset.
+table t
+|> where x = 1
+|> select y
+|> limit 2 offset 1;
+
+-- Offset is allowed without limit.
+table t
+|> where x = 1
+|> select y
+|> offset 1;
+
+-- LIMIT ALL and OFFSET 0 are equivalent to no LIMIT or OFFSET clause, respectively.
+table t
+|> limit all offset 0;
+
+-- Distribute by.
+table t
+|> distribute by x;
+
+-- Cluster by.
+table t
+|> cluster by x;
+
+-- Sort and distribute by.
+table t
+|> sort by x distribute by x;
+
+-- It is possible to apply a final ORDER BY clause on the result of a query containing pipe
+-- operators.
+table t
+|> order by x desc
+order by y;
+
+-- Sorting and repartitioning operators: negative tests.
+--------------------------------------------------------
+
+-- Multiple order by clauses are not supported in the same pipe operator.
+-- We add an extra "ORDER BY y" clause at the end in this test to show that the "ORDER BY x + y"
+-- clause was consumed end the of the final query, not as part of the pipe operator.
+table t
+|> order by x desc order by x + y
+order by y;
+
+-- The ORDER BY clause may only refer to column names from the previous input relation.
+table t
+|> select 1 + 2 as result
+|> order by x;
+
+-- The DISTRIBUTE BY clause may only refer to column names from the previous input relation.
+table t
+|> select 1 + 2 as result
+|> distribute by x;
+
+-- Combinations of multiple ordering and limit clauses are not supported.
+table t
+|> order by x limit 1;
+
+-- ORDER BY and SORT BY are not supported at the same time.
+table t
+|> order by x sort by x;
+
+-- Aggregation operators: positive tests.
+-----------------------------------------
+
+-- Basic aggregation with a GROUP BY clause. The resulting table contains all the attributes from
+-- the grouping keys followed by all the attributes from the aggregate functions, in order.
+table other
+|> aggregate sum(b) as result group by a;
+
+-- Basic aggregation with a GROUP BY clause, followed by a SELECT of just the aggregate function.
+-- This restricts the output attributes to just the aggregate function.
+table other
+|> aggregate sum(b) as result group by a
+|> select result;
+
+-- Basic aggregation with a GROUP BY clause, followed by a SELECT of just the grouping expression.
+-- This restricts the output attributes to just the grouping expression. Note that we must use an
+-- alias for the grouping expression to refer to it in the SELECT clause.
+table other
+|> aggregate sum(b) group by a + 1 as gkey
+|> select gkey;
+
+-- Basic aggregation on a constant table.
+select 1 as x, 2 as y
+|> aggregate group by x, y;
+
+-- Basic aggregation with group by ordinals.
+select 3 as x, 4 as y
+|> aggregate group by 1, 2;
+
+values (3, 4) as tab(x, y)
+|> aggregate sum(y) group by 1;
+
+values (3, 4), (5, 4) as tab(x, y)
+|> aggregate sum(y) group by 1;
+
+select 3 as x, 4 as y
+|> aggregate sum(y) group by 1, 1;
+
+select 1 as `1`, 2 as `2`
+|> aggregate sum(`2`) group by `1`;
+
+select 3 as x, 4 as y
+|> aggregate sum(y) group by 2;
+
+select 3 as x, 4 as y, 5 as z
+|> aggregate sum(y) group by 2;
+
+select 3 as x, 4 as y, 5 as z
+|> aggregate sum(y) group by 3;
+
+select 3 as x, 4 as y, 5 as z
+|> aggregate sum(y) group by 2, 3;
+
+select 3 as x, 4 as y, 5 as z
+|> aggregate sum(y) group by 1, 2, 3;
+
+select 3 as x, 4 as y, 5 as z
+|> aggregate sum(y) group by x, 2, 3;
+
+-- Basic table aggregation.
+table t
+|> aggregate sum(x);
+
+-- Basic table aggregation with an alias.
+table t
+|> aggregate sum(x) + 1 as result_plus_one;
+
+-- Grouping with no aggregate functions.
+table other
+|> aggregate group by a
+|> where a = 1;
+
+-- Group by an expression on columns, all of which are already grouped.
+select 1 as x, 2 as y, 3 as z
+|> aggregate group by x, y, x + y as z;
+
+-- Group by an expression on columns, some of which (y) aren't already grouped.
+select 1 as x, 2 as y, 3 as z
+|> aggregate group by x as z, x + y as z;
+
+-- We get an output column for each item in GROUP BY, even when they are duplicate expressions.
+select 1 as x, 2 as y, named_struct('z', 3) as st
+|> aggregate group by x, y, x, x, st.z, (st).z, 1 + x, 2 + x;
+
+-- Chained aggregates.
+select 1 x, 2 y, 3 z
+|> aggregate sum(z) z group by x, y
+|> aggregate avg(z) z group by x
+|> aggregate count(distinct z) c;
+
+-- Ambiguous name from duplicate GROUP BY item. This is generally allowed.
+select 1 x, 3 z
+|> aggregate count(*) group by x, z, x
+|> select x;
+
+-- Aggregate expressions may contain a mix of aggregate functions and grouping expressions.
+table other
+|> aggregate a + count(b) group by a;
+
+-- Aggregation operators: negative tests.
+-----------------------------------------
+
+-- All aggregate expressions must contain at least one aggregate function.
+table other
+|> aggregate a group by a;
+
+-- GROUP BY ALL is not currently supported.
+select 3 as x, 4 as y
+|> aggregate group by all;
+
+-- GROUP BY ROLLUP is not supported yet.
+table courseSales
+|> aggregate sum(earnings) group by rollup(course, `year`)
+|> where course = 'dotNET' and `year` = '2013';
+
+-- GROUP BY CUBE is not supported yet.
+table courseSales
+|> aggregate sum(earnings) group by cube(course, `year`)
+|> where course = 'dotNET' and `year` = '2013';
+
+-- GROUPING SETS is not supported yet.
+table courseSales
+|> aggregate sum(earnings) group by course, `year` grouping sets(course, `year`)
+|> where course = 'dotNET' and `year` = '2013';
+
+-- GROUPING/GROUPING_ID is not supported yet.
+table courseSales
+|> aggregate sum(earnings), grouping(course) + 1
+ group by course
+|> where course = 'dotNET' and `year` = '2013';
+
+-- GROUPING/GROUPING_ID is not supported yet.
+table courseSales
+|> aggregate sum(earnings), grouping_id(course)
+ group by course
+|> where course = 'dotNET' and `year` = '2013';
+
+-- GROUP BY () is not valid syntax.
+select 1 as x, 2 as y
+|> aggregate group by ();
+
+-- Non-aggregate expressions are not allowed in place of aggregate functions.
+table other
+|> aggregate a;
+
+-- Using aggregate functions without the AGGREGATE keyword is not allowed.
+table other
+|> select sum(a) as result;
+
+-- The AGGREGATE keyword requires a GROUP BY clause and/or aggregation function(s).
+table other
+|> aggregate;
+
+-- The AGGREGATE GROUP BY list cannot be empty.
+table other
+|> aggregate group by;
+
+-- The AGGREGATE keyword is required to perform grouping.
+table other
+|> group by a;
+
+-- Window functions are not allowed in the AGGREGATE expression list.
+table other
+|> aggregate sum(a) over () group by b;
+
+-- Ambiguous name from AGGREGATE list vs GROUP BY.
+select 1 x, 2 y, 3 z
+|> aggregate count(*) AS c, sum(x) AS x group by x
+|> where c = 1
+|> where x = 1;
+
+-- WINDOW operators (within SELECT): positive tests.
+---------------------------------------------------
+
+-- SELECT with a WINDOW clause.
+table windowTestData
+|> select cate, sum(val) over w
+ window w as (partition by cate order by val);
+
+-- SELECT with RANGE BETWEEN as part of the window definition.
+table windowTestData
+|> select cate, sum(val) over w
+ window w as (order by val_timestamp range between unbounded preceding and current row);
+
+-- SELECT with a WINDOW clause not being referred in the SELECT list.
+table windowTestData
+|> select cate, val
+ window w as (partition by cate order by val);
+
+-- multiple SELECT clauses, each with a WINDOW clause (with the same window definition names).
+table windowTestData
+|> select cate, val, sum(val) over w as sum_val
+ window w as (partition by cate)
+|> select cate, val, sum_val, first_value(cate) over w
+ window w as (order by val);
+
+-- SELECT with a WINDOW clause for multiple window definitions.
+table windowTestData
+|> select cate, val, sum(val) over w1, first_value(cate) over w2
+ window w1 as (partition by cate), w2 as (order by val);
+
+-- SELECT with a WINDOW clause for multiple window functions over one window definition
+table windowTestData
+|> select cate, val, sum(val) over w, first_value(val) over w
+ window w1 as (partition by cate order by val);
+
+-- SELECT with a WINDOW clause, using struct fields.
+(select col from st)
+|> select col.i1, sum(col.i2) over w
+ window w as (partition by col.i1 order by col.i2);
+
+table st
+|> select st.col.i1, sum(st.col.i2) over w
+ window w as (partition by st.col.i1 order by st.col.i2);
+
+table st
+|> select spark_catalog.default.st.col.i1, sum(spark_catalog.default.st.col.i2) over w
+ window w as (partition by spark_catalog.default.st.col.i1 order by spark_catalog.default.st.col.i2);
+
+-- SELECT with one WINDOW definition shadowing a column name.
+table windowTestData
+|> select cate, sum(val) over val
+ window val as (partition by cate order by val);
+
+-- WINDOW operators (within SELECT): negative tests.
+---------------------------------------------------
+
+-- WINDOW without definition is not allowed in the pipe operator SELECT clause.
+table windowTestData
+|> select cate, sum(val) over w;
+
+-- Multiple WINDOW clauses are not supported in the pipe operator SELECT clause.
+table windowTestData
+|> select cate, val, sum(val) over w1, first_value(cate) over w2
+ window w1 as (partition by cate)
+ window w2 as (order by val);
+
+-- WINDOW definition cannot be referred across different pipe operator SELECT clauses.
+table windowTestData
+|> select cate, val, sum(val) over w as sum_val
+ window w as (partition by cate order by val)
+|> select cate, val, sum_val, first_value(cate) over w;
+
+table windowTestData
+|> select cate, val, first_value(cate) over w as first_val
+|> select cate, val, sum(val) over w as sum_val
+ window w as (order by val);
+
+-- Exercise SQL compilation using a subset of TPC-DS table schemas.
+-------------------------------------------------------------------
+
+-- Q1
+with customer_total_return as
+(select
+ sr_customer_sk as ctr_customer_sk,
+ sr_store_sk as ctr_store_sk,
+ sum(sr_return_amt) as ctr_total_return
+ from store_returns, date_dim
+ where sr_returned_date_sk = d_date_sk and d_year = 2000
+ group by sr_customer_sk, sr_store_sk)
+select c_customer_id
+from customer_total_return ctr1, store, customer
+where ctr1.ctr_total_return >
+ (select avg(ctr_total_return) * 1.2
+ from customer_total_return ctr2
+ where ctr1.ctr_store_sk = ctr2.ctr_store_sk)
+ and s_store_sk = ctr1.ctr_store_sk
+ and s_state = 'tn'
+ and ctr1.ctr_customer_sk = c_customer_sk
+order by c_customer_id
+limit 100;
+
+with customer_total_return as
+ (from store_returns
+ |> join date_dim
+ |> where sr_returned_date_sk = d_date_sk and d_year = 2000
+ |> aggregate sum(sr_return_amt) as ctr_total_return
+ group by sr_customer_sk as ctr_customer_sk, sr_store_sk as ctr_store_sk)
+from customer_total_return ctr1
+|> join store
+|> join customer
+|> where ctr1.ctr_total_return >
+ (table customer_total_return
+ |> as ctr2
+ |> where ctr1.ctr_store_sk = ctr2.ctr_store_sk
+ |> aggregate avg(ctr_total_return) * 1.2)
+ and s_store_sk = ctr1.ctr_store_sk
+ and s_state = 'tn'
+ and ctr1.ctr_customer_sk = c_customer_sk
+|> order by c_customer_id
+|> limit 100
+|> select c_customer_id;
+
+-- Q2
+with wscs as
+( select
+ sold_date_sk,
+ sales_price
+ from (select
+ ws_sold_date_sk sold_date_sk,
+ ws_ext_sales_price sales_price
+ from web_sales) x
+ union all
+ (select
+ cs_sold_date_sk sold_date_sk,
+ cs_ext_sales_price sales_price
+ from catalog_sales)),
+ wswscs as
+ ( select
+ d_week_seq,
+ sum(case when (d_day_name = 'sunday')
+ then sales_price
+ else null end)
+ sun_sales,
+ sum(case when (d_day_name = 'monday')
+ then sales_price
+ else null end)
+ mon_sales,
+ sum(case when (d_day_name = 'tuesday')
+ then sales_price
+ else null end)
+ tue_sales,
+ sum(case when (d_day_name = 'wednesday')
+ then sales_price
+ else null end)
+ wed_sales,
+ sum(case when (d_day_name = 'thursday')
+ then sales_price
+ else null end)
+ thu_sales,
+ sum(case when (d_day_name = 'friday')
+ then sales_price
+ else null end)
+ fri_sales,
+ sum(case when (d_day_name = 'saturday')
+ then sales_price
+ else null end)
+ sat_sales
+ from wscs, date_dim
+ where d_date_sk = sold_date_sk
+ group by d_week_seq)
+select
+ d_week_seq1,
+ round(sun_sales1 / sun_sales2, 2),
+ round(mon_sales1 / mon_sales2, 2),
+ round(tue_sales1 / tue_sales2, 2),
+ round(wed_sales1 / wed_sales2, 2),
+ round(thu_sales1 / thu_sales2, 2),
+ round(fri_sales1 / fri_sales2, 2),
+ round(sat_sales1 / sat_sales2, 2)
+from
+ (select
+ wswscs.d_week_seq d_week_seq1,
+ sun_sales sun_sales1,
+ mon_sales mon_sales1,
+ tue_sales tue_sales1,
+ wed_sales wed_sales1,
+ thu_sales thu_sales1,
+ fri_sales fri_sales1,
+ sat_sales sat_sales1
+ from wswscs, date_dim
+ where date_dim.d_week_seq = wswscs.d_week_seq and d_year = 2001) y,
+ (select
+ wswscs.d_week_seq d_week_seq2,
+ sun_sales sun_sales2,
+ mon_sales mon_sales2,
+ tue_sales tue_sales2,
+ wed_sales wed_sales2,
+ thu_sales thu_sales2,
+ fri_sales fri_sales2,
+ sat_sales sat_sales2
+ from wswscs, date_dim
+ where date_dim.d_week_seq = wswscs.d_week_seq and d_year = 2001 + 1) z
+where d_week_seq1 = d_week_seq2 - 53
+order by d_week_seq1;
+
+with wscs as
+ (table web_sales
+ |> select
+ ws_sold_date_sk sold_date_sk,
+ ws_ext_sales_price sales_price
+ |> as x
+ |> union all (
+ table catalog_sales
+ |> select
+ cs_sold_date_sk sold_date_sk,
+ cs_ext_sales_price sales_price)
+ |> select
+ sold_date_sk,
+ sales_price),
+wswscs as
+ (table wscs
+ |> join date_dim
+ |> where d_date_sk = sold_date_sk
+ |> aggregate
+ sum(case when (d_day_name = 'sunday')
+ then sales_price
+ else null end)
+ sun_sales,
+ sum(case when (d_day_name = 'monday')
+ then sales_price
+ else null end)
+ mon_sales,
+ sum(case when (d_day_name = 'tuesday')
+ then sales_price
+ else null end)
+ tue_sales,
+ sum(case when (d_day_name = 'wednesday')
+ then sales_price
+ else null end)
+ wed_sales,
+ sum(case when (d_day_name = 'thursday')
+ then sales_price
+ else null end)
+ thu_sales,
+ sum(case when (d_day_name = 'friday')
+ then sales_price
+ else null end)
+ fri_sales,
+ sum(case when (d_day_name = 'saturday')
+ then sales_price
+ else null end)
+ sat_sales
+ group by d_week_seq)
+table wswscs
+|> join date_dim
+|> where date_dim.d_week_seq = wswscs.d_week_seq AND d_year = 2001
+|> select
+ wswscs.d_week_seq d_week_seq1,
+ sun_sales sun_sales1,
+ mon_sales mon_sales1,
+ tue_sales tue_sales1,
+ wed_sales wed_sales1,
+ thu_sales thu_sales1,
+ fri_sales fri_sales1,
+ sat_sales sat_sales1
+|> as y
+|> join (
+ table wswscs
+ |> join date_dim
+ |> where date_dim.d_week_seq = wswscs.d_week_seq AND d_year = 2001 + 1
+ |> select
+ wswscs.d_week_seq d_week_seq2,
+ sun_sales sun_sales2,
+ mon_sales mon_sales2,
+ tue_sales tue_sales2,
+ wed_sales wed_sales2,
+ thu_sales thu_sales2,
+ fri_sales fri_sales2,
+ sat_sales sat_sales2
+ |> as z)
+|> where d_week_seq1 = d_week_seq2 - 53
+|> order by d_week_seq1
+|> select
+ d_week_seq1,
+ round(sun_sales1 / sun_sales2, 2),
+ round(mon_sales1 / mon_sales2, 2),
+ round(tue_sales1 / tue_sales2, 2),
+ round(wed_sales1 / wed_sales2, 2),
+ round(thu_sales1 / thu_sales2, 2),
+ round(fri_sales1 / fri_sales2, 2),
+ round(sat_sales1 / sat_sales2, 2);
+
+-- Q3
+select
+ dt.d_year,
+ item.i_brand_id brand_id,
+ item.i_brand brand,
+ sum(ss_ext_sales_price) sum_agg
+from date_dim dt, store_sales, item
+where dt.d_date_sk = store_sales.ss_sold_date_sk
+ and store_sales.ss_item_sk = item.i_item_sk
+ and item.i_manufact_id = 128
+ and dt.d_moy = 11
+group by dt.d_year, item.i_brand, item.i_brand_id
+order by dt.d_year, sum_agg desc, brand_id
+limit 100;
+
+table date_dim
+|> as dt
+|> join store_sales
+|> join item
+|> where dt.d_date_sk = store_sales.ss_sold_date_sk
+ and store_sales.ss_item_sk = item.i_item_sk
+ and item.i_manufact_id = 128
+ and dt.d_moy = 11
+|> aggregate sum(ss_ext_sales_price) sum_agg
+ group by dt.d_year d_year, item.i_brand_id brand_id, item.i_brand brand
+|> order by d_year, sum_agg desc, brand_id
+|> limit 100;
+
+-- Q12
+select
+ i_item_desc,
+ i_category,
+ i_class,
+ i_current_price,
+ sum(ws_ext_sales_price) as itemrevenue,
+ sum(ws_ext_sales_price) * 100 / sum(sum(ws_ext_sales_price))
+ over
+ (partition by i_class) as revenueratio
+from
+ web_sales, item, date_dim
+where
+ ws_item_sk = i_item_sk
+ and i_category in ('sports', 'books', 'home')
+ and ws_sold_date_sk = d_date_sk
+ and d_date between cast('1999-02-22' as date)
+ and (cast('1999-02-22' as date) + interval 30 days)
+group by
+ i_item_id, i_item_desc, i_category, i_class, i_current_price
+order by
+ i_category, i_class, i_item_id, i_item_desc, revenueratio
+limit 100;
+
+table web_sales
+|> join item
+|> join date_dim
+|> where ws_item_sk = i_item_sk
+ and i_category in ('sports', 'books', 'home')
+ and ws_sold_date_sk = d_date_sk
+ and d_date between cast('1999-02-22' as date)
+ and (cast('1999-02-22' as date) + interval 30 days)
+|> aggregate sum(ws_ext_sales_price) AS itemrevenue
+ group by i_item_id, i_item_desc, i_category, i_class, i_current_price
+|> extend
+ itemrevenue * 100 / sum(itemrevenue)
+ over (partition by i_class) as revenueratio
+|> order by i_category, i_class, i_item_id, i_item_desc, revenueratio
+|> select i_item_desc, i_category, i_class, i_current_price, itemrevenue, revenueratio
+|> limit 100;
+
+-- Q44
+select
+ asceding.rnk,
+ i1.i_product_name best_performing,
+ i2.i_product_name worst_performing
+from (select *
+from (select
+ item_sk,
+ rank()
+ over (
+ order by rank_col asc) rnk
+from (select
+ ss_item_sk item_sk,
+ avg(ss_net_profit) rank_col
+from store_sales ss1
+where ss_store_sk = 4
+group by ss_item_sk
+having avg(ss_net_profit) > 0.9 * (select avg(ss_net_profit) rank_col
+from store_sales
+where ss_store_sk = 4
+ and ss_addr_sk is null
+group by ss_store_sk)) v1) v11
+where rnk < 11) asceding,
+ (select *
+ from (select
+ item_sk,
+ rank()
+ over (
+ order by rank_col desc) rnk
+ from (select
+ ss_item_sk item_sk,
+ avg(ss_net_profit) rank_col
+ from store_sales ss1
+ where ss_store_sk = 4
+ group by ss_item_sk
+ having avg(ss_net_profit) > 0.9 * (select avg(ss_net_profit) rank_col
+ from store_sales
+ where ss_store_sk = 4
+ and ss_addr_sk is null
+ group by ss_store_sk)) v2) v21
+ where rnk < 11) descending,
+ item i1, item i2
+where asceding.rnk = descending.rnk
+ and i1.i_item_sk = asceding.item_sk
+ and i2.i_item_sk = descending.item_sk
+order by asceding.rnk
+limit 100;
+
+from store_sales ss1
+|> where ss_store_sk = 4
+|> aggregate avg(ss_net_profit) rank_col
+ group by ss_item_sk as item_sk
+|> where rank_col > 0.9 * (
+ from store_sales
+ |> where ss_store_sk = 4
+ and ss_addr_sk is null
+ |> aggregate avg(ss_net_profit) rank_col
+ group by ss_store_sk
+ |> select rank_col)
+|> as v1
+|> select
+ item_sk,
+ rank() over (
+ order by rank_col asc) rnk
+|> as v11
+|> where rnk < 11
+|> as asceding
+|> join (
+ from store_sales ss1
+ |> where ss_store_sk = 4
+ |> aggregate avg(ss_net_profit) rank_col
+ group by ss_item_sk as item_sk
+ |> where rank_col > 0.9 * (
+ table store_sales
+ |> where ss_store_sk = 4
+ and ss_addr_sk is null
+ |> aggregate avg(ss_net_profit) rank_col
+ group by ss_store_sk
+ |> select rank_col)
+ |> as v2
+ |> select
+ item_sk,
+ rank() over (
+ order by rank_col asc) rnk
+ |> as v21
+ |> where rnk < 11) descending
+|> join item i1
+|> join item i2
+|> where asceding.rnk = descending.rnk
+ and i1.i_item_sk = asceding.item_sk
+ and i2.i_item_sk = descending.item_sk
+|> order by asceding.rnk
+|> select
+ asceding.rnk,
+ i1.i_product_name best_performing,
+ i2.i_product_name worst_performing;
+
+-- Q51
+with web_v1 as (
+ select
+ ws_item_sk item_sk,
+ d_date,
+ sum(sum(ws_sales_price))
+ over (partition by ws_item_sk
+ order by d_date
+ rows between unbounded preceding and current row) cume_sales
+ from web_sales, date_dim
+ where ws_sold_date_sk = d_date_sk
+ and d_month_seq between 1200 and 1200 + 11
+ and ws_item_sk is not null
+ group by ws_item_sk, d_date),
+ store_v1 as (
+ select
+ ss_item_sk item_sk,
+ d_date,
+ sum(sum(ss_sales_price))
+ over (partition by ss_item_sk
+ order by d_date
+ rows between unbounded preceding and current row) cume_sales
+ from store_sales, date_dim
+ where ss_sold_date_sk = d_date_sk
+ and d_month_seq between 1200 and 1200 + 11
+ and ss_item_sk is not null
+ group by ss_item_sk, d_date)
+select *
+from (select
+ item_sk,
+ d_date,
+ web_sales,
+ store_sales,
+ max(web_sales)
+ over (partition by item_sk
+ order by d_date
+ rows between unbounded preceding and current row) web_cumulative,
+ max(store_sales)
+ over (partition by item_sk
+ order by d_date
+ rows between unbounded preceding and current row) store_cumulative
+from (select
+ case when web.item_sk is not null
+ then web.item_sk
+ else store.item_sk end item_sk,
+ case when web.d_date is not null
+ then web.d_date
+ else store.d_date end d_date,
+ web.cume_sales web_sales,
+ store.cume_sales store_sales
+from web_v1 web full outer join store_v1 store on (web.item_sk = store.item_sk
+ and web.d_date = store.d_date)
+ ) x) y
+where web_cumulative > store_cumulative
+order by item_sk, d_date
+limit 100;
+
+with web_v1 as (
+ table web_sales
+ |> join date_dim
+ |> where ws_sold_date_sk = d_date_sk
+ and d_month_seq between 1200 and 1200 + 11
+ and ws_item_sk is not null
+ |> aggregate sum(ws_sales_price) as sum_ws_sales_price
+ group by ws_item_sk as item_sk, d_date
+ |> extend sum(sum_ws_sales_price)
+ over (partition by item_sk
+ order by d_date
+ rows between unbounded preceding and current row)
+ as cume_sales),
+store_v1 as (
+ table store_sales
+ |> join date_dim
+ |> where ss_sold_date_sk = d_date_sk
+ and d_month_seq between 1200 and 1200 + 11
+ and ss_item_sk is not null
+ |> aggregate sum(ss_sales_price) as sum_ss_sales_price
+ group by ss_item_sk as item_sk, d_date
+ |> extend sum(sum_ss_sales_price)
+ over (partition by item_sk
+ order by d_date
+ rows between unbounded preceding and current row)
+ as cume_sales)
+table web_v1
+|> as web
+|> full outer join store_v1 store
+ on (web.item_sk = store.item_sk and web.d_date = store.d_date)
+|> select
+ case when web.item_sk is not null
+ then web.item_sk
+ else store.item_sk end item_sk,
+ case when web.d_date is not null
+ then web.d_date
+ else store.d_date end d_date,
+ web.cume_sales web_sales,
+ store.cume_sales store_sales
+|> as x
+|> select
+ item_sk,
+ d_date,
+ web_sales,
+ store_sales,
+ max(web_sales)
+ over (partition by item_sk
+ order by d_date
+ rows between unbounded preceding and current row) web_cumulative,
+ max(store_sales)
+ over (partition by item_sk
+ order by d_date
+ rows between unbounded preceding and current row) store_cumulative
+|> as y
+|> where web_cumulative > store_cumulative
+|> order by item_sk, d_date
+|> limit 100;
+
+-- Cleanup.
+-----------
+drop table t;
+drop table other;
+drop table st;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/pivot.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/pivot.sql
new file mode 100644
index 000000000000..c2ecd97e2b02
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/pivot.sql
@@ -0,0 +1,300 @@
+create temporary view courseSales as select * from values
+ ("dotNET", 2012, 10000),
+ ("Java", 2012, 20000),
+ ("dotNET", 2012, 5000),
+ ("dotNET", 2013, 48000),
+ ("Java", 2013, 30000)
+ as courseSales(course, year, earnings);
+
+create temporary view years as select * from values
+ (2012, 1),
+ (2013, 2)
+ as years(y, s);
+
+create temporary view yearsWithComplexTypes as select * from values
+ (2012, array(1, 1), map('1', 1), struct(1, 'a')),
+ (2013, array(2, 2), map('2', 2), struct(2, 'b'))
+ as yearsWithComplexTypes(y, a, m, s);
+
+-- pivot courses
+SELECT * FROM (
+ SELECT year, course, earnings FROM courseSales
+)
+PIVOT (
+ sum(earnings)
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot years with no subquery
+SELECT * FROM courseSales
+PIVOT (
+ sum(earnings)
+ FOR year IN (2012, 2013)
+);
+
+-- pivot courses with multiple aggregations
+SELECT * FROM (
+ SELECT year, course, earnings FROM courseSales
+)
+PIVOT (
+ sum(earnings), avg(earnings)
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot with no group by column
+SELECT * FROM (
+ SELECT course, earnings FROM courseSales
+)
+PIVOT (
+ sum(earnings)
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot with no group by column and with multiple aggregations on different columns
+SELECT * FROM (
+ SELECT year, course, earnings FROM courseSales
+)
+PIVOT (
+ sum(earnings), min(year)
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot on join query with multiple group by columns
+SELECT * FROM (
+ SELECT course, year, earnings, s
+ FROM courseSales
+ JOIN years ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR s IN (1, 2)
+);
+
+-- pivot on join query with multiple aggregations on different columns
+SELECT * FROM (
+ SELECT course, year, earnings, s
+ FROM courseSales
+ JOIN years ON year = y
+)
+PIVOT (
+ sum(earnings), min(s)
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot on join query with multiple columns in one aggregation
+SELECT * FROM (
+ SELECT course, year, earnings, s
+ FROM courseSales
+ JOIN years ON year = y
+)
+PIVOT (
+ sum(earnings * s)
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot with aliases and projection
+SELECT 2012_s, 2013_s, 2012_a, 2013_a, c FROM (
+ SELECT year y, course c, earnings e FROM courseSales
+)
+PIVOT (
+ sum(e) s, avg(e) a
+ FOR y IN (2012, 2013)
+);
+
+-- pivot with projection and value aliases
+SELECT firstYear_s, secondYear_s, firstYear_a, secondYear_a, c FROM (
+ SELECT year y, course c, earnings e FROM courseSales
+)
+PIVOT (
+ sum(e) s, avg(e) a
+ FOR y IN (2012 as firstYear, 2013 secondYear)
+);
+
+-- pivot years with non-aggregate function
+SELECT * FROM courseSales
+PIVOT (
+ abs(earnings)
+ FOR year IN (2012, 2013)
+);
+
+-- pivot with one of the expressions as non-aggregate function
+SELECT * FROM (
+ SELECT year, course, earnings FROM courseSales
+)
+PIVOT (
+ sum(earnings), year
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot with unresolvable columns
+SELECT * FROM (
+ SELECT course, earnings FROM courseSales
+)
+PIVOT (
+ sum(earnings)
+ FOR year IN (2012, 2013)
+);
+
+-- pivot with complex aggregate expressions
+SELECT * FROM (
+ SELECT year, course, earnings FROM courseSales
+)
+PIVOT (
+ ceil(sum(earnings)), avg(earnings) + 1 as a1
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot with invalid arguments in aggregate expressions
+SELECT * FROM (
+ SELECT year, course, earnings FROM courseSales
+)
+PIVOT (
+ sum(avg(earnings))
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot on multiple pivot columns
+SELECT * FROM (
+ SELECT course, year, earnings, s
+ FROM courseSales
+ JOIN years ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR (course, year) IN (('dotNET', 2012), ('Java', 2013))
+);
+
+-- pivot on multiple pivot columns with aliased values
+SELECT * FROM (
+ SELECT course, year, earnings, s
+ FROM courseSales
+ JOIN years ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR (course, s) IN (('dotNET', 2) as c1, ('Java', 1) as c2)
+);
+
+-- pivot on multiple pivot columns with values of wrong data types
+SELECT * FROM (
+ SELECT course, year, earnings, s
+ FROM courseSales
+ JOIN years ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR (course, year) IN ('dotNET', 'Java')
+);
+
+-- pivot with unresolvable values
+SELECT * FROM courseSales
+PIVOT (
+ sum(earnings)
+ FOR year IN (s, 2013)
+);
+
+-- pivot with non-literal values
+SELECT * FROM courseSales
+PIVOT (
+ sum(earnings)
+ FOR year IN (course, 2013)
+);
+
+-- pivot on join query with columns of complex data types
+SELECT * FROM (
+ SELECT course, year, a
+ FROM courseSales
+ JOIN yearsWithComplexTypes ON year = y
+)
+PIVOT (
+ min(a)
+ FOR course IN ('dotNET', 'Java')
+);
+
+-- pivot on multiple pivot columns with agg columns of complex data types
+SELECT * FROM (
+ SELECT course, year, y, a
+ FROM courseSales
+ JOIN yearsWithComplexTypes ON year = y
+)
+PIVOT (
+ max(a)
+ FOR (y, course) IN ((2012, 'dotNET'), (2013, 'Java'))
+);
+
+-- pivot on pivot column of array type
+SELECT * FROM (
+ SELECT earnings, year, a
+ FROM courseSales
+ JOIN yearsWithComplexTypes ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR a IN (array(1, 1), array(2, 2))
+);
+
+-- pivot on multiple pivot columns containing array type
+SELECT * FROM (
+ SELECT course, earnings, year, a
+ FROM courseSales
+ JOIN yearsWithComplexTypes ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR (course, a) IN (('dotNET', array(1, 1)), ('Java', array(2, 2)))
+);
+
+-- pivot on pivot column of struct type
+SELECT * FROM (
+ SELECT earnings, year, s
+ FROM courseSales
+ JOIN yearsWithComplexTypes ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR s IN ((1, 'a'), (2, 'b'))
+);
+
+-- pivot on multiple pivot columns containing struct type
+SELECT * FROM (
+ SELECT course, earnings, year, s
+ FROM courseSales
+ JOIN yearsWithComplexTypes ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR (course, s) IN (('dotNET', (1, 'a')), ('Java', (2, 'b')))
+);
+
+-- pivot on pivot column of map type
+SELECT * FROM (
+ SELECT earnings, year, m
+ FROM courseSales
+ JOIN yearsWithComplexTypes ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR m IN (map('1', 1), map('2', 2))
+);
+
+-- pivot on multiple pivot columns containing map type
+SELECT * FROM (
+ SELECT course, earnings, year, m
+ FROM courseSales
+ JOIN yearsWithComplexTypes ON year = y
+)
+PIVOT (
+ sum(earnings)
+ FOR (course, m) IN (('dotNET', map('1', 1)), ('Java', map('2', 2)))
+);
+
+-- grouping columns output in the same order as input
+-- correctly handle pivot columns with different cases
+SELECT * FROM (
+ SELECT course, earnings, "a" as a, "z" as z, "b" as b, "y" as y, "c" as c, "x" as x, "d" as d, "w" as w
+ FROM courseSales
+)
+PIVOT (
+ sum(Earnings)
+ FOR Course IN ('dotNET', 'Java')
+);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part1.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part1.sql
new file mode 100644
index 000000000000..1152d77da0cf
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part1.sql
@@ -0,0 +1,153 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- AGGREGATES [Part 1]
+-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/aggregates.sql#L1-L143
+
+-- avoid bit-exact output here because operations may not be bit-exact.
+-- SET extra_float_digits = 0;
+
+-- Test aggregate 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
+
+SELECT avg(four) AS avg_1 FROM onek;
+
+SELECT avg(a) AS avg_32 FROM aggtest WHERE a < 100;
+
+-- In 7.1, avg(float4) is computed using float8 arithmetic.
+-- Round the result to 3 digits to avoid platform-specific results.
+
+select CAST(avg(b) AS Decimal(10,3)) AS avg_107_943 FROM aggtest;
+-- `student` has a column with data type POINT, which is not supported by Spark [SPARK-27766]
+-- SELECT avg(gpa) AS avg_3_4 FROM ONLY student;
+
+SELECT sum(four) AS sum_1500 FROM onek;
+SELECT sum(a) AS sum_198 FROM aggtest;
+SELECT sum(b) AS avg_431_773 FROM aggtest;
+-- `student` has a column with data type POINT, which is not supported by Spark [SPARK-27766]
+-- SELECT sum(gpa) AS avg_6_8 FROM ONLY student;
+
+SELECT max(four) AS max_3 FROM onek;
+SELECT max(a) AS max_100 FROM aggtest;
+SELECT max(aggtest.b) AS max_324_78 FROM aggtest;
+-- `student` has a column with data type POINT, which is not supported by Spark [SPARK-27766]
+-- SELECT max(student.gpa) AS max_3_7 FROM student;
+
+SELECT stddev_pop(b) FROM aggtest;
+SELECT stddev_samp(b) FROM aggtest;
+SELECT var_pop(b) FROM aggtest;
+SELECT var_samp(b) FROM aggtest;
+
+SELECT stddev_pop(CAST(b AS Decimal(38,0))) FROM aggtest;
+SELECT stddev_samp(CAST(b AS Decimal(38,0))) FROM aggtest;
+SELECT var_pop(CAST(b AS Decimal(38,0))) FROM aggtest;
+SELECT var_samp(CAST(b AS Decimal(38,0))) FROM aggtest;
+
+-- population variance is defined for a single tuple, sample variance
+-- is not
+SELECT var_pop(1.0), var_samp(2.0);
+SELECT stddev_pop(CAST(3.0 AS Decimal(38,0))), stddev_samp(CAST(4.0 AS Decimal(38,0)));
+
+
+-- verify correct results for null and NaN inputs
+select sum(CAST(null AS int)) from range(1,4);
+select sum(CAST(null AS long)) from range(1,4);
+select sum(CAST(null AS Decimal(38,0))) from range(1,4);
+select sum(CAST(null AS DOUBLE)) from range(1,4);
+select avg(CAST(null AS int)) from range(1,4);
+select avg(CAST(null AS long)) from range(1,4);
+select avg(CAST(null AS Decimal(38,0))) from range(1,4);
+select avg(CAST(null AS DOUBLE)) from range(1,4);
+select sum(CAST('NaN' AS DOUBLE)) from range(1,4);
+select avg(CAST('NaN' AS DOUBLE)) from range(1,4);
+
+SELECT avg(CAST(x AS DOUBLE)), var_pop(CAST(x AS DOUBLE))
+FROM (VALUES (CAST('1' AS DOUBLE)), (CAST('infinity' AS DOUBLE))) v(x);
+SELECT avg(CAST(x AS DOUBLE)), var_pop(CAST(x AS DOUBLE))
+FROM (VALUES ('infinity'), ('1')) v(x);
+SELECT avg(CAST(x AS DOUBLE)), var_pop(CAST(x AS DOUBLE))
+FROM (VALUES ('infinity'), ('infinity')) v(x);
+SELECT avg(CAST(x AS DOUBLE)), var_pop(CAST(x AS DOUBLE))
+FROM (VALUES ('-infinity'), ('infinity')) v(x);
+
+-- test accuracy with a large input offset
+SELECT avg(CAST(x AS DOUBLE)), var_pop(CAST(x AS DOUBLE))
+FROM (VALUES (100000003), (100000004), (100000006), (100000007)) v(x);
+SELECT avg(CAST(x AS DOUBLE)), var_pop(CAST(x AS DOUBLE))
+FROM (VALUES (7000000000005), (7000000000007)) v(x);
+
+-- SQL2003 binary aggregates [SPARK-23907]
+SELECT regr_count(b, a) FROM aggtest;
+SELECT regr_sxx(b, a) FROM aggtest;
+SELECT regr_syy(b, a) FROM aggtest;
+SELECT regr_sxy(b, a) FROM aggtest;
+SELECT regr_avgx(b, a), regr_avgy(b, a) FROM aggtest;
+SELECT regr_r2(b, a) FROM aggtest;
+SELECT regr_slope(b, a), regr_intercept(b, a) FROM aggtest;
+SELECT covar_pop(b, a), covar_samp(b, a) FROM aggtest;
+SELECT corr(b, a) FROM aggtest;
+
+
+-- test accum and combine functions directly [SPARK-23907]
+CREATE TEMPORARY VIEW regr_test AS SELECT * FROM VALUES (10,150),(20,250),(30,350),(80,540),(100,200) AS regr_test (x, y);
+SELECT count(*), sum(x), regr_sxx(y,x), sum(y),regr_syy(y,x), regr_sxy(y,x)
+FROM regr_test WHERE x IN (10,20,30,80);
+SELECT count(*), sum(x), regr_sxx(y,x), sum(y),regr_syy(y,x), regr_sxy(y,x)
+FROM regr_test;
+-- SELECT float8_accum('{4,140,2900}'::float8[], 100);
+-- SELECT float8_regr_accum('{4,140,2900,1290,83075,15050}'::float8[], 200, 100);
+SELECT count(*), sum(x), regr_sxx(y,x), sum(y),regr_syy(y,x), regr_sxy(y,x)
+FROM regr_test WHERE x IN (10,20,30);
+SELECT count(*), sum(x), regr_sxx(y,x), sum(y),regr_syy(y,x), regr_sxy(y,x)
+FROM regr_test WHERE x IN (80,100);
+-- SELECT float8_combine('{3,60,200}'::float8[], '{0,0,0}'::float8[]);
+-- SELECT float8_combine('{0,0,0}'::float8[], '{2,180,200}'::float8[]);
+-- SELECT float8_combine('{3,60,200}'::float8[], '{2,180,200}'::float8[]);
+-- SELECT float8_regr_combine('{3,60,200,750,20000,2000}'::float8[],
+-- '{0,0,0,0,0,0}'::float8[]);
+-- SELECT float8_regr_combine('{0,0,0,0,0,0}'::float8[],
+-- '{2,180,200,740,57800,-3400}'::float8[]);
+-- SELECT float8_regr_combine('{3,60,200,750,20000,2000}'::float8[],
+-- '{2,180,200,740,57800,-3400}'::float8[]);
+DROP VIEW regr_test;
+
+
+-- test count, distinct
+SELECT count(four) AS cnt_1000 FROM onek;
+SELECT count(DISTINCT four) AS cnt_4 FROM onek;
+
+select ten, count(*), sum(four) from onek
+group by ten order by ten;
+
+select ten, count(four), sum(DISTINCT four) from onek
+group by ten order by ten;
+
+-- user-defined aggregates
+-- SELECT newavg(four) AS avg_1 FROM onek;
+-- SELECT newsum(four) AS sum_1500 FROM onek;
+-- SELECT newcnt(four) AS cnt_1000 FROM onek;
+-- SELECT newcnt(*) AS cnt_1000 FROM onek;
+-- SELECT oldcnt(*) AS cnt_1000 FROM onek;
+-- SELECT sum2(q1,q2) FROM int8_tbl;
+
+-- test for outer-level aggregates
+
+-- this should work
+select ten, sum(distinct four) from onek a
+group by ten
+having exists (select 1 from onek b where sum(distinct a.four) = b.four);
+
+-- this should fail because subquery has an agg of its own in WHERE
+select ten, sum(distinct four) from onek a
+group by ten
+having exists (select 1 from onek b
+ where sum(distinct a.four + b.four) = b.four);
+
+-- [SPARK-27769] Test handling of sublinks within outer-level aggregates.
+-- Per bug report from Daniel Grace.
+select
+ (select max((select i.unique2 from tenk1 i where i.unique1 = o.unique1)))
+from tenk1 o;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part2.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part2.sql
new file mode 100644
index 000000000000..a8af1db77563
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part2.sql
@@ -0,0 +1,218 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- AGGREGATES [Part 2]
+-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/aggregates.sql#L145-L350
+
+-- Test aggregate 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 int4_tbl as select * from values
+ (0),
+ (123456),
+ (-123456),
+ (2147483647),
+ (-2147483647)
+ as int4_tbl(f1);
+
+-- Test handling of Params within aggregate arguments in hashed aggregation.
+-- Per bug report from Jeevan Chalke.
+-- [SPARK-27877] Implement SQL-standard LATERAL subqueries
+-- explain (verbose, costs off)
+-- select s1, s2, sm
+-- from generate_series(1, 3) s1,
+-- lateral (select s2, sum(s1 + s2) sm
+-- from generate_series(1, 3) s2 group by s2) ss
+-- order by 1, 2;
+-- select s1, s2, sm
+-- from generate_series(1, 3) s1,
+-- lateral (select s2, sum(s1 + s2) sm
+-- from generate_series(1, 3) s2 group by s2) ss
+-- order by 1, 2;
+
+-- [SPARK-27878] Support ARRAY(sub-SELECT) expressions
+-- explain (verbose, costs off)
+-- select array(select sum(x+y) s
+-- from generate_series(1,3) y group by y order by s)
+-- from generate_series(1,3) x;
+-- select array(select sum(x+y) s
+-- from generate_series(1,3) y group by y order by s)
+-- from generate_series(1,3) x;
+
+-- [SPARK-27879] Implement bitwise integer aggregates(BIT_AND and BIT_OR)
+--
+-- test for bitwise integer aggregates
+--
+CREATE OR REPLACE TEMPORARY VIEW bitwise_test AS SELECT * FROM VALUES
+ (1, 1, 1, 1L),
+ (3, 3, 3, null),
+ (7, 7, 7, 3L) AS bitwise_test(b1, b2, b3, b4);
+
+-- empty case
+SELECT BIT_AND(b1) AS n1, BIT_OR(b2) AS n2 FROM bitwise_test where 1 = 0;
+
+-- null case
+SELECT BIT_AND(b4) AS n1, BIT_OR(b4) AS n2 FROM bitwise_test where b4 is null;
+
+SELECT
+ BIT_AND(cast(b1 as tinyint)) AS a1,
+ BIT_AND(cast(b2 as smallint)) AS b1,
+ BIT_AND(b3) AS c1,
+ BIT_AND(b4) AS d1,
+ BIT_OR(cast(b1 as tinyint)) AS e7,
+ BIT_OR(cast(b2 as smallint)) AS f7,
+ BIT_OR(b3) AS g7,
+ BIT_OR(b4) AS h3
+FROM bitwise_test;
+
+-- group by
+SELECT b1 , bit_and(b2), bit_or(b4) FROM bitwise_test GROUP BY b1;
+
+--having
+SELECT b1, bit_and(b2) FROM bitwise_test GROUP BY b1 HAVING bit_and(b2) < 7;
+
+-- window
+SELECT b1, b2, bit_and(b2) OVER (PARTITION BY b1 ORDER BY b2) FROM bitwise_test;
+SELECT b1, b2, bit_or(b2) OVER (PARTITION BY b1 ORDER BY b2) FROM bitwise_test;
+
+--
+-- test boolean aggregates
+--
+-- first test all possible transition and final states
+
+-- The result is inconsistent with PostgreSQL because our AND does not have strict mode
+SELECT
+ -- boolean and transitions
+ -- null because strict
+ (NULL AND NULL) IS NULL AS `t`,
+ (TRUE AND NULL) IS NULL AS `t`,
+ (FALSE AND NULL) IS NULL AS `t`,
+ (NULL AND TRUE) IS NULL AS `t`,
+ (NULL AND FALSE) IS NULL AS `t`,
+ -- and actual computations
+ (TRUE AND TRUE) AS `t`,
+ NOT (TRUE AND FALSE) AS `t`,
+ NOT (FALSE AND TRUE) AS `t`,
+ NOT (FALSE AND FALSE) AS `t`;
+
+-- The result is inconsistent with PostgreSQL because our OR does not have strict mode
+SELECT
+ -- boolean or transitions
+ -- null because strict
+ (NULL OR NULL) IS NULL AS `t`,
+ (TRUE OR NULL) IS NULL AS `t`,
+ (FALSE OR NULL) IS NULL AS `t`,
+ (NULL OR TRUE) IS NULL AS `t`,
+ (NULL OR FALSE) IS NULL AS `t`,
+ -- actual computations
+ (TRUE OR TRUE) AS `t`,
+ (TRUE OR FALSE) AS `t`,
+ (FALSE OR TRUE) AS `t`,
+ NOT (FALSE OR FALSE) AS `t`;
+
+-- [SPARK-27880] Implement boolean aggregates(BOOL_AND, BOOL_OR and EVERY)
+CREATE OR REPLACE TEMPORARY VIEW bool_test AS SELECT * FROM VALUES
+ (TRUE, null, FALSE, null),
+ (FALSE, TRUE, null, null),
+ (null, TRUE, FALSE, null) AS bool_test(b1, b2, b3, b4);
+
+-- empty case
+SELECT BOOL_AND(b1) AS n1, BOOL_OR(b3) AS n2 FROM bool_test WHERE 1 = 0;
+
+SELECT
+ BOOL_AND(b1) AS f1,
+ BOOL_AND(b2) AS t2,
+ BOOL_AND(b3) AS f3,
+ BOOL_AND(b4) AS n4,
+ BOOL_AND(NOT b2) AS f5,
+ BOOL_AND(NOT b3) AS t6
+FROM bool_test;
+
+SELECT
+ EVERY(b1) AS f1,
+ EVERY(b2) AS t2,
+ EVERY(b3) AS f3,
+ EVERY(b4) AS n4,
+ EVERY(NOT b2) AS f5,
+ EVERY(NOT b3) AS t6
+FROM bool_test;
+
+SELECT
+ BOOL_OR(b1) AS t1,
+ BOOL_OR(b2) AS t2,
+ BOOL_OR(b3) AS f3,
+ BOOL_OR(b4) AS n4,
+ BOOL_OR(NOT b2) AS f5,
+ BOOL_OR(NOT b3) AS t6
+FROM bool_test;
+
+--
+-- Test cases that should be optimized into indexscans instead of
+-- the generic aggregate implementation.
+--
+
+-- Basic cases
+-- explain
+-- select min(unique1) from tenk1;
+select min(unique1) from tenk1;
+-- explain
+-- select max(unique1) from tenk1;
+select max(unique1) from tenk1;
+-- explain
+-- select max(unique1) from tenk1 where unique1 < 42;
+select max(unique1) from tenk1 where unique1 < 42;
+-- explain
+-- select max(unique1) from tenk1 where unique1 > 42;
+select max(unique1) from tenk1 where unique1 > 42;
+
+-- the planner may choose a generic aggregate here if parallel query is
+-- enabled, since that plan will be parallel safe and the "optimized"
+-- plan, which has almost identical cost, will not be. we want to test
+-- the optimized plan, so temporarily disable parallel query.
+-- begin;
+-- set local max_parallel_workers_per_gather = 0;
+-- explain
+-- select max(unique1) from tenk1 where unique1 > 42000;
+select max(unique1) from tenk1 where unique1 > 42000;
+-- rollback;
+
+-- multi-column index (uses tenk1_thous_tenthous)
+-- explain
+-- select max(tenthous) from tenk1 where thousand = 33;
+select max(tenthous) from tenk1 where thousand = 33;
+-- explain
+-- select min(tenthous) from tenk1 where thousand = 33;
+select min(tenthous) from tenk1 where thousand = 33;
+
+-- [SPARK-17348] Correlated column is not allowed in a non-equality predicate
+-- check parameter propagation into an indexscan subquery
+-- explain
+-- select f1, (select min(unique1) from tenk1 where unique1 > f1) AS gt
+-- from int4_tbl;
+-- select f1, (select min(unique1) from tenk1 where unique1 > f1) AS gt
+-- from int4_tbl;
+
+-- check some cases that were handled incorrectly in 8.3.0
+-- explain
+-- select distinct max(unique2) from tenk1;
+select distinct max(unique2) from tenk1;
+-- explain
+-- select max(unique2) from tenk1 order by 1;
+select max(unique2) from tenk1 order by 1;
+-- explain
+-- select max(unique2) from tenk1 order by max(unique2);
+select max(unique2) from tenk1 order by max(unique2);
+-- explain
+-- select max(unique2) from tenk1 order by max(unique2)+1;
+select max(unique2) from tenk1 order by max(unique2)+1;
+-- explain
+-- select max(unique2), generate_series(1,3) as g from tenk1 order by g desc;
+select t1.max_unique2, g from (select max(unique2) as max_unique2 FROM tenk1) t1 LATERAL VIEW explode(array(1,2,3)) t2 AS g order by g desc;
+
+-- interesting corner case: constant gets optimized into a seqscan
+-- explain
+-- select max(100) from tenk1;
+select max(100) from tenk1;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part3.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part3.sql
new file mode 100644
index 000000000000..41fd4de2a097
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part3.sql
@@ -0,0 +1,276 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- AGGREGATES [Part 3]
+-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/aggregates.sql#L352-L605
+
+-- Test aggregate 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-28865] Table inheritance
+-- try it on an inheritance tree
+-- create table minmaxtest(f1 int);
+-- create table minmaxtest1() inherits (minmaxtest);
+-- create table minmaxtest2() inherits (minmaxtest);
+-- create table minmaxtest3() inherits (minmaxtest);
+-- create index minmaxtesti on minmaxtest(f1);
+-- create index minmaxtest1i on minmaxtest1(f1);
+-- create index minmaxtest2i on minmaxtest2(f1 desc);
+-- create index minmaxtest3i on minmaxtest3(f1) where f1 is not null;
+
+-- insert into minmaxtest values(11), (12);
+-- insert into minmaxtest1 values(13), (14);
+-- insert into minmaxtest2 values(15), (16);
+-- insert into minmaxtest3 values(17), (18);
+
+-- explain (costs off)
+-- select min(f1), max(f1) from minmaxtest;
+-- select min(f1), max(f1) from minmaxtest;
+
+-- DISTINCT doesn't do anything useful here, but it shouldn't fail
+-- explain (costs off)
+-- select distinct min(f1), max(f1) from minmaxtest;
+-- select distinct min(f1), max(f1) from minmaxtest;
+
+-- drop table minmaxtest cascade;
+
+-- check for correct detection of nested-aggregate errors
+select max(min(unique1)) from tenk1;
+-- select (select max(min(unique1)) from int8_tbl) from tenk1;
+
+-- These tests only test the explain. Skip these tests.
+--
+-- Test removal of redundant GROUP BY columns
+--
+
+-- create temp table t1 (a int, b int, c int, d int, primary key (a, b));
+-- create temp table t2 (x int, y int, z int, primary key (x, y));
+-- create temp table t3 (a int, b int, c int, primary key(a, b) deferrable);
+
+-- Non-primary-key columns can be removed from GROUP BY
+-- explain (costs off) select * from t1 group by a,b,c,d;
+
+-- No removal can happen if the complete PK is not present in GROUP BY
+-- explain (costs off) select a,c from t1 group by a,c,d;
+
+-- Test removal across multiple relations
+-- explain (costs off) select *
+-- from t1 inner join t2 on t1.a = t2.x and t1.b = t2.y
+-- group by t1.a,t1.b,t1.c,t1.d,t2.x,t2.y,t2.z;
+
+-- Test case where t1 can be optimized but not t2
+-- explain (costs off) select t1.*,t2.x,t2.z
+-- from t1 inner join t2 on t1.a = t2.x and t1.b = t2.y
+-- group by t1.a,t1.b,t1.c,t1.d,t2.x,t2.z;
+
+-- Cannot optimize when PK is deferrable
+-- explain (costs off) select * from t3 group by a,b,c;
+
+-- drop table t1;
+-- drop table t2;
+-- drop table t3;
+
+-- [SPARK-28664] ORDER BY in aggregate function
+--
+-- Test combinations of DISTINCT and/or ORDER BY
+--
+
+-- select array_agg(a order by b)
+-- from (values (1,4),(2,3),(3,1),(4,2)) v(a,b);
+-- select array_agg(a order by a)
+-- from (values (1,4),(2,3),(3,1),(4,2)) v(a,b);
+-- select array_agg(a order by a desc)
+-- from (values (1,4),(2,3),(3,1),(4,2)) v(a,b);
+-- select array_agg(b order by a desc)
+-- from (values (1,4),(2,3),(3,1),(4,2)) v(a,b);
+
+-- select array_agg(distinct a)
+-- from (values (1),(2),(1),(3),(null),(2)) v(a);
+-- select array_agg(distinct a order by a)
+-- from (values (1),(2),(1),(3),(null),(2)) v(a);
+-- select array_agg(distinct a order by a desc)
+-- from (values (1),(2),(1),(3),(null),(2)) v(a);
+-- select array_agg(distinct a order by a desc nulls last)
+-- from (values (1),(2),(1),(3),(null),(2)) v(a);
+
+-- Skip the test below because it requires 4 UDAFs: aggf_trans, aggfns_trans, aggfstr, and aggfns
+-- multi-arg aggs, strict/nonstrict, distinct/order by
+
+-- select aggfstr(a,b,c)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
+-- select aggfns(a,b,c)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
+
+-- select aggfstr(distinct a,b,c)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,3) i;
+-- select aggfns(distinct a,b,c)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,3) i;
+
+-- select aggfstr(distinct a,b,c order by b)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,3) i;
+-- select aggfns(distinct a,b,c order by b)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,3) i;
+
+-- test specific code paths
+
+-- [SPARK-28768] Implement more text pattern operators
+-- select aggfns(distinct a,a,c order by c using ~<~,a)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,2) i;
+-- select aggfns(distinct a,a,c order by c using ~<~)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,2) i;
+-- select aggfns(distinct a,a,c order by a)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,2) i;
+-- select aggfns(distinct a,b,c order by a,c using ~<~,b)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,2) i;
+
+-- check node I/O via view creation and usage, also deparsing logic
+
+-- create view agg_view1 as
+-- select aggfns(a,b,c)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
+
+-- select * from agg_view1;
+-- select pg_get_viewdef('agg_view1'::regclass);
+
+-- create or replace view agg_view1 as
+-- select aggfns(distinct a,b,c)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,3) i;
+
+-- select * from agg_view1;
+-- select pg_get_viewdef('agg_view1'::regclass);
+
+-- create or replace view agg_view1 as
+-- select aggfns(distinct a,b,c order by b)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,3) i;
+
+-- select * from agg_view1;
+-- select pg_get_viewdef('agg_view1'::regclass);
+
+-- create or replace view agg_view1 as
+-- select aggfns(a,b,c order by b+1)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
+
+-- select * from agg_view1;
+-- select pg_get_viewdef('agg_view1'::regclass);
+
+-- create or replace view agg_view1 as
+-- select aggfns(a,a,c order by b)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
+
+-- select * from agg_view1;
+-- select pg_get_viewdef('agg_view1'::regclass);
+
+-- create or replace view agg_view1 as
+-- select aggfns(a,b,c order by c using ~<~)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c);
+
+-- select * from agg_view1;
+-- select pg_get_viewdef('agg_view1'::regclass);
+
+-- create or replace view agg_view1 as
+-- select aggfns(distinct a,b,c order by a,c using ~<~,b)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,2) i;
+
+-- select * from agg_view1;
+-- select pg_get_viewdef('agg_view1'::regclass);
+
+-- drop view agg_view1;
+
+-- incorrect DISTINCT usage errors
+
+-- select aggfns(distinct a,b,c order by i)
+-- from (values (1,1,'foo')) v(a,b,c), generate_series(1,2) i;
+-- select aggfns(distinct a,b,c order by a,b+1)
+-- from (values (1,1,'foo')) v(a,b,c), generate_series(1,2) i;
+-- select aggfns(distinct a,b,c order by a,b,i,c)
+-- from (values (1,1,'foo')) v(a,b,c), generate_series(1,2) i;
+-- select aggfns(distinct a,a,c order by a,b)
+-- from (values (1,1,'foo')) v(a,b,c), generate_series(1,2) i;
+
+-- [SPARK-27978] Add built-in Aggregate Functions: string_agg
+-- string_agg tests
+-- select string_agg(a,',') from (values('aaaa'),('bbbb'),('cccc')) g(a);
+-- select string_agg(a,',') from (values('aaaa'),(null),('bbbb'),('cccc')) g(a);
+-- select string_agg(a,'AB') from (values(null),(null),('bbbb'),('cccc')) g(a);
+-- select string_agg(a,',') from (values(null),(null)) g(a);
+
+-- check some implicit casting cases, as per bug #5564
+-- select string_agg(distinct f1, ',' order by f1) from varchar_tbl; -- ok
+-- select string_agg(distinct f1::text, ',' order by f1) from varchar_tbl; -- not ok
+-- select string_agg(distinct f1, ',' order by f1::text) from varchar_tbl; -- not ok
+-- select string_agg(distinct f1::text, ',' order by f1::text) from varchar_tbl; -- ok
+
+-- [SPARK-28121] decode can not accept 'hex' as charset
+-- string_agg bytea tests
+-- CREATE TABLE bytea_test_table(v BINARY) USING parquet;
+
+-- select string_agg(v, '') from bytea_test_table;
+
+-- insert into bytea_test_table values(decode('ff','hex'));
+
+-- select string_agg(v, '') from bytea_test_table;
+
+-- insert into bytea_test_table values(decode('aa','hex'));
+
+-- select string_agg(v, '') from bytea_test_table;
+-- select string_agg(v, NULL) from bytea_test_table;
+-- select string_agg(v, decode('ee', 'hex')) from bytea_test_table;
+
+-- drop table bytea_test_table;
+
+-- FILTER tests
+
+select min(unique1) filter (where unique1 > 100) from tenk1;
+
+select sum(1/ten) filter (where ten > 0) from tenk1;
+
+-- select ten, sum(distinct four) filter (where four::text ~ '123') from onek a
+-- group by ten;
+
+select ten, sum(distinct four) filter (where four > 10) from onek a
+group by ten
+having exists (select 1 from onek b where sum(distinct a.four) = b.four);
+
+-- [SPARK-28682] ANSI SQL: Collation Support
+-- select max(foo COLLATE "C") filter (where (bar collate "POSIX") > '0')
+-- from (values ('a', 'b')) AS v(foo,bar);
+
+-- outer reference in FILTER (PostgreSQL extension)
+select (select count(*)
+ from (values (1)) t0(inner_c))
+from (values (2),(3)) t1(outer_c); -- inner query is aggregation query
+-- [SPARK-30219] Support Filter expression reference the outer query
+-- select (select count(*) filter (where outer_c <> 0)
+-- from (values (1)) t0(inner_c))
+-- from (values (2),(3)) t1(outer_c); -- outer query is aggregation query
+-- select (select count(inner_c) filter (where outer_c <> 0)
+-- from (values (1)) t0(inner_c))
+-- from (values (2),(3)) t1(outer_c); -- inner query is aggregation query
+-- select
+-- (select max((select i.unique2 from tenk1 i where i.unique1 = o.unique1))
+-- filter (where o.unique1 < 10))
+-- from tenk1 o; -- outer query is aggregation query
+
+-- [SPARK-30220] Support Filter expression uses IN/EXISTS predicate sub-queries
+-- subquery in FILTER clause (PostgreSQL extension)
+-- select sum(unique1) FILTER (WHERE
+-- unique1 IN (SELECT unique1 FROM onek where unique1 < 100)) FROM tenk1;
+
+-- exercise lots of aggregate parts with FILTER
+-- select aggfns(distinct a,b,c order by a,c using ~<~,b) filter (where a > 1)
+-- from (values (1,3,'foo'),(0,null,null),(2,2,'bar'),(3,1,'baz')) v(a,b,c),
+-- generate_series(1,2) i;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part4.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part4.sql
new file mode 100644
index 000000000000..3cf57b1f0e50
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/aggregates_part4.sql
@@ -0,0 +1,424 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- AGGREGATES [Part 4]
+-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/aggregates.sql#L607-L997
+
+-- Test aggregate 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-27980] Ordered-Set Aggregate Functions
+-- ordered-set aggregates
+
+-- select p, percentile_cont(p) within group (order by x::float8)
+-- from generate_series(1,5) x,
+-- (values (0::float8),(0.1),(0.25),(0.4),(0.5),(0.6),(0.75),(0.9),(1)) v(p)
+-- group by p order by p;
+
+-- select p, percentile_cont(p order by p) within group (order by x) -- error
+-- from generate_series(1,5) x,
+-- (values (0::float8),(0.1),(0.25),(0.4),(0.5),(0.6),(0.75),(0.9),(1)) v(p)
+-- group by p order by p;
+
+-- select p, sum() within group (order by x::float8) -- error
+-- from generate_series(1,5) x,
+-- (values (0::float8),(0.1),(0.25),(0.4),(0.5),(0.6),(0.75),(0.9),(1)) v(p)
+-- group by p order by p;
+
+-- select p, percentile_cont(p,p) -- error
+-- from generate_series(1,5) x,
+-- (values (0::float8),(0.1),(0.25),(0.4),(0.5),(0.6),(0.75),(0.9),(1)) v(p)
+-- group by p order by p;
+
+select percentile_cont(0.5) within group (order by b) from aggtest;
+select percentile_cont(0.5) within group (order by b), sum(b) from aggtest;
+select percentile_cont(0.5) within group (order by thousand) from tenk1;
+select percentile_disc(0.5) within group (order by thousand) from tenk1;
+-- [SPARK-28661] Hypothetical-Set Aggregate Functions
+-- select rank(3) within group (order by x)
+-- from (values (1),(1),(2),(2),(3),(3),(4)) v(x);
+-- select cume_dist(3) within group (order by x)
+-- from (values (1),(1),(2),(2),(3),(3),(4)) v(x);
+-- select percent_rank(3) within group (order by x)
+-- from (values (1),(1),(2),(2),(3),(3),(4),(5)) v(x);
+-- select dense_rank(3) within group (order by x)
+-- from (values (1),(1),(2),(2),(3),(3),(4)) v(x);
+
+-- [SPARK-27980] Ordered-Set Aggregate Functions
+-- select percentile_disc(array[0,0.1,0.25,0.5,0.75,0.9,1]) within group (order by thousand)
+-- from tenk1;
+-- select percentile_cont(array[0,0.25,0.5,0.75,1]) within group (order by thousand)
+-- from tenk1;
+-- select percentile_disc(array[[null,1,0.5],[0.75,0.25,null]]) within group (order by thousand)
+-- from tenk1;
+-- select percentile_cont(array[0,1,0.25,0.75,0.5,1,0.3,0.32,0.35,0.38,0.4]) within group (order by x)
+-- from generate_series(1,6) x;
+
+-- [SPARK-27980] Ordered-Set Aggregate Functions
+-- [SPARK-28382] Array Functions: unnest
+-- select ten, mode() within group (order by string4) from tenk1 group by ten;
+
+-- select percentile_disc(array[0.25,0.5,0.75]) within group (order by x)
+-- from unnest('{fred,jim,fred,jack,jill,fred,jill,jim,jim,sheila,jim,sheila}'::text[]) u(x);
+
+-- [SPARK-28669] System Information Functions
+-- check collation propagates up in suitable cases:
+-- select pg_collation_for(percentile_disc(1) within group (order by x collate "POSIX"))
+-- from (values ('fred'),('jim')) v(x);
+
+-- test_rank and test_percentile_disc function created by create_aggregate.sql
+-- ordered-set aggs created with CREATE AGGREGATE
+-- select test_rank(3) within group (order by x)
+-- from (values (1),(1),(2),(2),(3),(3),(4)) v(x);
+-- select test_percentile_disc(0.5) within group (order by thousand) from tenk1;
+
+-- [SPARK-28661] Hypothetical-Set Aggregate Functions
+-- ordered-set aggs can't use ungrouped vars in direct args:
+-- select rank(x) within group (order by x) from generate_series(1,5) x;
+
+-- [SPARK-27980] Ordered-Set Aggregate Functions
+-- outer-level agg can't use a grouped arg of a lower level, either:
+-- select array(select percentile_disc(a) within group (order by x)
+-- from (values (0.3),(0.7)) v(a) group by a)
+-- from generate_series(1,5) g(x);
+
+-- [SPARK-28661] Hypothetical-Set Aggregate Functions
+-- agg in the direct args is a grouping violation, too:
+--select rank(sum(x)) within group (order by x) from generate_series(1,5) x;
+
+-- [SPARK-28661] Hypothetical-Set Aggregate Functions
+-- hypothetical-set type unification and argument-count failures:
+-- select rank(3) within group (order by x) from (values ('fred'),('jim')) v(x);
+-- select rank(3) within group (order by stringu1,stringu2) from tenk1;
+-- select rank('fred') within group (order by x) from generate_series(1,5) x;
+-- select rank('adam'::text collate "C") within group (order by x collate "POSIX")
+-- from (values ('fred'),('jim')) v(x);
+-- hypothetical-set type unification successes:
+-- select rank('adam'::varchar) within group (order by x) from (values ('fred'),('jim')) v(x);
+-- select rank('3') within group (order by x) from generate_series(1,5) x;
+
+-- [SPARK-28661] Hypothetical-Set Aggregate Functions
+-- divide by zero check
+-- select percent_rank(0) within group (order by x) from generate_series(1,0) x;
+
+-- [SPARK-27980] Ordered-Set Aggregate Functions
+-- deparse and multiple features:
+-- create view aggordview1 as
+-- select ten,
+-- percentile_disc(0.5) within group (order by thousand) as p50,
+-- percentile_disc(0.5) within group (order by thousand) filter (where hundred=1) as px,
+-- rank(5,'AZZZZ',50) within group (order by hundred, string4 desc, hundred)
+-- from tenk1
+-- group by ten order by ten;
+
+-- select pg_get_viewdef('aggordview1');
+-- select * from aggordview1 order by ten;
+-- drop view aggordview1;
+
+-- least_agg created by create_aggregate.sql
+-- variadic aggregates
+-- select least_agg(q1,q2) from int8_tbl;
+-- select least_agg(variadic array[q1,q2]) from int8_tbl;
+
+
+-- Skip these tests because we do not support create type
+-- test aggregates with common transition functions share the same states
+-- begin work;
+
+-- create type avg_state as (total bigint, count bigint);
+
+-- create or replace function avg_transfn(state avg_state, n int) returns avg_state as
+-- $$
+-- declare new_state avg_state;
+-- begin
+-- raise notice 'avg_transfn called with %', n;
+-- if state is null then
+-- if n is not null then
+-- new_state.total := n;
+-- new_state.count := 1;
+-- return new_state;
+-- end if;
+-- return null;
+-- elsif n is not null then
+-- state.total := state.total + n;
+-- state.count := state.count + 1;
+-- return state;
+-- end if;
+--
+-- return null;
+-- end
+-- $$ language plpgsql;
+
+-- create function avg_finalfn(state avg_state) returns int4 as
+-- $$
+-- begin
+-- if state is null then
+-- return NULL;
+-- else
+-- return state.total / state.count;
+-- end if;
+-- end
+-- $$ language plpgsql;
+
+-- create function sum_finalfn(state avg_state) returns int4 as
+-- $$
+-- begin
+-- if state is null then
+-- return NULL;
+-- else
+-- return state.total;
+-- end if;
+-- end
+-- $$ language plpgsql;
+
+-- create aggregate my_avg(int4)
+-- (
+-- stype = avg_state,
+-- sfunc = avg_transfn,
+-- finalfunc = avg_finalfn
+-- );
+--
+-- create aggregate my_sum(int4)
+-- (
+-- stype = avg_state,
+-- sfunc = avg_transfn,
+-- finalfunc = sum_finalfn
+-- );
+
+-- aggregate state should be shared as aggs are the same.
+-- select my_avg(one),my_avg(one) from (values(1),(3)) t(one);
+
+-- aggregate state should be shared as transfn is the same for both aggs.
+-- select my_avg(one),my_sum(one) from (values(1),(3)) t(one);
+
+-- same as previous one, but with DISTINCT, which requires sorting the input.
+-- select my_avg(distinct one),my_sum(distinct one) from (values(1),(3),(1)) t(one);
+
+-- shouldn't share states due to the distinctness not matching.
+-- select my_avg(distinct one),my_sum(one) from (values(1),(3)) t(one);
+
+-- shouldn't share states due to the filter clause not matching.
+-- select my_avg(one) filter (where one > 1),my_sum(one) from (values(1),(3)) t(one);
+
+-- this should not share the state due to different input columns.
+-- select my_avg(one),my_sum(two) from (values(1,2),(3,4)) t(one,two);
+
+-- [SPARK-27980] Ordered-Set Aggregate Functions
+-- exercise cases where OSAs share state
+-- select
+-- percentile_cont(0.5) within group (order by a),
+-- percentile_disc(0.5) within group (order by a)
+-- from (values(1::float8),(3),(5),(7)) t(a);
+
+-- select
+-- percentile_cont(0.25) within group (order by a),
+-- percentile_disc(0.5) within group (order by a)
+-- from (values(1::float8),(3),(5),(7)) t(a);
+
+-- [SPARK-28661] Hypothetical-Set Aggregate Functions
+-- these can't share state currently
+-- select
+-- rank(4) within group (order by a),
+-- dense_rank(4) within group (order by a)
+-- from (values(1),(3),(5),(7)) t(a);
+
+-- test that aggs with the same sfunc and initcond share the same agg state
+-- create aggregate my_sum_init(int4)
+-- (
+-- stype = avg_state,
+-- sfunc = avg_transfn,
+-- finalfunc = sum_finalfn,
+-- initcond = '(10,0)'
+-- );
+
+-- create aggregate my_avg_init(int4)
+-- (
+-- stype = avg_state,
+-- sfunc = avg_transfn,
+-- finalfunc = avg_finalfn,
+-- initcond = '(10,0)'
+-- );
+
+-- create aggregate my_avg_init2(int4)
+-- (
+-- stype = avg_state,
+-- sfunc = avg_transfn,
+-- finalfunc = avg_finalfn,
+-- initcond = '(4,0)'
+-- );
+
+-- state should be shared if INITCONDs are matching
+-- select my_sum_init(one),my_avg_init(one) from (values(1),(3)) t(one);
+
+-- Varying INITCONDs should cause the states not to be shared.
+-- select my_sum_init(one),my_avg_init2(one) from (values(1),(3)) t(one);
+
+-- rollback;
+
+-- test aggregate state sharing to ensure it works if one aggregate has a
+-- finalfn and the other one has none.
+-- begin work;
+
+-- create or replace function sum_transfn(state int4, n int4) returns int4 as
+-- $$
+-- declare new_state int4;
+-- begin
+-- raise notice 'sum_transfn called with %', n;
+-- if state is null then
+-- if n is not null then
+-- new_state := n;
+-- return new_state;
+-- end if;
+-- return null;
+-- elsif n is not null then
+-- state := state + n;
+-- return state;
+-- end if;
+--
+-- return null;
+-- end
+-- $$ language plpgsql;
+
+-- create function halfsum_finalfn(state int4) returns int4 as
+-- $$
+-- begin
+-- if state is null then
+-- return NULL;
+-- else
+-- return state / 2;
+-- end if;
+-- end
+-- $$ language plpgsql;
+
+-- create aggregate my_sum(int4)
+-- (
+-- stype = int4,
+-- sfunc = sum_transfn
+-- );
+
+-- create aggregate my_half_sum(int4)
+-- (
+-- stype = int4,
+-- sfunc = sum_transfn,
+-- finalfunc = halfsum_finalfn
+-- );
+
+-- Agg state should be shared even though my_sum has no finalfn
+-- select my_sum(one),my_half_sum(one) from (values(1),(2),(3),(4)) t(one);
+
+-- rollback;
+
+
+-- test that the aggregate transition logic correctly handles
+-- transition / combine functions returning NULL
+
+-- First test the case of a normal transition function returning NULL
+-- BEGIN;
+-- CREATE FUNCTION balkifnull(int8, int4)
+-- RETURNS int8
+-- STRICT
+-- LANGUAGE plpgsql AS $$
+-- BEGIN
+-- IF $1 IS NULL THEN
+-- RAISE 'erroneously called with NULL argument';
+-- END IF;
+-- RETURN NULL;
+-- END$$;
+
+-- CREATE AGGREGATE balk(int4)
+-- (
+-- SFUNC = balkifnull(int8, int4),
+-- STYPE = int8,
+-- PARALLEL = SAFE,
+-- INITCOND = '0'
+-- );
+
+-- SELECT balk(hundred) FROM tenk1;
+
+-- ROLLBACK;
+
+-- Secondly test the case of a parallel aggregate combiner function
+-- returning NULL. For that use normal transition function, but a
+-- combiner function returning NULL.
+-- BEGIN ISOLATION LEVEL REPEATABLE READ;
+-- CREATE FUNCTION balkifnull(int8, int8)
+-- RETURNS int8
+-- PARALLEL SAFE
+-- STRICT
+-- LANGUAGE plpgsql AS $$
+-- BEGIN
+-- IF $1 IS NULL THEN
+-- RAISE 'erroneously called with NULL argument';
+-- END IF;
+-- RETURN NULL;
+-- END$$;
+
+-- CREATE AGGREGATE balk(int4)
+-- (
+-- SFUNC = int4_sum(int8, int4),
+-- STYPE = int8,
+-- COMBINEFUNC = balkifnull(int8, int8),
+-- PARALLEL = SAFE,
+-- INITCOND = '0'
+-- );
+
+-- force use of parallelism
+-- ALTER TABLE tenk1 set (parallel_workers = 4);
+-- SET LOCAL parallel_setup_cost=0;
+-- SET LOCAL max_parallel_workers_per_gather=4;
+
+-- EXPLAIN (COSTS OFF) SELECT balk(hundred) FROM tenk1;
+-- SELECT balk(hundred) FROM tenk1;
+
+-- ROLLBACK;
+
+-- test coverage for aggregate combine/serial/deserial functions
+-- BEGIN ISOLATION LEVEL REPEATABLE READ;
+
+-- SET parallel_setup_cost = 0;
+-- SET parallel_tuple_cost = 0;
+-- SET min_parallel_table_scan_size = 0;
+-- SET max_parallel_workers_per_gather = 4;
+-- SET enable_indexonlyscan = off;
+
+-- [SPARK-28663] Aggregate Functions for Statistics
+-- variance(int4) covers numeric_poly_combine
+-- sum(int8) covers int8_avg_combine
+-- regr_count(float8, float8) covers int8inc_float8_float8 and aggregates with > 1 arg
+-- EXPLAIN (COSTS OFF, VERBOSE)
+-- SELECT variance(unique1::int4), sum(unique1::int8), regr_count(unique1::float8, unique1::float8) FROM tenk1;
+
+-- SELECT variance(unique1::int4), sum(unique1::int8), regr_count(unique1::float8, unique1::float8) FROM tenk1;
+
+-- ROLLBACK;
+
+-- [SPARK-28661] Hypothetical-Set Aggregate Functions
+-- test coverage for dense_rank
+-- SELECT dense_rank(x) WITHIN GROUP (ORDER BY x) FROM (VALUES (1),(1),(2),(2),(3),(3)) v(x) GROUP BY (x) ORDER BY 1;
+
+
+-- [SPARK-28664] ORDER BY in aggregate function
+-- Ensure that the STRICT checks for aggregates does not take NULLness
+-- of ORDER BY columns into account. See bug report around
+-- 2a505161-2727-2473-7c46-591ed108ac52@email.cz
+-- SELECT min(x ORDER BY y) FROM (VALUES(1, NULL)) AS d(x,y);
+-- SELECT min(x ORDER BY y) FROM (VALUES(1, 2)) AS d(x,y);
+
+-- [SPARK-28382] Array Functions: unnest
+-- check collation-sensitive matching between grouping expressions
+-- select v||'a', case v||'a' when 'aa' then 1 else 0 end, count(*)
+-- from unnest(array['a','b']) u(v)
+-- group by v||'a' order by 1;
+-- select v||'a', case when v||'a' = 'aa' then 1 else 0 end, count(*)
+-- from unnest(array['a','b']) u(v)
+-- group by v||'a' order by 1;
+
+-- Make sure that generation of HashAggregate for uniqification purposes
+-- does not lead to array overflow due to unexpected duplicate hash keys
+-- see CAFeeJoKKu0u+A_A9R9316djW-YW3-+Gtgvy3ju655qRHR3jtdA@mail.gmail.com
+-- explain (costs off)
+-- select 1 from tenk1
+-- where (hundred, thousand) in (select twothousand, twothousand from onek);
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/boolean.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/boolean.sql
new file mode 100644
index 000000000000..3a949c834deb
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/boolean.sql
@@ -0,0 +1,281 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- BOOLEAN
+-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/boolean.sql
+
+--
+-- sanity check - if this fails go insane!
+--
+SELECT 1 AS one;
+
+
+-- ******************testing built-in type bool********************
+
+-- check bool input syntax
+
+SELECT true AS true;
+
+-- [SPARK-28349] We do not need to follow PostgreSQL to support reserved words in column alias
+SELECT false AS `false`;
+
+SELECT boolean('t') AS true;
+
+SELECT boolean(' f ') AS `false`;
+
+SELECT boolean('true') AS true;
+
+-- [SPARK-27923] PostgreSQL does not accept 'test' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('test') AS error;
+
+SELECT boolean('false') AS `false`;
+
+-- [SPARK-27923] PostgreSQL does not accept 'foo' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('foo') AS error;
+
+SELECT boolean('y') AS true;
+
+SELECT boolean('yes') AS true;
+
+-- [SPARK-27923] PostgreSQL does not accept 'yeah' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('yeah') AS error;
+
+SELECT boolean('n') AS `false`;
+
+SELECT boolean('no') AS `false`;
+
+-- [SPARK-27923] PostgreSQL does not accept 'nay' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('nay') AS error;
+
+SELECT boolean('on') AS true;
+
+SELECT boolean('off') AS `false`;
+
+SELECT boolean('of') AS `false`;
+
+-- [SPARK-27923] PostgreSQL does not accept 'o' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('o') AS error;
+
+-- [SPARK-27923] PostgreSQL does not accept 'on_' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('on_') AS error;
+
+-- [SPARK-27923] PostgreSQL does not accept 'off_' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('off_') AS error;
+
+SELECT boolean('1') AS true;
+
+-- [SPARK-27923] PostgreSQL does not accept '11' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('11') AS error;
+
+SELECT boolean('0') AS `false`;
+
+-- [SPARK-27923] PostgreSQL does not accept '000' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('000') AS error;
+
+-- [SPARK-27923] PostgreSQL does not accept '' but Spark SQL accepts it and sets it to NULL
+SELECT boolean('') AS error;
+
+-- and, or, not in qualifications
+
+SELECT boolean('t') or boolean('f') AS true;
+
+SELECT boolean('t') and boolean('f') AS `false`;
+
+SELECT not boolean('f') AS true;
+
+SELECT boolean('t') = boolean('f') AS `false`;
+
+SELECT boolean('t') <> boolean('f') AS true;
+
+SELECT boolean('t') > boolean('f') AS true;
+
+SELECT boolean('t') >= boolean('f') AS true;
+
+SELECT boolean('f') < boolean('t') AS true;
+
+SELECT boolean('f') <= boolean('t') AS true;
+
+-- explicit casts to/from text
+SELECT boolean(string('TrUe')) AS true, boolean(string('fAlse')) AS `false`;
+SELECT boolean(string(' true ')) AS true,
+ boolean(string(' FALSE')) AS `false`;
+SELECT string(boolean(true)) AS true, string(boolean(false)) AS `false`;
+
+-- [SPARK-27923] PostgreSQL does not accept ' tru e ' but Spark SQL accepts it and sets it to NULL
+SELECT boolean(string(' tru e ')) AS invalid; -- error
+-- [SPARK-27923] PostgreSQL does not accept '' but Spark SQL accepts it and sets it to NULL
+SELECT boolean(string('')) AS invalid; -- error
+
+CREATE TABLE BOOLTBL1 (f1 boolean) USING parquet;
+
+INSERT INTO BOOLTBL1 VALUES (cast('t' as boolean));
+
+INSERT INTO BOOLTBL1 VALUES (cast('True' as boolean));
+
+INSERT INTO BOOLTBL1 VALUES (cast('true' as boolean));
+
+
+-- BOOLTBL1 should be full of true's at this point
+SELECT '' AS t_3, BOOLTBL1.* FROM BOOLTBL1;
+
+
+SELECT '' AS t_3, BOOLTBL1.*
+ FROM BOOLTBL1
+ WHERE f1 = boolean('true');
+
+
+SELECT '' AS t_3, BOOLTBL1.*
+ FROM BOOLTBL1
+ WHERE f1 <> boolean('false');
+
+SELECT '' AS zero, BOOLTBL1.*
+ FROM BOOLTBL1
+ WHERE booleq(boolean('false'), f1);
+
+INSERT INTO BOOLTBL1 VALUES (boolean('f'));
+
+SELECT '' AS f_1, BOOLTBL1.*
+ FROM BOOLTBL1
+ WHERE f1 = boolean('false');
+
+
+CREATE TABLE BOOLTBL2 (f1 boolean) USING parquet;
+
+INSERT INTO BOOLTBL2 VALUES (boolean('f'));
+
+INSERT INTO BOOLTBL2 VALUES (boolean('false'));
+
+INSERT INTO BOOLTBL2 VALUES (boolean('False'));
+
+INSERT INTO BOOLTBL2 VALUES (boolean('FALSE'));
+
+-- [SPARK-27923] PostgreSQL does not accept 'XXX' but Spark SQL accepts it and sets it to NULL
+-- This is now an invalid expression
+-- For pre-v6.3 this evaluated to false - thomas 1997-10-23
+INSERT INTO BOOLTBL2
+ VALUES (boolean('XXX'));
+
+-- BOOLTBL2 should be full of false's at this point
+SELECT '' AS f_4, BOOLTBL2.* FROM BOOLTBL2;
+
+
+SELECT '' AS tf_12, BOOLTBL1.*, BOOLTBL2.*
+ FROM BOOLTBL1, BOOLTBL2
+ WHERE BOOLTBL2.f1 <> BOOLTBL1.f1;
+
+
+SELECT '' AS tf_12, BOOLTBL1.*, BOOLTBL2.*
+ FROM BOOLTBL1, BOOLTBL2
+ WHERE boolne(BOOLTBL2.f1,BOOLTBL1.f1);
+
+
+SELECT '' AS ff_4, BOOLTBL1.*, BOOLTBL2.*
+ FROM BOOLTBL1, BOOLTBL2
+ WHERE BOOLTBL2.f1 = BOOLTBL1.f1 and BOOLTBL1.f1 = boolean('false');
+
+
+SELECT '' AS tf_12_ff_4, BOOLTBL1.*, BOOLTBL2.*
+ FROM BOOLTBL1, BOOLTBL2
+ WHERE BOOLTBL2.f1 = BOOLTBL1.f1 or BOOLTBL1.f1 = boolean('true')
+ ORDER BY BOOLTBL1.f1, BOOLTBL2.f1;
+
+-- [SPARK-27924] E061-14: Search Conditions
+--
+-- SQL syntax
+-- Try all combinations to ensure that we get nothing when we expect nothing
+-- - thomas 2000-01-04
+--
+
+SELECT '' AS True, f1
+ FROM BOOLTBL1
+ WHERE f1 IS TRUE;
+
+SELECT '' AS `Not False`, f1
+ FROM BOOLTBL1
+ WHERE f1 IS NOT FALSE;
+
+SELECT '' AS `False`, f1
+ FROM BOOLTBL1
+ WHERE f1 IS FALSE;
+
+SELECT '' AS `Not True`, f1
+ FROM BOOLTBL1
+ WHERE f1 IS NOT TRUE;
+
+SELECT '' AS `True`, f1
+ FROM BOOLTBL2
+ WHERE f1 IS TRUE;
+
+SELECT '' AS `Not False`, f1
+ FROM BOOLTBL2
+ WHERE f1 IS NOT FALSE;
+
+SELECT '' AS `False`, f1
+ FROM BOOLTBL2
+ WHERE f1 IS FALSE;
+
+SELECT '' AS `Not True`, f1
+ FROM BOOLTBL2
+ WHERE f1 IS NOT TRUE;
+
+--
+-- Tests for BooleanTest
+--
+CREATE TABLE BOOLTBL3 (d string, b boolean, o int) USING parquet;
+INSERT INTO BOOLTBL3 VALUES ('true', true, 1);
+INSERT INTO BOOLTBL3 VALUES ('false', false, 2);
+INSERT INTO BOOLTBL3 VALUES ('null', null, 3);
+
+-- [SPARK-27924] E061-14: Search Conditions
+SELECT
+ d,
+ b IS TRUE AS istrue,
+ b IS NOT TRUE AS isnottrue,
+ b IS FALSE AS isfalse,
+ b IS NOT FALSE AS isnotfalse,
+ b IS UNKNOWN AS isunknown,
+ b IS NOT UNKNOWN AS isnotunknown
+FROM booltbl3 ORDER BY o;
+
+
+-- Test to make sure short-circuiting and NULL handling is
+-- correct. Use a table as source to prevent constant simplification
+-- to interfer.
+CREATE TABLE booltbl4(isfalse boolean, istrue boolean, isnul boolean) USING parquet;
+INSERT INTO booltbl4 VALUES (false, true, null);
+-- \pset null '(null)'
+
+-- AND expression need to return null if there's any nulls and not all
+-- of the value are true
+SELECT istrue AND isnul AND istrue FROM booltbl4;
+SELECT istrue AND istrue AND isnul FROM booltbl4;
+SELECT isnul AND istrue AND istrue FROM booltbl4;
+SELECT isfalse AND isnul AND istrue FROM booltbl4;
+SELECT istrue AND isfalse AND isnul FROM booltbl4;
+SELECT isnul AND istrue AND isfalse FROM booltbl4;
+
+-- OR expression need to return null if there's any nulls and none
+-- of the value is true
+SELECT isfalse OR isnul OR isfalse FROM booltbl4;
+SELECT isfalse OR isfalse OR isnul FROM booltbl4;
+SELECT isnul OR isfalse OR isfalse FROM booltbl4;
+SELECT isfalse OR isnul OR istrue FROM booltbl4;
+SELECT istrue OR isfalse OR isnul FROM booltbl4;
+SELECT isnul OR istrue OR isfalse FROM booltbl4;
+
+
+--
+-- Clean up
+-- Many tables are retained by the regression test, but these do not seem
+-- particularly useful so just get rid of them for now.
+-- - thomas 1997-11-30
+--
+
+DROP TABLE BOOLTBL1;
+
+DROP TABLE BOOLTBL2;
+
+DROP TABLE BOOLTBL3;
+
+DROP TABLE BOOLTBL4;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/case.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/case.sql
new file mode 100644
index 000000000000..e8129b8cfaf6
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/case.sql
@@ -0,0 +1,262 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- CASE
+-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/case.sql
+-- Test the CASE statement
+--
+CREATE TABLE CASE_TBL (
+ i integer,
+ f double
+) USING parquet;
+
+CREATE TABLE CASE2_TBL (
+ i integer,
+ j integer
+) USING parquet;
+
+INSERT INTO CASE_TBL VALUES (1, 10.1);
+INSERT INTO CASE_TBL VALUES (2, 20.2);
+INSERT INTO CASE_TBL VALUES (3, -30.3);
+INSERT INTO CASE_TBL VALUES (4, NULL);
+
+INSERT INTO CASE2_TBL VALUES (1, -1);
+INSERT INTO CASE2_TBL VALUES (2, -2);
+INSERT INTO CASE2_TBL VALUES (3, -3);
+INSERT INTO CASE2_TBL VALUES (2, -4);
+INSERT INTO CASE2_TBL VALUES (1, NULL);
+INSERT INTO CASE2_TBL VALUES (NULL, -6);
+
+--
+-- Simplest examples without tables
+--
+
+SELECT '3' AS `One`,
+ CASE
+ WHEN 1 < 2 THEN 3
+ END AS `Simple WHEN`;
+
+SELECT '' AS `One`,
+ CASE
+ WHEN 1 > 2 THEN 3
+ END AS `Simple default`;
+
+SELECT '3' AS `One`,
+ CASE
+ WHEN 1 < 2 THEN 3
+ ELSE 4
+ END AS `Simple ELSE`;
+
+SELECT '4' AS `One`,
+ CASE
+ WHEN 1 > 2 THEN 3
+ ELSE 4
+ END AS `ELSE default`;
+
+SELECT '6' AS `One`,
+ CASE
+ WHEN 1 > 2 THEN 3
+ WHEN 4 < 5 THEN 6
+ ELSE 7
+ END AS `Two WHEN with default`;
+
+SELECT '7' AS `None`,
+ CASE WHEN rand() < 0 THEN 1
+ END AS `NULL on no matches`;
+
+-- Constant-expression folding shouldn't evaluate unreachable subexpressions
+SELECT CASE WHEN 1=0 THEN 1/0 WHEN 1=1 THEN 1 ELSE 2/0 END;
+SELECT CASE 1 WHEN 0 THEN 1/0 WHEN 1 THEN 1 ELSE 2/0 END;
+
+-- However we do not currently suppress folding of potentially
+-- reachable subexpressions
+SELECT CASE WHEN i > 100 THEN 1/0 ELSE 0 END FROM case_tbl;
+
+-- Test for cases involving untyped literals in test expression
+SELECT CASE 'a' WHEN 'a' THEN 1 ELSE 2 END;
+
+--
+-- Examples of targets involving tables
+--
+
+SELECT '' AS `Five`,
+ CASE
+ WHEN i >= 3 THEN i
+ END AS `>= 3 or Null`
+ FROM CASE_TBL;
+
+SELECT '' AS `Five`,
+ CASE WHEN i >= 3 THEN (i + i)
+ ELSE i
+ END AS `Simplest Math`
+ FROM CASE_TBL;
+
+SELECT '' AS `Five`, i AS `Value`,
+ CASE WHEN (i < 0) THEN 'small'
+ WHEN (i = 0) THEN 'zero'
+ WHEN (i = 1) THEN 'one'
+ WHEN (i = 2) THEN 'two'
+ ELSE 'big'
+ END AS `Category`
+ FROM CASE_TBL;
+
+SELECT '' AS `Five`,
+ CASE WHEN ((i < 0) or (i < 0)) THEN 'small'
+ WHEN ((i = 0) or (i = 0)) THEN 'zero'
+ WHEN ((i = 1) or (i = 1)) THEN 'one'
+ WHEN ((i = 2) or (i = 2)) THEN 'two'
+ ELSE 'big'
+ END AS `Category`
+ FROM CASE_TBL;
+
+--
+-- Examples of qualifications involving tables
+--
+
+--
+-- NULLIF() and COALESCE()
+-- Shorthand forms for typical CASE constructs
+-- defined in the SQL standard.
+--
+
+SELECT * FROM CASE_TBL WHERE COALESCE(f,i) = 4;
+
+SELECT * FROM CASE_TBL WHERE NULLIF(f,i) = 2;
+
+SELECT COALESCE(a.f, b.i, b.j)
+ FROM CASE_TBL a, CASE2_TBL b;
+
+SELECT *
+ FROM CASE_TBL a, CASE2_TBL b
+ WHERE COALESCE(a.f, b.i, b.j) = 2;
+
+SELECT '' AS Five, NULLIF(a.i,b.i) AS `NULLIF(a.i,b.i)`,
+ NULLIF(b.i, 4) AS `NULLIF(b.i,4)`
+ FROM CASE_TBL a, CASE2_TBL b;
+
+SELECT '' AS `Two`, *
+ FROM CASE_TBL a, CASE2_TBL b
+ WHERE COALESCE(f,b.i) = 2;
+
+-- We don't support update now.
+--
+-- Examples of updates involving tables
+--
+
+-- UPDATE CASE_TBL
+-- SET i = CASE WHEN i >= 3 THEN (- i)
+-- ELSE (2 * i) END;
+
+-- SELECT * FROM CASE_TBL;
+
+-- UPDATE CASE_TBL
+-- SET i = CASE WHEN i >= 2 THEN (2 * i)
+-- ELSE (3 * i) END;
+
+-- SELECT * FROM CASE_TBL;
+
+-- UPDATE CASE_TBL
+-- SET i = CASE WHEN b.i >= 2 THEN (2 * j)
+-- ELSE (3 * j) END
+-- FROM CASE2_TBL b
+-- WHERE j = -CASE_TBL.i;
+
+-- SELECT * FROM CASE_TBL;
+
+--
+-- Nested CASE expressions
+--
+
+-- This test exercises a bug caused by aliasing econtext->caseValue_isNull
+-- with the isNull argument of the inner CASE's CaseExpr evaluation. After
+-- evaluating the vol(null) expression in the inner CASE's second WHEN-clause,
+-- the isNull flag for the case test value incorrectly became true, causing
+-- the third WHEN-clause not to match. The volatile function calls are needed
+-- to prevent constant-folding in the planner, which would hide the bug.
+
+-- Wrap this in a single transaction so the transient '=' operator doesn't
+-- cause problems in concurrent sessions
+-- BEGIN;
+
+-- CREATE FUNCTION vol(text) returns text as
+-- 'begin return $1; end' language plpgsql volatile;
+
+SELECT CASE
+ (CASE vol('bar')
+ WHEN 'foo' THEN 'it was foo!'
+ WHEN vol(null) THEN 'null input'
+ WHEN 'bar' THEN 'it was bar!' END
+ )
+ WHEN 'it was foo!' THEN 'foo recognized'
+ WHEN 'it was bar!' THEN 'bar recognized'
+ ELSE 'unrecognized' END;
+
+-- We don't support the features below:
+-- 1. CREATE DOMAIN ...
+-- 2. CREATE OPERATOR ...
+-- 3. CREATE TYPE ...
+
+-- In this case, we can't inline the SQL function without confusing things.
+-- CREATE DOMAIN foodomain AS text;
+
+-- CREATE FUNCTION volfoo(text) returns foodomain as
+-- 'begin return $1::foodomain; end' language plpgsql volatile;
+
+-- CREATE FUNCTION inline_eq(foodomain, foodomain) returns boolean as
+-- 'SELECT CASE $2::text WHEN $1::text THEN true ELSE false END' language sql;
+
+-- CREATE OPERATOR = (procedure = inline_eq,
+-- leftarg = foodomain, rightarg = foodomain);
+
+-- SELECT CASE volfoo('bar') WHEN 'foo'::foodomain THEN 'is foo' ELSE 'is not foo' END;
+
+-- ROLLBACK;
+
+-- Test multiple evaluation of a CASE arg that is a read/write object (#14472)
+-- Wrap this in a single transaction so the transient '=' operator doesn't
+-- cause problems in concurrent sessions
+-- BEGIN;
+
+-- CREATE DOMAIN arrdomain AS int[];
+
+-- CREATE FUNCTION make_ad(int,int) returns arrdomain as
+-- 'declare x arrdomain;
+-- begin
+-- x := array[$1,$2];
+-- return x;
+-- end' language plpgsql volatile;
+
+-- CREATE FUNCTION ad_eq(arrdomain, arrdomain) returns boolean as
+-- 'begin return array_eq($1, $2); end' language plpgsql;
+
+-- CREATE OPERATOR = (procedure = ad_eq,
+-- leftarg = arrdomain, rightarg = arrdomain);
+
+-- SELECT CASE make_ad(1,2)
+-- WHEN array[2,4]::arrdomain THEN 'wrong'
+-- WHEN array[2,5]::arrdomain THEN 'still wrong'
+-- WHEN array[1,2]::arrdomain THEN 'right'
+-- END;
+
+-- ROLLBACK;
+
+-- Test interaction of CASE with ArrayCoerceExpr (bug #15471)
+-- BEGIN;
+
+-- CREATE TYPE casetestenum AS ENUM ('e', 'f', 'g');
+
+-- SELECT
+-- CASE 'foo'::text
+-- WHEN 'foo' THEN ARRAY['a', 'b', 'c', 'd'] || enum_range(NULL::casetestenum)::text[]
+-- ELSE ARRAY['x', 'y']
+-- END;
+
+-- ROLLBACK;
+
+--
+-- Clean up
+--
+
+DROP TABLE CASE_TBL;
+DROP TABLE CASE2_TBL;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/comments.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/comments.sql
new file mode 100644
index 000000000000..b4614bf2e469
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/comments.sql
@@ -0,0 +1,49 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- COMMENTS
+-- https://github.com/postgres/postgres/blob/REL_12_BETA3/src/test/regress/sql/comments.sql
+--
+
+SELECT 'trailing' AS first; -- trailing single line
+SELECT /* embedded single line */ 'embedded' AS `second`;
+SELECT /* both embedded and trailing single line */ 'both' AS third; -- trailing single line
+
+SELECT 'before multi-line' AS fourth;
+--QUERY-DELIMITER-START
+/* This is an example of SQL which should not execute:
+ * select 'multi-line';
+ */
+SELECT 'after multi-line' AS fifth;
+--QUERY-DELIMITER-END
+
+--
+-- Nested comments
+--
+--QUERY-DELIMITER-START
+/*
+SELECT 'trailing' as x1; -- inside block comment
+*/
+
+/* This block comment surrounds a query which itself has a block comment...
+SELECT /* embedded single line */ 'embedded' AS x2;
+*/
+
+SELECT -- continued after the following block comments...
+/* Deeply nested comment.
+ This includes a single apostrophe to make sure we aren't decoding this part as a string.
+SELECT 'deep nest' AS n1;
+/* Second level of nesting...
+SELECT 'deeper nest' as n2;
+/* Third level of nesting...
+SELECT 'deepest nest' as n3;
+*/
+Hoo boy. Still two deep...
+*/
+Now just one deep...
+*/
+'deeply nested example' AS sixth;
+--QUERY-DELIMITER-END
+-- [SPARK-30824] Support submit sql content only contains comments.
+-- /* and this is the end of the file */
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/create_view.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/create_view.sql
new file mode 100644
index 000000000000..2889941c1fcc
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/create_view.sql
@@ -0,0 +1,779 @@
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+-- CREATE VIEW
+-- https://github.com/postgres/postgres/blob/REL_12_STABLE/src/test/regress/sql/create_view.sql
+
+-- [SPARK-27764] Support geometric types
+-- CREATE VIEW street AS
+-- SELECT r.name, r.thepath, c.cname AS cname
+-- FROM ONLY road r, real_city c
+-- WHERE c.outline ## r.thepath;
+
+-- [SPARK-27764] Support geometric types
+-- CREATE VIEW iexit AS
+-- SELECT ih.name, ih.thepath,
+-- interpt_pp(ih.thepath, r.thepath) AS exit
+-- FROM ihighway ih, ramp r
+-- WHERE ih.thepath ## r.thepath;
+
+CREATE TABLE emp (
+ name string,
+ age int,
+ -- [SPARK-27764] Support geometric types
+ -- location point
+ salary int,
+ manager string
+) USING parquet;
+
+CREATE VIEW toyemp AS
+ SELECT name, age, /* location ,*/ 12*salary AS annualsal
+ FROM emp;
+
+-- [SPARK-29659] Support COMMENT ON syntax
+-- Test comments
+-- COMMENT ON VIEW noview IS 'no view';
+-- COMMENT ON VIEW toyemp IS 'is a view';
+-- COMMENT ON VIEW toyemp IS NULL;
+
+DROP VIEW toyemp;
+DROP TABLE emp;
+
+-- These views are left around mainly to exercise special cases in pg_dump.
+
+-- [SPARK-19842] Informational Referential Integrity Constraints Support in Spark
+CREATE TABLE view_base_table (key int /* PRIMARY KEY */, data varchar(20)) USING PARQUET;
+--
+CREATE VIEW key_dependent_view AS
+ SELECT * FROM view_base_table GROUP BY key;
+--
+-- [SPARK-19842] Informational Referential Integrity Constraints Support in Spark
+-- ALTER TABLE view_base_table DROP CONSTRAINT view_base_table_pkey; -- fails
+
+CREATE VIEW key_dependent_view_no_cols AS
+ SELECT FROM view_base_table GROUP BY key HAVING length(data) > 0;
+
+--
+-- CREATE OR REPLACE VIEW
+--
+
+CREATE TABLE viewtest_tbl (a int, b int) using parquet;
+-- [SPARK-29386] Copy data between a file and a table
+-- COPY viewtest_tbl FROM stdin;
+-- 5 10
+-- 10 15
+-- 15 20
+-- 20 25
+-- \.
+INSERT INTO viewtest_tbl VALUES (5, 10), (10, 15), (15, 20), (20, 25);
+
+CREATE OR REPLACE VIEW viewtest AS
+ SELECT * FROM viewtest_tbl;
+
+CREATE OR REPLACE VIEW viewtest AS
+ SELECT * FROM viewtest_tbl WHERE a > 10;
+
+SELECT * FROM viewtest;
+
+CREATE OR REPLACE VIEW viewtest AS
+ SELECT a, b FROM viewtest_tbl WHERE a > 5 ORDER BY b DESC;
+
+SELECT * FROM viewtest;
+
+-- should fail
+-- [SPARK-29660] Dropping columns and changing column names/types are prohibited in VIEW definition
+CREATE OR REPLACE VIEW viewtest AS
+ SELECT a FROM viewtest_tbl WHERE a <> 20;
+
+-- should fail
+-- [SPARK-29660] Dropping columns and changing column names/types are prohibited in VIEW definition
+CREATE OR REPLACE VIEW viewtest AS
+ SELECT 1, * FROM viewtest_tbl;
+
+-- should fail
+-- [SPARK-29660] Dropping columns and changing column names/types are prohibited in VIEW definition
+CREATE OR REPLACE VIEW viewtest AS
+ SELECT a, decimal(b) FROM viewtest_tbl;
+
+-- should work
+CREATE OR REPLACE VIEW viewtest AS
+ SELECT a, b, 0 AS c FROM viewtest_tbl;
+
+DROP VIEW viewtest;
+DROP TABLE viewtest_tbl;
+
+-- tests for temporary views
+
+-- [SPARK-29661] Support cascaded syntax in CREATE SCHEMA
+-- CREATE SCHEMA temp_view_test
+-- CREATE TABLE base_table (a int, id int) using parquet
+-- CREATE TABLE base_table2 (a int, id int) using parquet;
+CREATE SCHEMA temp_view_test;
+CREATE TABLE temp_view_test.base_table (a int, id int) using parquet;
+CREATE TABLE temp_view_test.base_table2 (a int, id int) using parquet;
+
+-- Replace SET with USE
+-- SET search_path TO temp_view_test, public;
+USE temp_view_test;
+
+-- Since Spark doesn't support CREATE TEMPORARY TABLE, we used CREATE TEMPORARY VIEW instead
+-- CREATE TEMPORARY TABLE temp_table (a int, id int);
+CREATE TEMPORARY VIEW temp_table AS SELECT * FROM VALUES
+ (1, 1) as temp_table(a, id);
+
+-- should be created in temp_view_test schema
+CREATE VIEW v1 AS SELECT * FROM base_table;
+DESC TABLE EXTENDED v1;
+-- should be created in temp object schema
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW v1_temp AS SELECT * FROM temp_table;
+-- should be created in temp object schema
+CREATE TEMP VIEW v2_temp AS SELECT * FROM base_table;
+DESC TABLE EXTENDED v2_temp;
+-- should be created in temp_views schema
+CREATE VIEW temp_view_test.v2 AS SELECT * FROM base_table;
+DESC TABLE EXTENDED temp_view_test.v2;
+-- should fail
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW temp_view_test.v3_temp AS SELECT * FROM temp_table;
+-- should fail
+-- [SPARK-29661] Support cascaded syntax in CREATE SCHEMA
+-- CREATE SCHEMA test_view_schema
+-- CREATE TEMP VIEW testview AS SELECT 1;
+
+-- joins: if any of the join relations are temporary, the view
+-- should also be temporary
+
+-- should be non-temp
+CREATE VIEW v3 AS
+ SELECT t1.a AS t1_a, t2.a AS t2_a
+ FROM base_table t1, base_table2 t2
+ WHERE t1.id = t2.id;
+DESC TABLE EXTENDED v3;
+-- should be temp (one join rel is temp)
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW v4_temp AS
+ SELECT t1.a AS t1_a, t2.a AS t2_a
+ FROM base_table t1, temp_table t2
+ WHERE t1.id = t2.id;
+-- should be temp
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW v5_temp AS
+ SELECT t1.a AS t1_a, t2.a AS t2_a, t3.a AS t3_a
+ FROM base_table t1, base_table2 t2, temp_table t3
+ WHERE t1.id = t2.id and t2.id = t3.id;
+
+-- subqueries
+CREATE VIEW v4 AS SELECT * FROM base_table WHERE id IN (SELECT id FROM base_table2);
+DESC TABLE EXTENDED v4;
+CREATE VIEW v5 AS SELECT t1.id, t2.a FROM base_table t1, (SELECT * FROM base_table2) t2;
+DESC TABLE EXTENDED v5;
+CREATE VIEW v6 AS SELECT * FROM base_table WHERE EXISTS (SELECT 1 FROM base_table2);
+DESC TABLE EXTENDED v6;
+CREATE VIEW v7 AS SELECT * FROM base_table WHERE NOT EXISTS (SELECT 1 FROM base_table2);
+DESC TABLE EXTENDED v7;
+CREATE VIEW v8 AS SELECT * FROM base_table WHERE EXISTS (SELECT 1);
+DESC TABLE EXTENDED v8;
+
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW v6_temp AS SELECT * FROM base_table WHERE id IN (SELECT id FROM temp_table);
+CREATE VIEW v7_temp AS SELECT t1.id, t2.a FROM base_table t1, (SELECT * FROM temp_table) t2;
+CREATE VIEW v8_temp AS SELECT * FROM base_table WHERE EXISTS (SELECT 1 FROM temp_table);
+CREATE VIEW v9_temp AS SELECT * FROM base_table WHERE NOT EXISTS (SELECT 1 FROM temp_table);
+
+-- a view should also be temporary if it references a temporary view
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW v10_temp AS SELECT * FROM v7_temp;
+CREATE VIEW v11_temp AS SELECT t1.id, t2.a FROM base_table t1, v10_temp t2;
+CREATE VIEW v12_temp AS SELECT true FROM v11_temp;
+
+-- [SPARK-27764] Support ANSI SQL CREATE SEQUENCE
+-- a view should also be temporary if it references a temporary sequence
+-- CREATE SEQUENCE seq1;
+-- CREATE TEMPORARY SEQUENCE seq1_temp;
+-- CREATE VIEW v9 AS SELECT seq1.is_called FROM seq1;
+-- CREATE VIEW v13_temp AS SELECT seq1_temp.is_called FROM seq1_temp;
+
+-- Skip the tests below because of PostgreSQL specific cases
+-- SELECT relname FROM pg_class
+-- WHERE relname LIKE 'v_'
+-- AND relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'temp_view_test')
+-- ORDER BY relname;
+-- SELECT relname FROM pg_class
+-- WHERE relname LIKE 'v%'
+-- AND relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname LIKE 'pg_temp%')
+-- ORDER BY relname;
+
+CREATE SCHEMA testviewschm2;
+-- Replace SET with USE
+-- SET search_path TO testviewschm2, public;
+USE testviewschm2;
+
+CREATE TABLE t1 (num int, name string) using parquet;
+CREATE TABLE t2 (num2 int, value string) using parquet;
+-- Since Spark doesn't support CREATE TEMPORARY TABLE, we used CREATE TEMPORARY VIEW instead
+-- CREATE TEMP TABLE tt (num2 int, value string);
+CREATE TEMP VIEW tt AS SELECT * FROM VALUES
+ (1, 'a') AS tt(num2, value);
+
+CREATE VIEW nontemp1 AS SELECT * FROM t1 CROSS JOIN t2;
+DESC TABLE EXTENDED nontemp1;
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW temporal1 AS SELECT * FROM t1 CROSS JOIN tt;
+CREATE VIEW nontemp2 AS SELECT * FROM t1 INNER JOIN t2 ON t1.num = t2.num2;
+DESC TABLE EXTENDED nontemp2;
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW temporal2 AS SELECT * FROM t1 INNER JOIN tt ON t1.num = tt.num2;
+CREATE VIEW nontemp3 AS SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num2;
+DESC TABLE EXTENDED nontemp3;
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW temporal3 AS SELECT * FROM t1 LEFT JOIN tt ON t1.num = tt.num2;
+CREATE VIEW nontemp4 AS SELECT * FROM t1 LEFT JOIN t2 ON t1.num = t2.num2 AND t2.value = 'xxx';
+DESC TABLE EXTENDED nontemp4;
+-- [SPARK-29628] Forcibly create a temporary view in CREATE VIEW if referencing a temporary view
+CREATE VIEW temporal4 AS SELECT * FROM t1 LEFT JOIN tt ON t1.num = tt.num2 AND tt.value = 'xxx';
+CREATE VIEW temporal5 AS SELECT * FROM t1 WHERE num IN (SELECT num FROM t1 WHERE EXISTS (SELECT 1 FROM tt));
+
+-- Skip the tests below because of PostgreSQL specific cases
+-- SELECT relname FROM pg_class
+-- WHERE relname LIKE 'nontemp%'
+-- AND relnamespace = (SELECT oid FROM pg_namespace WHERE nspname = 'testviewschm2')
+-- ORDER BY relname;
+-- SELECT relname FROM pg_class
+-- WHERE relname LIKE 'temporal%'
+-- AND relnamespace IN (SELECT oid FROM pg_namespace WHERE nspname LIKE 'pg_temp%')
+-- ORDER BY relname;
+
+CREATE TABLE tbl1 ( a int, b int) using parquet;
+CREATE TABLE tbl2 (c int, d int) using parquet;
+CREATE TABLE tbl3 (e int, f int) using parquet;
+CREATE TABLE tbl4 (g int, h int) using parquet;
+-- Since Spark doesn't support CREATE TEMPORARY TABLE, we used CREATE TABLE instead
+-- CREATE TEMP TABLE tmptbl (i int, j int);
+CREATE TABLE tmptbl (i int, j int) using parquet;
+INSERT INTO tmptbl VALUES (1, 1);
+
+--Should be in testviewschm2
+CREATE VIEW pubview AS SELECT * FROM tbl1 WHERE tbl1.a
+BETWEEN (SELECT d FROM tbl2 WHERE c = 1) AND (SELECT e FROM tbl3 WHERE f = 2)
+AND EXISTS (SELECT g FROM tbl4 LEFT JOIN tbl3 ON tbl4.h = tbl3.f);
+DESC TABLE EXTENDED pubview;
+
+-- Skip the test below because of PostgreSQL specific cases
+-- SELECT count(*) FROM pg_class where relname = 'pubview'
+-- AND relnamespace IN (SELECT OID FROM pg_namespace WHERE nspname = 'testviewschm2');
+
+--Should be in temp object schema
+CREATE VIEW mytempview AS SELECT * FROM tbl1 WHERE tbl1.a
+BETWEEN (SELECT d FROM tbl2 WHERE c = 1) AND (SELECT e FROM tbl3 WHERE f = 2)
+AND EXISTS (SELECT g FROM tbl4 LEFT JOIN tbl3 ON tbl4.h = tbl3.f)
+AND NOT EXISTS (SELECT g FROM tbl4 LEFT JOIN tmptbl ON tbl4.h = tmptbl.j);
+DESC TABLE EXTENDED mytempview;
+
+-- Skip the test below because of PostgreSQL specific cases
+-- SELECT count(*) FROM pg_class where relname LIKE 'mytempview'
+-- And relnamespace IN (SELECT OID FROM pg_namespace WHERE nspname LIKE 'pg_temp%');
+
+--
+-- CREATE VIEW and WITH(...) clause
+-- CREATE VIEW mysecview1
+-- AS SELECT * FROM tbl1 WHERE a = 0;
+--
+-- Skip the tests below because Spark doesn't support `WITH options`
+-- CREATE VIEW mysecview2 WITH (security_barrier=true)
+-- AS SELECT * FROM tbl1 WHERE a > 0;
+-- CREATE VIEW mysecview3 WITH (security_barrier=false)
+-- AS SELECT * FROM tbl1 WHERE a < 0;
+-- CREATE VIEW mysecview4 WITH (security_barrier)
+-- AS SELECT * FROM tbl1 WHERE a <> 0;
+-- Spark cannot support options in WITH clause
+-- CREATE VIEW mysecview5 WITH (security_barrier=100) -- Error
+-- AS SELECT * FROM tbl1 WHERE a > 100;
+-- CREATE VIEW mysecview6 WITH (invalid_option) -- Error
+-- AS SELECT * FROM tbl1 WHERE a < 100;
+-- Skip the test below because of PostgreSQL specific cases
+-- SELECT relname, relkind, reloptions FROM pg_class
+-- WHERE oid in ('mysecview1'::regclass, 'mysecview2'::regclass,
+-- 'mysecview3'::regclass, 'mysecview4'::regclass)
+-- ORDER BY relname;
+
+-- CREATE OR REPLACE VIEW mysecview1
+-- AS SELECT * FROM tbl1 WHERE a = 256;
+-- CREATE OR REPLACE VIEW mysecview2
+-- AS SELECT * FROM tbl1 WHERE a > 256;
+-- CREATE OR REPLACE VIEW mysecview3 WITH (security_barrier=true)
+-- AS SELECT * FROM tbl1 WHERE a < 256;
+-- CREATE OR REPLACE VIEW mysecview4 WITH (security_barrier=false)
+-- AS SELECT * FROM tbl1 WHERE a <> 256;
+-- Skip the test below because of PostgreSQL specific cases
+-- SELECT relname, relkind, reloptions FROM pg_class
+-- WHERE oid in ('mysecview1'::regclass, 'mysecview2'::regclass,
+-- 'mysecview3'::regclass, 'mysecview4'::regclass)
+-- ORDER BY relname;
+
+-- Check that unknown literals are converted to "text" in CREATE VIEW,
+-- so that we don't end up with unknown-type columns.
+
+-- Skip the tests below because of PostgreSQL specific cases
+-- CREATE VIEW unspecified_types AS
+-- SELECT 42 as i, 42.5 as num, 'foo' as u, 'foo'::unknown as u2, null as n;
+-- \d+ unspecified_types
+-- SELECT * FROM unspecified_types;
+
+-- This test checks that proper typmods are assigned in a multi-row VALUES
+
+CREATE VIEW tt1 AS
+ SELECT * FROM (
+ VALUES
+ ('abc', '0123456789', 42, 'abcd'),
+ ('0123456789', 'abc', 42.12, 'abc')
+ ) vv(a,b,c,d);
+-- Replace the PostgreSQL meta command `\d` with `DESC`
+-- \d+ tt1
+SELECT * FROM tt1;
+SELECT string(a) FROM tt1;
+DROP VIEW tt1;
+
+-- Test view decompilation in the face of relation renaming conflicts
+
+CREATE TABLE tt1 (f1 int, f2 int, f3 string) using parquet;
+CREATE TABLE tx1 (x1 int, x2 int, x3 string) using parquet;
+CREATE TABLE temp_view_test.tt1 (y1 int, f2 int, f3 string) using parquet;
+
+CREATE VIEW aliased_view_1 AS
+ select * from tt1
+ where exists (select 1 from tx1 where tt1.f1 = tx1.x1);
+CREATE VIEW aliased_view_2 AS
+ select * from tt1 a1
+ where exists (select 1 from tx1 where a1.f1 = tx1.x1);
+CREATE VIEW aliased_view_3 AS
+ select * from tt1
+ where exists (select 1 from tx1 a2 where tt1.f1 = a2.x1);
+CREATE VIEW aliased_view_4 AS
+ select * from temp_view_test.tt1
+ where exists (select 1 from tt1 where temp_view_test.tt1.y1 = tt1.f1);
+
+-- Replace the PostgreSQL meta command `\d` with `DESC`
+-- \d+ aliased_view_1
+DESC TABLE aliased_view_1;
+-- \d+ aliased_view_2
+DESC TABLE aliased_view_2;
+-- \d+ aliased_view_3
+DESC TABLE aliased_view_3;
+-- \d+ aliased_view_4
+DESC TABLE aliased_view_4;
+
+ALTER TABLE tx1 RENAME TO a1;
+
+-- Replace the PostgreSQL meta command `\d` with `DESC`
+-- \d+ aliased_view_1
+DESC TABLE aliased_view_1;
+-- \d+ aliased_view_2
+DESC TABLE aliased_view_2;
+-- \d+ aliased_view_3
+DESC TABLE aliased_view_3;
+-- \d+ aliased_view_4
+DESC TABLE aliased_view_4;
+
+ALTER TABLE tt1 RENAME TO a2;
+
+-- Replace the PostgreSQL meta command `\d` with `DESC`
+-- \d+ aliased_view_1
+DESC TABLE aliased_view_1;
+-- \d+ aliased_view_2
+DESC TABLE aliased_view_2;
+-- \d+ aliased_view_3
+DESC TABLE aliased_view_3;
+-- \d+ aliased_view_4
+DESC TABLE aliased_view_4;
+
+ALTER TABLE a1 RENAME TO tt1;
+
+-- Replace the PostgreSQL meta command `\d` with `DESC`
+-- \d+ aliased_view_1
+DESC TABLE aliased_view_1;
+-- \d+ aliased_view_2
+DESC TABLE aliased_view_2;
+-- \d+ aliased_view_3
+DESC TABLE aliased_view_3;
+-- \d+ aliased_view_4
+DESC TABLE aliased_view_4;
+
+ALTER TABLE a2 RENAME TO tx1;
+-- [SPARK-29632] Support ALTER TABLE [relname] SET SCHEMA [dbname]
+-- ALTER TABLE tx1 SET SCHEMA temp_view_test;
+
+-- \d+ aliased_view_1
+-- \d+ aliased_view_2
+-- \d+ aliased_view_3
+-- \d+ aliased_view_4
+
+-- [SPARK-29632] Support ALTER TABLE [relname] SET SCHEMA [dbname]
+-- ALTER TABLE temp_view_test.tt1 RENAME TO tmp1;
+-- ALTER TABLE temp_view_test.tmp1 SET SCHEMA testviewschm2;
+-- ALTER TABLE tmp1 RENAME TO tx1;
+
+-- Replace the PostgreSQL meta command `\d` with `DESC`
+-- \d+ aliased_view_1
+-- \d+ aliased_view_2
+-- \d+ aliased_view_3
+-- \d+ aliased_view_4
+
+-- Test aliasing of joins
+
+create view view_of_joins as
+select * from
+ (select * from (tbl1 cross join tbl2) same) ss,
+ (tbl3 cross join tbl4) same;
+
+-- Replace the PostgreSQL meta command `\d` with `DESC`
+-- \d+ view_of_joins
+
+-- Test view decompilation in the face of column addition/deletion/renaming
+
+create table tt2 (a int, b int, c int) using parquet;
+create table tt3 (ax bigint, b short, c decimal) using parquet;
+create table tt4 (ay int, b int, q int) using parquet;
+
+create view v1 as select * from tt2 natural join tt3;
+create view v1a as select * from (tt2 natural join tt3) j;
+create view v2 as select * from tt2 join tt3 using (b,c) join tt4 using (b);
+create view v2a as select * from (tt2 join tt3 using (b,c) join tt4 using (b)) j;
+create view v3 as select * from tt2 join tt3 using (b,c) full join tt4 using (b);
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('v1', true);
+DESC TABLE v1;
+-- select pg_get_viewdef('v1a', true);
+DESC TABLE v1a;
+-- select pg_get_viewdef('v2', true);
+DESC TABLE v2;
+-- select pg_get_viewdef('v2a', true);
+DESC TABLE v2a;
+-- select pg_get_viewdef('v3', true);
+DESC TABLE v3;
+
+alter table tt2 add column d int;
+alter table tt2 add column e int;
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('v1', true);
+DESC TABLE v1;
+-- select pg_get_viewdef('v1a', true);
+DESC TABLE v1a;
+-- select pg_get_viewdef('v2', true);
+DESC TABLE v2;
+-- select pg_get_viewdef('v2a', true);
+DESC TABLE v2a;
+-- select pg_get_viewdef('v3', true);
+DESC TABLE v3;
+
+-- [SPARK-27764] Make COLUMN optional in ALTER TABLE
+-- [SPARK-27589] Spark file source V2 (For supporting RENAME COLUMN in ALTER TABLE)
+-- alter table tt3 rename c to d;
+drop table tt3;
+create table tt3 (ax bigint, b short, d decimal) using parquet;
+
+-- select pg_get_viewdef('v1', true);
+-- select pg_get_viewdef('v1a', true);
+-- select pg_get_viewdef('v2', true);
+-- select pg_get_viewdef('v2a', true);
+-- select pg_get_viewdef('v3', true);
+
+alter table tt3 add column c int;
+alter table tt3 add column e int;
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('v1', true);
+DESC TABLE v1;
+-- select pg_get_viewdef('v1a', true);
+DESC TABLE v1a;
+-- select pg_get_viewdef('v2', true);
+DESC TABLE v2;
+-- select pg_get_viewdef('v2a', true);
+DESC TABLE v2a;
+-- select pg_get_viewdef('v3', true);
+DESC TABLE v3;
+
+-- [SPARK-27589] Spark file source V2 (For supporting DROP COLUMN in ALTER TABLE)
+-- alter table tt2 drop column d;
+
+-- select pg_get_viewdef('v1', true);
+-- select pg_get_viewdef('v1a', true);
+-- select pg_get_viewdef('v2', true);
+-- select pg_get_viewdef('v2a', true);
+-- select pg_get_viewdef('v3', true);
+
+create table tt5 (a int, b int) using parquet;
+create table tt6 (c int, d int) using parquet;
+create view vv1 as select * from (tt5 cross join tt6) j(aa,bb,cc,dd);
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv1', true);
+DESC TABLE vv1;
+alter table tt5 add column c int;
+-- select pg_get_viewdef('vv1', true);
+DESC TABLE vv1;
+alter table tt5 add column cc int;
+-- select pg_get_viewdef('vv1', true);
+DESC TABLE vv1;
+-- [SPARK-27589] Spark file source V2 (For supporting DROP COLUMN in ALTER TABLE)
+-- alter table tt5 drop column c;
+-- select pg_get_viewdef('vv1', true);
+
+-- Unnamed FULL JOIN USING is lots of fun too
+
+-- [SPARK-27589] Spark file source V2 (For supporting DROP COLUMN in ALTER TABLE)
+create table tt7 (x int, /* xx int, */ y int) using parquet;
+-- alter table tt7 drop column xx;
+create table tt8 (x int, z int) using parquet;
+
+create view vv2 as
+select * from (values(1,2,3,4,5)) v(a,b,c,d,e)
+union all
+select * from tt7 full join tt8 using (x), tt8 tt8x;
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv2', true);
+DESC TABLE vv2;
+
+create view vv3 as
+select * from (values(1,2,3,4,5,6)) v(a,b,c,x,e,f)
+union all
+select * from
+ tt7 full join tt8 using (x),
+ tt7 tt7x full join tt8 tt8x using (x);
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv3', true);
+DESC TABLE vv3;
+
+create view vv4 as
+select * from (values(1,2,3,4,5,6,7)) v(a,b,c,x,e,f,g)
+union all
+select * from
+ tt7 full join tt8 using (x),
+ tt7 tt7x full join tt8 tt8x using (x) full join tt8 tt8y using (x);
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv4', true);
+DESC TABLE vv4;
+
+alter table tt7 add column zz int;
+alter table tt7 add column z int;
+-- [SPARK-27589] Spark file source V2 (For supporting DROP COLUMN in ALTER TABLE)
+-- alter table tt7 drop column zz;
+alter table tt8 add column z2 int;
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv2', true);
+DESC TABLE vv2;
+-- select pg_get_viewdef('vv3', true);
+DESC TABLE vv3;
+-- select pg_get_viewdef('vv4', true);
+DESC TABLE vv4;
+
+-- Implicit coercions in a JOIN USING create issues similar to FULL JOIN
+
+-- [SPARK-27589] Spark file source V2 (For supporting DROP COLUMN in ALTER TABLE)
+create table tt7a (x date, /* xx int, */ y int) using parquet;
+-- alter table tt7a drop column xx;
+create table tt8a (x timestamp, z int) using parquet;
+
+-- To pass the query, added exact column names in the select stmt
+create view vv2a as
+select * from (values(now(),2,3,now(),5)) v(a,b,c,d,e)
+union all
+select * from tt7a left join tt8a using (x), tt8a tt8ax;
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv4', true);
+DESC TABLE vv4;
+-- select pg_get_viewdef('vv2a', true);
+DESC TABLE vv2a;
+
+--
+-- Also check dropping a column that existed when the view was made
+--
+
+create table tt9 (x int, xx int, y int) using parquet;
+create table tt10 (x int, z int) using parquet;
+
+create view vv5 as select x,y,z from tt9 join tt10 using(x);
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv5', true);
+DESC TABLE vv5;
+
+-- [SPARK-27589] Spark file source V2 (For supporting DROP COLUMN in ALTER TABLE)
+-- alter table tt9 drop column xx;
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv5', true);
+DESC TABLE vv5;
+
+--
+-- Another corner case is that we might add a column to a table below a
+-- JOIN USING, and thereby make the USING column name ambiguous
+--
+
+create table tt11 (x int, y int) using parquet;
+create table tt12 (x int, z int) using parquet;
+create table tt13 (z int, q int) using parquet;
+
+create view vv6 as select x,y,z,q from
+ (tt11 join tt12 using(x)) join tt13 using(z);
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv6', true);
+DESC TABLE vv6;
+
+alter table tt11 add column z int;
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('vv6', true);
+DESC TABLE vv6;
+
+--
+-- Check cases involving dropped/altered columns in a function's rowtype result
+--
+
+-- Skip the tests below because Spark doesn't support PostgreSQL-specific UDFs/transactions
+-- create table tt14t (f1 text, f2 text, f3 text, f4 text);
+-- insert into tt14t values('foo', 'bar', 'baz', '42');
+--
+-- alter table tt14t drop column f2;
+--
+-- create function tt14f() returns setof tt14t as
+-- $$
+-- declare
+-- rec1 record;
+-- begin
+-- for rec1 in select * from tt14t
+-- loop
+-- return next rec1;
+-- end loop;
+-- end;
+-- $$
+-- language plpgsql;
+--
+-- create view tt14v as select t.* from tt14f() t;
+--
+-- select pg_get_viewdef('tt14v', true);
+-- select * from tt14v;
+--
+-- begin;
+--
+-- -- this perhaps should be rejected, but it isn't:
+-- alter table tt14t drop column f3;
+--
+-- -- f3 is still in the view ...
+-- select pg_get_viewdef('tt14v', true);
+-- -- but will fail at execution
+-- select f1, f4 from tt14v;
+-- select * from tt14v;
+--
+-- rollback;
+--
+-- begin;
+--
+-- -- this perhaps should be rejected, but it isn't:
+-- alter table tt14t alter column f4 type integer using f4::integer;
+--
+-- -- f4 is still in the view ...
+-- select pg_get_viewdef('tt14v', true);
+-- -- but will fail at execution
+-- select f1, f3 from tt14v;
+-- select * from tt14v;
+--
+-- rollback;
+
+-- check display of whole-row variables in some corner cases
+
+-- Skip the tests below because we do not support creating types
+-- create type nestedcomposite as (x int8_tbl);
+-- create view tt15v as select row(i)::nestedcomposite from int8_tbl i;
+-- select * from tt15v;
+-- select pg_get_viewdef('tt15v', true);
+-- select row(i.*::int8_tbl)::nestedcomposite from int8_tbl i;
+--
+-- create view tt16v as select * from int8_tbl i, lateral(values(i)) ss;
+-- select * from tt16v;
+-- select pg_get_viewdef('tt16v', true);
+-- select * from int8_tbl i, lateral(values(i.*::int8_tbl)) ss;
+--
+-- create view tt17v as select * from int8_tbl i where i in (values(i));
+-- select * from tt17v;
+-- select pg_get_viewdef('tt17v', true);
+-- select * from int8_tbl i where i.* in (values(i.*::int8_tbl));
+
+-- check unique-ification of overlength names
+
+CREATE TABLE int8_tbl (q1 int, q2 int) USING parquet;
+
+create view tt18v as
+ select * from int8_tbl xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxy
+ union all
+ select * from int8_tbl xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxz;
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('tt18v', true);
+DESC TABLE tt18v;
+-- explain (costs off) select * from tt18v;
+
+-- check display of ScalarArrayOp with a sub-select
+
+-- Skip the tests below because of PostgreSQL specific cases
+-- select 'foo'::text = any(array['abc','def','foo']::text[]);
+-- select 'foo'::text = any((select array['abc','def','foo']::text[])); -- fail
+-- select 'foo'::text = any((select array['abc','def','foo']::text[])::text[]);
+--
+-- create view tt19v as
+-- select 'foo'::text = any(array['abc','def','foo']::text[]) c1,
+-- 'foo'::text = any((select array['abc','def','foo']::text[])::text[]) c2;
+-- select pg_get_viewdef('tt19v', true);
+
+-- check display of assorted RTE_FUNCTION expressions
+
+-- [SPARK-28682] ANSI SQL: Collation Support
+-- create view tt20v as
+-- select * from
+-- coalesce(1,2) as c,
+-- collation for ('x'::text) col,
+-- current_date as d,
+-- localtimestamp(3) as t,
+-- cast(1+2 as int4) as i4,
+-- cast(1+2 as int8) as i8;
+-- select pg_get_viewdef('tt20v', true);
+
+-- corner cases with empty join conditions
+
+create view tt21v as
+select * from tt5 natural inner join tt6;
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('tt21v', true);
+DESC TABLE tt21v;
+
+create view tt22v as
+select * from tt5 natural left join tt6;
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('tt22v', true);
+DESC TABLE tt22v;
+
+-- check handling of views with immediately-renamed columns
+
+create view tt23v (col_a, col_b) as
+select q1 as other_name1, q2 as other_name2 from int8_tbl
+union
+select 42, 43;
+
+-- Replace `pg_get_viewdef` with `DESC`
+-- select pg_get_viewdef('tt23v', true);
+DESC TABLE tt23v;
+-- Skip the test below because of PostgreSQL specific cases
+-- select pg_get_ruledef(oid, true) from pg_rewrite
+-- where ev_class = 'tt23v'::regclass and ev_type = '1';
+
+-- clean up all the random objects we made above
+DROP SCHEMA temp_view_test CASCADE;
+DROP SCHEMA testviewschm2 CASCADE;
+
+DROP VIEW temp_table;
+DROP VIEW tt;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/date.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/date.sql
new file mode 100644
index 000000000000..69851080847b
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/date.sql
@@ -0,0 +1,362 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- DATE
+-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/date.sql
+
+CREATE TABLE DATE_TBL (f1 date) USING parquet;
+
+-- PostgreSQL implicitly casts string literals to data with date types, but
+-- Spark does not support that kind of implicit casts.
+INSERT INTO DATE_TBL VALUES (date('1957-04-09'));
+INSERT INTO DATE_TBL VALUES (date('1957-06-13'));
+INSERT INTO DATE_TBL VALUES (date('1996-02-28'));
+INSERT INTO DATE_TBL VALUES (date('1996-02-29'));
+INSERT INTO DATE_TBL VALUES (date('1996-03-01'));
+INSERT INTO DATE_TBL VALUES (date('1996-03-02'));
+INSERT INTO DATE_TBL VALUES (date('1997-02-28'));
+-- [SPARK-27923] Skip invalid date: 1997-02-29
+-- INSERT INTO DATE_TBL VALUES ('1997-02-29'));
+INSERT INTO DATE_TBL VALUES (date('1997-03-01'));
+INSERT INTO DATE_TBL VALUES (date('1997-03-02'));
+INSERT INTO DATE_TBL VALUES (date('2000-04-01'));
+INSERT INTO DATE_TBL VALUES (date('2000-04-02'));
+INSERT INTO DATE_TBL VALUES (date('2000-04-03'));
+INSERT INTO DATE_TBL VALUES (date('2038-04-08'));
+INSERT INTO DATE_TBL VALUES (date('2039-04-09'));
+INSERT INTO DATE_TBL VALUES (date('2040-04-10'));
+
+SELECT f1 AS `Fifteen` FROM DATE_TBL;
+
+SELECT f1 AS `Nine` FROM DATE_TBL WHERE f1 < '2000-01-01';
+
+SELECT f1 AS `Three` FROM DATE_TBL
+ WHERE f1 BETWEEN '2000-01-01' AND '2001-01-01';
+
+-- Skip the formats that we do not supported. Please check [SPARK-8995] for all supported formats
+--
+-- Check all the documented input formats
+--
+-- [SPARK-28259] Date/Time Output Styles and Date Order Conventions
+-- SET datestyle TO iso; -- display results in ISO
+
+-- SET datestyle TO ymd;
+
+-- SELECT date 'January 8, 1999';
+SELECT date '1999-01-08';
+SELECT date '1999-01-18';
+-- SELECT date '1/8/1999';
+-- SELECT date '1/18/1999';
+-- SELECT date '18/1/1999';
+-- SELECT date '01/02/03';
+-- SELECT date '19990108';
+-- SELECT date '990108';
+-- SELECT date '1999.008';
+-- SELECT date 'J2451187';
+-- SELECT date 'January 8, 99 BC';
+
+-- SELECT date '99-Jan-08';
+-- SELECT date '1999-Jan-08';
+-- SELECT date '08-Jan-99';
+-- SELECT date '08-Jan-1999';
+-- SELECT date 'Jan-08-99';
+-- SELECT date 'Jan-08-1999';
+-- SELECT date '99-08-Jan';
+-- SELECT date '1999-08-Jan';
+
+-- SELECT date '99 Jan 08';
+SELECT date '1999 Jan 08';
+-- SELECT date '08 Jan 99';
+-- SELECT date '08 Jan 1999';
+-- SELECT date 'Jan 08 99';
+-- SELECT date 'Jan 08 1999';
+-- SELECT date '99 08 Jan';
+SELECT date '1999 08 Jan';
+
+-- SELECT date '99-01-08';
+SELECT date '1999-01-08';
+-- SELECT date '08-01-99';
+-- SELECT date '08-01-1999';
+-- SELECT date '01-08-99';
+-- SELECT date '01-08-1999';
+-- SELECT date '99-08-01';
+SELECT date '1999-08-01';
+
+-- SELECT date '99 01 08';
+SELECT date '1999 01 08';
+-- SELECT date '08 01 99';
+-- SELECT date '08 01 1999';
+-- SELECT date '01 08 99';
+-- SELECT date '01 08 1999';
+-- SELECT date '99 08 01';
+SELECT date '1999 08 01';
+
+-- SET datestyle TO dmy;
+
+-- SELECT date 'January 8, 1999';
+SELECT date '1999-01-08';
+-- SELECT date '1999-01-18';
+-- SELECT date '1/8/1999';
+-- SELECT date '1/18/1999';
+-- SELECT date '18/1/1999';
+-- SELECT date '01/02/03';
+-- SELECT date '19990108';
+-- SELECT date '990108';
+-- SELECT date '1999.008';
+-- SELECT date 'J2451187';
+-- SELECT date 'January 8, 99 BC';
+
+-- SELECT date '99-Jan-08';
+-- SELECT date '1999-Jan-08';
+-- SELECT date '08-Jan-99';
+-- SELECT date '08-Jan-1999';
+-- SELECT date 'Jan-08-99';
+-- SELECT date 'Jan-08-1999';
+-- SELECT date '99-08-Jan';
+-- SELECT date '1999-08-Jan';
+
+-- SELECT date '99 Jan 08';
+SELECT date '1999 Jan 08';
+-- SELECT date '08 Jan 99';
+-- SELECT date '08 Jan 1999';
+-- SELECT date 'Jan 08 99';
+-- SELECT date 'Jan 08 1999';
+-- SELECT date '99 08 Jan';
+SELECT date '1999 08 Jan';
+
+-- SELECT date '99-01-08';
+SELECT date '1999-01-08';
+-- SELECT date '08-01-99';
+-- SELECT date '08-01-1999';
+-- SELECT date '01-08-99';
+-- SELECT date '01-08-1999';
+-- SELECT date '99-08-01';
+SELECT date '1999-08-01';
+
+-- SELECT date '99 01 08';
+SELECT date '1999 01 08';
+-- SELECT date '08 01 99';
+-- SELECT date '08 01 1999';
+-- SELECT date '01 08 99';
+-- SELECT date '01 08 1999';
+-- SELECT date '99 08 01';
+SELECT date '1999 08 01';
+
+-- SET datestyle TO mdy;
+
+-- SELECT date 'January 8, 1999';
+SELECT date '1999-01-08';
+SELECT date '1999-01-18';
+-- SELECT date '1/8/1999';
+-- SELECT date '1/18/1999';
+-- SELECT date '18/1/1999';
+-- SELECT date '01/02/03';
+-- SELECT date '19990108';
+-- SELECT date '990108';
+-- SELECT date '1999.008';
+-- SELECT date 'J2451187';
+-- SELECT date 'January 8, 99 BC';
+
+-- SELECT date '99-Jan-08';
+-- SELECT date '1999-Jan-08';
+-- SELECT date '08-Jan-99';
+-- SELECT date '08-Jan-1999';
+-- SELECT date 'Jan-08-99';
+-- SELECT date 'Jan-08-1999';
+-- SELECT date '99-08-Jan';
+-- SELECT date '1999-08-Jan';
+
+-- SELECT date '99 Jan 08';
+SELECT date '1999 Jan 08';
+-- SELECT date '08 Jan 99';
+-- SELECT date '08 Jan 1999';
+-- SELECT date 'Jan 08 99';
+-- SELECT date 'Jan 08 1999';
+-- SELECT date '99 08 Jan';
+SELECT date '1999 08 Jan';
+
+-- SELECT date '99-01-08';
+SELECT date '1999-01-08';
+-- SELECT date '08-01-99';
+-- SELECT date '08-01-1999';
+-- SELECT date '01-08-99';
+-- SELECT date '01-08-1999';
+-- SELECT date '99-08-01';
+SELECT date '1999-08-01';
+
+-- SELECT date '99 01 08';
+SELECT date '1999 01 08';
+-- SELECT date '08 01 99';
+-- SELECT date '08 01 1999';
+-- SELECT date '01 08 99';
+-- SELECT date '01 08 1999';
+-- SELECT date '99 08 01';
+SELECT date '1999 08 01';
+
+-- [SPARK-28253] Date type have different low value and high value
+-- Check upper and lower limits of date range
+SELECT date '4714-11-24 BC';
+SELECT date '4714-11-23 BC'; -- out of range
+SELECT date '5874897-12-31';
+SELECT date '5874898-01-01'; -- out of range
+
+-- RESET datestyle;
+
+--
+-- Simple math
+-- Leave most of it for the horology tests
+--
+
+SELECT f1 - date '2000-01-01' AS `Days From 2K` FROM DATE_TBL;
+
+SELECT f1 - date 'epoch' AS `Days From Epoch` FROM DATE_TBL;
+
+SELECT date 'yesterday' - date 'today' AS `One day`;
+
+SELECT date 'today' - date 'tomorrow' AS `One day`;
+
+SELECT date 'yesterday' - date 'tomorrow' AS `Two days`;
+
+SELECT date 'tomorrow' - date 'today' AS `One day`;
+
+SELECT date 'today' - date 'yesterday' AS `One day`;
+
+SELECT date 'tomorrow' - date 'yesterday' AS `Two days`;
+
+-- [SPARK-28017] Enhance date EXTRACT
+--
+-- test extract!
+--
+-- epoch
+--
+-- SELECT EXTRACT(EPOCH FROM DATE '1970-01-01'); -- 0
+-- SELECT EXTRACT(EPOCH FROM TIMESTAMP '1970-01-01'); -- 0
+-- SELECT EXTRACT(EPOCH FROM TIMESTAMPTZ '1970-01-01+00'); -- 0
+--
+-- century
+--
+-- SELECT EXTRACT(CENTURY FROM TO_DATE('0101-12-31 BC', 'yyyy-MM-dd G')); -- -2
+-- SELECT EXTRACT(CENTURY FROM TO_DATE('0100-12-31 BC', 'yyyy-MM-dd G')); -- -1
+-- SELECT EXTRACT(CENTURY FROM TO_DATE('0001-12-31 BC', 'yyyy-MM-dd G')); -- -1
+-- SELECT EXTRACT(CENTURY FROM DATE '0001-01-01'); -- 1
+-- SELECT EXTRACT(CENTURY FROM DATE '0001-01-01 AD'); -- 1
+-- SELECT EXTRACT(CENTURY FROM DATE '1900-12-31'); -- 19
+-- SELECT EXTRACT(CENTURY FROM DATE '1901-01-01'); -- 20
+-- SELECT EXTRACT(CENTURY FROM DATE '2000-12-31'); -- 20
+-- SELECT EXTRACT(CENTURY FROM DATE '2001-01-01'); -- 21
+-- SELECT EXTRACT(CENTURY FROM CURRENT_DATE)>=21 AS True; -- true
+--
+-- millennium
+--
+-- SELECT EXTRACT(MILLENNIUM FROM TO_DATE('0001-12-31 BC', 'yyyy-MM-dd G')); -- -1
+-- SELECT EXTRACT(MILLENNIUM FROM DATE '0001-01-01 AD'); -- 1
+-- SELECT EXTRACT(MILLENNIUM FROM DATE '1000-12-31'); -- 1
+-- SELECT EXTRACT(MILLENNIUM FROM DATE '1001-01-01'); -- 2
+-- SELECT EXTRACT(MILLENNIUM FROM DATE '2000-12-31'); -- 2
+-- SELECT EXTRACT(MILLENNIUM FROM DATE '2001-01-01'); -- 3
+-- next test to be fixed on the turn of the next millennium;-)
+-- SELECT EXTRACT(MILLENNIUM FROM CURRENT_DATE); -- 3
+--
+-- decade
+--
+-- SELECT EXTRACT(DECADE FROM DATE '1994-12-25'); -- 199
+-- SELECT EXTRACT(DECADE FROM DATE '0010-01-01'); -- 1
+-- SELECT EXTRACT(DECADE FROM DATE '0009-12-31'); -- 0
+-- SELECT EXTRACT(DECADE FROM TO_DATE('0001-01-01 BC', 'yyyy-MM-dd G')); -- 0
+-- SELECT EXTRACT(DECADE FROM TO_DATE('0002-12-31 BC', 'yyyy-MM-dd G')); -- -1
+-- SELECT EXTRACT(DECADE FROM TO_DATE('0011-01-01 BC', 'yyyy-MM-dd G')); -- -1
+-- SELECT EXTRACT(DECADE FROM TO_DATE('0012-12-31 BC', 'yyyy-MM-dd G')); -- -2
+--
+-- some other types:
+--
+-- on a timestamp.
+-- SELECT EXTRACT(CENTURY FROM NOW())>=21 AS True; -- true
+-- SELECT EXTRACT(CENTURY FROM TIMESTAMP '1970-03-20 04:30:00.00000'); -- 20
+-- on an interval
+-- SELECT EXTRACT(CENTURY FROM INTERVAL '100 y'); -- 1
+-- SELECT EXTRACT(CENTURY FROM INTERVAL '99 y'); -- 0
+-- SELECT EXTRACT(CENTURY FROM INTERVAL '-99 y'); -- 0
+-- SELECT EXTRACT(CENTURY FROM INTERVAL '-100 y'); -- -1
+--
+-- test trunc function!
+-- SELECT DATE_TRUNC('MILLENNIUM', TIMESTAMP '1970-03-20 04:30:00.00000'); -- 1001
+-- SELECT DATE_TRUNC('MILLENNIUM', DATE '1970-03-20'); -- 1001-01-01
+-- SELECT DATE_TRUNC('CENTURY', TIMESTAMP '1970-03-20 04:30:00.00000'); -- 1901
+-- SELECT DATE_TRUNC('CENTURY', DATE '1970-03-20'); -- 1901
+-- SELECT DATE_TRUNC('CENTURY', DATE '2004-08-10'); -- 2001-01-01
+-- SELECT DATE_TRUNC('CENTURY', DATE '0002-02-04'); -- 0001-01-01
+-- SELECT DATE_TRUNC('CENTURY', TO_DATE('0055-08-10 BC', 'yyyy-MM-dd G')); -- 0100-01-01 BC
+-- SELECT DATE_TRUNC('DECADE', DATE '1993-12-25'); -- 1990-01-01
+-- SELECT DATE_TRUNC('DECADE', DATE '0004-12-25'); -- 0001-01-01 BC
+-- SELECT DATE_TRUNC('DECADE', TO_DATE('0002-12-31 BC', 'yyyy-MM-dd G')); -- 0011-01-01 BC
+
+-- [SPARK-29006] Support special date/timestamp values `infinity`/`-infinity`
+--
+-- test infinity
+--
+-- select 'infinity'::date, '-infinity'::date;
+-- select 'infinity'::date > 'today'::date as t;
+-- select '-infinity'::date < 'today'::date as t;
+-- select isfinite('infinity'::date), isfinite('-infinity'::date), isfinite('today'::date);
+--
+-- oscillating fields from non-finite date/timestamptz:
+--
+-- SELECT EXTRACT(HOUR FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(HOUR FROM DATE '-infinity'); -- NULL
+-- SELECT EXTRACT(HOUR FROM TIMESTAMP 'infinity'); -- NULL
+-- SELECT EXTRACT(HOUR FROM TIMESTAMP '-infinity'); -- NULL
+-- SELECT EXTRACT(HOUR FROM TIMESTAMPTZ 'infinity'); -- NULL
+-- SELECT EXTRACT(HOUR FROM TIMESTAMPTZ '-infinity'); -- NULL
+-- all possible fields
+-- SELECT EXTRACT(MICROSECONDS FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(MILLISECONDS FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(SECOND FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(MINUTE FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(HOUR FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(DAY FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(MONTH FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(QUARTER FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(WEEK FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(DOW FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(ISODOW FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(DOY FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(TIMEZONE FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(TIMEZONE_M FROM DATE 'infinity'); -- NULL
+-- SELECT EXTRACT(TIMEZONE_H FROM DATE 'infinity'); -- NULL
+--
+-- monotonic fields from non-finite date/timestamptz:
+--
+-- SELECT EXTRACT(EPOCH FROM DATE 'infinity'); -- Infinity
+-- SELECT EXTRACT(EPOCH FROM DATE '-infinity'); -- -Infinity
+-- SELECT EXTRACT(EPOCH FROM TIMESTAMP 'infinity'); -- Infinity
+-- SELECT EXTRACT(EPOCH FROM TIMESTAMP '-infinity'); -- -Infinity
+-- SELECT EXTRACT(EPOCH FROM TIMESTAMPTZ 'infinity'); -- Infinity
+-- SELECT EXTRACT(EPOCH FROM TIMESTAMPTZ '-infinity'); -- -Infinity
+-- all possible fields
+-- SELECT EXTRACT(YEAR FROM DATE 'infinity'); -- Infinity
+-- SELECT EXTRACT(DECADE FROM DATE 'infinity'); -- Infinity
+-- SELECT EXTRACT(CENTURY FROM DATE 'infinity'); -- Infinity
+-- SELECT EXTRACT(MILLENNIUM FROM DATE 'infinity'); -- Infinity
+-- SELECT EXTRACT(JULIAN FROM DATE 'infinity'); -- Infinity
+-- SELECT EXTRACT(ISOYEAR FROM DATE 'infinity'); -- Infinity
+-- SELECT EXTRACT(EPOCH FROM DATE 'infinity'); -- Infinity
+--
+-- wrong fields from non-finite date:
+--
+-- SELECT EXTRACT(MICROSEC FROM DATE 'infinity'); -- ERROR: timestamp units "microsec" not recognized
+-- SELECT EXTRACT(UNDEFINED FROM DATE 'infinity'); -- ERROR: timestamp units "undefined" not supported
+
+-- test constructors
+select make_date(2013, 7, 15);
+-- [SPARK-28471] Formatting dates with negative years
+select make_date(-44, 3, 15);
+-- select make_time(8, 20, 0.0);
+-- should fail
+select make_date(2013, 2, 30);
+select make_date(2013, 13, 1);
+select make_date(2013, 11, -1);
+-- select make_time(10, 55, 100.1);
+-- select make_time(24, 0, 2.1);
+
+DROP TABLE DATE_TBL;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/float4.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/float4.sql
new file mode 100644
index 000000000000..2989569e219f
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/float4.sql
@@ -0,0 +1,363 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- FLOAT4
+-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/float4.sql
+
+CREATE TABLE FLOAT4_TBL (f1 float) USING parquet;
+
+-- PostgreSQL implicitly casts string literals to data with floating point types, but
+-- Spark does not support that kind of implicit casts.
+INSERT INTO FLOAT4_TBL VALUES (float(' 0.0'));
+INSERT INTO FLOAT4_TBL VALUES (float('1004.30 '));
+INSERT INTO FLOAT4_TBL VALUES (float(' -34.84 '));
+INSERT INTO FLOAT4_TBL VALUES (float('1.2345678901234e+20'));
+INSERT INTO FLOAT4_TBL VALUES (float('1.2345678901234e-20'));
+
+-- [SPARK-28024] Incorrect numeric values when out of range
+-- test for over and under flow
+-- INSERT INTO FLOAT4_TBL VALUES ('10e70');
+-- INSERT INTO FLOAT4_TBL VALUES ('-10e70');
+-- INSERT INTO FLOAT4_TBL VALUES ('10e-70');
+-- INSERT INTO FLOAT4_TBL VALUES ('-10e-70');
+
+-- INSERT INTO FLOAT4_TBL VALUES ('10e400');
+-- INSERT INTO FLOAT4_TBL VALUES ('-10e400');
+-- INSERT INTO FLOAT4_TBL VALUES ('10e-400');
+-- INSERT INTO FLOAT4_TBL VALUES ('-10e-400');
+
+-- [SPARK-27923] Spark SQL insert there bad inputs to NULL
+-- bad input
+-- INSERT INTO FLOAT4_TBL VALUES ('');
+-- INSERT INTO FLOAT4_TBL VALUES (' ');
+-- INSERT INTO FLOAT4_TBL VALUES ('xyz');
+-- INSERT INTO FLOAT4_TBL VALUES ('5.0.0');
+-- INSERT INTO FLOAT4_TBL VALUES ('5 . 0');
+-- INSERT INTO FLOAT4_TBL VALUES ('5. 0');
+-- INSERT INTO FLOAT4_TBL VALUES (' - 3.0');
+-- INSERT INTO FLOAT4_TBL VALUES ('123 5');
+
+-- special inputs
+SELECT float('NaN');
+SELECT float('nan');
+SELECT float(' NAN ');
+SELECT float('infinity');
+SELECT float(' -INFINiTY ');
+-- [SPARK-27923] Spark SQL insert there bad special inputs to NULL
+-- bad special inputs
+SELECT float('N A N');
+SELECT float('NaN x');
+SELECT float(' INFINITY x');
+
+SELECT float('Infinity') + 100.0;
+SELECT float('Infinity') / float('Infinity');
+SELECT float('nan') / float('nan');
+SELECT float(decimal('nan'));
+
+SELECT '' AS five, * FROM FLOAT4_TBL;
+
+SELECT '' AS four, f.* FROM FLOAT4_TBL f WHERE f.f1 <> '1004.3';
+
+SELECT '' AS one, f.* FROM FLOAT4_TBL f WHERE f.f1 = '1004.3';
+
+SELECT '' AS three, f.* FROM FLOAT4_TBL f WHERE '1004.3' > f.f1;
+
+SELECT '' AS three, f.* FROM FLOAT4_TBL f WHERE f.f1 < '1004.3';
+
+SELECT '' AS four, f.* FROM FLOAT4_TBL f WHERE '1004.3' >= f.f1;
+
+SELECT '' AS four, f.* FROM FLOAT4_TBL f WHERE f.f1 <= '1004.3';
+
+SELECT '' AS three, f.f1, f.f1 * '-10' AS x FROM FLOAT4_TBL f
+ WHERE f.f1 > '0.0';
+
+SELECT '' AS three, f.f1, f.f1 + '-10' AS x FROM FLOAT4_TBL f
+ WHERE f.f1 > '0.0';
+
+SELECT '' AS three, f.f1, f.f1 / '-10' AS x FROM FLOAT4_TBL f
+ WHERE f.f1 > '0.0';
+
+SELECT '' AS three, f.f1, f.f1 - '-10' AS x FROM FLOAT4_TBL f
+ WHERE f.f1 > '0.0';
+
+-- [SPARK-27923] Spark SQL returns NULL
+-- test divide by zero
+-- SELECT '' AS bad, f.f1 / '0.0' from FLOAT4_TBL f;
+
+SELECT '' AS five, * FROM FLOAT4_TBL;
+
+-- [SPARK-28027] Spark SQL does not support prefix operator @
+-- test the unary float4abs operator
+-- SELECT '' AS five, f.f1, @f.f1 AS abs_f1 FROM FLOAT4_TBL f;
+
+-- Spark SQL does not support update now.
+-- UPDATE FLOAT4_TBL
+-- SET f1 = FLOAT4_TBL.f1 * '-1'
+-- WHERE FLOAT4_TBL.f1 > '0.0';
+
+-- SELECT '' AS five, * FROM FLOAT4_TBL;
+
+-- [SPARK-28028] Cast numeric to integral type need round
+-- [SPARK-28024] Incorrect numeric values when out of range
+-- test edge-case coercions to integer
+SELECT smallint(float('32767.4'));
+SELECT smallint(float('32767.6'));
+SELECT smallint(float('-32768.4'));
+SELECT smallint(float('-32768.6'));
+SELECT int(float('2147483520'));
+SELECT int(float('2147483647'));
+SELECT int(float('-2147483648.5'));
+SELECT int(float('-2147483900'));
+SELECT bigint(float('9223369837831520256'));
+SELECT bigint(float('9223372036854775807'));
+SELECT bigint(float('-9223372036854775808.5'));
+SELECT bigint(float('-9223380000000000000'));
+
+-- [SPARK-28061] Support for converting float to binary format
+-- Test for correct input rounding in edge cases.
+-- These lists are from Paxson 1991, excluding subnormals and
+-- inputs of over 9 sig. digits.
+
+-- SELECT float4send('5e-20'::float4);
+-- SELECT float4send('67e14'::float4);
+-- SELECT float4send('985e15'::float4);
+-- SELECT float4send('55895e-16'::float4);
+-- SELECT float4send('7038531e-32'::float4);
+-- SELECT float4send('702990899e-20'::float4);
+
+-- SELECT float4send('3e-23'::float4);
+-- SELECT float4send('57e18'::float4);
+-- SELECT float4send('789e-35'::float4);
+-- SELECT float4send('2539e-18'::float4);
+-- SELECT float4send('76173e28'::float4);
+-- SELECT float4send('887745e-11'::float4);
+-- SELECT float4send('5382571e-37'::float4);
+-- SELECT float4send('82381273e-35'::float4);
+-- SELECT float4send('750486563e-38'::float4);
+
+-- Test that the smallest possible normalized input value inputs
+-- correctly, either in 9-significant-digit or shortest-decimal
+-- format.
+--
+-- exact val is 1.1754943508...
+-- shortest val is 1.1754944000
+-- midpoint to next val is 1.1754944208...
+
+-- SELECT float4send('1.17549435e-38'::float4);
+-- SELECT float4send('1.1754944e-38'::float4);
+
+-- We do not support creating types, skip the test below
+-- test output (and round-trip safety) of various values.
+-- To ensure we're testing what we think we're testing, start with
+-- float values specified by bit patterns (as a useful side effect,
+-- this means we'll fail on non-IEEE platforms).
+
+-- create type xfloat4;
+-- create function xfloat4in(cstring) returns xfloat4 immutable strict
+-- language internal as 'int4in';
+-- create function xfloat4out(xfloat4) returns cstring immutable strict
+-- language internal as 'int4out';
+-- create type xfloat4 (input = xfloat4in, output = xfloat4out, like = float4);
+-- create cast (xfloat4 as float4) without function;
+-- create cast (float4 as xfloat4) without function;
+-- create cast (xfloat4 as integer) without function;
+-- create cast (integer as xfloat4) without function;
+
+-- float4: seeeeeee emmmmmmm mmmmmmmm mmmmmmmm
+
+-- we don't care to assume the platform's strtod() handles subnormals
+-- correctly; those are "use at your own risk". However we do test
+-- subnormal outputs, since those are under our control.
+
+-- with testdata(bits) as (values
+-- -- small subnormals
+-- (x'00000001'),
+-- (x'00000002'), (x'00000003'),
+-- (x'00000010'), (x'00000011'), (x'00000100'), (x'00000101'),
+-- (x'00004000'), (x'00004001'), (x'00080000'), (x'00080001'),
+-- -- stress values
+-- (x'0053c4f4'), -- 7693e-42
+-- (x'006c85c4'), -- 996622e-44
+-- (x'0041ca76'), -- 60419369e-46
+-- (x'004b7678'), -- 6930161142e-48
+-- -- taken from upstream testsuite
+-- (x'00000007'),
+-- (x'00424fe2'),
+-- -- borderline between subnormal and normal
+-- (x'007ffff0'), (x'007ffff1'), (x'007ffffe'), (x'007fffff'))
+-- select float4send(flt) as ibits,
+-- flt
+-- from (select bits::integer::xfloat4::float4 as flt
+-- from testdata
+-- offset 0) s;
+
+-- with testdata(bits) as (values
+-- (x'00000000'),
+-- -- smallest normal values
+-- (x'00800000'), (x'00800001'), (x'00800004'), (x'00800005'),
+-- (x'00800006'),
+-- -- small normal values chosen for short vs. long output
+-- (x'008002f1'), (x'008002f2'), (x'008002f3'),
+-- (x'00800e17'), (x'00800e18'), (x'00800e19'),
+-- -- assorted values (random mantissae)
+-- (x'01000001'), (x'01102843'), (x'01a52c98'),
+-- (x'0219c229'), (x'02e4464d'), (x'037343c1'), (x'03a91b36'),
+-- (x'047ada65'), (x'0496fe87'), (x'0550844f'), (x'05999da3'),
+-- (x'060ea5e2'), (x'06e63c45'), (x'07f1e548'), (x'0fc5282b'),
+-- (x'1f850283'), (x'2874a9d6'),
+-- -- values around 5e-08
+-- (x'3356bf94'), (x'3356bf95'), (x'3356bf96'),
+-- -- around 1e-07
+-- (x'33d6bf94'), (x'33d6bf95'), (x'33d6bf96'),
+-- -- around 3e-07 .. 1e-04
+-- (x'34a10faf'), (x'34a10fb0'), (x'34a10fb1'),
+-- (x'350637bc'), (x'350637bd'), (x'350637be'),
+-- (x'35719786'), (x'35719787'), (x'35719788'),
+-- (x'358637bc'), (x'358637bd'), (x'358637be'),
+-- (x'36a7c5ab'), (x'36a7c5ac'), (x'36a7c5ad'),
+-- (x'3727c5ab'), (x'3727c5ac'), (x'3727c5ad'),
+-- -- format crossover at 1e-04
+-- (x'38d1b714'), (x'38d1b715'), (x'38d1b716'),
+-- (x'38d1b717'), (x'38d1b718'), (x'38d1b719'),
+-- (x'38d1b71a'), (x'38d1b71b'), (x'38d1b71c'),
+-- (x'38d1b71d'),
+-- --
+-- (x'38dffffe'), (x'38dfffff'), (x'38e00000'),
+-- (x'38efffff'), (x'38f00000'), (x'38f00001'),
+-- (x'3a83126e'), (x'3a83126f'), (x'3a831270'),
+-- (x'3c23d709'), (x'3c23d70a'), (x'3c23d70b'),
+-- (x'3dcccccc'), (x'3dcccccd'), (x'3dccccce'),
+-- -- chosen to need 9 digits for 3dcccd70
+-- (x'3dcccd6f'), (x'3dcccd70'), (x'3dcccd71'),
+-- --
+-- (x'3effffff'), (x'3f000000'), (x'3f000001'),
+-- (x'3f333332'), (x'3f333333'), (x'3f333334'),
+-- -- approach 1.0 with increasing numbers of 9s
+-- (x'3f666665'), (x'3f666666'), (x'3f666667'),
+-- (x'3f7d70a3'), (x'3f7d70a4'), (x'3f7d70a5'),
+-- (x'3f7fbe76'), (x'3f7fbe77'), (x'3f7fbe78'),
+-- (x'3f7ff971'), (x'3f7ff972'), (x'3f7ff973'),
+-- (x'3f7fff57'), (x'3f7fff58'), (x'3f7fff59'),
+-- (x'3f7fffee'), (x'3f7fffef'),
+-- -- values very close to 1
+-- (x'3f7ffff0'), (x'3f7ffff1'), (x'3f7ffff2'),
+-- (x'3f7ffff3'), (x'3f7ffff4'), (x'3f7ffff5'),
+-- (x'3f7ffff6'), (x'3f7ffff7'), (x'3f7ffff8'),
+-- (x'3f7ffff9'), (x'3f7ffffa'), (x'3f7ffffb'),
+-- (x'3f7ffffc'), (x'3f7ffffd'), (x'3f7ffffe'),
+-- (x'3f7fffff'),
+-- (x'3f800000'),
+-- (x'3f800001'), (x'3f800002'), (x'3f800003'),
+-- (x'3f800004'), (x'3f800005'), (x'3f800006'),
+-- (x'3f800007'), (x'3f800008'), (x'3f800009'),
+-- -- values 1 to 1.1
+-- (x'3f80000f'), (x'3f800010'), (x'3f800011'),
+-- (x'3f800012'), (x'3f800013'), (x'3f800014'),
+-- (x'3f800017'), (x'3f800018'), (x'3f800019'),
+-- (x'3f80001a'), (x'3f80001b'), (x'3f80001c'),
+-- (x'3f800029'), (x'3f80002a'), (x'3f80002b'),
+-- (x'3f800053'), (x'3f800054'), (x'3f800055'),
+-- (x'3f800346'), (x'3f800347'), (x'3f800348'),
+-- (x'3f8020c4'), (x'3f8020c5'), (x'3f8020c6'),
+-- (x'3f8147ad'), (x'3f8147ae'), (x'3f8147af'),
+-- (x'3f8ccccc'), (x'3f8ccccd'), (x'3f8cccce'),
+-- --
+-- (x'3fc90fdb'), -- pi/2
+-- (x'402df854'), -- e
+-- (x'40490fdb'), -- pi
+-- --
+-- (x'409fffff'), (x'40a00000'), (x'40a00001'),
+-- (x'40afffff'), (x'40b00000'), (x'40b00001'),
+-- (x'411fffff'), (x'41200000'), (x'41200001'),
+-- (x'42c7ffff'), (x'42c80000'), (x'42c80001'),
+-- (x'4479ffff'), (x'447a0000'), (x'447a0001'),
+-- (x'461c3fff'), (x'461c4000'), (x'461c4001'),
+-- (x'47c34fff'), (x'47c35000'), (x'47c35001'),
+-- (x'497423ff'), (x'49742400'), (x'49742401'),
+-- (x'4b18967f'), (x'4b189680'), (x'4b189681'),
+-- (x'4cbebc1f'), (x'4cbebc20'), (x'4cbebc21'),
+-- (x'4e6e6b27'), (x'4e6e6b28'), (x'4e6e6b29'),
+-- (x'501502f8'), (x'501502f9'), (x'501502fa'),
+-- (x'51ba43b6'), (x'51ba43b7'), (x'51ba43b8'),
+-- -- stress values
+-- (x'1f6c1e4a'), -- 5e-20
+-- (x'59be6cea'), -- 67e14
+-- (x'5d5ab6c4'), -- 985e15
+-- (x'2cc4a9bd'), -- 55895e-16
+-- (x'15ae43fd'), -- 7038531e-32
+-- (x'2cf757ca'), -- 702990899e-20
+-- (x'665ba998'), -- 25933168707e13
+-- (x'743c3324'), -- 596428896559e20
+-- -- exercise fixed-point memmoves
+-- (x'47f1205a'),
+-- (x'4640e6ae'),
+-- (x'449a5225'),
+-- (x'42f6e9d5'),
+-- (x'414587dd'),
+-- (x'3f9e064b'),
+-- -- these cases come from the upstream's testsuite
+-- -- BoundaryRoundEven
+-- (x'4c000004'),
+-- (x'50061c46'),
+-- (x'510006a8'),
+-- -- ExactValueRoundEven
+-- (x'48951f84'),
+-- (x'45fd1840'),
+-- -- LotsOfTrailingZeros
+-- (x'39800000'),
+-- (x'3b200000'),
+-- (x'3b900000'),
+-- (x'3bd00000'),
+-- -- Regression
+-- (x'63800000'),
+-- (x'4b000000'),
+-- (x'4b800000'),
+-- (x'4c000001'),
+-- (x'4c800b0d'),
+-- (x'00d24584'),
+-- (x'00d90b88'),
+-- (x'45803f34'),
+-- (x'4f9f24f7'),
+-- (x'3a8722c3'),
+-- (x'5c800041'),
+-- (x'15ae43fd'),
+-- (x'5d4cccfb'),
+-- (x'4c800001'),
+-- (x'57800ed8'),
+-- (x'5f000000'),
+-- (x'700000f0'),
+-- (x'5f23e9ac'),
+-- (x'5e9502f9'),
+-- (x'5e8012b1'),
+-- (x'3c000028'),
+-- (x'60cde861'),
+-- (x'03aa2a50'),
+-- (x'43480000'),
+-- (x'4c000000'),
+-- -- LooksLikePow5
+-- (x'5D1502F9'),
+-- (x'5D9502F9'),
+-- (x'5E1502F9'),
+-- -- OutputLength
+-- (x'3f99999a'),
+-- (x'3f9d70a4'),
+-- (x'3f9df3b6'),
+-- (x'3f9e0419'),
+-- (x'3f9e0610'),
+-- (x'3f9e064b'),
+-- (x'3f9e0651'),
+-- (x'03d20cfe')
+-- )
+-- select float4send(flt) as ibits,
+-- flt,
+-- flt::text::float4 as r_flt,
+-- float4send(flt::text::float4) as obits,
+-- float4send(flt::text::float4) = float4send(flt) as correct
+-- from (select bits::integer::xfloat4::float4 as flt
+-- from testdata
+-- offset 0) s;
+
+-- clean up, lest opr_sanity complain
+-- drop type xfloat4 cascade;
+DROP TABLE FLOAT4_TBL;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/float8.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/float8.sql
new file mode 100644
index 000000000000..932cdb95fcf3
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/float8.sql
@@ -0,0 +1,502 @@
+--
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+--
+-- FLOAT8
+-- https://github.com/postgres/postgres/blob/REL_12_BETA2/src/test/regress/sql/float8.sql
+
+CREATE TABLE FLOAT8_TBL(f1 double) USING parquet;
+
+-- PostgreSQL implicitly casts string literals to data with floating point types, but
+-- Spark does not support that kind of implicit casts.
+INSERT INTO FLOAT8_TBL VALUES (double(' 0.0 '));
+INSERT INTO FLOAT8_TBL VALUES (double('1004.30 '));
+INSERT INTO FLOAT8_TBL VALUES (double(' -34.84'));
+INSERT INTO FLOAT8_TBL VALUES (double('1.2345678901234e+200'));
+INSERT INTO FLOAT8_TBL VALUES (double('1.2345678901234e-200'));
+
+-- [SPARK-28024] Incorrect numeric values when out of range
+-- test for underflow and overflow handling
+SELECT double('10e400');
+SELECT double('-10e400');
+SELECT double('10e-400');
+SELECT double('-10e-400');
+
+-- [SPARK-28061] Support for converting float to binary format
+-- test smallest normalized input
+-- SELECT float8send('2.2250738585072014E-308'::float8);
+
+-- [SPARK-27923] Spark SQL insert there bad inputs to NULL
+-- bad input
+-- INSERT INTO FLOAT8_TBL VALUES ('');
+-- INSERT INTO FLOAT8_TBL VALUES (' ');
+-- INSERT INTO FLOAT8_TBL VALUES ('xyz');
+-- INSERT INTO FLOAT8_TBL VALUES ('5.0.0');
+-- INSERT INTO FLOAT8_TBL VALUES ('5 . 0');
+-- INSERT INTO FLOAT8_TBL VALUES ('5. 0');
+-- INSERT INTO FLOAT8_TBL VALUES (' - 3');
+-- INSERT INTO FLOAT8_TBL VALUES ('123 5');
+
+-- special inputs
+SELECT double('NaN');
+SELECT double('nan');
+SELECT double(' NAN ');
+SELECT double('infinity');
+SELECT double(' -INFINiTY ');
+-- [SPARK-27923] Spark SQL insert there bad special inputs to NULL
+-- bad special inputs
+SELECT double('N A N');
+SELECT double('NaN x');
+SELECT double(' INFINITY x');
+
+SELECT double('Infinity') + 100.0;
+SELECT double('Infinity') / double('Infinity');
+SELECT double('NaN') / double('NaN');
+-- [SPARK-28315] Decimal can not accept NaN as input
+SELECT double(decimal('nan'));
+
+SELECT '' AS five, * FROM FLOAT8_TBL;
+
+SELECT '' AS four, f.* FROM FLOAT8_TBL f WHERE f.f1 <> '1004.3';
+
+SELECT '' AS one, f.* FROM FLOAT8_TBL f WHERE f.f1 = '1004.3';
+
+SELECT '' AS three, f.* FROM FLOAT8_TBL f WHERE '1004.3' > f.f1;
+
+SELECT '' AS three, f.* FROM FLOAT8_TBL f WHERE f.f1 < '1004.3';
+
+SELECT '' AS four, f.* FROM FLOAT8_TBL f WHERE '1004.3' >= f.f1;
+
+SELECT '' AS four, f.* FROM FLOAT8_TBL f WHERE f.f1 <= '1004.3';
+
+SELECT '' AS three, f.f1, f.f1 * '-10' AS x
+ FROM FLOAT8_TBL f
+ WHERE f.f1 > '0.0';
+
+SELECT '' AS three, f.f1, f.f1 + '-10' AS x
+ FROM FLOAT8_TBL f
+ WHERE f.f1 > '0.0';
+
+SELECT '' AS three, f.f1, f.f1 / '-10' AS x
+ FROM FLOAT8_TBL f
+ WHERE f.f1 > '0.0';
+
+SELECT '' AS three, f.f1, f.f1 - '-10' AS x
+ FROM FLOAT8_TBL f
+ WHERE f.f1 > '0.0';
+-- [SPARK-28007] Caret operator (^) means bitwise XOR in Spark/Hive and exponentiation in Postgres
+-- SELECT '' AS one, f.f1 ^ '2.0' AS square_f1
+-- FROM FLOAT8_TBL f where f.f1 = '1004.3';
+
+-- [SPARK-28027] Spark SQL does not support prefix operator @
+-- absolute value
+-- SELECT '' AS five, f.f1, @f.f1 AS abs_f1
+-- FROM FLOAT8_TBL f;
+
+-- [SPARK-23906] Support Truncate number
+-- truncate
+-- SELECT '' AS five, f.f1, trunc(f.f1) AS trunc_f1
+-- FROM FLOAT8_TBL f;
+
+-- round
+SELECT '' AS five, f.f1, round(f.f1) AS round_f1
+ FROM FLOAT8_TBL f;
+
+-- [SPARK-28135] ceil/ceiling/floor returns incorrect values
+-- ceil / ceiling
+select ceil(f1) as ceil_f1 from float8_tbl f;
+select ceiling(f1) as ceiling_f1 from float8_tbl f;
+
+-- floor
+select floor(f1) as floor_f1 from float8_tbl f;
+
+-- sign
+select sign(f1) as sign_f1 from float8_tbl f;
+
+-- avoid bit-exact output here because operations may not be bit-exact.
+-- SET extra_float_digits = 0;
+
+-- square root
+SELECT sqrt(double('64')) AS eight;
+
+-- [SPARK-28027] Spark SQL does not support prefix operator |/
+-- SELECT |/ float8 '64' AS eight;
+
+-- SELECT '' AS three, f.f1, |/f.f1 AS sqrt_f1
+-- FROM FLOAT8_TBL f
+-- WHERE f.f1 > '0.0';
+
+-- power
+SELECT power(double('144'), double('0.5'));
+SELECT power(double('NaN'), double('0.5'));
+SELECT power(double('144'), double('NaN'));
+SELECT power(double('NaN'), double('NaN'));
+SELECT power(double('-1'), double('NaN'));
+-- [SPARK-28135] power returns incorrect values
+SELECT power(double('1'), double('NaN'));
+SELECT power(double('NaN'), double('0'));
+
+-- take exp of ln(f.f1)
+SELECT '' AS three, f.f1, exp(ln(f.f1)) AS exp_ln_f1
+ FROM FLOAT8_TBL f
+ WHERE f.f1 > '0.0';
+
+-- [SPARK-28027] Spark SQL does not support prefix operator ||/
+-- cube root
+-- SELECT ||/ float8 '27' AS three;
+
+-- SELECT '' AS five, f.f1, ||/f.f1 AS cbrt_f1 FROM FLOAT8_TBL f;
+
+
+SELECT '' AS five, * FROM FLOAT8_TBL;
+
+-- UPDATE FLOAT8_TBL
+-- SET f1 = FLOAT8_TBL.f1 * '-1'
+-- WHERE FLOAT8_TBL.f1 > '0.0';
+-- Update the FLOAT8_TBL to UPDATED_FLOAT8_TBL
+CREATE TEMPORARY VIEW UPDATED_FLOAT8_TBL as
+SELECT
+ CASE WHEN FLOAT8_TBL.f1 > '0.0' THEN FLOAT8_TBL.f1 * '-1' ELSE FLOAT8_TBL.f1 END AS f1
+FROM FLOAT8_TBL;
+
+-- [SPARK-27923] Out of range, Spark SQL returns Infinity
+SELECT '' AS bad, f.f1 * '1e200' from UPDATED_FLOAT8_TBL f;
+
+-- [SPARK-28007] Caret operator (^) means bitwise XOR in Spark/Hive and exponentiation in Postgres
+-- SELECT '' AS bad, f.f1 ^ '1e200' from UPDATED_FLOAT8_TBL f;
+
+-- SELECT 0 ^ 0 + 0 ^ 1 + 0 ^ 0.0 + 0 ^ 0.5;
+
+-- [SPARK-27923] Cannot take logarithm of zero
+-- SELECT '' AS bad, ln(f.f1) from UPDATED_FLOAT8_TBL f where f.f1 = '0.0' ;
+
+-- [SPARK-27923] Cannot take logarithm of a negative number
+-- SELECT '' AS bad, ln(f.f1) from UPDATED_FLOAT8_TBL f where f.f1 < '0.0' ;
+
+-- [SPARK-28024] Incorrect numeric values when out of range
+-- SELECT '' AS bad, exp(f.f1) from UPDATED_FLOAT8_TBL f;
+
+-- [SPARK-27923] Divide by zero, Spark SQL returns NULL
+-- SELECT '' AS bad, f.f1 / '0.0' from UPDATED_FLOAT8_TBL f;
+
+SELECT '' AS five, * FROM UPDATED_FLOAT8_TBL;
+
+-- hyperbolic functions
+-- we run these with extra_float_digits = 0 too, since different platforms
+-- tend to produce results that vary in the last place.
+SELECT sinh(double('1'));
+SELECT cosh(double('1'));
+SELECT tanh(double('1'));
+SELECT asinh(double('1'));
+SELECT acosh(double('2'));
+SELECT atanh(double('0.5'));
+
+-- test Inf/NaN cases for hyperbolic functions
+SELECT sinh(double('Infinity'));
+SELECT sinh(double('-Infinity'));
+SELECT sinh(double('NaN'));
+SELECT cosh(double('Infinity'));
+SELECT cosh(double('-Infinity'));
+SELECT cosh(double('NaN'));
+SELECT tanh(double('Infinity'));
+SELECT tanh(double('-Infinity'));
+SELECT tanh(double('NaN'));
+SELECT asinh(double('Infinity'));
+SELECT asinh(double('-Infinity'));
+SELECT asinh(double('NaN'));
+-- acosh(Inf) should be Inf, but some mingw versions produce NaN, so skip test
+SELECT acosh(double('Infinity'));
+SELECT acosh(double('-Infinity'));
+SELECT acosh(double('NaN'));
+SELECT atanh(double('Infinity'));
+SELECT atanh(double('-Infinity'));
+SELECT atanh(double('NaN'));
+
+-- RESET extra_float_digits;
+
+-- [SPARK-28024] Incorrect numeric values when out of range
+-- test for over- and underflow
+-- INSERT INTO FLOAT8_TBL VALUES ('10e400');
+
+-- INSERT INTO FLOAT8_TBL VALUES ('-10e400');
+
+-- INSERT INTO FLOAT8_TBL VALUES ('10e-400');
+
+-- INSERT INTO FLOAT8_TBL VALUES ('-10e-400');
+
+-- maintain external table consistency across platforms
+-- delete all values and reinsert well-behaved ones
+
+TRUNCATE TABLE FLOAT8_TBL;
+
+-- PostgreSQL implicitly casts string literals to data with floating point types, but
+-- Spark does not support that kind of implicit casts.
+INSERT INTO FLOAT8_TBL VALUES (double('0.0'));
+
+INSERT INTO FLOAT8_TBL VALUES (double('-34.84'));
+
+INSERT INTO FLOAT8_TBL VALUES (double('-1004.30'));
+
+INSERT INTO FLOAT8_TBL VALUES (double('-1.2345678901234e+200'));
+
+INSERT INTO FLOAT8_TBL VALUES (double('-1.2345678901234e-200'));
+
+SELECT '' AS five, * FROM FLOAT8_TBL;
+
+-- [SPARK-28028] Cast numeric to integral type need round
+-- [SPARK-28024] Incorrect numeric values when out of range
+-- test edge-case coercions to integer
+SELECT smallint(double('32767.4'));
+SELECT smallint(double('32767.6'));
+SELECT smallint(double('-32768.4'));
+SELECT smallint(double('-32768.6'));
+SELECT int(double('2147483647.4'));
+SELECT int(double('2147483647.6'));
+SELECT int(double('-2147483648.4'));
+SELECT int(double('-2147483648.6'));
+SELECT bigint(double('9223372036854773760'));
+SELECT bigint(double('9223372036854775807'));
+SELECT bigint(double('-9223372036854775808.5'));
+SELECT bigint(double('-9223372036854780000'));
+
+-- [SPARK-28134] Missing Trigonometric Functions
+-- test exact cases for trigonometric functions in degrees
+
+-- SELECT x,
+-- sind(x),
+-- sind(x) IN (-1,-0.5,0,0.5,1) AS sind_exact
+-- FROM (VALUES (0), (30), (90), (150), (180),
+-- (210), (270), (330), (360)) AS t(x);
+
+-- SELECT x,
+-- cosd(x),
+-- cosd(x) IN (-1,-0.5,0,0.5,1) AS cosd_exact
+-- FROM (VALUES (0), (60), (90), (120), (180),
+-- (240), (270), (300), (360)) AS t(x);
+
+-- SELECT x,
+-- tand(x),
+-- tand(x) IN ('-Infinity'::float8,-1,0,
+-- 1,'Infinity'::float8) AS tand_exact,
+-- cotd(x),
+-- cotd(x) IN ('-Infinity'::float8,-1,0,
+-- 1,'Infinity'::float8) AS cotd_exact
+-- FROM (VALUES (0), (45), (90), (135), (180),
+-- (225), (270), (315), (360)) AS t(x);
+
+-- SELECT x,
+-- asind(x),
+-- asind(x) IN (-90,-30,0,30,90) AS asind_exact,
+-- acosd(x),
+-- acosd(x) IN (0,60,90,120,180) AS acosd_exact
+-- FROM (VALUES (-1), (-0.5), (0), (0.5), (1)) AS t(x);
+
+-- SELECT x,
+-- atand(x),
+-- atand(x) IN (-90,-45,0,45,90) AS atand_exact
+-- FROM (VALUES ('-Infinity'::float8), (-1), (0), (1),
+-- ('Infinity'::float8)) AS t(x);
+
+-- SELECT x, y,
+-- atan2d(y, x),
+-- atan2d(y, x) IN (-90,0,90,180) AS atan2d_exact
+-- FROM (SELECT 10*cosd(a), 10*sind(a)
+-- FROM generate_series(0, 360, 90) AS t(a)) AS t(x,y);
+
+-- We do not support creating types, skip the test below
+--
+-- test output (and round-trip safety) of various values.
+-- To ensure we're testing what we think we're testing, start with
+-- float values specified by bit patterns (as a useful side effect,
+-- this means we'll fail on non-IEEE platforms).
+
+-- create type xfloat8;
+-- create function xfloat8in(cstring) returns xfloat8 immutable strict
+-- language internal as 'int8in';
+-- create function xfloat8out(xfloat8) returns cstring immutable strict
+-- language internal as 'int8out';
+-- create type xfloat8 (input = xfloat8in, output = xfloat8out, like = float8);
+-- create cast (xfloat8 as float8) without function;
+-- create cast (float8 as xfloat8) without function;
+-- create cast (xfloat8 as bigint) without function;
+-- create cast (bigint as xfloat8) without function;
+
+-- float8: seeeeeee eeeeeeee eeeeeeee mmmmmmmm mmmmmmmm(x4)
+
+-- we don't care to assume the platform's strtod() handles subnormals
+-- correctly; those are "use at your own risk". However we do test
+-- subnormal outputs, since those are under our control.
+
+-- with testdata(bits) as (values
+-- -- small subnormals
+-- (x'0000000000000001'),
+-- (x'0000000000000002'), (x'0000000000000003'),
+-- (x'0000000000001000'), (x'0000000100000000'),
+-- (x'0000010000000000'), (x'0000010100000000'),
+-- (x'0000400000000000'), (x'0000400100000000'),
+-- (x'0000800000000000'), (x'0000800000000001'),
+-- -- these values taken from upstream testsuite
+-- (x'00000000000f4240'),
+-- (x'00000000016e3600'),
+-- (x'0000008cdcdea440'),
+-- -- borderline between subnormal and normal
+-- (x'000ffffffffffff0'), (x'000ffffffffffff1'),
+-- (x'000ffffffffffffe'), (x'000fffffffffffff'))
+-- select float8send(flt) as ibits,
+-- flt
+-- from (select bits::bigint::xfloat8::float8 as flt
+-- from testdata
+-- offset 0) s;
+
+-- round-trip tests
+
+-- with testdata(bits) as (values
+-- (x'0000000000000000'),
+-- -- smallest normal values
+-- (x'0010000000000000'), (x'0010000000000001'),
+-- (x'0010000000000002'), (x'0018000000000000'),
+-- --
+-- (x'3ddb7cdfd9d7bdba'), (x'3ddb7cdfd9d7bdbb'), (x'3ddb7cdfd9d7bdbc'),
+-- (x'3e112e0be826d694'), (x'3e112e0be826d695'), (x'3e112e0be826d696'),
+-- (x'3e45798ee2308c39'), (x'3e45798ee2308c3a'), (x'3e45798ee2308c3b'),
+-- (x'3e7ad7f29abcaf47'), (x'3e7ad7f29abcaf48'), (x'3e7ad7f29abcaf49'),
+-- (x'3eb0c6f7a0b5ed8c'), (x'3eb0c6f7a0b5ed8d'), (x'3eb0c6f7a0b5ed8e'),
+-- (x'3ee4f8b588e368ef'), (x'3ee4f8b588e368f0'), (x'3ee4f8b588e368f1'),
+-- (x'3f1a36e2eb1c432c'), (x'3f1a36e2eb1c432d'), (x'3f1a36e2eb1c432e'),
+-- (x'3f50624dd2f1a9fb'), (x'3f50624dd2f1a9fc'), (x'3f50624dd2f1a9fd'),
+-- (x'3f847ae147ae147a'), (x'3f847ae147ae147b'), (x'3f847ae147ae147c'),
+-- (x'3fb9999999999999'), (x'3fb999999999999a'), (x'3fb999999999999b'),
+-- -- values very close to 1
+-- (x'3feffffffffffff0'), (x'3feffffffffffff1'), (x'3feffffffffffff2'),
+-- (x'3feffffffffffff3'), (x'3feffffffffffff4'), (x'3feffffffffffff5'),
+-- (x'3feffffffffffff6'), (x'3feffffffffffff7'), (x'3feffffffffffff8'),
+-- (x'3feffffffffffff9'), (x'3feffffffffffffa'), (x'3feffffffffffffb'),
+-- (x'3feffffffffffffc'), (x'3feffffffffffffd'), (x'3feffffffffffffe'),
+-- (x'3fefffffffffffff'),
+-- (x'3ff0000000000000'),
+-- (x'3ff0000000000001'), (x'3ff0000000000002'), (x'3ff0000000000003'),
+-- (x'3ff0000000000004'), (x'3ff0000000000005'), (x'3ff0000000000006'),
+-- (x'3ff0000000000007'), (x'3ff0000000000008'), (x'3ff0000000000009'),
+-- --
+-- (x'3ff921fb54442d18'),
+-- (x'4005bf0a8b14576a'),
+-- (x'400921fb54442d18'),
+-- --
+-- (x'4023ffffffffffff'), (x'4024000000000000'), (x'4024000000000001'),
+-- (x'4058ffffffffffff'), (x'4059000000000000'), (x'4059000000000001'),
+-- (x'408f3fffffffffff'), (x'408f400000000000'), (x'408f400000000001'),
+-- (x'40c387ffffffffff'), (x'40c3880000000000'), (x'40c3880000000001'),
+-- (x'40f869ffffffffff'), (x'40f86a0000000000'), (x'40f86a0000000001'),
+-- (x'412e847fffffffff'), (x'412e848000000000'), (x'412e848000000001'),
+-- (x'416312cfffffffff'), (x'416312d000000000'), (x'416312d000000001'),
+-- (x'4197d783ffffffff'), (x'4197d78400000000'), (x'4197d78400000001'),
+-- (x'41cdcd64ffffffff'), (x'41cdcd6500000000'), (x'41cdcd6500000001'),
+-- (x'4202a05f1fffffff'), (x'4202a05f20000000'), (x'4202a05f20000001'),
+-- (x'42374876e7ffffff'), (x'42374876e8000000'), (x'42374876e8000001'),
+-- (x'426d1a94a1ffffff'), (x'426d1a94a2000000'), (x'426d1a94a2000001'),
+-- (x'42a2309ce53fffff'), (x'42a2309ce5400000'), (x'42a2309ce5400001'),
+-- (x'42d6bcc41e8fffff'), (x'42d6bcc41e900000'), (x'42d6bcc41e900001'),
+-- (x'430c6bf52633ffff'), (x'430c6bf526340000'), (x'430c6bf526340001'),
+-- (x'4341c37937e07fff'), (x'4341c37937e08000'), (x'4341c37937e08001'),
+-- (x'4376345785d89fff'), (x'4376345785d8a000'), (x'4376345785d8a001'),
+-- (x'43abc16d674ec7ff'), (x'43abc16d674ec800'), (x'43abc16d674ec801'),
+-- (x'43e158e460913cff'), (x'43e158e460913d00'), (x'43e158e460913d01'),
+-- (x'4415af1d78b58c3f'), (x'4415af1d78b58c40'), (x'4415af1d78b58c41'),
+-- (x'444b1ae4d6e2ef4f'), (x'444b1ae4d6e2ef50'), (x'444b1ae4d6e2ef51'),
+-- (x'4480f0cf064dd591'), (x'4480f0cf064dd592'), (x'4480f0cf064dd593'),
+-- (x'44b52d02c7e14af5'), (x'44b52d02c7e14af6'), (x'44b52d02c7e14af7'),
+-- (x'44ea784379d99db3'), (x'44ea784379d99db4'), (x'44ea784379d99db5'),
+-- (x'45208b2a2c280290'), (x'45208b2a2c280291'), (x'45208b2a2c280292'),
+-- --
+-- (x'7feffffffffffffe'), (x'7fefffffffffffff'),
+-- -- round to even tests (+ve)
+-- (x'4350000000000002'),
+-- (x'4350000000002e06'),
+-- (x'4352000000000003'),
+-- (x'4352000000000004'),
+-- (x'4358000000000003'),
+-- (x'4358000000000004'),
+-- (x'435f000000000020'),
+-- -- round to even tests (-ve)
+-- (x'c350000000000002'),
+-- (x'c350000000002e06'),
+-- (x'c352000000000003'),
+-- (x'c352000000000004'),
+-- (x'c358000000000003'),
+-- (x'c358000000000004'),
+-- (x'c35f000000000020'),
+-- -- exercise fixed-point memmoves
+-- (x'42dc12218377de66'),
+-- (x'42a674e79c5fe51f'),
+-- (x'4271f71fb04cb74c'),
+-- (x'423cbe991a145879'),
+-- (x'4206fee0e1a9e061'),
+-- (x'41d26580b487e6b4'),
+-- (x'419d6f34540ca453'),
+-- (x'41678c29dcd6e9dc'),
+-- (x'4132d687e3df217d'),
+-- (x'40fe240c9fcb68c8'),
+-- (x'40c81cd6e63c53d3'),
+-- (x'40934a4584fd0fdc'),
+-- (x'405edd3c07fb4c93'),
+-- (x'4028b0fcd32f7076'),
+-- (x'3ff3c0ca428c59f8'),
+-- -- these cases come from the upstream's testsuite
+-- -- LotsOfTrailingZeros)
+-- (x'3e60000000000000'),
+-- -- Regression
+-- (x'c352bd2668e077c4'),
+-- (x'434018601510c000'),
+-- (x'43d055dc36f24000'),
+-- (x'43e052961c6f8000'),
+-- (x'3ff3c0ca2a5b1d5d'),
+-- -- LooksLikePow5
+-- (x'4830f0cf064dd592'),
+-- (x'4840f0cf064dd592'),
+-- (x'4850f0cf064dd592'),
+-- -- OutputLength
+-- (x'3ff3333333333333'),
+-- (x'3ff3ae147ae147ae'),
+-- (x'3ff3be76c8b43958'),
+-- (x'3ff3c083126e978d'),
+-- (x'3ff3c0c1fc8f3238'),
+-- (x'3ff3c0c9539b8887'),
+-- (x'3ff3c0ca2a5b1d5d'),
+-- (x'3ff3c0ca4283de1b'),
+-- (x'3ff3c0ca43db770a'),
+-- (x'3ff3c0ca428abd53'),
+-- (x'3ff3c0ca428c1d2b'),
+-- (x'3ff3c0ca428c51f2'),
+-- (x'3ff3c0ca428c58fc'),
+-- (x'3ff3c0ca428c59dd'),
+-- (x'3ff3c0ca428c59f8'),
+-- (x'3ff3c0ca428c59fb'),
+-- -- 32-bit chunking
+-- (x'40112e0be8047a7d'),
+-- (x'40112e0be815a889'),
+-- (x'40112e0be826d695'),
+-- (x'40112e0be83804a1'),
+-- (x'40112e0be84932ad'),
+-- -- MinMaxShift
+-- (x'0040000000000000'),
+-- (x'007fffffffffffff'),
+-- (x'0290000000000000'),
+-- (x'029fffffffffffff'),
+-- (x'4350000000000000'),
+-- (x'435fffffffffffff'),
+-- (x'1330000000000000'),
+-- (x'133fffffffffffff'),
+-- (x'3a6fa7161a4d6e0c')
+-- )
+-- select float8send(flt) as ibits,
+-- flt,
+-- flt::text::float8 as r_flt,
+-- float8send(flt::text::float8) as obits,
+-- float8send(flt::text::float8) = float8send(flt) as correct
+-- from (select bits::bigint::xfloat8::float8 as flt
+-- from testdata
+-- offset 0) s;
+
+-- clean up, lest opr_sanity complain
+-- drop type xfloat8 cascade;
+DROP TABLE FLOAT8_TBL;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/groupingsets.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/groupingsets.sql
new file mode 100644
index 000000000000..f06b0276b008
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/groupingsets.sql
@@ -0,0 +1,561 @@
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+-- GROUPING SETS
+-- https://github.com/postgres/postgres/blob/REL_12_STABLE/src/test/regress/sql/groupingsets.sql
+
+-- test data sources
+
+create temp view gstest1(a,b,v)
+ as values (1,1,10),(1,1,11),(1,2,12),(1,2,13),(1,3,14),
+ (2,3,15),
+ (3,3,16),(3,4,17),
+ (4,1,18),(4,1,19);
+
+-- Since Spark doesn't support CREATE TEMPORARY TABLE, we used CREATE TABLE instead
+-- create temp table gstest2 (a integer, b integer, c integer, d integer,
+-- e integer, f integer, g integer, h integer);
+create table gstest2 (a integer, b integer, c integer, d integer,
+ e integer, f integer, g integer, h integer) using parquet;
+-- [SPARK-29386] Copy data between a file and a table
+-- copy gstest2 from stdin;
+-- 1 1 1 1 1 1 1 1
+-- 1 1 1 1 1 1 1 2
+-- 1 1 1 1 1 1 2 2
+-- 1 1 1 1 1 2 2 2
+-- 1 1 1 1 2 2 2 2
+-- 1 1 1 2 2 2 2 2
+-- 1 1 2 2 2 2 2 2
+-- 1 2 2 2 2 2 2 2
+-- 2 2 2 2 2 2 2 2
+-- \.
+insert into gstest2 values
+ (1, 1, 1, 1, 1, 1, 1, 1),
+ (1, 1, 1, 1, 1, 1, 1, 2),
+ (1, 1, 1, 1, 1, 1, 2, 2),
+ (1, 1, 1, 1, 1, 2, 2, 2),
+ (1, 1, 1, 1, 2, 2, 2, 2),
+ (1, 1, 1, 2, 2, 2, 2, 2),
+ (1, 1, 2, 2, 2, 2, 2, 2),
+ (1, 2, 2, 2, 2, 2, 2, 2),
+ (2, 2, 2, 2, 2, 2, 2, 2);
+
+-- Since Spark doesn't support CREATE TEMPORARY TABLE, we used CREATE TABLE instead
+-- create temp table gstest3 (a integer, b integer, c integer, d integer);
+create table gstest3 (a integer, b integer, c integer, d integer) using parquet;
+-- [SPARK-29386] Copy data between a file and a table
+-- copy gstest3 from stdin;
+-- 1 1 1 1
+-- 2 2 2 2
+-- \.
+insert into gstest3 values
+ (1, 1, 1, 1),
+ (2, 2, 2, 2);
+-- [SPARK-19842] Informational Referential Integrity Constraints Support in Spark
+-- alter table gstest3 add primary key (a);
+
+-- Since Spark doesn't support CREATE TEMPORARY TABLE, we used CREATE TABLE instead
+-- create temp table gstest4(id integer, v integer,
+-- unhashable_col bit(4), unsortable_col xid);
+-- [SPARK-29697] Support bit string types/literals
+create table gstest4(id integer, v integer,
+ unhashable_col /* bit(4) */ byte, unsortable_col /* xid */ integer) using parquet;
+insert into gstest4
+-- values (1,1,b'0000','1'), (2,2,b'0001','1'),
+-- (3,4,b'0010','2'), (4,8,b'0011','2'),
+-- (5,16,b'0000','2'), (6,32,b'0001','2'),
+-- (7,64,b'0010','1'), (8,128,b'0011','1');
+values (1,1,tinyint('0'),1), (2,2,tinyint('1'),1),
+ (3,4,tinyint('2'),2), (4,8,tinyint('3'),2),
+ (5,16,tinyint('0'),2), (6,32,tinyint('1'),2),
+ (7,64,tinyint('2'),1), (8,128,tinyint('3'),1);
+
+-- Since Spark doesn't support CREATE TEMPORARY TABLE, we used CREATE TABLE instead
+-- create temp table gstest_empty (a integer, b integer, v integer);
+create table gstest_empty (a integer, b integer, v integer) using parquet;
+
+-- Spark doesn't handle UDFs in SQL
+-- create function gstest_data(v integer, out a integer, out b integer)
+-- returns setof record
+-- as $f$
+-- begin
+-- return query select v, i from generate_series(1,3) i;
+-- end;
+-- $f$ language plpgsql;
+
+-- basic functionality
+
+-- Ignore a PostgreSQL-specific option
+-- set enable_hashagg = false; -- test hashing explicitly later
+
+-- simple rollup with multiple plain aggregates, with and without ordering
+-- (and with ordering differing from grouping)
+
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- select a, b, grouping(a,b), sum(v), count(*), max(v)
+select a, b, grouping(a), grouping(b), sum(v), count(*), max(v)
+ from gstest1 group by rollup (a,b);
+-- select a, b, grouping(a,b), sum(v), count(*), max(v)
+select a, b, grouping(a), grouping(b), sum(v), count(*), max(v)
+ from gstest1 group by rollup (a,b) order by a,b;
+-- select a, b, grouping(a,b), sum(v), count(*), max(v)
+select a, b, grouping(a), grouping(b), sum(v), count(*), max(v)
+ from gstest1 group by rollup (a,b) order by b desc, a;
+-- select a, b, grouping(a,b), sum(v), count(*), max(v)
+select a, b, grouping(a), grouping(b), sum(v), count(*), max(v)
+ from gstest1 group by rollup (a,b) order by coalesce(a,0)+coalesce(b,0), a;
+
+-- [SPARK-28664] ORDER BY in aggregate function
+-- various types of ordered aggs
+-- select a, b, grouping(a,b),
+-- array_agg(v order by v),
+-- string_agg(string(v:text, ':' order by v desc),
+-- percentile_disc(0.5) within group (order by v),
+-- rank(1,2,12) within group (order by a,b,v)
+-- from gstest1 group by rollup (a,b) order by a,b;
+
+-- [SPARK-28664] ORDER BY in aggregate function
+-- test usage of grouped columns in direct args of aggs
+-- select grouping(a), a, array_agg(b),
+-- rank(a) within group (order by b nulls first),
+-- rank(a) within group (order by b nulls last)
+-- from (values (1,1),(1,4),(1,5),(3,1),(3,2)) v(a,b)
+-- group by rollup (a) order by a;
+
+-- nesting with window functions
+-- [SPARK-29699] Different answers in nested aggregates with window functions
+select a, b, sum(c), sum(sum(c)) over (order by a,b) as rsum
+ from gstest2 group by rollup (a,b) order by rsum, a, b;
+
+-- [SPARK-29700] Support nested grouping sets
+-- nesting with grouping sets
+-- select sum(c) from gstest2
+-- group by grouping sets((), grouping sets((), grouping sets(())))
+-- order by 1 desc;
+-- select sum(c) from gstest2
+-- group by grouping sets((), grouping sets((), grouping sets(((a, b)))))
+-- order by 1 desc;
+-- select sum(c) from gstest2
+-- group by grouping sets(grouping sets(rollup(c), grouping sets(cube(c))))
+-- order by 1 desc;
+-- select sum(c) from gstest2
+-- group by grouping sets(a, grouping sets(a, cube(b)))
+-- order by 1 desc;
+-- select sum(c) from gstest2
+-- group by grouping sets(grouping sets((a, (b))))
+-- order by 1 desc;
+-- select sum(c) from gstest2
+-- group by grouping sets(grouping sets((a, b)))
+-- order by 1 desc;
+-- select sum(c) from gstest2
+-- group by grouping sets(grouping sets(a, grouping sets(a), a))
+-- order by 1 desc;
+-- select sum(c) from gstest2
+-- group by grouping sets(grouping sets(a, grouping sets(a, grouping sets(a), ((a)), a, grouping sets(a), (a)), a))
+-- order by 1 desc;
+-- select sum(c) from gstest2
+-- group by grouping sets((a,(a,b)), grouping sets((a,(a,b)),a))
+-- order by 1 desc;
+
+-- empty input: first is 0 rows, second 1, third 3 etc.
+select a, b, sum(v), count(*) from gstest_empty group by grouping sets ((a,b),a);
+-- [SPARK-29701] Different answers when empty input given in GROUPING SETS
+select a, b, sum(v), count(*) from gstest_empty group by grouping sets ((a,b),());
+select a, b, sum(v), count(*) from gstest_empty group by grouping sets ((a,b),(),(),());
+select sum(v), count(*) from gstest_empty group by grouping sets ((),(),());
+
+-- empty input with joins tests some important code paths
+-- [SPARK-29701] Different answers when empty input given in GROUPING SETS
+select t1.a, t2.b, sum(t1.v), count(*) from gstest_empty t1, gstest_empty t2
+ group by grouping sets ((t1.a,t2.b),());
+
+-- simple joins, var resolution, GROUPING on join vars
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- select t1.a, t2.b, grouping(t1.a, t2.b), sum(t1.v), max(t2.a)
+select t1.a, t2.b, grouping(t1.a), grouping(t2.b), sum(t1.v), max(t2.a)
+ from gstest1 t1, gstest2 t2
+ group by grouping sets ((t1.a, t2.b), ());
+
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- select t1.a, t2.b, grouping(t1.a, t2.b), sum(t1.v), max(t2.a)
+select t1.a, t2.b, grouping(t1.a), grouping(t2.b), sum(t1.v), max(t2.a)
+ from gstest1 t1 join gstest2 t2 on (t1.a=t2.a)
+ group by grouping sets ((t1.a, t2.b), ());
+
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- select a, b, grouping(a, b), sum(t1.v), max(t2.c)
+select a, b, grouping(a), grouping(b), sum(t1.v), max(t2.c)
+ from gstest1 t1 join gstest2 t2 using (a,b)
+ group by grouping sets ((a, b), ());
+
+-- check that functionally dependent cols are not nulled
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- [SPARK-19842] Informational Referential Integrity Constraints Support in Spark
+-- [SPARK-29702] Resolve group-by columns with functional dependencies
+-- select a, d, grouping(a,b,c)
+-- from gstest3
+-- group by grouping sets ((a,b), (a,c));
+
+-- check that distinct grouping columns are kept separate
+-- even if they are equal()
+-- explain (costs off)
+-- select g as alias1, g as alias2
+-- from generate_series(1,3) g
+-- group by alias1, rollup(alias2);
+
+-- [SPARK-27767] Built-in function: generate_series
+-- [SPARK-29704] Support the combinations of grouping operations
+-- select g as alias1, g as alias2
+-- from generate_series(1,3) g
+-- group by alias1, rollup(alias2);
+
+-- check that pulled-up subquery outputs still go to null when appropriate
+select four, x
+ from (select four, ten, 'foo' as x from tenk1) as t
+ group by grouping sets (four, x)
+ having x = 'foo';
+
+select four, x || 'x'
+ from (select four, ten, 'foo' as x from tenk1) as t
+ group by grouping sets (four, x)
+ order by four;
+
+select (x+y)*1, sum(z)
+ from (select 1 as x, 2 as y, 3 as z) s
+ group by grouping sets (x+y, x);
+
+CREATE TEMP VIEW int8_tbl AS SELECT * FROM VALUES
+ (123L, 456L),
+ (123L, 4567890123456789L),
+ (4567890123456789L, 123L),
+ (4567890123456789L, 4567890123456789L),
+ (4567890123456789L, -4567890123456789L) as int8_tbl(q1, q2);
+
+select x, not x as not_x, q2 from
+ (select *, q1 = 1 as x from int8_tbl i1) as t
+ group by grouping sets(x, q2)
+ order by x, q2;
+
+DROP VIEW int8_tbl;
+
+-- simple rescan tests
+
+-- Spark doesn't handle UDFs in SQL
+-- select a, b, sum(v.x)
+-- from (values (1),(2)) v(x), gstest_data(v.x)
+-- group by rollup (a,b);
+
+-- Spark doesn't handle UDFs in SQL
+-- select *
+-- from (values (1),(2)) v(x),
+-- lateral (select a, b, sum(v.x) from gstest_data(v.x) group by rollup (a,b)) s;
+
+-- min max optimization should still work with GROUP BY ()
+-- explain (costs off)
+-- select min(unique1) from tenk1 GROUP BY ();
+
+-- Views with GROUPING SET queries
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- [SPARK-29705] Support more expressive forms in GroupingSets/Cube/Rollup
+-- CREATE VIEW gstest_view AS select a, b, grouping(a,b), sum(c), count(*), max(c)
+-- from gstest2 group by rollup ((a,b,c),(c,d));
+
+-- select pg_get_viewdef('gstest_view'::regclass, true);
+
+-- Nested queries with 3 or more levels of nesting
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- [SPARK-29703] grouping() can only be used with GroupingSets/Cube/Rollup
+-- select(select (select grouping(a,b) from (values (1)) v2(c)) from (values (1,2)) v1(a,b) group by (a,b)) from (values(6,7)) v3(e,f) GROUP BY ROLLUP(e,f);
+-- select(select (select grouping(e,f) from (values (1)) v2(c)) from (values (1,2)) v1(a,b) group by (a,b)) from (values(6,7)) v3(e,f) GROUP BY ROLLUP(e,f);
+-- select(select (select grouping(c) from (values (1)) v2(c) GROUP BY c) from (values (1,2)) v1(a,b) group by (a,b)) from (values(6,7)) v3(e,f) GROUP BY ROLLUP(e,f);
+
+-- Combinations of operations
+-- [SPARK-29704] Support the combinations of grouping operations
+-- select a, b, c, d from gstest2 group by rollup(a,b),grouping sets(c,d);
+-- select a, b from (values (1,2),(2,3)) v(a,b) group by a,b, grouping sets(a);
+
+-- Spark doesn't handle UDFs in SQL
+-- Tests for chained aggregates
+-- select a, b, grouping(a,b), sum(v), count(*), max(v)
+-- from gstest1 group by grouping sets ((a,b),(a+1,b+1),(a+2,b+2)) order by 3,6;
+-- select(select (select grouping(a,b) from (values (1)) v2(c)) from (values (1,2)) v1(a,b) group by (a,b)) from (values(6,7)) v3(e,f) GROUP BY ROLLUP((e+1),(f+1));
+-- select(select (select grouping(a,b) from (values (1)) v2(c)) from (values (1,2)) v1(a,b) group by (a,b)) from (values(6,7)) v3(e,f) GROUP BY CUBE((e+1),(f+1)) ORDER BY (e+1),(f+1);
+-- select a, b, sum(c), sum(sum(c)) over (order by a,b) as rsum
+-- from gstest2 group by cube (a,b) order by rsum, a, b;
+-- select a, b, sum(c) from (values (1,1,10),(1,1,11),(1,2,12),(1,2,13),(1,3,14),(2,3,15),(3,3,16),(3,4,17),(4,1,18),(4,1,19)) v(a,b,c) group by rollup (a,b);
+-- select a, b, sum(v.x)
+-- from (values (1),(2)) v(x), gstest_data(v.x)
+-- group by cube (a,b) order by a,b;
+
+-- Test reordering of grouping sets
+-- explain (costs off)
+-- select * from gstest1 group by grouping sets((a,b,v),(v)) order by v,b,a;
+
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- [SPARK-29703] grouping() can only be used with GroupingSets/Cube/Rollup
+-- Agg level check. This query should error out.
+-- select (select grouping(a), grouping(b) from gstest2) from gstest2 group by a,b;
+
+--Nested queries
+-- [SPARK-29700] Support nested grouping sets
+-- select a, b, sum(c), count(*) from gstest2 group by grouping sets (rollup(a,b),a);
+
+-- HAVING queries
+select ten, sum(distinct four) from onek a
+group by grouping sets((ten,four),(ten))
+having exists (select 1 from onek b where sum(distinct a.four) = b.four);
+
+-- Tests around pushdown of HAVING clauses, partially testing against previous bugs
+select a,count(*) from gstest2 group by rollup(a) order by a;
+select a,count(*) from gstest2 group by rollup(a) having a is distinct from 1 order by a;
+-- explain (costs off)
+-- select a,count(*) from gstest2 group by rollup(a) having a is distinct from 1 order by a;
+
+-- [SPARK-29706] Support an empty grouping expression
+-- select v.c, (select count(*) from gstest2 group by () having v.c)
+-- from (values (false),(true)) v(c) order by v.c;
+-- explain (costs off)
+-- select v.c, (select count(*) from gstest2 group by () having v.c)
+-- from (values (false),(true)) v(c) order by v.c;
+
+-- HAVING with GROUPING queries
+select ten, grouping(ten) from onek
+group by grouping sets(ten) having grouping(ten) >= 0
+order by 2,1;
+select ten, grouping(ten) from onek
+group by grouping sets(ten, four) having grouping(ten) > 0
+order by 2,1;
+select ten, grouping(ten) from onek
+group by rollup(ten) having grouping(ten) > 0
+order by 2,1;
+select ten, grouping(ten) from onek
+group by cube(ten) having grouping(ten) > 0
+order by 2,1;
+-- [SPARK-29703] grouping() can only be used with GroupingSets/Cube/Rollup
+-- select ten, grouping(ten) from onek
+-- group by (ten) having grouping(ten) >= 0
+-- order by 2,1;
+
+-- FILTER queries
+select ten, sum(distinct four) filter (where string(four) like '123') from onek a
+group by rollup(ten);
+
+-- More rescan tests
+-- [SPARK-35554] Support outer references in Aggregate
+-- select * from (values (1),(2)) v(a) left join lateral (select v.a, four, ten, count(*) from onek group by cube(four,ten)) s on true order by v.a,four,ten;
+-- [SPARK-27878] Support ARRAY(sub-SELECT) expressions
+-- select array(select row(v.a,s1.*) from (select two,four, count(*) from onek group by cube(two,four) order by two,four) s1) from (values (1),(2)) v(a);
+
+-- [SPARK-29704] Support the combinations of grouping operations
+-- Grouping on text columns
+-- select sum(ten) from onek group by two, rollup(string(four)) order by 1;
+-- select sum(ten) from onek group by rollup(string(four)), two order by 1;
+
+-- hashing support
+
+-- Ignore a PostgreSQL-specific option
+-- set enable_hashagg = true;
+
+-- failure cases
+
+-- Since this test is implementation specific for plans, it passes in Spark
+select count(*) from gstest4 group by rollup(unhashable_col,unsortable_col);
+-- [SPARK-27878] Support ARRAY(sub-SELECT) expressions
+-- select array_agg(v order by v) from gstest4 group by grouping sets ((id,unsortable_col),(id));
+
+-- simple cases
+
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- select a, b, grouping(a,b), sum(v), count(*), max(v)
+select a, b, grouping(a), grouping(b), sum(v), count(*), max(v)
+ from gstest1 group by grouping sets ((a),(b)) order by 3,4,1,2 /* 3,1,2 */;
+-- explain (costs off) select a, b, grouping(a,b), sum(v), count(*), max(v)
+-- from gstest1 group by grouping sets ((a),(b)) order by 3,1,2;
+
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- select a, b, grouping(a,b), sum(v), count(*), max(v)
+select a, b, grouping(a), grouping(b), sum(v), count(*), max(v)
+ from gstest1 group by cube(a,b) order by 3,4,1,2 /* 3,1,2 */;
+-- explain (costs off) select a, b, grouping(a,b), sum(v), count(*), max(v)
+-- from gstest1 group by cube(a,b) order by 3,1,2;
+
+-- shouldn't try and hash
+-- explain (costs off)
+-- select a, b, grouping(a,b), array_agg(v order by v)
+-- from gstest1 group by cube(a,b);
+
+-- unsortable cases
+select unsortable_col, count(*)
+ from gstest4 group by grouping sets ((unsortable_col),(unsortable_col))
+ order by string(unsortable_col);
+
+-- mixed hashable/sortable cases
+-- [SPARK-29698] Support grouping function with multiple arguments
+select unhashable_col, unsortable_col,
+ -- grouping(unhashable_col, unsortable_col),
+ grouping(unhashable_col), grouping(unsortable_col),
+ count(*), sum(v)
+ from gstest4 group by grouping sets ((unhashable_col),(unsortable_col))
+ order by 3, 4, 6 /* 3, 5 */;
+-- explain (costs off)
+-- select unhashable_col, unsortable_col,
+-- grouping(unhashable_col, unsortable_col),
+-- count(*), sum(v)
+-- from gstest4 group by grouping sets ((unhashable_col),(unsortable_col))
+-- order by 3,5;
+
+-- [SPARK-29698] Support grouping function with multiple arguments
+select unhashable_col, unsortable_col,
+ -- grouping(unhashable_col, unsortable_col),
+ grouping(unhashable_col), grouping(unsortable_col),
+ count(*), sum(v)
+ from gstest4 group by grouping sets ((v,unhashable_col),(v,unsortable_col))
+ order by 3, 4, 6 /* 3,5 */;
+-- explain (costs off)
+-- select unhashable_col, unsortable_col,
+-- grouping(unhashable_col, unsortable_col),
+-- count(*), sum(v)
+-- from gstest4 group by grouping sets ((v,unhashable_col),(v,unsortable_col))
+-- order by 3,5;
+
+-- empty input: first is 0 rows, second 1, third 3 etc.
+select a, b, sum(v), count(*) from gstest_empty group by grouping sets ((a,b),a);
+-- explain (costs off)
+-- select a, b, sum(v), count(*) from gstest_empty group by grouping sets ((a,b),a);
+-- [SPARK-29701] Different answers when empty input given in GROUPING SETS
+select a, b, sum(v), count(*) from gstest_empty group by grouping sets ((a,b),());
+select a, b, sum(v), count(*) from gstest_empty group by grouping sets ((a,b),(),(),());
+-- explain (costs off)
+-- select a, b, sum(v), count(*) from gstest_empty group by grouping sets ((a,b),(),(),());
+-- [SPARK-29701] Different answers when empty input given in GROUPING SETS
+select sum(v), count(*) from gstest_empty group by grouping sets ((),(),());
+-- explain (costs off)
+-- select sum(v), count(*) from gstest_empty group by grouping sets ((),(),());
+
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- [SPARK-19842] Informational Referential Integrity Constraints Support in Spark
+-- [SPARK-29702] Resolve group-by columns with functional dependencies
+-- check that functionally dependent cols are not nulled
+-- select a, d, grouping(a,b,c)
+-- from gstest3
+-- group by grouping sets ((a,b), (a,c));
+-- explain (costs off)
+-- select a, d, grouping(a,b,c)
+-- from gstest3
+-- group by grouping sets ((a,b), (a,c));
+
+-- simple rescan tests
+
+-- select a, b, sum(v.x)
+-- from (values (1),(2)) v(x), gstest_data(v.x)
+-- group by grouping sets (a,b)
+-- order by 1, 2, 3;
+-- explain (costs off)
+-- select a, b, sum(v.x)
+-- from (values (1),(2)) v(x), gstest_data(v.x)
+-- group by grouping sets (a,b)
+-- order by 3, 1, 2;
+-- select *
+-- from (values (1),(2)) v(x),
+-- lateral (select a, b, sum(v.x) from gstest_data(v.x) group by grouping sets (a,b)) s;
+-- explain (costs off)
+-- select *
+-- from (values (1),(2)) v(x),
+-- lateral (select a, b, sum(v.x) from gstest_data(v.x) group by grouping sets (a,b)) s;
+
+-- Tests for chained aggregates
+-- [SPARK-29698] Support grouping function with multiple arguments
+-- select a, b, grouping(a,b), sum(v), count(*), max(v)
+select a, b, grouping(a), grouping(b), sum(v), count(*), max(v)
+ from gstest1 group by grouping sets ((a,b),(a+1,b+1),(a+2,b+2)) order by 3,4,7 /* 3,6 */;
+-- explain (costs off)
+-- select a, b, grouping(a,b), sum(v), count(*), max(v)
+-- from gstest1 group by grouping sets ((a,b),(a+1,b+1),(a+2,b+2)) order by 3,6;
+-- [SPARK-29699] Different answers in nested aggregates with window functions
+select a, b, sum(c), sum(sum(c)) over (order by a,b) as rsum
+ from gstest2 group by cube (a,b) order by rsum, a, b;
+-- explain (costs off)
+-- select a, b, sum(c), sum(sum(c)) over (order by a,b) as rsum
+-- from gstest2 group by cube (a,b) order by rsum, a, b;
+-- select a, b, sum(v.x)
+-- from (values (1),(2)) v(x), gstest_data(v.x)
+-- group by cube (a,b) order by a,b;
+-- explain (costs off)
+-- select a, b, sum(v.x)
+-- from (values (1),(2)) v(x), gstest_data(v.x)
+-- group by cube (a,b) order by a,b;
+
+-- Verify that we correctly handle the child node returning a
+-- non-minimal slot, which happens if the input is pre-sorted,
+-- e.g. due to an index scan.
+-- BEGIN;
+-- Ignore a PostgreSQL-specific option
+-- SET LOCAL enable_hashagg = false;
+-- EXPLAIN (COSTS OFF) SELECT a, b, count(*), max(a), max(b) FROM gstest3 GROUP BY GROUPING SETS(a, b,()) ORDER BY a, b;
+SELECT a, b, count(*), max(a), max(b) FROM gstest3 GROUP BY GROUPING SETS(a, b,()) ORDER BY a, b;
+-- Ignore a PostgreSQL-specific option
+-- SET LOCAL enable_seqscan = false;
+-- EXPLAIN (COSTS OFF) SELECT a, b, count(*), max(a), max(b) FROM gstest3 GROUP BY GROUPING SETS(a, b,()) ORDER BY a, b;
+-- SELECT a, b, count(*), max(a), max(b) FROM gstest3 GROUP BY GROUPING SETS(a, b,()) ORDER BY a, b;
+-- COMMIT;
+
+-- More rescan tests
+-- [SPARK-35554] Support outer references in Aggregate
+-- select * from (values (1),(2)) v(a) left join lateral (select v.a, four, ten, count(*) from onek group by cube(four,ten)) s on true order by v.a,four,ten;
+-- [SPARK-27878] Support ARRAY(sub-SELECT) expressions
+-- select array(select row(v.a,s1.*) from (select two,four, count(*) from onek group by cube(two,four) order by two,four) s1) from (values (1),(2)) v(a);
+
+-- Rescan logic changes when there are no empty grouping sets, so test
+-- that too:
+-- [SPARK-35554] Support outer references in Aggregate
+-- select * from (values (1),(2)) v(a) left join lateral (select v.a, four, ten, count(*) from onek group by grouping sets(four,ten)) s on true order by v.a,four,ten;
+-- [SPARK-27878] Support ARRAY(sub-SELECT) expressions
+-- select array(select row(v.a,s1.*) from (select two,four, count(*) from onek group by grouping sets(two,four) order by two,four) s1) from (values (1),(2)) v(a);
+
+-- test the knapsack
+
+-- Ignore a PostgreSQL-specific option
+-- set enable_indexscan = false;
+-- set work_mem = '64kB';
+-- explain (costs off)
+-- select unique1,
+-- count(two), count(four), count(ten),
+-- count(hundred), count(thousand), count(twothousand),
+-- count(*)
+-- from tenk1 group by grouping sets (unique1,twothousand,thousand,hundred,ten,four,two);
+-- explain (costs off)
+-- select unique1,
+-- count(two), count(four), count(ten),
+-- count(hundred), count(thousand), count(twothousand),
+-- count(*)
+-- from tenk1 group by grouping sets (unique1,hundred,ten,four,two);
+
+-- Ignore a PostgreSQL-specific option
+-- set work_mem = '384kB';
+-- explain (costs off)
+-- select unique1,
+-- count(two), count(four), count(ten),
+-- count(hundred), count(thousand), count(twothousand),
+-- count(*)
+-- from tenk1 group by grouping sets (unique1,twothousand,thousand,hundred,ten,four,two);
+
+-- check collation-sensitive matching between grouping expressions
+-- (similar to a check for aggregates, but there are additional code
+-- paths for GROUPING, so check again here)
+
+-- [SPARK-28382] Array Functions: unnest
+select v||'a', case grouping(v||'a') when 1 then 1 else 0 end, count(*)
+ -- from unnest(array[1,1], array['a','b']) u(i,v)
+ from values (1, 'a'), (1, 'b') u(i,v)
+ group by rollup(i, v||'a') order by 1,3;
+select v||'a', case when grouping(v||'a') = 1 then 1 else 0 end, count(*)
+ -- from unnest(array[1,1], array['a','b']) u(i,v)
+ from values (1, 'a'), (1, 'b') u(i,v)
+ group by rollup(i, v||'a') order by 1,3;
+
+-- end
+
+DROP VIEW gstest1;
+DROP TABLE gstest2;
+DROP TABLE gstest3;
+DROP TABLE gstest4;
+DROP TABLE gstest_empty;
diff --git a/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/insert.sql b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/insert.sql
new file mode 100644
index 000000000000..6783dda9ff01
--- /dev/null
+++ b/gluten-ut/spark41/src/test/resources/backends-velox/sql-tests/inputs/postgreSQL/insert.sql
@@ -0,0 +1,653 @@
+-- Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
+--
+-- INSERT
+-- https://github.com/postgres/postgres/blob/REL_12_STABLE/src/test/regress/sql/insert.sql
+
+--
+-- insert with DEFAULT in the target_list
+--
+-- [SPARK-19842] Informational Referential Integrity Constraints Support in Spark
+-- [SPARK-29119] DEFAULT option is not supported in Spark
+create table inserttest (col1 int, col2 int /* NOT NULL */, col3 string /* default 'testing' */) using parquet;
+-- [SPARK-29119] DEFAULT option is not supported in Spark
+-- [SPARK-20845] Support specification of column names in INSERT INTO
+-- Skip a test below because the PK constraint is violated and the query fails in PostgreSQL
+-- insert into inserttest (col1, col2, col3) values (DEFAULT, DEFAULT, DEFAULT);
+-- insert into inserttest (col2, col3) values (3, DEFAULT);
+insert into inserttest values (NULL, 3, 'testing');
+-- insert into inserttest (col1, col2, col3) values (DEFAULT, 5, DEFAULT);
+insert into inserttest values (NULL, 5, 'testing');
+-- insert into inserttest values (DEFAULT, 5, 'test');
+insert into inserttest values (NULL, 5, 'test');
+-- insert into inserttest values (DEFAULT, 7);
+insert into inserttest values (NULL, 7, 'testing');
+
+select * from inserttest;
+
+--
+-- insert with similar expression / target_list values (all fail)
+--
+-- [SPARK-20845] Support specification of column names in INSERT INTO
+-- [SPARK-29119] DEFAULT option is not supported in Spark
+-- insert into inserttest (col1, col2, col3) values (DEFAULT, DEFAULT);
+-- insert into inserttest (col1, col2, col3) values (1, 2);
+-- insert into inserttest (col1) values (1, 2);
+-- insert into inserttest (col1) values (DEFAULT, DEFAULT);
+
+-- select * from inserttest;
+
+--
+-- VALUES test
+--
+-- [SPARK-29119] DEFAULT option is not supported in Spark
+-- [SPARK-29715] Support SELECT statements in VALUES of INSERT INTO
+-- insert into inserttest values(10, 20, '40'), (-1, 2, DEFAULT),
+-- ((select 2), (select i from (values(3)) as foo (i)), 'values are fun!');
+
+-- select * from inserttest;
+
+--
+-- TOASTed value test
+--
+insert into inserttest values(30, 50, repeat('x', 10000));
+
+select col1, col2, char_length(col3) from inserttest;
+
+drop table inserttest;
+
+--
+-- check indirection (field/array assignment), cf bug #14265
+--
+-- these tests are aware that transformInsertStmt has 3 separate code paths
+--
+
+-- [SPARK-29716] Support [CREATE|DROP] TYPE
+-- create type insert_test_type as (if1 int, if2 array