diff --git a/integration_tests/pom.xml b/integration_tests/pom.xml
index c40e47a5171..929c69a27e3 100644
--- a/integration_tests/pom.xml
+++ b/integration_tests/pom.xml
@@ -151,7 +151,8 @@
${skipTests}
${test}
- ${argLine}
+ ${argLine}
+ ${pytest.TEST_TAGS}
diff --git a/integration_tests/pytest.ini b/integration_tests/pytest.ini
index 0079c8610a1..19d8d87e2ea 100644
--- a/integration_tests/pytest.ini
+++ b/integration_tests/pytest.ini
@@ -19,3 +19,5 @@ markers =
ignore_order(local): Ignores the order of the result in asserts. If local is true the results are sorted in python instead of using spark.
incompat: Enable incompat operators
limit(num_rows): Limit the number of rows that will be check in a result
+ qarun: Mark qa test
+
diff --git a/integration_tests/run_pyspark_from_build.sh b/integration_tests/run_pyspark_from_build.sh
index f0ff0dd9515..bdd1e636190 100755
--- a/integration_tests/run_pyspark_from_build.sh
+++ b/integration_tests/run_pyspark_from_build.sh
@@ -31,5 +31,9 @@ else
then
TEST_ARGS="-k $TEST"
fi
- "$SPARK_HOME"/bin/spark-submit --jars "${ALL_JARS// /,}" --conf "spark.driver.extraJavaOptions=-Duser.timezone=GMT $COVERAGE_SUBMIT_FLAGS" --conf 'spark.executor.extraJavaOptions=-Duser.timezone=GMT' --conf 'spark.sql.session.timeZone=UTC' --conf 'spark.sql.shuffle.partitions=12' $SPARK_SUBMIT_FLAGS ./runtests.py -v -rfExXs --std_input_path=./src/test/resources/ "$TEST_ARGS" $RUN_TEST_PARAMS "$@"
+ if [[ "${TEST_TAGS}" != "" ]];
+ then
+ TEST_TAGS="-m $TEST_TAGS"
+ fi
+ "$SPARK_HOME"/bin/spark-submit --jars "${ALL_JARS// /,}" --conf "spark.driver.extraJavaOptions=-Duser.timezone=GMT $COVERAGE_SUBMIT_FLAGS" --conf 'spark.executor.extraJavaOptions=-Duser.timezone=GMT' --conf 'spark.sql.session.timeZone=UTC' --conf 'spark.sql.shuffle.partitions=12' $SPARK_SUBMIT_FLAGS ./runtests.py -v -rfExXs "$TEST_TAGS" --std_input_path=./src/test/resources/ "$TEST_ARGS" $RUN_TEST_PARAMS "$@"
fi
diff --git a/integration_tests/src/main/python/marks.py b/integration_tests/src/main/python/marks.py
index 37effc2e7fa..8f5b4fca242 100644
--- a/integration_tests/src/main/python/marks.py
+++ b/integration_tests/src/main/python/marks.py
@@ -19,4 +19,4 @@
ignore_order = pytest.mark.ignore_order
incompat = pytest.mark.incompat
limit = pytest.mark.limit
-
+qarun = pytest.mark.qarun
diff --git a/integration_tests/src/main/python/qa_nightly_select_test.py b/integration_tests/src/main/python/qa_nightly_select_test.py
new file mode 100644
index 00000000000..f5ff00fd0ae
--- /dev/null
+++ b/integration_tests/src/main/python/qa_nightly_select_test.py
@@ -0,0 +1,194 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.
+#
+# Licensed 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.
+
+
+from pyspark.sql.types import *
+from pyspark import SparkConf, SparkContext, SQLContext
+import datetime
+from argparse import ArgumentParser
+from decimal import Decimal
+from asserts import assert_gpu_and_cpu_are_equal_collect
+from qa_nightly_sql import *
+import pytest
+from spark_session import spark as s
+from marks import approximate_float, ignore_order, incompat, qarun
+
+def num_stringDf(spark):
+ print("### CREATE DATAFRAME 1 ####")
+ schema = StructType([StructField("strF", StringType()),
+ StructField("byteF", ByteType()),
+ StructField("shortF", ShortType()),
+ StructField("intF", IntegerType()),
+ StructField("longF", LongType()),
+ StructField("floatF", FloatType()),
+ StructField("doubleF", DoubleType()),
+ StructField("decimalF", DoubleType()),
+ StructField("booleanF", BooleanType()),
+ StructField("timestampF", TimestampType()),
+ StructField("dateF", DateType())])
+ dt = datetime.date(1990, 1, 1)
+ print(dt)
+ tm = datetime.datetime(2020,2,1,12,1,1)
+
+ data = [("FIRST", None, 500, 1200, 10, 10.001, 10.0003, 1.01, True, tm, dt),
+ ("sold out", 20, 600, None, 20, 20.12, 2.000013, 2.01, True, tm, dt),
+ ("take out", 20, 600, None, 20, 20.12, 2.000013, 2.01, True, tm, dt),
+ ("Yuan", 20, 600, 2200, None, 20.12, 2.000013, 2.01, False, tm, dt),
+ ("Alex", 30, 700, 3200, 30, None, 3.000013, 2.01, True, None, dt),
+ ("Satish", 30, 700, 3200, 30, 30.12, None, 3.01, False, tm, dt),
+ ("Gary", 40, 800, 4200, 40, 40.12, 4.000013, None, False, tm, dt),
+ ("NVIDIA", 40, 800, 4200, -40, 40.12, 4.00013, 4.01, None, tm, dt),
+ ("Mellanox", 40, 800, 4200, -20, -20.12, 4.00013, 4.01, False,None, dt),
+ (None, 30, 500, -3200, -20, 2.012, 4.000013, -4.01, False, tm, None),
+ ("NVIDIASPARKTEAM", 0, 500, -3200, -20, 2.012, 4.000013, -4.01, False, tm, dt),
+ ("NVIDIASPARKTEAM", 20, 0, -3200, -20, 2.012, 4.000013, -4.01, False, tm, dt),
+ ("NVIDIASPARKTEAM", 0, 50, 0, -20, 2.012, 4.000013, -4.01, False, tm, dt),
+ (None, 0, 500, -3200, 0, 0.0, 0.0, -4.01, False, tm, dt),
+ ("phuoc", 30, 500, 3200, -20, 20.12, 4.000013, 4.01, False, tm, dt)]
+ df = spark.createDataFrame(data,schema=schema)
+ df.createOrReplaceTempView("test_table")
+
+
+# create dataframe for join & union operation testing
+def num_stringDf_two(spark):
+ print("### CREATE DATAFRAME TWO ####")
+ schema = StructType([StructField("strF", StringType()),
+ StructField("byteF", ByteType()),
+ StructField("shortF", ShortType()),
+ StructField("intF", IntegerType()),
+ StructField("longF", LongType()),
+ StructField("floatF", FloatType()),
+ StructField("doubleF", DoubleType()),
+ StructField("decimalF", DoubleType()),
+ StructField("booleanF", BooleanType()),
+ StructField("timestampF", TimestampType()),
+ StructField("dateF", DateType())])
+
+ dt = datetime.date(2000, 1, 1)
+ print(dt)
+ tm = datetime.datetime(2022,12,1,12,1,1)
+ data = [("AL", 10, 500, 1200, 10, 10.001, 10.0003, 1.01, True, tm, dt),
+ ("Jhon", 20, 600, 2200, 20, 20.12, 2.000013, 2.01, True, tm, dt),
+ ("Alex", 30, 700, 3200, 30, 30.12, 3.000013, 3.01, True, tm, dt),
+ ("Satish", 30, 700, 3200, 30, 30.12, 3.000013, 3.01, False, tm, dt),
+ ("Kary", 40, 800, 4200, 40, 40.12, 4.000013, 4.01, False, tm, dt),
+ (None, 40, 800, 4200, -40, 40.12, 4.00013, 4.01, False, tm, dt),
+ (None, 40, 800, 4200, -20, -20.12, 4.00013, 4.01, False, tm, dt),
+ (None, 30, 500, -3200, -20, 2.012, 4.000013, -4.01, False, tm, dt),
+ ("phuoc", 30, 500, 3200, -20, 20.12, 4.000013, 4.01, False, tm, dt)]
+
+ df = spark.createDataFrame(data, schema=schema)
+ df.createOrReplaceTempView("test_table1")
+
+def num_stringDf_first_last(spark, field_name):
+ print("### CREATE DATAFRAME 1 ####")
+ schema = StructType([StructField("strF", StringType()),
+ StructField("byteF", ByteType()),
+ StructField("shortF", ShortType()),
+ StructField("intF", IntegerType()),
+ StructField("longF", LongType()),
+ StructField("floatF", FloatType()),
+ StructField("doubleF", DoubleType()),
+ StructField("decimalF", DoubleType()),
+ StructField("booleanF", BooleanType()),
+ StructField("timestampF", TimestampType()),
+ StructField("dateF", DateType())])
+ dt = datetime.date(1990, 1, 1)
+ print(dt)
+ tm = datetime.datetime(2020,2,1,12,1,1)
+
+ data = [("FIRST", None, 500, 1200, 10, 10.001, 10.0003, 1.01, True, tm, dt),
+ ("sold out", 20, 600, None, 20, 20.12, 2.000013, 2.01, True, tm, dt),
+ ("take out", 20, 600, None, 20, 20.12, 2.000013, 2.01, True, tm, dt),
+ ("Yuan", 20, 600, 2200, None, 20.12, 2.000013, 2.01, False, tm, dt),
+ ("Alex", 30, 700, 3200, 30, None, 3.000013, 2.01, True, None, dt),
+ ("Satish", 30, 700, 3200, 30, 30.12, None, 3.01, False, tm, dt),
+ ("Gary", 40, 800, 4200, 40, 40.12, 4.000013, None, False, tm, dt),
+ ("NVIDIA", 40, 800, 4200, -40, 40.12, 4.00013, 4.01, None, tm, dt),
+ ("Mellanox", 40, 800, 4200, -20, -20.12, 4.00013, 4.01, False,None, dt),
+ (None, 30, 500, -3200, -20, 2.012, 4.000013, -4.01, False, tm, None),
+ ("NVIDIASPARKTEAM", 0, 500, -3200, -20, 2.012, 4.000013, -4.01, False, tm, dt),
+ ("NVIDIASPARKTEAM", 20, 0, -3200, -20, 2.012, 4.000013, -4.01, False, tm, dt),
+ ("NVIDIASPARKTEAM", 0, 50, 0, -20, 2.012, 4.000013, -4.01, False, tm, dt),
+ (None, 0, 500, -3200, 0, 0.0, 0.0, -4.01, False, tm, dt),
+ ("phuoc", 30, 500, 3200, -20, 20.12, 4.000013, 4.01, False, tm, dt)]
+ df = spark.createDataFrame(data,schema=schema).repartition(1).orderBy(field_name)
+ df.createOrReplaceTempView("test_table")
+
+def idfn(val):
+ return val[1]
+
+_qa_conf = {
+ 'spark.rapids.sql.variableFloatAgg.enabled': 'true',
+ 'spark.rapids.sql.hasNans': 'false',
+ 'spark.rapids.sql.castStringToFloat.enabled': 'true',
+ 'spark.rapids.sql.castFloatToString.enabled': 'true',
+ 'spark.rapids.sql.expression.InitCap': 'true',
+ 'spark.rapids.sql.expression.Lower': 'true',
+ 'spark.rapids.sql.expression.Upper': 'true',
+ 'spark.rapids.sql.expression.UnixTimestamp': 'true',
+ }
+
+
+
+@approximate_float
+@incompat
+@ignore_order
+@qarun
+@pytest.mark.parametrize('sql_query_line', SELECT_SQL, ids=idfn)
+def test_select(sql_query_line, pytestconfig):
+ sql_query = sql_query_line[0]
+ if sql_query:
+ print(sql_query)
+ num_stringDf(s)
+ assert_gpu_and_cpu_are_equal_collect(lambda spark: spark.sql(sql_query), conf=_qa_conf)
+
+@approximate_float
+@incompat
+@ignore_order("local")
+@qarun
+@pytest.mark.parametrize('sql_query_line', SELECT_JOIN_SQL, ids=idfn)
+def test_select_join(sql_query_line, pytestconfig):
+ sql_query = sql_query_line[0]
+ if sql_query:
+ print(sql_query)
+ num_stringDf(s)
+ if ("UNION" in sql_query) or ("JOIN" in sql_query):
+ num_stringDf_two(s)
+ assert_gpu_and_cpu_are_equal_collect(lambda spark: spark.sql(sql_query), conf=_qa_conf)
+
+@approximate_float
+@incompat
+@ignore_order("local")
+@qarun
+@pytest.mark.parametrize('sql_query_line', SELECT_PRE_ORDER_SQL, ids=idfn)
+def test_select_first_last(sql_query_line, pytestconfig):
+ sql_query = sql_query_line[0]
+ if sql_query:
+ print(sql_query)
+ num_stringDf_first_last(s, sql_query_line[2])
+ assert_gpu_and_cpu_are_equal_collect(lambda spark: spark.sql(sql_query).orderBy('res'), conf=_qa_conf)
+
+@approximate_float(abs=1e-6)
+@incompat
+@ignore_order("local")
+@qarun
+@pytest.mark.parametrize('sql_query_line', SELECT_FLOAT_SQL, ids=idfn)
+def test_select_float_order_local(sql_query_line, pytestconfig):
+ sql_query = sql_query_line[0]
+ if sql_query:
+ print(sql_query)
+ num_stringDf(s)
+ assert_gpu_and_cpu_are_equal_collect(lambda spark: spark.sql(sql_query), conf=_qa_conf)
+
diff --git a/integration_tests/src/main/python/qa_nightly_sql.py b/integration_tests/src/main/python/qa_nightly_sql.py
new file mode 100644
index 00000000000..0b9bee57810
--- /dev/null
+++ b/integration_tests/src/main/python/qa_nightly_sql.py
@@ -0,0 +1,808 @@
+# Copyright (c) 2020, NVIDIA CORPORATION.
+#
+# Licensed 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.
+
+SELECT_SQL = [
+# (" FUNCTIONAL CHECKING", "FUNCTIONAL CHECKING"),
+# (" AGG functions", "AGG functions"),
+("SELECT AVG(intF) FROM test_table", "AVG(intF)"),
+("SELECT AVG(byteF) FROM test_table", "AVG(byteF)"),
+("SELECT AVG(shortF) FROM test_table", "AVG(shortF)"),
+("SELECT AVG(longF) FROM test_table", "AVG(longF)"),
+("SELECT AVG(floatF) FROM test_table", "AVG(floatF)"),
+("SELECT AVG(doubleF) FROM test_table", "AVG(doubleF)"),
+("SELECT AVG(byteF) FROM test_table GROUP BY intF", "AVG(byteF) GROUP BY intF"),
+("SELECT AVG(shortF) FROM test_table GROUP BY intF", "AVG(shortF) GROUP BY intF"),
+("SELECT AVG(intF) FROM test_table GROUP BY byteF", "AVG(intF) GROUP BY byteF"),
+("SELECT AVG(longF) FROM test_table GROUP BY byteF", "AVG(longF) GROUP BY byteF"),
+("SELECT AVG(floatF) FROM test_table GROUP BY byteF", "AVG(floatF) GROUP BY byteF"),
+("SELECT AVG(doubleF) FROM test_table GROUP BY byteF", "AVG(doubleF) GROUP BY byteF"),
+("SELECT AVG(intF) FROM test_table GROUP BY byteF, doubleF", "AVG(intF) GROUP BY byteF, doubleF"),
+("SELECT AVG(floatF) FROM test_table GROUP BY byteF, shortF, intF ", "AVG(floatF) GROUP BY byteF, shortF, intF"),
+("SELECT SUM(byteF) FROM test_table", "SUM(byteF)"),
+("SELECT SUM(shortF) FROM test_table", "SUM(shortF)"),
+("SELECT SUM(intF) FROM test_table", "SUM(intF)"),
+("SELECT SUM(longF) FROM test_table", "SUM(longF)"),
+("SELECT SUM(floatF) FROM test_table", "SUM(floatF)"),
+("SELECT SUM(doubleF) FROM test_table", "SUM(doubleF)"),
+("SELECT SUM(byteF) FROM test_table GROUP BY intF", "SUM(byteF) GROUP BY intF"),
+("SELECT SUM(shortF) FROM test_table GROUP BY intF", "SUM(shortF) GROUP BY intF"),
+("SELECT SUM(intF) FROM test_table GROUP BY shortF", "SUM(intF) GROUP BY shortF"),
+("SELECT SUM(longF) FROM test_table GROUP BY shortF", "SUM(longF) GROUP BY shortF"),
+("SELECT SUM(floatF) FROM test_table GROUP BY byteF", "SUM(floatF) GROUP BY byteF"),
+("SELECT SUM(doubleF) FROM test_table GROUP BY intF", "SUM(doubleF) GROUP BY intF"),
+("SELECT SUM(byteF) FROM test_table GROUP BY intF, shortF", "SUM(byteF) GROUP BY intF, shortF"),
+("SELECT SUM(shortF) FROM test_table GROUP BY intF, floatF", "SUM(shortF) GROUP BY intF, floatF"),
+("SELECT COUNT(byteF) FROM test_table", "COUNT(byteF)"),
+("SELECT COUNT(shortF) FROM test_table", "COUNT(shortF)"),
+("SELECT COUNT(intF) FROM test_table", "COUNT(intF)"),
+("SELECT COUNT(longF) FROM test_table", "COUNT(longF)"),
+("SELECT COUNT(floatF) FROM test_table", "COUNT(floatF)"),
+("SELECT COUNT(doubleF) FROM test_table", "COUNT(doubleF)"),
+("SELECT COUNT(booleanF) FROM test_table", "COUNT(booleanF)"),
+("SELECT COUNT(strF) FROM test_table", "COUNT(strF)"),
+("SELECT COUNT(dateF) FROM test_table", "COUNT(dateF)"),
+("SELECT COUNT(timestampF) FROM test_table", "COUNT(timestampF)"),
+("SELECT COUNT(byteF) FROM test_table GROUP BY intF", "COUNT(byteF) GROUP BY intF"),
+("SELECT COUNT(shortF) FROM test_table GROUP BY intF", "COUNT(shortF) GROUP BY intF"),
+("SELECT COUNT(intF) FROM test_table GROUP BY byteF", "COUNT(intF) GROUP BY byteF"),
+("SELECT COUNT(longF) FROM test_table GROUP BY byteF", "COUNT(longF) GROUP BY byteF"),
+("SELECT COUNT(floatF) FROM test_table GROUP BY intF", "COUNT(floatF) GROUP BY intF"),
+("SELECT COUNT(doubleF) FROM test_table GROUP BY intF", "COUNT(doubleF) GROUP BY intF"),
+("SELECT COUNT(byteF) FROM test_table GROUP BY intF, shortF", "COUNT(byteF) GROUP BY intF, shortF"),
+("SELECT COUNT(shortF) FROM test_table GROUP BY intF, byteF", "COUNT(shortF) GROUP BY intF, byteF"),
+("SELECT COUNT(intF) FROM test_table GROUP BY byteF, shortF", "COUNT(intF) GROUP BY byteF, shortF"),
+("SELECT MIN(byteF) FROM test_table", "MIN(byteF)"),
+("SELECT MIN(shortF) FROM test_table", "MIN(shortF)"),
+("SELECT MIN(intF) FROM test_table", "MIN(intF)"),
+("SELECT MIN(longF) FROM test_table", "MIN(longF)"),
+("SELECT MIN(floatF) FROM test_table", "MIN(floatF)"),
+("SELECT MIN(doubleF) FROM test_table", "MIN(doubleF)"),
+("SELECT MIN(booleanF) FROM test_table", "MIN(booleanF)"),
+("SELECT MIN(dateF) FROM test_table", "MIN(dateF)"),
+("SELECT MIN(timestampF) FROM test_table", "MIN(timestampF)"),
+("SELECT MIN(byteF) FROM test_table GROUP BY intF", "MIN(byteF) GROUP BY intF"),
+("SELECT MIN(shortF) FROM test_table GROUP BY intF", "MIN(shortF) GROUP BY intF"),
+("SELECT MIN(intF) FROM test_table GROUP BY intF", "MIN(intF) GROUP BY intF"),
+("SELECT MIN(longF) FROM test_table GROUP BY intF", "MIN(longF) GROUP BY intF"),
+("SELECT MIN(floatF) FROM test_table GROUP BY intF", "MIN(floatF) GROUP BY intF"),
+("SELECT MIN(doubleF) FROM test_table GROUP BY intF", "MIN(doubleF) GROUP BY intF"),
+("SELECT MIN(booleanF) FROM test_table GROUP BY intF", "MIN(booleanF) GROUP BY intF"),
+("SELECT MIN(dateF) FROM test_table GROUP BY intF", "MIN(dateF) GROUP BY intF"),
+("SELECT MIN(timestampF) FROM test_table GROUP BY intF", "MIN(timestampF) GROUP BY intF"),
+("SELECT MIN(byteF) FROM test_table GROUP BY intF, shortF", "MIN(byteF) GROUP BY intF, shortF"),
+("SELECT MIN(shortF) FROM test_table GROUP BY intF, byteF", "MIN(shortF) GROUP BY intF, byteF"),
+("SELECT MAX(intF) FROM test_table", "MAX(intF)"),
+("SELECT MAX(byteF) FROM test_table", "MAX(byteF)"),
+("SELECT MAX(shortF) FROM test_table", "MAX(shortF)"),
+("SELECT MAX(longF) FROM test_table", "MAX(longF)"),
+("SELECT MAX(floatF) FROM test_table", "MAX(floatF)"),
+("SELECT MAX(doubleF) FROM test_table", "MAX(doubleF)"),
+("SELECT MAX(booleanF) FROM test_table", "MAX(booleanF)"),
+("SELECT MAX(dateF) FROM test_table", "MAX(dateF)"),
+("SELECT MAX(timestampF) FROM test_table", "MAX(timestampF)"),
+("SELECT MAX(byteF) FROM test_table GROUP BY intF", "MAX(byteF) GROUP BY intF"),
+("SELECT MAX(shortF) FROM test_table GROUP BY intF", "MAX(shortF) GROUP BY intF"),
+("SELECT MAX(intF) FROM test_table GROUP BY byteF", "MAX(intF) GROUP BY byteF"),
+("SELECT MAX(longF) FROM test_table GROUP BY intF", "MAX(longF) GROUP BY intF"),
+("SELECT MAX(floatF) FROM test_table GROUP BY intF", "MAX(floatF) GROUP BY intF"),
+("SELECT MAX(doubleF) FROM test_table GROUP BY intF", "MAX(doubleF) GROUP BY intF"),
+("SELECT MAX(booleanF) FROM test_table GROUP BY intF", "MAX(booleanF) GROUP BY intF"),
+("SELECT MAX(dateF) FROM test_table GROUP BY intF", "MAX(dateF) GROUP BY intF"),
+("SELECT MAX(timestampF) FROM test_table GROUP BY intF", "MAX(timestampF) GROUP BY intF"),
+("SELECT MAX(byteF) FROM test_table GROUP BY intF, shortF", "MAX(byteF) GROUP BY intF, shortF"),
+("SELECT MAX(shortF) FROM test_table GROUP BY intF, byteF", "MAX(shortF) GROUP BY intF, byteF"),
+("SELECT DISTINCT(byteF) FROM test_table", "DISTINCT(byteF)"),
+("SELECT DISTINCT(shortF) FROM test_table", "DISTINCT(shortF)"),
+("SELECT DISTINCT(intF) FROM test_table", "DISTINCT(intF)"),
+("SELECT DISTINCT(longF) FROM test_table", "DISTINCT(longF)"),
+("SELECT DISTINCT(floatF) FROM test_table", "DISTINCT(floatF)"),
+("SELECT DISTINCT(doubleF) FROM test_table", "DISTINCT(doubleF)"),
+("SELECT DISTINCT(booleanF) FROM test_table", "DISTINCT(booleanF)"),
+("SELECT DISTINCT(strF) FROM test_table", "DISTINCT(strF)"),
+("SELECT DISTINCT(dateF) FROM test_table", "DISTINCT(dateF)"),
+("SELECT DISTINCT(timestampF) FROM test_table", "DISTINCT(timestampF)"),
+("SELECT COUNT(DISTINCT(byteF)) FROM test_table GROUP BY intF", "COUNT(DISTINCT(byteF)) GROUP BY intF"),
+("SELECT COUNT(DISTINCT(shortF)) FROM test_table GROUP BY intF", "COUNT(DISTINCT(shortF)) GROUP BY intF"),
+("SELECT COUNT(DISTINCT(intF)) FROM test_table GROUP BY byteF", "COUNT(DISTINCT(intF)) GROUP BY byteF"),
+("SELECT COUNT(DISTINCT(longF)) FROM test_table GROUP BY intF", "COUNT(DISTINCT(longF)) GROUP BY intF"),
+("SELECT COUNT(DISTINCT(floatF)) FROM test_table GROUP BY intF", "COUNT(DISTINCT(floatF)) GROUP BY intF"),
+("SELECT COUNT(DISTINCT(doubleF)) FROM test_table GROUP BY intF", "COUNT(DISTINCT(doubleF)) GROUP BY intF"),
+("SELECT COUNT(DISTINCT(booleanF)) FROM test_table GROUP BY intF", "COUNT(DISTINCT(booleanF)) GROUP BY intF"),
+("SELECT COUNT(DISTINCT(strF)) FROM test_table GROUP BY intF", "COUNT(DISTINCT(strF)) GROUP BY intF"),
+("SELECT COUNT(DISTINCT(dateF)) FROM test_table GROUP BY intF", "COUNT(DISTINCT(dateF)) GROUP BY intF"),
+("SELECT COUNT(DISTINCT(timestampF)) FROM test_table GROUP BY intF", "COUNT(DISTINCT(timestampF)) GROUP BY intF"),
+("SELECT COUNT(DISTINCT(intF)), COUNT(DISTINCT(byteF)), COUNT(DISTINCT(shortF)), COUNT(DISTINCT(longF)) FROM test_table", "COUNT(DISTINCT(intF)), COUNT(DISTINCT(byteF)), COUNT(DISTINCT(shortF)), COUNT(DISTINCT(longF))"),
+("SELECT COUNT(DISTINCT(intF)), COUNT(DISTINCT(floatF)), COUNT(DISTINCT(doubleF)), COUNT(DISTINCT(booleanF)) FROM test_table", "COUNT(DISTINCT(intF)), COUNT(DISTINCT(floatF)), COUNT(DISTINCT(doubleF)), COUNT(DISTINCT(booleanF))"),
+("SELECT COUNT(DISTINCT(dateF)), COUNT(DISTINCT(strF)), COUNt(DISTINCT(timestampF)) FROM test_table", "COUNT(DISTINCT(dateF)), COUNT(DISTINCT(strF)), COUNt(DISTINCT(timestampF))"),
+("SELECT COUNT(DISTINCT(intF)), COUNT(DISTINCT(byteF)), COUNT(DISTINCT(shortF)) FROM test_table GROUP BY longF ", "COUNT(DISTINCT(intF)), COUNT(DISTINCT(byteF)), COUNT(DISTINCT(shortF)) GROUP BY longF"),
+("SELECT COUNT(DISTINCT(intF)), COUNt(DISTINCT(byteF)) FROM test_table GROUP BY longF, floatF", "COUNT(DISTINCT(intF)), COUNt(DISTINCT(byteF)) GROUP BY longF, floatF"),
+# (" MATH functions", "MATH functions"),
+("SELECT abs(intF*(-1)) FROM test_table", "abs(intF*(-1))"),
+("SELECT abs(floatF*(-1)) FROM test_table", "abs(floatF*(-1))"),
+("SELECT abs(doubleF*(-1)) FROM test_table", "abs(doubleF*(-1))"),
+("SELECT acosh(intF) FROM test_table", "acosh(intF)"),
+("SELECT acosh(floatF) FROM test_table", "acosh(floatF)"),
+("SELECT acosh(doubleF) FROM test_table", "acosh(doubleF)"),
+("SELECT asin(intF) FROM test_table", "asin(intF)"),
+("SELECT asin(floatF) FROM test_table", "asin(floatF)"),
+("SELECT asin(doubleF) FROM test_table", "asin(doubleF)"),
+("SELECT asinh(intF*(-1)) FROM test_table", "asinh(intF*(-1))"),
+("SELECT asinh(doubleF) FROM test_table", "asinh(doubleF)"),
+("SELECT asinh(floatF) FROM test_table", "asinh(floatF)"),
+("SELECT atan(byteF) FROM test_table", "atan(byteF)"),
+("SELECT atan(shortF) FROM test_table", "atan(shortF)"),
+("SELECT atan(intF) FROM test_table", "atan(intF)"),
+("SELECT atan(longF) FROM test_table", "atan(longF)"),
+("SELECT atan(floatF) FROM test_table", "atan(floatF)"),
+("SELECT atan(doubleF) FROM test_table", "atan(doubleF)"),
+("SELECT atanh(intF) FROM test_table", "atanh(intF)"),
+("SELECT atanh(byteF) FROM test_table", "atanh(byteF)"),
+("SELECT atanh(shortF) FROM test_table", "atanh(shortF)"),
+("SELECT atanh(longF) FROM test_table", "atanh(longF)"),
+("SELECT atanh(floatF) FROM test_table", "atanh(floatF)"),
+("SELECT atanh(doubleF) FROM test_table", "atanh(doubleF)"),
+("SELECT cbrt(intF) FROM test_table", "cbrt(intF)"),
+("SELECT cbrt(byteF) FROM test_table", "cbrt(byteF)"),
+("SELECT cbrt(shortF) FROM test_table", "cbrt(shortF)"),
+("SELECT cbrt(longF) FROM test_table", "cbrt(longF)"),
+("SELECT cbrt(floatF) FROM test_table", "cbrt(floatF)"),
+("SELECT cbrt(doubleF) FROM test_table", "cbrt(doubleF)"),
+("SELECT ceil(intF) FROM test_table ", "ceil(intF)"),
+("SELECT ceil(byteF) FROM test_table ", "ceil(byteF)"),
+("SELECT ceil(shortF) FROM test_table ", "ceil(shortF)"),
+("SELECT ceil(longF) FROM test_table ", "ceil(longF)"),
+("SELECT ceil(floatF) FROM test_table ", "ceil(floatF)"),
+("SELECT ceil(doubleF) FROM test_table ", "ceil(doubleF)"),
+("SELECT cos(intF) FROM test_table", "cos(intF)"),
+("SELECT cos(byteF) FROM test_table", "cos(byteF)"),
+("SELECT cos(shortF) FROM test_table", "cos(shortF)"),
+("SELECT cos(longF) FROM test_table", "cos(longF)"),
+("SELECT cos(floatF) FROM test_table", "cos(floatF)"),
+("SELECT cos(doubleF) FROM test_table", "cos(doubleF)"),
+("SELECT cot(byteF) FROM test_table", "cot(byteF)"),
+("SELECT cot(shortF) FROM test_table", "cot(shortF)"),
+("SELECT cot(intF) FROM test_table", "cot(intF)"),
+("SELECT cot(longF) FROM test_table", "cot(longF)"),
+("SELECT cot(floatF) FROM test_table", "cot(floatF)"),
+("SELECT cot(doubleF) FROM test_table", "cot(doubleF)"),
+("SELECT cot(byteF) FROM test_table", "cot(byteF)"),
+("SELECT cot(shortF) FROM test_table", "cot(shortF)"),
+("SELECT cot(intF) FROM test_table", "cot(intF)"),
+("SELECT cot(longF) FROM test_table", "cot(longF)"),
+("SELECT cot(floatF) FROM test_table", "cot(floatF)"),
+("SELECT cot(doubleF) FROM test_table", "cot(doubleF)"),
+("SELECT e()*doubleF FROM test_table", "e()*doubleF"),
+("SELECT exp(intF) FROM test_table", "exp(intF)"),
+("SELECT exp(byteF) FROM test_table", "exp(byteF)"),
+("SELECT exp(shortF) FROM test_table", "exp(shortF)"),
+("SELECT exp(longF) FROM test_table", "exp(longF)"),
+("SELECT exp(floatF) FROM test_table", "exp(floatF)"),
+("SELECT exp(doubleF) FROM test_table", "exp(doubleF)"),
+("SELECT expm1(intF) FROM test_table", "expm1(intF)"),
+("SELECT expm1(byteF) FROM test_table", "expm1(byteF)"),
+("SELECT expm1(shortF) FROM test_table", "expm1(shortF)"),
+("SELECT expm1(longF) FROM test_table", "expm1(longF)"),
+("SELECT expm1(floatF) FROM test_table", "expm1(floatF)"),
+("SELECT expm1(doubleF) FROM test_table", "expm1(doubleF)"),
+("SELECT floor(intF) FROM test_table", "floor(intF)"),
+("SELECT floor(byteF) FROM test_table", "floor(byteF)"),
+("SELECT floor(shortF) FROM test_table", "floor(shortF)"),
+("SELECT floor(longF) FROM test_table", "floor(longF)"),
+("SELECT floor(floatF) FROM test_table", "floor(floatF)"),
+("SELECT floor(doubleF) FROM test_table", "floor(doubleF)"),
+("SELECT log2(intF) FROM test_table", "log2(intF)"),
+("SELECT log2(shortF) FROM test_table", "log2(shortF)"),
+("SELECT log2(byteF) FROM test_table", "log2(byteF)"),
+("SELECT log2(longF) FROM test_table", "log2(longF)"),
+("SELECT log2(floatF) FROM test_table", "log2(floatF)"),
+("SELECT log2(doubleF) FROM test_table", "log2(doubleF)"),
+("SELECT log10(intF) FROM test_table", "log10(intF)"),
+("SELECT log10(byteF) FROM test_table", "log10(byteF)"),
+("SELECT log10(shortF) FROM test_table", "log10(shortF)"),
+("SELECT log10(longF) FROM test_table", "log10(longF)"),
+("SELECT log10(floatF) FROM test_table", "log10(floatF)"),
+("SELECT log10(doubleF) FROM test_table", "log10(doubleF)"),
+("SELECT log1p(intF) FROM test_table", "log1p(intF)"),
+("SELECT log1p(byteF) FROM test_table", "log1p(byteF)"),
+("SELECT log1p(shortF) FROM test_table", "log1p(shortF)"),
+("SELECT log1p(longF) FROM test_table", "log1p(longF)"),
+("SELECT log1p(floatF) FROM test_table", "log1p(floatF)"),
+("SELECT log1p(doubleF) FROM test_table", "log1p(doubleF)"),
+("SELECT log(intF, intF) FROM test_table", "log(intF, intF)"),
+("SELECT log(byteF, byteF) FROM test_table", "log(byteF, byteF)"),
+("SELECT log(shortF, shortF) FROM test_table", "log(shortF, shortF)"),
+("SELECT log(longF, longF) FROM test_table", "log(longF, longF)"),
+("SELECT log(floatF, floatF) FROM test_table", "log(floatF, floatF)"),
+("SELECT log(doubleF, doubleF) FROM test_table", "log(doubleF, doubleF)"),
+("SELECT MOD(intF,10) FROM test_table", "MOD(intF,10)"),
+("SELECT MOD(byteF,10) FROM test_table", "MOD(byteF,10)"),
+("SELECT MOD(shortF,10) FROM test_table", "MOD(shortF,10)"),
+("SELECT MOD(longF,10) FROM test_table", "MOD(longF,10)"),
+("SELECT MOD(floatF,10) FROM test_table", "MOD(floatF,10)"),
+("SELECT MOD(doubleF,10) FROM test_table", "MOD(doubleF,10)"),
+("SELECT pi()*intF FROM test_table", "pi()*intF"),
+("SELECT pi()*floatF*10 FROM test_table", "pi()*floatF*10"),
+("SELECT pow(intF,2) FROM test_table", "pow(intF,2)"),
+("SELECT pow(byteF,2) FROM test_table", "pow(byteF,2)"),
+("SELECT pow(shortF,2) FROM test_table", "pow(shortF,2)"),
+("SELECT pow(longF,2) FROM test_table", "pow(longF,2)"),
+("SELECT pow(floatF,2) FROM test_table", "pow(floatF,2)"),
+("SELECT pow(doubleF,2) FROM test_table", "pow(doubleF,2)"),
+("SELECT rint(intF) FROM test_table", "rint(intF)"),
+("SELECT rint(byteF) FROM test_table", "rint(byteF)"),
+("SELECT rint(shortF) FROM test_table", "rint(shortF)"),
+("SELECT rint(longF) FROM test_table", "rint(longF)"),
+("SELECT rint(floatF) FROM test_table", "rint(floatF)"),
+("SELECT rint(doubleF) FROM test_table", "rint(doubleF)"),
+("SELECT signum(intF) FROM test_table", "signum(intF)"),
+("SELECT signum(byteF) FROM test_table", "signum(byteF)"),
+("SELECT signum(shortF) FROM test_table", "signum(shortF)"),
+("SELECT signum(longF) FROM test_table", "signum(longF)"),
+("SELECT signum(floatF) FROM test_table", "signum(floatF)"),
+("SELECT signum(doubleF) FROM test_table", "signum(doubleF)"),
+("SELECT sin(intF) FROM test_table", "sin(intF)"),
+("SELECT sin(byteF) FROM test_table", "sin(byteF)"),
+("SELECT sin(shortF) FROM test_table", "sin(shortF)"),
+("SELECT sin(longF) FROM test_table", "sin(longF)"),
+("SELECT sin(floatF) FROM test_table", "sin(floatF)"),
+("SELECT sin(doubleF) FROM test_table", "sin(doubleF)"),
+("SELECT tan(intF) FROM test_table", "tan(intF)"),
+("SELECT tan(byteF) FROM test_table", "tan(byteF)"),
+("SELECT tan(shortF) FROM test_table", "tan(shortF)"),
+("SELECT tan(longF) FROM test_table", "tan(longF)"),
+("SELECT tan(floatF) FROM test_table", "tan(floatF)"),
+("SELECT tan(doubleF) FROM test_table", "tan(doubleF)"),
+("SELECT intF+intF FROM test_table", "intF+intF"),
+("SELECT byteF+byteF FROM test_table", "byteF+byteF"),
+("SELECT shortF+shortF FROM test_table", "shortF+shortF"),
+("SELECT longF+longF FROM test_table", "longF+longF"),
+("SELECT floatF+floatF FROM test_table", "floatF+floatF"),
+("SELECT doubleF+doubleF FROM test_table", "doubleF+doubleF"),
+("SELECT byteF-doubleF FROM test_table", "byteF-doubleF"),
+("SELECT shortF-byteF FROM test_table", "shortF-byteF"),
+("SELECT intF-byteF FROM test_table", "intF-byteF"),
+("SELECT longF-byteF FROM test_table", "longF-byteF"),
+("SELECT floatF-intF FROM test_table", "floatF-intF"),
+("SELECT doubleF-floatF FROM test_table", "doubleF-floatF"),
+("SELECT intF*intF FROM test_table", "intF*intF"),
+("SELECT byteF*byteF FROM test_table", "byteF*byteF"),
+("SELECT shortF*shortF FROM test_table", "shortF*shortF"),
+("SELECT longF*longF FROM test_table", "longF*longF"),
+("SELECT floatF*floatF FROM test_table", "floatF*floatF"),
+("SELECT doubleF*doubleF FROM test_table", "doubleF*doubleF"),
+("SELECT intF/intF FROM test_table", "intF/intF"),
+("SELECT byteF/floatF FROM test_table", "byteF/floatF"),
+("SELECT shortF/doubleF FROM test_table", "shortF/doubleF"),
+("SELECT longF/intF FROM test_table", "longF/intF"),
+("SELECT floatF/floatF FROM test_table", "floatF/floatF"),
+("SELECT doubleF/doubleF FROM test_table", "doubleF/doubleF"),
+("SELECT intF%floatF FROM test_table", "intF%floatF"),
+("SELECT byteF%10 FROM test_table", "byteF%10"),
+("SELECT shortF%10 FROM test_table", "shortF%10"),
+("SELECT longF%floatF FROM test_table", "longF%floatF"),
+("SELECT floatF%10 FROM test_table", "floatF%10"),
+("SELECT doubleF%10 FROM test_table", "doubleF%10"),
+# ("STRING", "STRING"),
+("SELECT Lower(strF) FROM test_table", "Lower(strF)"),
+("SELECT Upper(strF) FROM test_table", "Upper(strF)"),
+("SELECT Substring(strF, 1, 3) FROM test_table", "Substring(strF, 1, 3)"),
+("SELECT Substring(strF, -1, 5) FROM test_table", "Substring(strF, -1, 5)"),
+("SELECT * FROM test_table WHERE strF LIKE 'Yuan' ", "* WHERE strF LIKE 'Yuan'"),
+("SELECT * FROM test_table WHERE strF LIKE '%Yuan%' ", "* WHERE strF LIKE '%Yuan%'"),
+("SELECT * FROM test_table WHERE strF LIKE 'Y%'", "* WHERE strF LIKE 'Y%'"),
+("SELECT * FROM test_table WHERE strF LIKE '%an' ", "* WHERE strF LIKE '%an'"),
+("SELECT REPLACE(strF, 'Yuan', 'Eric') FROM test_table", "REPLACE(strF, 'Yuan', 'Eric')"),
+("SELECT REGEXP_REPLACE(strF, 'Yu', 'Eric') FROM test_table", "REGEXP_REPLACE(strF, 'Yu', 'Eric')"),
+#("SELECT REGEXP_REPLACE(strF, 'Y*', 'Eric') FROM test_table", "REGEXP_REPLACE(strF, 'Y*', 'Eric')"),
+("SELECT CONCAT(strF, strF) FROM test_table", "CONCAT(strF, strF)"),
+# (" DATETIME", "DATETIME"),
+("SELECT dayofmonth(timestampF) from test_table", "dayofmonth(timestampF)"),
+("SELECT hour(timestampF) from test_table", "hour(timestampF)"),
+("SELECT minute(timestampF) from test_table", "minute(timestampF)"),
+("SELECT second(timestampF) from test_table", "second(timestampF)"),
+("SELECT year(timestampF) from test_table", "year(timestampF)"),
+("SELECT month(timestampF) from test_table", "month(timestampF)"),
+# (" CAST", "CAST"),
+("SELECT cast(intF as tinyint) from test_table", "cast(intF as tinyint)"),
+("SELECT cast(intF as smallint) from test_table", "cast(intF as smallint)"),
+("SELECT cast(intF as bigint) from test_table", "cast(intF as bigint)"),
+("SELECT cast(intF as long) from test_table", "cast(intF as long)"),
+("SELECT cast(intF as float) from test_table", "cast(intF as float)"),
+("SELECT cast(intF as double) from test_table", "cast(intF as double)"),
+("SELECT cast(byteF as tinyint) from test_table", "cast(byteF as tinyint)"),
+("SELECT cast(byteF as smallint) from test_table", "cast(byteF as smallint)"),
+("SELECT cast(byteF as Bigint) from test_table", "cast(byteF as Bigint)"),
+("SELECT cast(byteF as long) from test_table", "cast(byteF as long)"),
+("SELECT cast(byteF as float) from test_table", "cast(byteF as float)"),
+("SELECT cast(byteF as double) from test_table", "cast(byteF as double)"),
+("SELECT cast(shortF as tinyint) from test_table", "cast(shortF as tinyint)"),
+("SELECT cast(shortF as smallint) from test_table", "cast(shortF as smallint)"),
+("SELECT cast(shortF as Bigint) from test_table", "cast(shortF as Bigint)"),
+("SELECT cast(shortF as long) from test_table", "cast(shortF as long)"),
+("SELECT cast(shortF as float) from test_table", "cast(shortF as float)"),
+("SELECT cast(shortF as double) from test_table", "cast(shortF as double)"),
+("SELECT cast(longF as tinyint) from test_table", "cast(longF as tinyint)"),
+("SELECT cast(longF as smallint) from test_table", "cast(longF as smallint)"),
+("SELECT cast(longF as Bigint) from test_table", "cast(longF as Bigint)"),
+("SELECT cast(longF as long) from test_table", "cast(longF as long)"),
+("SELECT cast(longF as float) from test_table", "cast(longF as float)"),
+("SELECT cast(longF as double) from test_table", "cast(longF as double)"),
+("SELECT cast(floatF as tinyint) from test_table", "cast(floatF as tinyint)"),
+("SELECT cast(floatF as smallint) from test_table", "cast(floatF as smallint)"),
+("SELECT cast(floatF as Bigint) from test_table", "cast(floatF as Bigint)"),
+("SELECT cast(floatF as long) from test_table", "cast(floatF as long)"),
+("SELECT cast(floatF as float) from test_table", "cast(floatF as float)"),
+("SELECT cast(floatF as double) from test_table", "cast(floatF as double)"),
+("SELECT cast(doubleF as tinyint) from test_table", "cast(doubleF as tinyint)"),
+("SELECT cast(doubleF as smallint) from test_table", "cast(doubleF as smallint)"),
+("SELECT cast(doubleF as Bigint) from test_table", "cast(doubleF as Bigint)"),
+("SELECT cast(doubleF as long) from test_table", "cast(doubleF as long)"),
+("SELECT cast(doubleF as float) from test_table", "cast(doubleF as float)"),
+("SELECT cast(doubleF as double) from test_table", "cast(doubleF as double)"),
+# (" COMPARISON", "COMPARISON"),
+("SELECT * FROM test_table WHERE intF = 0", "* WHERE intF = 0"),
+("SELECT * FROM test_table WHERE byteF = 0", "* WHERE byteF = 0"),
+("SELECT * FROM test_table WHERE shortF = 0", "* WHERE shortF = 0"),
+("SELECT * FROM test_table WHERE longF = 0", "* WHERE longF = 0"),
+("SELECT * FROM test_table WHERE floatF = 0", "* WHERE floatF = 0"),
+("SELECT * FROM test_table WHERE doubleF = 0", "* WHERE doubleF = 0"),
+("SELECT * FROM test_table WHERE booleanF = true", "* WHERE booleanF = true"),
+("SELECT * FROM test_table WHERE strF = 'Alex'", "* WHERE strF = 'Alex'"),
+("SELECT * FROM test_table WHERE dateF = '1990-1-1'", "* WHERE dateF = '1990-1-1'"),
+("SELECT * FROM test_table WHERE dateF = '2020-05-01 12:01:01' ", "* WHERE dateF = '2020-05-01 12:01:01'"),
+("SELECT * FROM test_table WHERE intF == 0", "* WHERE intF == 0"),
+("SELECT * FROM test_table WHERE byteF == 0", "* WHERE byteF == 0"),
+("SELECT * FROM test_table WHERE shortF == 0", "* WHERE shortF == 0"),
+("SELECT * FROM test_table WHERE longF == 0", "* WHERE longF == 0"),
+("SELECT * FROM test_table WHERE floatF == 0", "* WHERE floatF == 0"),
+("SELECT * FROM test_table WHERE doubleF == 0", "* WHERE doubleF == 0"),
+("SELECT * FROM test_table WHERE booleanF == true", "* WHERE booleanF == true"),
+("SELECT * FROM test_table WHERE strF == 'Alex'", "* WHERE strF == 'Alex'"),
+("SELECT * FROM test_table WHERE dateF == '1990-1-1'", "* WHERE dateF == '1990-1-1'"),
+("SELECT * FROM test_table WHERE dateF == '2020-05-01 12:01:01' ", "* WHERE dateF == '2020-05-01 12:01:01'"),
+("SELECT * FROM test_table WHERE intF > 0", "* WHERE intF > 0"),
+("SELECT * FROM test_table WHERE byteF > 0", "* WHERE byteF > 0"),
+("SELECT * FROM test_table WHERE shortF > 0", "* WHERE shortF > 0"),
+("SELECT * FROM test_table WHERE longF > 0", "* WHERE longF > 0"),
+("SELECT * FROM test_table WHERE floatF > 0", "* WHERE floatF > 0"),
+("SELECT * FROM test_table WHERE doubleF > 0", "* WHERE doubleF > 0"),
+("SELECT * FROM test_table WHERE booleanF > false ", "* WHERE booleanF > false"),
+("SELECT * FROM test_table WHERE strF > 'Yuan'", "* WHERE strF > 'Yuan'"),
+("SELECT * FROM test_table WHERE dateF > '1990-1-1' ", "* WHERE dateF > '1990-1-1'"),
+("SELECT * FROM test_table WHERE dateF > '2020-05-01 12:01:01'", "* WHERE dateF > '2020-05-01 12:01:01'"),
+("SELECT * FROM test_table WHERE intF < 0", "* WHERE intF < 0"),
+("SELECT * FROM test_table WHERE byteF < 0", "* WHERE byteF < 0"),
+("SELECT * FROM test_table WHERE shortF < 0", "* WHERE shortF < 0"),
+("SELECT * FROM test_table WHERE longF < 0", "* WHERE longF < 0"),
+("SELECT * FROM test_table WHERE floatF < 0", "* WHERE floatF < 0"),
+("SELECT * FROM test_table WHERE doubleF < 0", "* WHERE doubleF < 0"),
+("SELECT * FROM test_table WHERE booleanF < true", "* WHERE booleanF < true"),
+("SELECT * FROM test_table WHERE strF < 'Yuan'", "* WHERE strF < 'Yuan'"),
+("SELECT * FROM test_table WHERE dateF < '1994-01-01' ", "* WHERE dateF < '1994-01-01'"),
+("SELECT * FROM test_table WHERE dateF < '2020-05-01 12:01:01' ", "* WHERE dateF < '2020-05-01 12:01:01'"),
+("SELECT * FROM test_table WHERE intF >= 0", "* WHERE intF >= 0"),
+("SELECT * FROM test_table WHERE byteF >= 0", "* WHERE byteF >= 0"),
+("SELECT * FROM test_table WHERE shortF >= 0", "* WHERE shortF >= 0"),
+("SELECT * FROM test_table WHERE longF >= 0", "* WHERE longF >= 0"),
+("SELECT * FROM test_table WHERE floatF >= 0", "* WHERE floatF >= 0"),
+("SELECT * FROM test_table WHERE doubleF >= 0", "* WHERE doubleF >= 0"),
+("SELECT * FROM test_table WHERE booleanF >= false ", "* WHERE booleanF >= false"),
+("SELECT * FROM test_table WHERE strF >= 'Yuan'", "* WHERE strF >= 'Yuan'"),
+("SELECT * FROM test_table WHERE dateF >= '1994-01-01' ", "* WHERE dateF >= '1994-01-01'"),
+("SELECT * FROM test_table WHERE dateF >= '2020-05-01 12:01:01' ", "* WHERE dateF >= '2020-05-01 12:01:01'"),
+("SELECT * FROM test_table WHERE intF <= 0", "* WHERE intF <= 0"),
+("SELECT * FROM test_table WHERE byteF <= 0", "* WHERE byteF <= 0"),
+("SELECT * FROM test_table WHERE shortF <= 0", "* WHERE shortF <= 0"),
+("SELECT * FROM test_table WHERE longF <= 0", "* WHERE longF <= 0"),
+("SELECT * FROM test_table WHERE floatF <= 0", "* WHERE floatF <= 0"),
+("SELECT * FROM test_table WHERE doubleF <= 0", "* WHERE doubleF <= 0"),
+("SELECT * FROM test_table WHERE booleanF <= true ", "* WHERE booleanF <= true"),
+("SELECT * FROM test_table WHERE strF <= 'Yuan'", "* WHERE strF <= 'Yuan'"),
+("SELECT * FROM test_table WHERE dateF <= '1994-01-01' ", "* WHERE dateF <= '1994-01-01'"),
+("SELECT * FROM test_table WHERE dateF <= '2020-05-01 12:01:01' ", "* WHERE dateF <= '2020-05-01 12:01:01'"),
+("SELECT * FROM test_table WHERE intF <> 0", "* WHERE intF <> 0"),
+("SELECT * FROM test_table WHERE byteF <> 0", "* WHERE byteF <> 0"),
+("SELECT * FROM test_table WHERE shortF <> 0", "* WHERE shortF <> 0"),
+("SELECT * FROM test_table WHERE longF <> 0", "* WHERE longF <> 0"),
+("SELECT * FROM test_table WHERE floatF <> 0", "* WHERE floatF <> 0"),
+("SELECT * FROM test_table WHERE doubleF <> 0", "* WHERE doubleF <> 0"),
+("SELECT * FROM test_table WHERE booleanF <> true ", "* WHERE booleanF <> true"),
+("SELECT * FROM test_table WHERE strF <> 'Yuan'", "* WHERE strF <> 'Yuan'"),
+("SELECT * FROM test_table WHERE dateF <> '1994-01-01' ", "* WHERE dateF <> '1994-01-01'"),
+("SELECT * FROM test_table WHERE dateF <> '2020-05-01 12:01:01' ", "* WHERE dateF <> '2020-05-01 12:01:01'"),
+("SELECT * FROM test_table WHERE intF != 0", "* WHERE intF != 0"),
+("SELECT * FROM test_table WHERE byteF != 0", "* WHERE byteF != 0"),
+("SELECT * FROM test_table WHERE shortF != 0", "* WHERE shortF != 0"),
+("SELECT * FROM test_table WHERE longF != 0", "* WHERE longF != 0"),
+("SELECT * FROM test_table WHERE floatF != 0", "* WHERE floatF != 0"),
+("SELECT * FROM test_table WHERE doubleF != 0", "* WHERE doubleF != 0"),
+("SELECT * FROM test_table WHERE booleanF != true ", "* WHERE booleanF != true"),
+("SELECT * FROM test_table WHERE strF != 'Yuan'", "* WHERE strF != 'Yuan'"),
+("SELECT * FROM test_table WHERE dateF != '1994-01-01' ", "* WHERE dateF != '1994-01-01'"),
+("SELECT * FROM test_table WHERE dateF != '2020-05-01 12:01:01' ", "* WHERE dateF != '2020-05-01 12:01:01'"),
+("SELECT * FROM test_table WHERE strF= 'Yuan' AND intF=10", "* WHERE strF= 'Yuan' AND intF=10"),
+("SELECT * FROM test_table WHERE strF= 'Yuan' OR intF=10", "* WHERE strF= 'Yuan' OR intF=10"),
+("SELECT * FROM test_table WHERE NOT strF= 'Alex' ", "* WHERE NOT strF= 'Alex'"),
+("SELECT * FROM test_table WHERE byteF IN (10, 100)", "* WHERE byteF IN (10, 100)"),
+("SELECT * FROM test_table WHERE shortF IN (10, 100)", "* WHERE shortF IN (10, 100)"),
+("SELECT * FROM test_table WHERE longF IN (10, 100)", "* WHERE longF IN (10.0, 100.0)"),
+("SELECT * FROM test_table WHERE intF IN (10, 100)", "* WHERE intF IN (10, 100)"),
+("SELECT * FROM test_table WHERE floatF IN (10.0, 100.0)", "* WHERE floatF IN (10.0, 100.0)"),
+("SELECT * FROM test_table WHERE doubleF IN (10.0, 100.0)", "* WHERE doubleF IN (10.0, 100.0)"),
+# (" BITWISE", "BITWISE"),
+("SELECT intF & 3 FROM test_table", "intF & 3"),
+("SELECT intF & intF FROM test_table", "intF & intF"),
+("SELECT intF | 5 FROM test_table", "intF | 5"),
+("SELECT intF | intF FROM test_table", "intF | intF"),
+("SELECT ~intF FROM test_table", "~intF"),
+("SELECT intF^intF FROM test_table", "intF^intF"),
+("SELECT shiftleft(intF, 1) FROM test_table", "shiftleft(intF, 1)"),
+("SELECT shiftright(intF, 1) FROM test_table", "shiftright(intF, 1)"),
+("SELECT shiftrightunsigned(intF, 1) FROM test_table", "shiftrightunsigned(intF, 1)"),
+("SELECT shortF & 3 FROM test_table", "shortF & 3"),
+("SELECT shortF & shortF FROM test_table", "shortF & shortF"),
+("SELECT shortF | shortF FROM test_table", "shortF | shortF"),
+("SELECT ~shortF FROM test_table", "~shortF"),
+("SELECT shortF^shortF FROM test_table", "shortF^shortF"),
+("SELECT shiftleft(shortF, 1) FROM test_table", "shiftleft(shortF, 1)"),
+("SELECT shiftright(shortF, 1) FROM test_table", "shiftright(shortF, 1)"),
+("SELECT shiftrightunsigned(shortF, 1) FROM test_table", "shiftrightunsigned(shortF, 1)"),
+("SELECT byteF & 3 FROM test_table", "byteF & 3"),
+("SELECT byteF & byteF FROM test_table", "byteF & byteF"),
+("SELECT byteF | 5 FROM test_table", "byteF | 5"),
+("SELECT byteF | byteF FROM test_table", "byteF | byteF"),
+("SELECT ~byteF FROM test_table", "~byteF"),
+("SELECT byteF^byteF FROM test_table", "byteF^byteF"),
+("SELECT shiftleft(byteF, 1) FROM test_table", "shiftleft(byteF, 1)"),
+("SELECT shiftright(byteF, 1) FROM test_table", "shiftright(byteF, 1)"),
+("SELECT shiftrightunsigned(byteF, 1) FROM test_table", "shiftrightunsigned(byteF, 1)"),
+("SELECT longF & 3 FROM test_table", "longF & 3"),
+("SELECT longF & longF FROM test_table", "longF & longF"),
+("SELECT longF | 5 FROM test_table", "longF | 5"),
+("SELECT ~longF FROM test_table", "~longF"),
+("SELECT longF^longF FROM test_table", "longF^longF"),
+("SELECT shiftleft(longF, 1) FROM test_table", "shiftleft(longF, 1)"),
+("SELECT shiftright(longF, 1) FROM test_table", "shiftright(longF, 1)"),
+("SELECT shiftrightunsigned(longF, 1) FROM test_table", "shiftrightunsigned(longF, 1)"),
+# (" OTHER", "OTHER"),
+# ("MULTIPLE CASES ", "MULTIPLE CASES"),
+("SELECT CASE WHEN byteF > 5 THEN 5*byteF WHEN intF > 5 THEN 5*shortF ELSE doubleF/2 END FROM test_table", "CASE WHEN byteF > 5 THEN 5*byteF WHEN intF > 5 THEN 5*shortF ELSE doubleF/2 END"),
+# ("IF", "IF"),
+("SELECT intF, IF (intF > 100, 10, 5) FROM test_table", "intF, IF (intF > 100, 10, 5)"),
+("SELECT byteF, IF (byteF > 100, 10, 5) FROM test_table", "byteF, IF (byteF > 100, 10, 5)"),
+("SELECT shortF, IF (shortF > 100, 10, 5) FROM test_table", "shortF, IF (shortF > 100, 10, 5)"),
+("SELECT longF, IF (longF > 100, 10, 5) FROM test_table", "longF, IF (longF > 100, 10, 5)"),
+("SELECT floatF, IF (floatF > 100.0, 10, 5) as if_float FROM test_table", "floatF, IF (floatF > 100.0, 10, 5)"),
+("SELECT doubleF, IF (longF > 100.0, 10, 5) FROM test_table", "doubleF, IF (longF > 100.0, 10, 5)"),
+("SELECT booleanF, IF (booleanF = True, False, True) FROM test_table", "booleanF, IF (booleanF = True, False, True)"),
+("SELECT strF, IF (strF = 'Alex', 10, 5) FROM test_table", "strF, IF (strF = 'Alex', 10, 5)"),
+("SELECT dateF, IF (dateF > '1994-01-01', 1990, 1980) FROM test_table", "dateF, IF (dateF > '1994-01-01', 1990, 1980)"),
+("SELECT dateF, IF (dateF > '2020-05-01 12:01:015', 1990, 1980) FROM test_table", "dateF, IF (dateF > '2020-05-01 12:01:015', 1990, 1980)"),
+# ("ISNAN", "ISNAN"),
+("SELECT ISNAN(intF/byteF) FROM test_table", "ISNAN(intF/byteF)"),
+("SELECT ISNAN(byteF/byteF) FROM test_table", "ISNAN(byteF/byteF)"),
+("SELECT ISNAN(shortF/byteF) FROM test_table", "ISNAN(shortF/byteF)"),
+("SELECT ISNAN(longF/byteF) FROM test_table", "ISNAN(longF/byteF)"),
+("SELECT ISNAN(floatF/byteF) FROM test_table", "ISNAN(floatF/byteF)"),
+("SELECT ISNAN(doubleF/byteF) FROM test_table", "ISNAN(doubleF/byteF)"),
+("SELECT ISNAN(strF/strF) FROM test_table", "ISNAN(strF/strF)"),
+("SELECT NANVL(byteF/byteF, 0) FROM test_table", "NANVL(byteF/byteF, 0)"),
+("SELECT NANVL(shortF/byteF, 0) FROM test_table", "NANVL(shortF/byteF, 0)"),
+("SELECT NANVL(intF/byteF, 0) FROM test_table", "NANVL(intF/byteF, 0)"),
+("SELECT NANVL(longF/byteF, 0) FROM test_table", "NANVL(longF/byteF, 0)"),
+("SELECT NANVL(floatF/byteF, 0) FROM test_table", "NANVL(floatF/byteF, 0)"),
+("SELECT NANVL(doubleF/byteF, 0) FROM test_table", "NANVL(doubleF/byteF, 0)"),
+("SELECT NANVL(strF/byteF, 0) FROM test_table", "NANVL(strF/byteF, 0)"),
+("SELECT IFNULL(byteF, 'nobody') as if_null FROM test_table", "IFNULL(byteF, 'nobody')"),
+("SELECT IFNULL(shortF, 'nobody') as if_null FROM test_table", "IFNULL(shortF, 'nobody')"),
+("SELECT IFNULL(intF, 'nobody') as if_null FROM test_table", "IFNULL(intF, 'nobody')"),
+("SELECT IFNULL(longF, 'nobody') as if_null FROM test_table", "IFNULL(longF, 'nobody')"),
+("SELECT IFNULL(doubleF, 'nobody') as if_null FROM test_table", "IFNULL(doubleF, 'nobody')"),
+("SELECT IFNULL(booleanF, True) as if_null FROM test_table", "IFNULL(booleanF, True)"),
+("SELECT IFNULL(strF, 'nobody') as if_null FROM test_table", "IFNULL(strF, 'nobody')"),
+("SELECT IFNULL(dateF, 'nobody') as if_null FROM test_table", "IFNULL(dateF, 'nobody')"),
+("SELECT IFNULL(timestampF, 'nobody') as if_null FROM test_table", "IFNULL(timestampF, 'nobody')"),
+("SELECT ISNULL(byteF) FROM test_table", "ISNULL(byteF)"),
+("SELECT ISNULL(shortF) FROM test_table", "ISNULL(shortF)"),
+("SELECT ISNULL(intF) FROM test_table", "ISNULL(intF)"),
+("SELECT ISNULL(longF) FROM test_table", "ISNULL(longF)"),
+("SELECT ISNULL(floatF ) FROM test_table", "ISNULL(floatF )"),
+("SELECT ISNULL(doubleF) FROM test_table", "ISNULL(doubleF)"),
+("SELECT ISNULL(booleanF) FROM test_table", "ISNULL(booleanF)"),
+("SELECT ISNULL(strF) FROM test_table", "ISNULL(strF)"),
+("SELECT ISNULL(dateF) FROM test_table", "ISNULL(dateF)"),
+("SELECT ISNULL(timestampF) FROM test_table", "ISNULL(timestampF)"),
+("SELECT ISNOTNULL(byteF) FROM test_table", "ISNOTNULL(byteF)"),
+("SELECT ISNOTNULL(shortF) FROM test_table", "ISNOTNULL(shortF)"),
+("SELECT ISNOTNULL(intF) FROM test_table", "ISNOTNULL(intF)"),
+("SELECT ISNOTNULL(longF) FROM test_table", "ISNOTNULL(longF)"),
+("SELECT ISNOTNULL(floatF) FROM test_table", "ISNOTNULL(floatF)"),
+("SELECT ISNOTNULL(doubleF) FROM test_table", "ISNOTNULL(doubleF)"),
+("SELECT ISNOTNULL(booleanF) FROM test_table", "ISNOTNULL(booleanF)"),
+("SELECT ISNOTNULL(strF) FROM test_table", "ISNOTNULL(strF)"),
+("SELECT ISNOTNULL(dateF) FROM test_table", "ISNOTNULL(dateF)"),
+("SELECT ISNOTNULL(timestampF) FROM test_table", "ISNOTNULL(timestampF)"),
+("SELECT NULLIF(intF, 0) as null_if FROM test_table", "NULLIF(intF, 0)"),
+("SELECT NULLIF(byteF, 0) as null_if FROM test_table", "NULLIF(byteF, 0)"),
+("SELECT NULLIF(shortF,0) as null_if FROM test_table", "NULLIF(shortF,0)"),
+("SELECT NULLIF(intF, 0) as null_if FROM test_table", "NULLIF(intF, 0)"),
+("SELECT NULLIF(longF, 0) as null_if FROM test_table", "NULLIF(longF, 0)"),
+("SELECT NULLIF(floatF,0) as null_if FROM test_table", "NULLIF(floatF,0)"),
+("SELECT NULLIF(doubleF, 0) as null_if FROM test_table", "NULLIF(doubleF, 0)"),
+("SELECT NULLIF(booleanF, True) as null_if FROM test_table", "NULLIF(booleanF, True)"),
+("SELECT NULLIF(dateF, '1990-1-1') as null_if FROM test_table", "NULLIF(dateF, '1990-1-1')"),
+("SELECT NULLIF(dateF, '2022-12-01 12:01:01') as null_if FROM test_table", "NULLIF(dateF, '2022-12-01 12:01:01')"),
+("SELECT NVL(byteF, 0) as nvl_value FROM test_table", "NVL(byteF, 0)"),
+("SELECT NVL(shortF, 0) as nvl_value FROM test_table", "NVL(shortF, 0)"),
+("SELECT NVL(intF, 0) as nvl_value FROM test_table", "NVL(intF, 0)"),
+("SELECT NVL(longF, 0) as nvl_value FROM test_table", "NVL(longF, 0)"),
+("SELECT NVL(floatF, 0) as nvl_value FROM test_table", "NVL(floatF, 0)"),
+("SELECT NVL(doubleF, 0) as nvl_value FROM test_table", "NVL(doubleF, 0)"),
+("SELECT NVL(booleanF, TRUE) as nvl_value FROM test_table", "NVL(booleanF, TRUE)"),
+("SELECT NVL(strF, 0) as nvl_value FROM test_table", "NVL(strF, 0)"),
+("SELECT NVL(dateF, '1990-1-1') as nvl_value FROM test_table", "NVL(dateF, '1990-1-1')"),
+("SELECT NVL(timestampF, '2022-12-01 12:01:01') as nvl_value FROM test_table", "NVL(timestampF, '2022-12-01 12:01:01')"),
+("SELECT NVL2(byteF, 'not null value','null value') as nvl2_value FROM test_table", "NVL2(byteF, 'not null value','null value')"),
+("SELECT NVL2(shortF, 'not null value','null value' ) as nvl2_value FROM test_table", "NVL2(shortF, 'not null value','null value' )"),
+("SELECT NVL2(intF, 'not null value','null value' ) as nvl2_value FROM test_table", "NVL2(intF, 'not null value','null value' )"),
+("SELECT NVL2(longF, 'not null value','null value' ) as nvl2_value FROM test_table", "NVL2(longF, 'not null value','null value' )"),
+("SELECT NVL2(floatF, 'not null value','null value' ) as nvl2_value FROM test_table", "NVL2(floatF, 'not null value','null value' )"),
+("SELECT NVL2(doubleF, 'not null value','null value' ) as nvl2_value FROM test_table", "NVL2(doubleF, 'not null value','null value' )"),
+("SELECT NVL2(booleanF, 'not null value','null value') as nvl2_value FROM test_table", "NVL2(booleanF, 'not null value','null value')"),
+("SELECT NVL2(strF, 'not null value','null value' ) as nvl2_value FROM test_table", "NVL2(strF, 'not null value','null value' )"),
+("SELECT NVL2(dateF, 'not null value','null value' ) as nvl2_value FROM test_table", "NVL2(dateF, 'not null value','null value' )"),
+("SELECT NVL2(timestampF, 'not null value','null value') as nvl2_value FROM test_table", "NVL2(timestampF, 'not null value','null value')"),
+# (" SQL FILTER", "SQL FILTER"),
+("SELECT byteF FROM test_table WHERE byteF = 20", "byteF WHERE byteF = 20"),
+("SELECT shortF FROM test_table WHERE shortF = 20", "shortF WHERE shortF = 20"),
+("SELECT intF FROM test_table WHERE intF = 20", "intF WHERE intF = 20"),
+("SELECT longF FROM test_table WHERE longF = 20", "longF WHERE longF = 20"),
+("SELECT floatF FROM test_table WHERE floatF >20", "floatF WHERE floatF >20"),
+("SELECT doubleF FROM test_table WHERE doubleF > 20", "doubleF WHERE doubleF > 20"),
+("SELECT booleanF FROM test_table WHERE booleanF = True", "booleanF WHERE booleanF = True"),
+("SELECT dateF FROM test_table WHERE dateF = '1990-1-1' ", "dateF WHERE dateF = '1990-1-1'"),
+("SELECT timestampF FROM test_table WHERE timestampF > '2020-02-01 12:01:01' ", "timestampF WHERE timestampF > '2020-02-01 12:01:01'"),
+("SELECT byteF FROM test_table WHERE byteF BETWEEN 10 AND 30", "byteF WHERE byteF BETWEEN 10 AND 30"),
+("SELECT shortF FROM test_table WHERE shortF BETWEEN 10 AND 30", "shortF WHERE shortF BETWEEN 10 AND 30"),
+("SELECT intF FROM test_table WHERE intF BETWEEN 10 AND 30", "intF WHERE intF BETWEEN 10 AND 30"),
+("SELECT longF FROM test_table WHERE longF BETWEEN 10 AND 30", "longF WHERE longF BETWEEN 10 AND 30"),
+("SELECT floatF FROM test_table WHERE floatF BETWEEN 10 AND 30", "floatF WHERE floatF BETWEEN 10 AND 30"),
+("SELECT doubleF FROM test_table WHERE doubleF BETWEEN 10 AND 30", "doubleF WHERE doubleF BETWEEN 10 AND 30"),
+("SELECT dateF FROM test_table WHERE dateF BETWEEN '1995-01-01' AND '1990-02-01' ", "dateF WHERE dateF BETWEEN '1995-01-01' AND '1990-02-01'"),
+("SELECT timestampF FROM test_table WHERE timestampF BETWEEN '2020-02-01 12:01:01' AND '2022-12-01 12:01:01' ", "timestampF WHERE timestampF BETWEEN '2020-02-01 12:01:01' AND '2022-12-01 12:01:01'"),
+# ("coalesce", "coalesce"),
+("SELECT byteF, COALESCE(byteF,'N/A') FROM test_table", "byteF, COALESCE(byteF,'N/A')"),
+("SELECT shortF, COALESCE(shortF,'N/A') FROM test_table", "shortF, COALESCE(shortF,'N/A')"),
+("SELECT intF, COALESCE(intF,'N/A') FROM test_table", "intF, COALESCE(intF,'N/A')"),
+("SELECT longF, COALESCE(longF,'N/A') FROM test_table", "longF, COALESCE(longF,'N/A')"),
+("SELECT doubleF, COALESCE(doubleF,'N/A') FROM test_table", "doubleF, COALESCE(doubleF,'N/A')"),
+("SELECT booleanF, COALESCE(booleanF, TRUE) FROM test_table", "booleanF, COALESCE(booleanF, TRUE)"),
+("SELECT strF, COALESCE(strF,'N/A') FROM test_table", "strF, COALESCE(strF,'N/A')"),
+# ("orderby/sort", "orderby/sort"),
+("SELECT byteF FROM test_table ORDER BY byteF, doubleF", "byteF ORDER BY byteF, doubleF"),
+("SELECT shortF FROM test_table ORDER BY shortF", "shortF ORDER BY shortF"),
+("SELECT intF FROM test_table ORDER BY intF", "intF ORDER BY intF"),
+("SELECT longF FROM test_table ORDER BY longF", "longF ORDER BY longF"),
+("SELECT floatF FROM test_table ORDER BY floatF", "floatF ORDER BY floatF"),
+("SELECT doubleF FROM test_table ORDER BY doubleF", "doubleF ORDER BY doubleF"),
+("SELECT booleanF FROM test_table ORDER BY booleanF", "booleanF ORDER BY booleanF"),
+("SELECT strF FROM test_table ORDER BY strF", "strF ORDER BY strF"),
+("SELECT dateF FROM test_table ORDER BY dateF", "dateF ORDER BY dateF"),
+("SELECT timestampF FROM test_table ORDER BY timestampF", "timestampF ORDER BY timestampF"),
+# (" FUNCTIONAL TEST END", "FUNCTIONAL TEST END"),
+# (" RANDOM TEST CHECKING", "RANDOM TEST CHECKING"),
+("SELECT shortF FROM test_table", "shortF"),
+("SELECT * FROM test_table", "*"),
+("SELECT strF, intF, byteF, shortF, longF, booleanF, floatF FROM test_table", "strF, intF, byteF, shortF, longF, booleanF, floatF"),
+("SELECT 100 FROM test_table", "100"),
+("SELECT intF, 2000 FROM test_table", "intF, 2000"),
+("SELECT strF IS NULL FROM test_table", "strF IS NULL"),
+("SELECT intF FROM test_table WHERE strF IS NULL", "intF WHERE strF IS NULL"),
+("SELECT CASE WHEN strF IS NULL THEN 'TRUE' ELSE 'FALSE' END FROM test_table", "CASE WHEN strF IS NULL THEN 'TRUE' ELSE 'FALSE' END"),
+("SELECT Case WHEN intF=1000 THEN 'TRUE' ELSE 'FALSE' END FROM test_table", "Case WHEN intF=1000 THEN 'TRUE' ELSE 'FALSE' END"),
+("SELECT intF IS NULL FROM test_table", "intF IS NULL"),
+("SELECT intF IS NOT NULL FROM test_table", "intF IS NOT NULL"),
+("SELECT * FROM test_table WHERE strF is NULL", "* WHERE strF is NULL"),
+("SELECT * FROM test_table WHERE strF IS NOT NULL", "* WHERE strF IS NOT NULL"),
+("SELECT * FROM test_table WHERE strF = 'Phuoc' OR strF = 'Yuan'", "* WHERE strF = 'Phuoc' OR strF = 'Yuan'"),
+("SELECT * FROM test_table WHERE intF > 1000", "* WHERE intF > 1000"),
+("SELECT strF, intF, shortF FROM test_table WHERE intF>1000 AND shortF>200", "strF, intF, shortF WHERE intF>1000 AND shortF>200"),
+("SELECT * FROM test_table WHERE intF > 1000 AND intF = 2000", "* WHERE intF > 1000 AND intF = 2000"),
+("SELECT strF, intF, longF, intF+longF FROM test_table", "strF, intF, longF, intF+longF"),
+("SELECT intF+2000 FROM test_table", "intF+2000"),
+("SELECT CAST(intF as long) FROM test_table", "CAST(intF as long)"),
+("SELECT strF AS user_name FROM test_table", "strF AS user_name"),
+("SELECT strF, intF, SUM(shortF) FROM test_table GROUP BY strF, intF", "strF, intF, SUM(shortF) GROUP BY strF, intF"),
+("SELECT COALESCE(strF,'N/A') strF FROM test_table", "COALESCE(strF,'N/A') strF"),
+# ("SELECT SUM(intF) OVER (PARTITION BY byteF ORDER BY shortF) as sum_total FROM test_table", "SUM(intF) OVER (PARTITION BY byteF ORDER BY shortF) as sum_total"),
+("SELECT SUM(shortF) FROM test_table", "SUM(shortF)"),
+("SELECT MIN(intF) FROM test_table", "MIN(intF)"),
+("SELECT MAX(intF) FROM test_table", "MAX(intF)"),
+("SELECT AVG(intF) FROM test_table", "AVG(intF)"),
+("SELECT intF, shortF FROM test_table ORDER by intF", "intF, shortF ORDER by intF"),
+
+("SELECT dateF, COALESCE(dateF,'N/A') FROM test_table", "dateF, COALESCE(dateF,'N/A')"),
+("SELECT timestampF, COALESCE(timestampF,'N/A') FROM test_table", "timestampF, COALESCE(timestampF,'N/A')"),
+
+("SELECT COUNT(1) FROM test_table", "COUNT(1)"),
+("SELECT COUNT('*') FROM test_table", "COUNT('*')"),
+("SELECT COUNT(strF) FROM test_table", "COUNT(strF)"),
+("SELECT COUNT(strF) FROM test_table WHERE intF=3000", "COUNT(strF) WHERE intF=3000"),
+("SELECT COUNT(byteF) as count, AVG(intF) as avg, (SUM(intF) + MAX(shortF * 3)) as summax FROM test_table GROUP BY intF", "COUNT(byteF), AVG(intF), SUM(intF) + MAX(shortF * 3) GROUP BY intF"),
+("SELECT COUNT(byteF) as count, (AVG(intF) * 5.0) as avg, (SUM(intF) + MAX(shortF * 3)) as summax FROM test_table GROUP BY intF*3", "COUNT(byteF), AVG(intF) * 5.0, SUM(intF) + MAX(shortF * 3) GROUP BY intF*3"),
+("SELECT COUNT(*) as count, (AVG(intF) * 5.0) as avg, (SUM(intF) + MAX(shortF * 3)) as summax FROM test_table GROUP BY intF*3", "COUNT(*), AVG(intF) * 5.0, SUM(intF) + MAX(shortF * 3) GROUP BY intF*3"),
+
+("SELECT A.shortF, B.intF from test_table A, test_table B where A.intF=B.intF ORDER BY A.intF", "A.shortF, B.intF A, test_table B where A.intF=B.intF ORDER BY A.intF"),
+("SELECT A.shortF, B.intF from test_table A, test_table B where A.intF=B.intF", "A.shortF, B.intF A, test_table B where A.intF=B.intF"),
+
+("SELECT CASE WHEN byteF > 5 THEN 5*byteF END FROM test_table", "CASE WHEN byteF > 5 THEN 5*byteF END"),
+("SELECT CASE WHEN shortF > 5 THEN 5+shortF END FROM test_table", "CASE WHEN shortF > 5 THEN 5+shortF END"),
+("SELECT CASE WHEN intF > 5 THEN 5 END FROM test_table", "CASE WHEN intF > 5 THEN 5 END"),
+("SELECT CASE WHEN longF > 5 THEN 5 END FROM test_table", "CASE WHEN longF > 5 THEN 5 END"),
+("SELECT CASE WHEN booleanF = True THEN 'TRUE' END FROM test_table", "CASE WHEN booleanF = True THEN 'TRUE' END"),
+("SELECT (CASE WHEN floatF > float(5.0) THEN float(5.0) END) as castwhen FROM test_table", "CASE WHEN floatF > 5.0 THEN 5.0 END"),
+("SELECT (CASE WHEN doubleF > double(5.0) THEN double(5.0) END) as castwhen FROM test_table", "CASE WHEN doubleF > 5.0 THEN 5.0 END"),
+("SELECT CASE WHEN dateF >= '1994-01-01' THEN 'good day' END FROM test_table", "CASE WHEN dateF >= '1994-01-01' THEN 'good day' END"),
+("SELECT CASE WHEN timestampF > '2020-05-01 12:01:015' THEN 'good time' END FROM test_table", "CASE WHEN timestampF > '2020-05-01 12:01:015' THEN 'good time' END"),
+("SELECT CASE WHEN byteF > 5 THEN 5*byteF ELSE byteF END FROM test_table", "CASE WHEN byteF > 5 THEN 5*byteF ELSE byteF END"),
+("SELECT CASE WHEN shortF > 5 THEN 5+shortF ELSE shortF END FROM test_table", "CASE WHEN shortF > 5 THEN 5+shortF ELSE shortF END"),
+("SELECT CASE WHEN intF > 5 THEN 5 ELSE 0 END FROM test_table", "CASE WHEN intF > 5 THEN 5 ELSE 0 END"),
+("SELECT CASE WHEN longF > 5 THEN 5 ELSE 5*longF END FROM test_table", "CASE WHEN longF > 5 THEN 5 ELSE 5*longF END"),
+("SELECT CASE WHEN booleanF = True THEN 'TRUE' ELSE 'false' END FROM test_table", "CASE WHEN booleanF = True THEN 'TRUE' ELSE 'false' END"),
+("SELECT (CASE WHEN floatF > float(5.0) THEN float(5.0) ELSE float(6.0) END) as casewhen FROM test_table", "CASE WHEN floatF > 5.0 THEN 5.0 ELSE 6.0 END"),
+("SELECT CASE WHEN doubleF > 5 THEN 5 ELSE doubleF/2 END FROM test_table", "CASE WHEN doubleF > 5.0 THEN 5.0 ELSE doubleF/2 END"),
+("SELECT CASE WHEN dateF >= '1994-01-01' THEN 'good day' ELSE 'bad day' END FROM test_table", "CASE WHEN dateF >= '1994-01-01' THEN 'good day' ELSE 'bad day' END"),
+("SELECT CASE WHEN timestampF > '2020-05-01 12:01:015' THEN 'good time' ELSE 'bad time' END FROM test_table", "CASE WHEN timestampF > '2020-05-01 12:01:015' THEN 'good time' ELSE 'bad time' END"),
+
+("SELECT ROW_NUMBER() OVER (PARTITION BY byteF ORDER BY byteF) row_num, byteF FROM test_table", "ROW_NUMBER() OVER (PARTITION BY byteF ORDER BY byteF) row_num, byteF"),
+("SELECT ROW_NUMBER() OVER (PARTITION BY shortF ORDER BY shortF) row_num, shortF FROM test_table", "ROW_NUMBER() OVER (PARTITION BY shortF ORDER BY shortF) row_num, shortF"),
+("SELECT ROW_NUMBER() OVER (PARTITION BY intF ORDER BY intF) row_num, intF FROM test_table", "ROW_NUMBER() OVER (PARTITION BY intF ORDER BY intF) row_num, intF"),
+("SELECT ROW_NUMBER() OVER (PARTITION BY longF ORDER BY longF) row_num, longF FROM test_table", "ROW_NUMBER() OVER (PARTITION BY longF ORDER BY longF) row_num, longF"),
+("SELECT ROW_NUMBER() OVER (PARTITION BY floatF ORDER BY floatF) row_num, floatF FROM test_table", "ROW_NUMBER() OVER (PARTITION BY floatF ORDER BY floatF) row_num, floatF"),
+("SELECT ROW_NUMBER() OVER (PARTITION BY booleanF ORDER BY booleanF) row_num, booleanF FROM test_table", "ROW_NUMBER() OVER (PARTITION BY booleanF ORDER BY booleanF) row_num, booleanF"),
+("SELECT ROW_NUMBER() OVER (PARTITION BY strF ORDER BY strF) row_num, strF FROM test_table", "ROW_NUMBER() OVER (PARTITION BY strF ORDER BY strF) row_num, strF"),
+("SELECT ROW_NUMBER() OVER (PARTITION BY dateF ORDER BY dateF) row_num, dateF FROM test_table", "ROW_NUMBER() OVER (PARTITION BY dateF ORDER BY dateF) row_num, dateF"),
+("SELECT ROW_NUMBER() OVER (PARTITION BY timestampF ORDER BY timestampF) row_num, timestampF FROM test_table", "ROW_NUMBER() OVER (PARTITION BY timestampF ORDER BY timestampF) row_num, timestampF"),
+# ("window/row/range (need change)", "window/row/range (need change)"),
+#("SELECT byteF, SUM(byteF) OVER (PARTITION BY byteF ORDER BY byteF RANGE BETWEEN 20 PRECEDING AND 10 FOLLOWING ) as sum_total FROM test_table", "byteF, SUM(byteF) OVER (PARTITION BY byteF ORDER BY byteF RANGE BETWEEN 20 PRECEDING AND 10 FOLLOWING ) as sum_total"),
+#("SELECT SUM(intF) OVER (PARTITION BY byteF ORDER BY byteF RANGE BETWEEN 20 PRECEDING AND 10 FOLLOWING ) as sum_total FROM test_table", "SUM(intF) OVER (PARTITION BY byteF ORDER BY byteF RANGE BETWEEN 20 PRECEDING AND 10 FOLLOWING ) as sum_total"),
+("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY shortF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY shortF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total"),
+#("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY shortF RANGE BETWEEN 20 PRECEDING AND 5 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY shortF RANGE BETWEEN 20 PRECEDING AND 5 FOLLOWING ) as sum_total"),
+("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY longF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY longF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total"),
+#("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY longF RANGE BETWEEN 20 PRECEDING AND 5 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY longF RANGE BETWEEN 20 PRECEDING AND 5 FOLLOWING ) as sum_total"),
+("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY floatF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY floatF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total"),
+#("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY floatF RANGE BETWEEN 20 PRECEDING AND 5 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY floatF RANGE BETWEEN 20 PRECEDING AND 5 FOLLOWING ) as sum_total"),
+("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY doubleF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY doubleF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total"),
+#("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY doubleF RANGE BETWEEN 20 PRECEDING AND 50 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY doubleF RANGE BETWEEN 20 PRECEDING AND 50 FOLLOWING ) as sum_total"),
+("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY booleanF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY booleanF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total"),
+("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY booleanF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY booleanF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total"),
+("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY dateF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY dateF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total"),
+("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY timestampF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY timestampF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total"),
+("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY CAST(dateF AS TIMESTAMP) RANGE BETWEEN INTERVAL 1 DAYS PRECEDING AND INTERVAL 1 DAYS FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY CAST(dateF AS TIMESTAMP) RANGE BETWEEN INTERVAL 1 DAYS PRECEDING AND INTERVAL 1 DAYS FOLLOWING ) as sum_total"),
+
+
+# ("not supported, filed bug", "not supported, filed bug"),
+# ("SELECT SUM(byteF) OVER (PARTITION BY byteF ORDER BY timestampF RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total FROM test_table", "SUM(byteF) OVER (PARTITION BY byteF ORDER BY timestampF RANGE BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as sum_total"),
+]
+
+SELECT_JOIN_SQL = [
+# (" JOIN", "JOIN"),
+("SELECT A.byteF as AbyteF, B.byteF as BbyteF from test_table A, test_table B where A.byteF=B.byteF ", "A.byteF, B.byteF A, test_table B where A.byteF=B.byteF"),
+("SELECT A.shortF as AshortF, B.shortF as BbyteF from test_table A, test_table B where A.shortF=B.shortF", "A.shortF, B.shortF A, test_table B where A.shortF=B.shortF"),
+("SELECT A.intF as AintF, B.intF as BintF from test_table A, test_table B where A.intF=B.intF ", "A.intF, B.intF A, test_table B where A.intF=B.intF"),
+("SELECT A.longF as AlongF, B.longF as BlongF from test_table A, test_table B where A.longF=B.longF", "A.longF, B.longF A, test_table B where A.longF=B.longF"),
+("SELECT A.floatF as AfloatF, B.floatF as BfloatF from test_table A, test_table B where A.floatF=B.floatF ", "A.floatF, B.floatF A, test_table B where A.floatF=B.floatF"),
+("SELECT A.doubleF as AdoubleF, B.doubleF as BdoubleF from test_table A, test_table B where A.doubleF=B.doubleF", "A.doubleF, B.doubleF A, test_table B where A.doubleF=B.doubleF"),
+("SELECT A.booleanF as AbooleanF, B.booleanF as BbooleanF from test_table A, test_table B where A.booleanF=B.booleanF ", "A.booleanF, B.booleanF A, test_table B where A.booleanF=B.booleanF"),
+("SELECT A.strF as AstrF, B.strF as BstrF from test_table A, test_table B where A.strF=B.strF", "A.strF, B.strF A, test_table B where A.strF=B.strF"),
+("SELECT A.dateF as AdateF, B.dateF as BdateF from test_table A, test_table B where A.dateF=B.dateF ", "A.dateF, B.dateF A, test_table B where A.dateF=B.dateF"),
+("SELECT A.timestampF as AtimestampF, B.timestampF as BtimestampF from test_table A, test_table B where A.timestampF=B.timestampF", "A.timestampF, B.timestampF A, test_table B where A.timestampF=B.timestampF"),
+("SELECT test_table.byteF as byteF, test_table1.byteF as byteF1 from test_table INNER JOIN test_table1 ON test_table.byteF=test_table1.byteF", "test_table.byteF, test_table1.byteF INNER JOIN test_table1 ON test_table.byteF=test_table1.byteF"),
+("SELECT test_table.shortF as shortF, test_table1.shortF as shortF1 from test_table INNER JOIN test_table1 ON test_table.shortF=test_table1.shortF", "test_table.shortF, test_table1.shortF INNER JOIN test_table1 ON test_table.shortF=test_table1.shortF"),
+("SELECT test_table.intF as intF, test_table1.intF as intF1 from test_table INNER JOIN test_table1 ON test_table.intF=test_table1.intF", "test_table.intF, test_table1.intF INNER JOIN test_table1 ON test_table.intF=test_table1.intF"),
+("SELECT test_table.longF as longF, test_table1.longF as longF1 from test_table INNER JOIN test_table1 ON test_table.longF=test_table1.longF", "test_table.longF, test_table1.longF INNER JOIN test_table1 ON test_table.longF=test_table1.longF"),
+("SELECT test_table.floatF as floatF, test_table1.floatF as floatF1 from test_table INNER JOIN test_table1 ON test_table.floatF=test_table1.floatF", "test_table.floatF, test_table1.floatF INNER JOIN test_table1 ON test_table.floatF=test_table1.floatF"),
+("SELECT test_table.doubleF as doubleF, test_table1.doubleF as doubleF1 from test_table INNER JOIN test_table1 ON test_table.doubleF=test_table1.doubleF", "test_table.doubleF, test_table1.doubleF INNER JOIN test_table1 ON test_table.doubleF=test_table1.doubleF"),
+("SELECT test_table.booleanF as booleanF, test_table1.booleanF as booleanF1 from test_table INNER JOIN test_table1 ON test_table.booleanF=test_table1.booleanF", "test_table.booleanF, test_table1.booleanF INNER JOIN test_table1 ON test_table.booleanF=test_table1.booleanF"),
+("SELECT test_table.strF as strF, test_table1.strF as strF1 from test_table INNER JOIN test_table1 ON test_table.strF=test_table1.strF", "test_table.strF, test_table1.strF INNER JOIN test_table1 ON test_table.strF=test_table1.strF"),
+("SELECT test_table.dateF as dateF, test_table1.dateF as dateF1 from test_table INNER JOIN test_table1 ON test_table.dateF=test_table1.dateF", "test_table.dateF, test_table1.dateF INNER JOIN test_table1 ON test_table.dateF=test_table1.dateF"),
+("SELECT test_table.timestampF as timestampF, test_table1.timestampF as timestampF1 from test_table INNER JOIN test_table1 ON test_table.timestampF=test_table1.timestampF", "test_table.timestampF, test_table1.timestampF INNER JOIN test_table1 ON test_table.timestampF=test_table1.timestampF"),
+("SELECT test_table.byteF as byteF, test_table1.byteF as byteF1 from test_table LEFT JOIN test_table1 ON test_table.byteF=test_table1.byteF", "test_table.byteF, test_table1.byteF LEFT JOIN test_table1 ON test_table.byteF=test_table1.byteF"),
+("SELECT test_table.shortF as shortF, test_table1.shortF as shortF1 from test_table LEFT JOIN test_table1 ON test_table.shortF=test_table1.shortF", "test_table.shortF, test_table1.shortF LEFT JOIN test_table1 ON test_table.shortF=test_table1.shortF"),
+("SELECT test_table.intF as intF, test_table1.intF as intF1 from test_table LEFT JOIN test_table1 ON test_table.intF=test_table1.intF", "test_table.intF, test_table1.intF LEFT JOIN test_table1 ON test_table.intF=test_table1.intF"),
+("SELECT test_table.longF as longF, test_table1.longF as longF1 from test_table LEFT JOIN test_table1 ON test_table.longF=test_table1.longF", "test_table.longF, test_table1.longF LEFT JOIN test_table1 ON test_table.longF=test_table1.longF"),
+("SELECT test_table.floatF as floatF, test_table1.floatF as floatF1 from test_table LEFT JOIN test_table1 ON test_table.floatF=test_table1.floatF", "test_table.floatF, test_table1.floatF LEFT JOIN test_table1 ON test_table.floatF=test_table1.floatF"),
+("SELECT test_table.doubleF as doubleF, test_table1.doubleF as doubleF1 from test_table LEFT JOIN test_table1 ON test_table.doubleF=test_table1.doubleF", "test_table.doubleF, test_table1.doubleF LEFT JOIN test_table1 ON test_table.doubleF=test_table1.doubleF"),
+("SELECT test_table.booleanF as booleanF, test_table1.booleanF as booleanF1 from test_table LEFT JOIN test_table1 ON test_table.booleanF=test_table1.booleanF", "test_table.booleanF, test_table1.booleanF LEFT JOIN test_table1 ON test_table.booleanF=test_table1.booleanF"),
+("SELECT test_table.strF as strF, test_table1.strF as strF1 from test_table LEFT JOIN test_table1 ON test_table.strF=test_table1.strF", "test_table.strF, test_table1.strF LEFT JOIN test_table1 ON test_table.strF=test_table1.strF"),
+("SELECT test_table.dateF as dateF, test_table1.dateF as dateF1 from test_table LEFT JOIN test_table1 ON test_table.dateF=test_table1.dateF", "test_table.dateF, test_table1.dateF LEFT JOIN test_table1 ON test_table.dateF=test_table1.dateF"),
+("SELECT test_table.timestampF as timestampF, test_table1.timestampF as timestampF1 from test_table LEFT JOIN test_table1 ON test_table.timestampF=test_table1.timestampF", "test_table.timestampF, test_table1.timestampF LEFT JOIN test_table1 ON test_table.timestampF=test_table1.timestampF"),
+#("SELECT test_table.byteF as byteF, test_table1.byteF as byteF1 from test_table RIGHT JOIN test_table1 ON test_table.byteF=test_table1.byteF", "test_table.byteF, test_table1.byteF RIGHT JOIN test_table1 ON test_table.byteF=test_table1.byteF"),
+#("SELECT test_table.shortF as shortF, test_table1.shortF as shortF1 from test_table RIGHT JOIN test_table1 ON test_table.shortF=test_table1.shortF", "test_table.shortF, test_table1.shortF RIGHT JOIN test_table1 ON test_table.shortF=test_table1.shortF"),
+#("SELECT test_table.intF as intF, test_table1.intF as intF1 from test_table RIGHT JOIN test_table1 ON test_table.intF=test_table1.intF", "test_table.intF, test_table1.intF RIGHT JOIN test_table1 ON test_table.intF=test_table1.intF"),
+#("SELECT test_table.longF as longF, test_table1.longF as longF1 from test_table RIGHT JOIN test_table1 ON test_table.longF=test_table1.longF", "test_table.longF, test_table1.longF RIGHT JOIN test_table1 ON test_table.longF=test_table1.longF"),
+#("SELECT test_table.floatF as floatF, test_table1.floatF as floatF1 from test_table RIGHT JOIN test_table1 ON test_table.floatF=test_table1.floatF", "test_table.floatF, test_table1.floatF RIGHT JOIN test_table1 ON test_table.floatF=test_table1.floatF"),
+#("SELECT test_table.doubleF as doubleF, test_table1.doubleF as doubleF1 from test_table RIGHT JOIN test_table1 ON test_table.doubleF=test_table1.doubleF", "test_table.doubleF, test_table1.doubleF RIGHT JOIN test_table1 ON test_table.doubleF=test_table1.doubleF"),
+#("SELECT test_table.booleanF as booleanF, test_table1.booleanF as booleanF1 from test_table RIGHT JOIN test_table1 ON test_table.booleanF=test_table1.booleanF", "test_table.booleanF, test_table1.booleanF RIGHT JOIN test_table1 ON test_table.booleanF=test_table1.booleanF"),
+#("SELECT test_table.strF as strF, test_table1.strF as strF1 from test_table RIGHT JOIN test_table1 ON test_table.strF=test_table1.strF", "test_table.strF, test_table1.strF RIGHT JOIN test_table1 ON test_table.strF=test_table1.strF"),
+#("SELECT test_table.dateF as dateF, test_table1.dateF as dateF1 from test_table RIGHT JOIN test_table1 ON test_table.dateF=test_table1.dateF", "test_table.dateF, test_table1.dateF RIGHT JOIN test_table1 ON test_table.dateF=test_table1.dateF"),
+#("SELECT test_table.timestampF as timestampF, test_table1.timestampF as timestampF1 from test_table RIGHT JOIN test_table1 ON test_table.timestampF=test_table1.timestampF", "test_table.timestampF, test_table1.timestampF RIGHT JOIN test_table1 ON test_table.timestampF=test_table1.timestampF"),
+#("SELECT test_table.byteF as byteF, test_table1.byteF as byteF1 from test_table FULL JOIN test_table1 ON test_table.byteF=test_table1.byteF", "test_table.byteF, test_table1.byteF FULL JOIN test_table1 ON test_table.byteF=test_table1.byteF"),
+#("SELECT test_table.shortF as shortF, test_table1.shortF as shortF1 from test_table FULL JOIN test_table1 ON test_table.shortF=test_table1.shortF", "test_table.shortF, test_table1.shortF FULL JOIN test_table1 ON test_table.shortF=test_table1.shortF"),
+#("SELECT test_table.intF as intF, test_table1.intF as intF1 from test_table FULL JOIN test_table1 ON test_table.intF=test_table1.intF", "test_table.intF, test_table1.intF FULL JOIN test_table1 ON test_table.intF=test_table1.intF"),
+#("SELECT test_table.longF as longF, test_table1.longF as longF1 from test_table FULL JOIN test_table1 ON test_table.longF=test_table1.longF", "test_table.longF, test_table1.longF FULL JOIN test_table1 ON test_table.longF=test_table1.longF"),
+#("SELECT test_table.floatF as floatF, test_table1.floatF as floatF1 from test_table FULL JOIN test_table1 ON test_table.floatF=test_table1.floatF", "test_table.floatF, test_table1.floatF FULL JOIN test_table1 ON test_table.floatF=test_table1.floatF"),
+#("SELECT test_table.doubleF as doubleF, test_table1.doubleF as doubleF1 from test_table FULL JOIN test_table1 ON test_table.doubleF=test_table1.doubleF", "test_table.doubleF, test_table1.doubleF FULL JOIN test_table1 ON test_table.doubleF=test_table1.doubleF"),
+#("SELECT test_table.booleanF as booleanF, test_table1.booleanF as booleanF1 from test_table FULL JOIN test_table1 ON test_table.booleanF=test_table1.booleanF", "test_table.booleanF, test_table1.booleanF FULL JOIN test_table1 ON test_table.booleanF=test_table1.booleanF"),
+#("SELECT test_table.strF as strF, test_table1.strF as strF1 from test_table FULL JOIN test_table1 ON test_table.strF=test_table1.strF", "test_table.strF, test_table1.strF FULL JOIN test_table1 ON test_table.strF=test_table1.strF"),
+#("SELECT test_table.dateF as dateF, test_table1.dateF as dateF1 from test_table FULL JOIN test_table1 ON test_table.dateF=test_table1.dateF", "test_table.dateF, test_table1.dateF FULL JOIN test_table1 ON test_table.dateF=test_table1.dateF"),
+#("SELECT test_table.timestampF as timestampF, test_table1.timestampF as timestampF1 from test_table FULL JOIN test_table1 ON test_table.timestampF=test_table1.timestampF", "test_table.timestampF, test_table1.timestampF FULL JOIN test_table1 ON test_table.timestampF=test_table1.timestampF"),
+]
+
+
+SELECT_PRE_ORDER_SQL=[
+("SELECT FIRST(byteF) as res FROM test_table GROUP BY intF", "FIRST(byteF) GROUP BY intF", "byteF"),
+("SELECT FIRST(shortF) as res FROM test_table GROUP BY intF", "FIRST(shortF) GROUP BY intF", "shortF"),
+("SELECT FIRST(intF) as res FROM test_table GROUP BY byteF", "FIRST(intF) GROUP BY byteF", "intF"),
+("SELECT FIRST(longF) as res FROM test_table GROUP BY intF", "FIRST(longF) GROUP BY intF", "longF"),
+("SELECT FIRST(floatF) as res FROM test_table GROUP BY intF", "FIRST(floatF) GROUP BY intF", "floatF"),
+("SELECT FIRST(doubleF) as res FROM test_table GROUP BY intF", "FIRST(doubleF) GROUP BY intF", "doubleF"),
+("SELECT FIRST(booleanF) as res FROM test_table GROUP BY intF", "FIRST(booleanF) GROUP BY intF", "booleanF"),
+("SELECT FIRST(strF) as res FROM test_table GROUP BY intF", "FIRST(strF) GROUP BY intF", "strF"),
+("SELECT FIRST(dateF) as res FROM test_table GROUP BY intF", "FIRST(dateF) GROUP BY intF", "dateF"),
+("SELECT FIRST(timestampF) as res FROM test_table GROUP BY intF", "FIRST(timestampF) GROUP BY intF", "timestampF"),
+("SELECT FIRST(byteF) as res FROM test_table GROUP BY intF, shortF", "FIRST(byteF) GROUP BY intF, shortF", "byteF"),
+("SELECT FIRST(shortF) as res FROM test_table GROUP BY intF, byteF", "FIRST(shortF) GROUP BY intF, byteF", "shortF"),
+
+("SELECT LAST(byteF) as res FROM test_table GROUP BY intF", "LAST(byteF) GROUP BY intF", "byteF"),
+("SELECT LAST(shortF) as res FROM test_table GROUP BY intF", "LAST(shortF) GROUP BY intF", "shortF"),
+("SELECT LAST(intF) as res FROM test_table GROUP BY byteF", "LAST(intF) GROUP BY byteF", "intF"),
+("SELECT LAST(longF) as res FROM test_table GROUP BY intF", "LAST(longF) GROUP BY intF", "longF"),
+("SELECT LAST(floatF) as res FROM test_table GROUP BY intF", "LAST(floatF) GROUP BY intF", "floatF"),
+("SELECT LAST(doubleF) as res FROM test_table GROUP BY intF", "LAST(doubleF) GROUP BY intF", "doubleF"),
+("SELECT LAST(booleanF) as res FROM test_table GROUP BY intF", "LAST(booleanF) GROUP BY intF", "booleanF"),
+("SELECT LAST(strF) as res FROM test_table GROUP BY intF", "LAST(strF) GROUP BY intF", "strF"),
+("SELECT LAST(dateF) as res FROM test_table GROUP BY intF", "LAST(dateF) GROUP BY intF", "dateF"),
+("SELECT LAST(timestampF) as res FROM test_table GROUP BY intF", "LAST(timestampF) GROUP BY intF", "timestampF"),
+
+("SELECT byteF, SUM(byteF) OVER (PARTITION BY shortF ORDER BY intF ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING ) as res FROM test_table", "byteF, SUM(byteF) OVER (PARTITION BY shortF ORDER BY intF ROWS BETWEEN 2 PRECEDING AND 2 FOLLOWING ) as res", "byteF"),
+("SELECT SUM(intF) OVER (PARTITION BY byteF ORDER BY byteF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as res FROM test_table", "SUM(intF) OVER (PARTITION BY byteF ORDER BY byteF ROWS BETWEEN 1 PRECEDING AND 1 FOLLOWING ) as res", "intF"),
+]
+'''
+("SELECT LAST(byteF) FROM test_table", "LAST(byteF)"),
+("SELECT LAST(shortF) FROM test_table", "LAST(shortF)"),
+("SELECT LAST(intF) FROM test_table", "LAST(intF)"),
+("SELECT LAST(longF) FROM test_table", "LAST(longF)"),
+("SELECT LAST(floatF) FROM test_table", "LAST(floatF)"),
+("SELECT LAST(doubleF) FROM test_table", "LAST(doubleF)"),
+("SELECT LAST(booleanF) FROM test_table", "LAST(booleanF)"),
+("SELECT LAST(strF) FROM test_table", "LAST(strF)"),
+("SELECT LAST(dateF) FROM test_table", "LAST(dateF)"),
+("SELECT LAST(timestampF) FROM test_table", "LAST(timestampF)"),
+
+("SELECT FIRST(byteF) FROM test_table", "FIRST(byteF)"),
+("SELECT FIRST(shortF) FROM test_table", "FIRST(shortF)"),
+("SELECT FIRST(intF) FROM test_table", "FIRST(intF)"),
+("SELECT FIRST(longF) FROM test_table", "FIRST(longF)"),
+("SELECT FIRST(floatF) FROM test_table", "FIRST(floatF)"),
+("SELECT FIRST(doubleF) FROM test_table", "FIRST(doubleF)"),
+("SELECT FIRST(booleanF) FROM test_table", "FIRST(booleanF)"),
+("SELECT FIRST(strF) FROM test_table", "FIRST(strF)"),
+("SELECT FIRST(dateF) FROM test_table", "FIRST(dateF)"),
+("SELECT FIRST(timestampF) FROM test_table", "FIRST(timestampF)"),
+'''
+SELECT_FLOAT_SQL=[
+("SELECT IFNULL(floatF, 0) as if_null FROM test_table", "IFNULL(floatF, 0)"),
+("SELECT floatF, COALESCE(floatF, 0) FROM test_table", "floatF, COALESCE(floatF,0)"),
+]
diff --git a/jenkins/spark-premerge-build.sh b/jenkins/spark-premerge-build.sh
index bca4ce1f34b..fa69c2d5ff1 100755
--- a/jenkins/spark-premerge-build.sh
+++ b/jenkins/spark-premerge-build.sh
@@ -49,7 +49,7 @@ export PATH="$SPARK_HOME/bin:$SPARK_HOME/sbin:$PATH"
tar zxf $SPARK_HOME.tar.gz -C $ARTF_ROOT && \
rm -f $SPARK_HOME.tar.gz
-mvn -U -B "$@" clean verify
+mvn -U -B "$@" clean verify -Dpytest.TEST_TAGS=''
# The jacoco coverage should have been collected, but because of how the shade plugin
# works and jacoco we need to clean some things up so jacoco will only report for the
diff --git a/pom.xml b/pom.xml
index 30402690abf..cfdcff5b66c 100644
--- a/pom.xml
+++ b/pom.xml
@@ -63,7 +63,8 @@
false
UTF-8
- UTF-8
+ UTF-8
+ not qarun