You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@datafusion.apache.org by gi...@apache.org on 2026/10/12 12:58:10 UTC
(datafusion-comet) 01/01: test: migrate scalar hash coverage to SQL fixtures (#6881)
This is an automated email from the ASF dual-hosted git repository.
github-merge-queue[bot] pushed a commit to branch gh-readonly-queue/main/pr-6881-031070adc40b7f40491ddfd512296b44aaef3ade
in repository https://gitbox.apache.org/repos/asf/datafusion-comet.git
commit 17c1413c8e879f17c8acea5c1a7987817063d648
Author: KUAN-HAO HUANG <10...@users.noreply.github.com>
AuthorDate: Mon Oct 12 12:29:25 2026 +0000
test: migrate scalar hash coverage to SQL fixtures (#6881)
Part of #6634. Preserve scalar input types, hash child order and dictionary configurations while replacing 18 Scala tests with SQL fixtures.
---
.../resources/sql-tests/expressions/hash/crc32.sql | 2 +
.../resources/sql-tests/expressions/hash/hash.sql | 65 +++++++++++
.../sql-tests/expressions/hash/hash_types.sql | 97 +++++++++++++++
.../org/apache/comet/CometExpressionSuite.scala | 94 ---------------
.../apache/comet/CometHashExpressionSuite.scala | 130 ---------------------
5 files changed, 164 insertions(+), 224 deletions(-)
diff --git a/spark/src/test/resources/sql-tests/expressions/hash/crc32.sql b/spark/src/test/resources/sql-tests/expressions/hash/crc32.sql
index 7b922df0cc..150cb11fe9 100644
--- a/spark/src/test/resources/sql-tests/expressions/hash/crc32.sql
+++ b/spark/src/test/resources/sql-tests/expressions/hash/crc32.sql
@@ -15,6 +15,8 @@
-- specific language governing permissions and limitations
-- under the License.
+-- ConfigMatrix: parquet.enable.dictionary=false,true
+
-- crc32 function
statement
CREATE TABLE test(col string, a int, b float) USING parquet
diff --git a/spark/src/test/resources/sql-tests/expressions/hash/hash.sql b/spark/src/test/resources/sql-tests/expressions/hash/hash.sql
index cbf90b1845..ca2065de38 100644
--- a/spark/src/test/resources/sql-tests/expressions/hash/hash.sql
+++ b/spark/src/test/resources/sql-tests/expressions/hash/hash.sql
@@ -16,6 +16,7 @@
-- under the License.
-- Config: spark.sql.legacy.allowHashOnMapType=true
+-- ConfigMatrix: parquet.enable.dictionary=false,true
-- hash functions
statement
@@ -27,6 +28,67 @@ INSERT INTO test VALUES ('Spark SQL ', 10, 1.2), (NULL, NULL, NULL), ('', 0, 0.
query
SELECT md5(col), md5(cast(a as string)), md5(cast(b as string)), hash(col), hash(col, 1), hash(col, 0), hash(col, a, b), hash(b, a, col), xxhash64(col), xxhash64(col, 1), xxhash64(col, 0), xxhash64(col, a, b), xxhash64(b, a, col), sha2(col, 0), sha2(col, 256), sha2(col, 224), sha2(col, 384), sha2(col, 512), sha2(col, 128), sha2(col, -1), sha1(col), sha1(cast(a as string)), sha1(cast(b as string)) FROM test
+-- Single-column strings, including the repeated inputs from the dictionary and md5 tests.
+statement
+CREATE TABLE test_hash_strings(c STRING) USING parquet
+
+statement
+INSERT INTO test_hash_strings VALUES
+ ('hello'), (''), ('Spark SQL'), ('苹果手机'), (NULL),
+ ('a'), ('b'), ('a'), ('b'), ('a'), ('c'),
+ ('test1'), ('test1'), ('test2'), ('test2')
+
+query expect_native(hash, xxhash64, md5)
+SELECT c, hash(c), xxhash64(c), md5(c) FROM test_hash_strings
+
+-- Keep DOUBLE distinct from the FLOAT column above and exercise both child orders.
+statement
+CREATE TABLE test_hash_columns(a INT, b STRING, c DOUBLE) USING parquet
+
+statement
+INSERT INTO test_hash_columns VALUES
+ (1, 'hello', 3.14), (2, '', 0.0), (NULL, NULL, NULL), (-1, 'test', -1.5), (3, 'test', 1.0)
+
+query expect_native(hash, xxhash64)
+SELECT hash(a, b, c), xxhash64(a, b, c), hash(c, b, a), xxhash64(c, b, a),
+ hash(a), xxhash64(a), hash(b), xxhash64(b), hash(c), xxhash64(c)
+FROM test_hash_columns
+
+-- Extra integers are hashed as children, not used as seeds.
+query expect_native(hash, xxhash64)
+SELECT hash(a, 0), xxhash64(a, 0), hash(a, 42), xxhash64(a, 42),
+ hash(a, -1), xxhash64(a, -1) FROM test_hash_columns
+
+-- A deterministic replacement for the generated corpus: 1000 rows with repeated strings,
+-- integer/float boundaries and timestamp-like strings containing control characters.
+statement
+CREATE TABLE test_hash_boundaries(col STRING, a INT, b FLOAT) USING parquet
+
+statement
+INSERT INTO test_hash_boundaries
+SELECT /*+ COALESCE(1) */ col, a, b FROM VALUES
+ ('012345', 2147483647, float('3.4028235E38')),
+ ('6789/:', -2147483648, float('-3.4028235E38')),
+ ('T \t\r\n', 0, float('1.4E-45')),
+ (' \t\r\n/:T', -1, float('-1.4E-45')),
+ ('', 1, float('-0.0')),
+ (NULL, NULL, CAST(NULL AS FLOAT)),
+ ('12:34T', NULL, float('0.0')),
+ (NULL, -42, float('NaN')),
+ ('012345', 10, CAST(NULL AS FLOAT)),
+ ('6789/:', -10, float('-Infinity'))
+AS v(col, a, b) CROSS JOIN range(100)
+
+-- FLOAT-to-string formatting has separate compatibility limits, so hash the float directly.
+query expect_native(md5, hash, xxhash64, crc32, sha2, sha1)
+SELECT md5(col), md5(CAST(a AS STRING)),
+ hash(col), hash(col, 1), hash(col, 0), hash(col, a, b), hash(b, a, col),
+ xxhash64(col), xxhash64(col, 1), xxhash64(col, 0), xxhash64(col, a, b), xxhash64(b, a, col),
+ crc32(col), crc32(CAST(a AS STRING)),
+ sha2(col, 0), sha2(col, 256), sha2(col, 224), sha2(col, 384), sha2(col, 512),
+ sha2(col, 128), sha2(col, -1), sha1(col), sha1(CAST(a AS STRING))
+FROM test_hash_boundaries
+
-- literal arguments
-- The SQL file test suite disables ConstantFolding, so these literal arguments reach Comet's
-- native engine as scalar values rather than being folded away by Spark's optimizer.
@@ -43,6 +105,9 @@ CREATE TABLE test_nan(d double, f float) USING parquet
statement
INSERT INTO test_nan VALUES (double('NaN'), float('NaN')), (0.0, 0.0), (double('-0.0'), float('-0.0')), (1.5, 1.5), (NULL, NULL), (double('Infinity'), float('Infinity')), (double('-Infinity'), float('-Infinity'))
+statement
+INSERT INTO test_nan VALUES (1.0, 1.0), (-1.0, -1.0), (3.14159265358979, 3.14159)
+
query
SELECT hash(d), hash(-d), xxhash64(d), xxhash64(-d), hash(f), hash(-f), xxhash64(f), xxhash64(-f), hash(-d, -f), xxhash64(-d, -f) FROM test_nan
diff --git a/spark/src/test/resources/sql-tests/expressions/hash/hash_types.sql b/spark/src/test/resources/sql-tests/expressions/hash/hash_types.sql
new file mode 100644
index 0000000000..2922be456f
--- /dev/null
+++ b/spark/src/test/resources/sql-tests/expressions/hash/hash_types.sql
@@ -0,0 +1,97 @@
+-- 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.
+
+-- Read typed columns from Parquet so hashing cannot be evaluated by the optimizer.
+statement
+CREATE TABLE test_hash_boolean(c BOOLEAN) USING parquet
+
+statement
+INSERT INTO test_hash_boolean VALUES (true), (false), (NULL)
+
+query expect_native(hash, xxhash64)
+SELECT c, hash(c), xxhash64(c) FROM test_hash_boolean
+
+statement
+CREATE TABLE test_hash_tinyint(c TINYINT) USING parquet
+
+statement
+INSERT INTO test_hash_tinyint VALUES (1), (0), (-1), (127), (-128), (NULL)
+
+query expect_native(hash, xxhash64)
+SELECT c, hash(c), xxhash64(c) FROM test_hash_tinyint
+
+statement
+CREATE TABLE test_hash_smallint(c SMALLINT) USING parquet
+
+statement
+INSERT INTO test_hash_smallint VALUES (1), (0), (-1), (32767), (-32768), (NULL)
+
+query expect_native(hash, xxhash64)
+SELECT c, hash(c), xxhash64(c) FROM test_hash_smallint
+
+statement
+CREATE TABLE test_hash_int(c INT) USING parquet
+
+statement
+INSERT INTO test_hash_int VALUES (1), (0), (-1), (2147483647), (-2147483648), (NULL)
+
+query expect_native(hash, xxhash64)
+SELECT c, hash(c), xxhash64(c) FROM test_hash_int
+
+statement
+CREATE TABLE test_hash_bigint(c BIGINT) USING parquet
+
+statement
+INSERT INTO test_hash_bigint VALUES
+ (1), (0), (-1), (9223372036854775807), (-9223372036854775808), (NULL)
+
+query expect_native(hash, xxhash64)
+SELECT c, hash(c), xxhash64(c) FROM test_hash_bigint
+
+statement
+CREATE TABLE test_hash_binary(c BINARY) USING parquet
+
+statement
+INSERT INTO test_hash_binary VALUES (X''), (X'00'), (X'0102030405'), (NULL)
+
+query expect_native(hash, xxhash64)
+SELECT c, hash(c), xxhash64(c) FROM test_hash_binary
+
+statement
+CREATE TABLE test_hash_date(c DATE) USING parquet
+
+statement
+INSERT INTO test_hash_date VALUES
+ (DATE '2023-01-01'), (DATE '1970-01-01'), (DATE '2000-12-31'),
+ (DATE '1969-12-31'), (NULL)
+
+query expect_native(hash, xxhash64)
+SELECT c, hash(c), xxhash64(c) FROM test_hash_date
+
+statement
+CREATE TABLE test_hash_timestamp(c TIMESTAMP, ntz TIMESTAMP_NTZ) USING parquet
+
+statement
+INSERT INTO test_hash_timestamp VALUES
+ (TIMESTAMP '2023-01-01 12:00:00', TIMESTAMP_NTZ '2023-01-01 12:00:00'),
+ (TIMESTAMP '1970-01-01 00:00:00', TIMESTAMP_NTZ '1970-01-01 00:00:00'),
+ (TIMESTAMP '2000-12-31 23:59:59', TIMESTAMP_NTZ '2000-12-31 23:59:59'),
+ (TIMESTAMP '1969-12-31 23:59:59.999999', TIMESTAMP_NTZ '1969-12-31 23:59:59.999999'),
+ (NULL, NULL)
+
+query expect_native(hash, xxhash64)
+SELECT c, hash(c), xxhash64(c), ntz, hash(ntz), xxhash64(ntz) FROM test_hash_timestamp
diff --git a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
index 6e1d77b361..f79c641556 100644
--- a/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/CometExpressionSuite.scala
@@ -2060,20 +2060,6 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
}
}
- test("md5") {
- Seq(false, true).foreach { dictionary =>
- withSQLConf("parquet.enable.dictionary" -> dictionary.toString) {
- val table = "test"
- withTable(table) {
- sql(s"create table $table(col String) using parquet")
- sql(
- s"insert into $table values ('test1'), ('test1'), ('test2'), ('test2'), (NULL), ('')")
- checkSparkAnswerAndOperator(s"select md5(col) FROM $table")
- }
- }
- }
- }
-
test("unhex") {
val table = "unhex_table"
Seq(false, true).foreach { dictionaryEnabled =>
@@ -2617,48 +2603,6 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
}
}
- test("hash functions") {
- Seq(true, false).foreach { dictionary =>
- withSQLConf("parquet.enable.dictionary" -> dictionary.toString) {
- val table = "test"
- withTable(table) {
- sql(s"create table $table(col string, a int, b float) using parquet")
- sql(s"""
- |insert into $table values
- |('Spark SQL ', 10, 1.2), (NULL, NULL, NULL), ('', 0, 0.0), ('苹果手机', NULL, 3.999999)
- |, ('Spark SQL ', 10, 1.2), (NULL, NULL, NULL), ('', 0, 0.0), ('苹果手机', NULL, 3.999999)
- |""".stripMargin)
- checkSparkAnswerAndOperator("""
- |select
- |md5(col), md5(cast(a as string)), md5(cast(b as string)),
- |hash(col), hash(col, 1), hash(col, 0), hash(col, a, b), hash(b, a, col),
- |xxhash64(col), xxhash64(col, 1), xxhash64(col, 0), xxhash64(col, a, b), xxhash64(b, a, col),
- |crc32(col), crc32(cast(a as string)), crc32(cast(b as string)),
- |sha2(col, 0), sha2(col, 256), sha2(col, 224), sha2(col, 384), sha2(col, 512), sha2(col, 128), sha2(col, -1),
- |sha1(col), sha1(cast(a as string)), sha1(cast(b as string))
- |from test
- |""".stripMargin)
- }
- }
- }
- }
-
- test("sha2 with all-literal arguments and ConstantFolding disabled") {
- // https://github.com/apache/datafusion-comet/issues/3340
- // When ConstantFolding is disabled, an all-literal sha2() call reaches the native
- // engine as scalar arguments. Verify it computes the correct result rather than crashing.
- withSQLConf(
- "spark.sql.optimizer.excludedRules" ->
- "org.apache.spark.sql.catalyst.optimizer.ConstantFolding") {
- checkSparkAnswerAndOperator("""
- |select
- |sha2('test', 0), sha2('test', 256), sha2('test', 224),
- |sha2('test', 384), sha2('test', 512), sha2('test', 128), sha2('test', -1),
- |sha2(cast(null as string), 256)
- |""".stripMargin)
- }
- }
-
test("remainder function") {
def withAnsiMode(enabled: Boolean)(f: => Unit): Unit = {
withSQLConf(
@@ -2738,44 +2682,6 @@ class CometExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
}
}
- test("hash functions with random input") {
- val dataGen = DataGenerator.DEFAULT
- // sufficient number of rows to create dictionary encoded ArrowArray.
- val randomNumRows = 1000
-
- val whitespaceChars = " \t\r\n"
- val timestampPattern = "0123456789/:T" + whitespaceChars
- Seq(true, false).foreach { dictionary =>
- withSQLConf("parquet.enable.dictionary" -> dictionary.toString) {
- val table = "test"
- withTable(table) {
- sql(s"create table $table(col string, a int, b float) using parquet")
- val tableSchema = spark.table(table).schema
- val rows = dataGen.generateRows(
- randomNumRows,
- tableSchema,
- Some(() => dataGen.generateString(timestampPattern, 6)))
- val data = spark.createDataFrame(spark.sparkContext.parallelize(rows), tableSchema)
- data.write
- .mode("append")
- .insertInto(table)
- // with random generated data
- // disable cast(b as string) for now, as the cast from float to string may produce incompatible result
- checkSparkAnswerAndOperator("""
- |select
- |md5(col), md5(cast(a as string)), --md5(cast(b as string)),
- |hash(col), hash(col, 1), hash(col, 0), hash(col, a, b), hash(b, a, col),
- |xxhash64(col), xxhash64(col, 1), xxhash64(col, 0), xxhash64(col, a, b), xxhash64(b, a, col),
- |crc32(col), crc32(cast(a as string)),
- |sha2(col, 0), sha2(col, 256), sha2(col, 224), sha2(col, 384), sha2(col, 512), sha2(col, 128), sha2(col, -1),
- |sha1(col), sha1(cast(a as string))
- |from test
- |""".stripMargin)
- }
- }
- }
- }
-
test("hash function with decimal input") {
val testPrecisionScales: Seq[(Int, Int)] = Seq(
(1, 0),
diff --git a/spark/src/test/scala/org/apache/comet/CometHashExpressionSuite.scala b/spark/src/test/scala/org/apache/comet/CometHashExpressionSuite.scala
index c20e5899b3..dc9ae920ef 100644
--- a/spark/src/test/scala/org/apache/comet/CometHashExpressionSuite.scala
+++ b/spark/src/test/scala/org/apache/comet/CometHashExpressionSuite.scala
@@ -34,100 +34,6 @@ import org.apache.comet.testing.{DataGenOptions, FuzzDataGenerator, ParquetGener
*/
class CometHashExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelper {
- test("hash - boolean") {
- withTable("t") {
- sql("CREATE TABLE t(c BOOLEAN) USING parquet")
- sql("INSERT INTO t VALUES (true), (false), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - byte/tinyint") {
- withTable("t") {
- sql("CREATE TABLE t(c TINYINT) USING parquet")
- sql("INSERT INTO t VALUES (1), (0), (-1), (127), (-128), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - short/smallint") {
- withTable("t") {
- sql("CREATE TABLE t(c SMALLINT) USING parquet")
- sql("INSERT INTO t VALUES (1), (0), (-1), (32767), (-32768), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - int") {
- withTable("t") {
- sql("CREATE TABLE t(c INT) USING parquet")
- sql("INSERT INTO t VALUES (1), (0), (-1), (2147483647), (-2147483648), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - long/bigint") {
- withTable("t") {
- sql("CREATE TABLE t(c BIGINT) USING parquet")
- sql(
- "INSERT INTO t VALUES (1), (0), (-1), (9223372036854775807), (-9223372036854775808), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - float") {
- withTable("t") {
- sql("CREATE TABLE t(c FLOAT) USING parquet")
- sql("INSERT INTO t VALUES (1.0), (0.0), (-0.0), (-1.0), (3.14159), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - double") {
- withTable("t") {
- sql("CREATE TABLE t(c DOUBLE) USING parquet")
- sql("INSERT INTO t VALUES (1.0), (0.0), (-0.0), (-1.0), (3.14159265358979), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - string") {
- withTable("t") {
- sql("CREATE TABLE t(c STRING) USING parquet")
- sql("INSERT INTO t VALUES ('hello'), (''), ('Spark SQL'), ('苹果手机'), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - binary") {
- withTable("t") {
- sql("CREATE TABLE t(c BINARY) USING parquet")
- sql("INSERT INTO t VALUES (X''), (X'00'), (X'0102030405'), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - date") {
- withTable("t") {
- sql("CREATE TABLE t(c DATE) USING parquet")
- sql(
- "INSERT INTO t VALUES (DATE '2023-01-01'), (DATE '1970-01-01'), (DATE '2000-12-31'), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
- test("hash - timestamp") {
- withTable("t") {
- sql("CREATE TABLE t(c TIMESTAMP) USING parquet")
- sql("""INSERT INTO t VALUES
- (TIMESTAMP '2023-01-01 12:00:00'),
- (TIMESTAMP '1970-01-01 00:00:00'),
- (TIMESTAMP '2000-12-31 23:59:59'),
- (null)""")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
-
test("hash - decimal (precision <= 18)") {
Seq((10, 2), (18, 0), (18, 10)).foreach { case (precision, scale) =>
withTable("t") {
@@ -312,19 +218,6 @@ class CometHashExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelpe
}
}
- test("hash - multiple primitive columns") {
- withTable("t") {
- sql("CREATE TABLE t(a INT, b STRING, c DOUBLE) USING parquet")
- sql("""INSERT INTO t VALUES
- (1, 'hello', 3.14),
- (2, '', 0.0),
- (null, null, null),
- (-1, 'test', -1.5)""")
- checkSparkAnswerAndOperator(
- "SELECT hash(a, b, c), xxhash64(a, b, c), hash(c, b, a), xxhash64(c, b, a), hash(a), xxhash64(a), hash(b), xxhash64(b), hash(c), xxhash64(c) FROM t")
- }
- }
-
test("hash - multiple columns with arrays") {
withTable("t") {
sql("CREATE TABLE t(a INT, b ARRAY<INT>, c STRING) USING parquet")
@@ -369,16 +262,6 @@ class CometHashExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelpe
}
}
- test("hash - with custom seed") {
- withTable("t") {
- sql("CREATE TABLE t(c INT) USING parquet")
- sql("INSERT INTO t VALUES (1), (2), (3), (null)")
- // Extra integer arguments are hashed as additional children, not as the Spark seed.
- checkSparkAnswerAndOperator(
- "SELECT hash(c), xxhash64(c), hash(c, 0), xxhash64(c, 0), hash(c, 42), xxhash64(c, 42), hash(c, -1), xxhash64(c, -1) FROM t ORDER BY c")
- }
- }
-
test("hash - large array") {
withTable("t") {
sql("CREATE TABLE t(c ARRAY<INT>) USING parquet")
@@ -406,19 +289,6 @@ class CometHashExpressionSuite extends CometTestBase with AdaptiveSparkPlanHelpe
}
}
- test("hash - with dictionary encoding") {
- Seq(true, false).foreach { dictionary =>
- withSQLConf("parquet.enable.dictionary" -> dictionary.toString) {
- withTable("t") {
- sql("CREATE TABLE t(c STRING) USING parquet")
- // Repeated values to trigger dictionary encoding
- sql("INSERT INTO t VALUES ('a'), ('b'), ('a'), ('b'), ('a'), ('c'), (null)")
- checkSparkAnswerAndOperator("SELECT c, hash(c), xxhash64(c) FROM t ORDER BY c")
- }
- }
- }
- }
-
test("hash - array with dictionary encoding") {
Seq(true, false).foreach { dictionary =>
withSQLConf("parquet.enable.dictionary" -> dictionary.toString) {
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@datafusion.apache.org
For additional commands, e-mail: commits-help@datafusion.apache.org