This is an automated email from the ASF dual-hosted git repository.
zclll pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new 226576b1de6 [Feature](func) Support function mmh64_v2 (#57180)
226576b1de6 is described below
commit 226576b1de64dea566fca8a8c12f2d74cfb008dc
Author: linrrarity <[email protected]>
AuthorDate: Mon Oct 27 10:52:40 2025 +0800
[Feature](func) Support function mmh64_v2 (#57180)
1. alias `xxhash3_64` for `xxhash_64`
2. Support function `murmur_hash3_64_v2`
Before:
```text
mysql> SELECT MURMUR_HASH3_64('1000209601_1756808272');
+------------------------------------------+
| MURMUR_HASH3_64('1000209601_1756808272') |
+------------------------------------------+
| 1680830166030441144 |
+------------------------------------------+
```
This result differs from the return value of directly calling
mmh3.hash64 in other languages, because external APIs all use mmh3_128
for calculation and then truncate the first 64 bits. The 64-bit version
inside Doris compared to the 128-bit version lacks an h2 register (the
64-bit version only has h1), which will affect the final mixing
calculation of h1 and h2 in the algorithm, leading to issues in the
result.
After support:
```text
mysql> SELECT MURMUR_HASH3_64_V2('1000209601_1756808272');
+---------------------------------------------+
| MURMUR_HASH3_64_V2('1000209601_1756808272') |
+---------------------------------------------+
| 4038800892574899471 |
+---------------------------------------------+
```
The result now is completely the same as the API call.
---
be/src/util/hash_util.hpp | 11 ++++
be/src/util/murmur_hash3.cpp | 34 ++++++++--
be/src/util/murmur_hash3.h | 4 ++
be/src/vec/functions/function_hash.cpp | 41 ++++++++++--
be/src/vec/functions/function_hash.h | 10 ++-
be/test/vec/function/function_hash_test.cpp | 63 ++++++++++++++++++
.../doris/catalog/BuiltinScalarFunctions.java | 4 +-
.../functions/scalar/MurmurHash364V2.java | 75 ++++++++++++++++++++++
.../expressions/visitor/ScalarFunctionVisitor.java | 5 ++
.../hash_functions/test_hash_function.out | 12 ++++
.../hash_functions/test_hash_function.groovy | 19 ++++++
11 files changed, 265 insertions(+), 13 deletions(-)
diff --git a/be/src/util/hash_util.hpp b/be/src/util/hash_util.hpp
index c5dce6c7292..8f799a18a46 100644
--- a/be/src/util/hash_util.hpp
+++ b/be/src/util/hash_util.hpp
@@ -132,6 +132,17 @@ public:
return out;
}
+ template <bool is_mmh64_v2>
+ static uint64_t murmur_hash3_64(const void* key, int64_t len, uint64_t
seed) {
+ uint64_t out = 0;
+ if constexpr (is_mmh64_v2) {
+ murmur_hash3_x64_64_shared(key, len, seed, &out);
+ } else {
+ murmur_hash3_x64_64(key, len, seed, &out);
+ }
+ return out;
+ }
+
static const int MURMUR_R = 47;
// Murmur2 hash implementation returning 64-bit hashes.
diff --git a/be/src/util/murmur_hash3.cpp b/be/src/util/murmur_hash3.cpp
index 23069862967..1dcff80404d 100644
--- a/be/src/util/murmur_hash3.cpp
+++ b/be/src/util/murmur_hash3.cpp
@@ -315,13 +315,11 @@ void murmur_hash3_x86_128(const void* key, const int len,
uint32_t seed, void* o
//-----------------------------------------------------------------------------
-void murmur_hash3_x64_128(const void* key, const int len, const uint32_t seed,
void* out) {
+// Helper function that implements the core MurmurHash3 128-bit hashing
algorithm
+void murmur_hash3_x64_process(const void* key, const int len, uint64_t& h1,
uint64_t& h2) {
const uint8_t* data = (const uint8_t*)key;
const int nblocks = len / 16;
- uint64_t h1 = seed;
- uint64_t h2 = seed;
-
const uint64_t c1 = BIG_CONSTANT(0x87c37b91114253d5);
const uint64_t c2 = BIG_CONSTANT(0x4cf5ad432745937f);
@@ -430,11 +428,39 @@ void murmur_hash3_x64_128(const void* key, const int len,
const uint32_t seed, v
h1 += h2;
h2 += h1;
+}
+//-----------------------------------------------------------------------------
+
+// The origin function `murmur_hash3_x64_128` is copied from:
https://github.com/aappleby/smhasher/blob/master/src/MurmurHash3.cpp
+// And Doris modified it into function `murmur_hash3_x64_process`
+// For this reason, this function is still retained even though it has no
calls.
+void murmur_hash3_x64_128(const void* key, const int len, const uint32_t seed,
void* out) {
+ uint64_t h1 = seed;
+ uint64_t h2 = seed;
+ murmur_hash3_x64_process(key, len, h1, h2);
((uint64_t*)out)[0] = h1;
((uint64_t*)out)[1] = h2;
}
+//-----------------------------------------------------------------------------
+
+// MurmurHash3 x64 64-bit variant using shared 128-bit processing function
+// This implementation reuses the murmur_hash3_x64_process function and only
outputs the first hash value
+// Used for function mmh3_64_v2
+void murmur_hash3_x64_64_shared(const void* key, const int64_t len, const
uint64_t seed,
+ void* out) {
+ uint64_t h1 = seed;
+ uint64_t h2 = seed;
+ murmur_hash3_x64_process(key, static_cast<int>(len), h1, h2);
+ ((uint64_t*)out)[0] = h1;
+}
+
+//-----------------------------------------------------------------------------
+
+// MurmurHash3 x64 64-bit variant with optimized standalone implementation
+// This implementation is specifically optimized for 64-bit output
+// Used for function mmh3_64
void murmur_hash3_x64_64(const void* key, const int64_t len, const uint64_t
seed, void* out) {
const uint8_t* data = (const uint8_t*)key;
const int nblocks = (int)len / 8;
diff --git a/be/src/util/murmur_hash3.h b/be/src/util/murmur_hash3.h
index 93e7ef13018..072cf9b12bd 100644
--- a/be/src/util/murmur_hash3.h
+++ b/be/src/util/murmur_hash3.h
@@ -11,8 +11,12 @@ void murmur_hash3_x86_32(const void* key, int64_t len,
uint32_t seed, void* out)
void murmur_hash3_x86_128(const void* key, int len, uint32_t seed, void* out);
+void murmur_hash3_x64_process(const void* key, const int len, uint64_t& h1,
uint64_t& h2);
+
void murmur_hash3_x64_128(const void* key, int len, uint32_t seed, void* out);
+void murmur_hash3_x64_64_shared(const void* key, const int64_t len, const
uint64_t seed, void* out);
+
void murmur_hash3_x64_64(const void* key, int64_t len, uint64_t seed, void*
out);
} // namespace doris
\ No newline at end of file
diff --git a/be/src/vec/functions/function_hash.cpp
b/be/src/vec/functions/function_hash.cpp
index 6bc38ddfcaf..332a3a2344f 100644
--- a/be/src/vec/functions/function_hash.cpp
+++ b/be/src/vec/functions/function_hash.cpp
@@ -41,9 +41,18 @@ namespace doris::vectorized {
#include "common/compile_check_begin.h"
constexpr uint64_t emtpy_value = 0xe28dbde7fe22e41c;
-template <PrimitiveType ReturnType>
+template <PrimitiveType ReturnType, bool is_mmh64_v2 = false>
struct MurmurHash3Impl {
- static constexpr auto name = ReturnType == TYPE_INT ? "murmur_hash3_32" :
"murmur_hash3_64";
+ static constexpr auto get_name() {
+ if constexpr (ReturnType == TYPE_INT) {
+ return "murmur_hash3_32";
+ } else if constexpr (is_mmh64_v2) {
+ return "murmur_hash3_64_v2";
+ } else {
+ return "murmur_hash3_64";
+ }
+ }
+ static constexpr auto name = get_name();
static Status empty_apply(IColumn& icolumn, size_t input_rows_count) {
ColumnVector<ReturnType>& vec_to =
assert_cast<ColumnVector<ReturnType>&>(icolumn);
@@ -87,9 +96,9 @@ struct MurmurHash3Impl {
reinterpret_cast<const
char*>(&data[current_offset]),
offsets[i] - current_offset, col_to_data[i]);
} else {
- murmur_hash3_x64_64(reinterpret_cast<const
char*>(&data[current_offset]),
- offsets[i] - current_offset,
col_to_data[i],
- col_to_data.data() + i);
+ col_to_data[i] = HashUtil::murmur_hash3_64<is_mmh64_v2>(
+ reinterpret_cast<const
char*>(&data[current_offset]),
+ offsets[i] - current_offset, col_to_data[i]);
}
current_offset = offsets[i];
}
@@ -101,8 +110,8 @@ struct MurmurHash3Impl {
col_to_data[i] =
HashUtil::murmur_hash3_32(value.data(),
value.size(), col_to_data[i]);
} else {
- murmur_hash3_x64_64(value.data(), value.size(),
col_to_data[i],
- col_to_data.data() + i);
+ col_to_data[i] = HashUtil::murmur_hash3_64<is_mmh64_v2>(
+ value.data(), value.size(), col_to_data[i]);
}
}
} else {
@@ -118,6 +127,22 @@ using FunctionMurmurHash3_32 =
FunctionVariadicArgumentsBase<DataTypeInt32,
MurmurHash3Impl<TYPE_INT>>;
using FunctionMurmurHash3_64 =
FunctionVariadicArgumentsBase<DataTypeInt64,
MurmurHash3Impl<TYPE_BIGINT>>;
+using FunctionMurmurHash3_64_V2 =
+ FunctionVariadicArgumentsBase<DataTypeInt64,
MurmurHash3Impl<TYPE_BIGINT, true>>;
+
+#ifdef BE_TEST
+const char* murmur_hash3_get_name_type_int_for_test() {
+ return MurmurHash3Impl<TYPE_INT>::get_name();
+}
+
+const char* murmur_hash3_get_name_type_bigint_for_test() {
+ return MurmurHash3Impl<TYPE_BIGINT>::get_name();
+}
+
+const char* murmur_hash3_get_name_type_bigint_v2_for_test() {
+ return MurmurHash3Impl<TYPE_BIGINT, true>::get_name();
+}
+#endif
template <PrimitiveType ReturnType>
struct XxHashImpl {
@@ -204,7 +229,9 @@ using FunctionXxHash_64 =
FunctionVariadicArgumentsBase<DataTypeInt64, XxHashImp
void register_function_hash(SimpleFunctionFactory& factory) {
factory.register_function<FunctionMurmurHash3_32>();
factory.register_function<FunctionMurmurHash3_64>();
+ factory.register_function<FunctionMurmurHash3_64_V2>();
factory.register_function<FunctionXxHash_32>();
factory.register_function<FunctionXxHash_64>();
+ factory.register_alias("xxhash_64", "xxhash3_64");
}
} // namespace doris::vectorized
\ No newline at end of file
diff --git a/be/src/vec/functions/function_hash.h
b/be/src/vec/functions/function_hash.h
index 0516dd85c4c..7da4a75dc3a 100644
--- a/be/src/vec/functions/function_hash.h
+++ b/be/src/vec/functions/function_hash.h
@@ -22,4 +22,12 @@
#include "vec/core/types.h"
-namespace doris::vectorized {} // namespace doris::vectorized
+namespace doris::vectorized {
+
+#ifdef BE_TEST
+const char* murmur_hash3_get_name_type_int_for_test();
+const char* murmur_hash3_get_name_type_bigint_for_test();
+const char* murmur_hash3_get_name_type_bigint_v2_for_test();
+#endif
+
+} // namespace doris::vectorized
diff --git a/be/test/vec/function/function_hash_test.cpp
b/be/test/vec/function/function_hash_test.cpp
index 3333fa72e9b..3e866cd1fd4 100644
--- a/be/test/vec/function/function_hash_test.cpp
+++ b/be/test/vec/function/function_hash_test.cpp
@@ -15,6 +15,8 @@
// specific language governing permissions and limitations
// under the License.
+#include "vec/functions/function_hash.h"
+
#include <stdint.h>
#include <string>
@@ -24,6 +26,7 @@
#include "function_test_util.h"
#include "gtest/gtest_pred_impl.h"
#include "testutil/any_type.h"
+#include "util/murmur_hash3.h"
#include "vec/core/types.h"
#include "vec/data_types/data_type_nullable.h"
#include "vec/data_types/data_type_number.h"
@@ -97,6 +100,26 @@ TEST(HashFunctionTest, murmur_hash_3_64_test) {
};
}
+TEST(HashFunctionTest, murmur_hash_3_64_v2_test) {
+ std::string func_name = "murmur_hash3_64_v2";
+
+ {
+ InputTypeSet input_types = {PrimitiveType::TYPE_VARCHAR};
+
+ DataSet data_set = {{{std::string("1000209601_1756808272")},
(int64_t)4038800892574899471},
+ {{std::string("hello world")},
(int64_t)5998619086395760910},
+ {{std::string("apache doris")},
(int64_t)3669213779466221743}};
+
+ static_cast<void>(check_function<DataTypeInt64, true>(func_name,
input_types, data_set));
+ };
+}
+
+TEST(HashFunctionTest, murmur_hash_get_name_test) {
+ EXPECT_STREQ(murmur_hash3_get_name_type_int_for_test(), "murmur_hash3_32");
+ EXPECT_STREQ(murmur_hash3_get_name_type_bigint_for_test(),
"murmur_hash3_64");
+ EXPECT_STREQ(murmur_hash3_get_name_type_bigint_v2_for_test(),
"murmur_hash3_64_v2");
+}
+
TEST(HashFunctionTest, xxhash_32_test) {
std::string func_name = "xxhash_32";
@@ -221,4 +244,44 @@ TEST(HashFunctionTest, xxhash_64_test) {
};
}
+TEST(HashFunctionTest, murmur_hash3_helper_functions_test) {
+ {
+ std::string input = "hello world";
+ uint64_t h1 = 0;
+ uint64_t h2 = 0;
+ murmur_hash3_x64_process(input.data(), input.size(), h1, h2);
+ EXPECT_EQ(h1, 5998619086395760910ULL);
+ EXPECT_EQ(h2, 12364428806279881649ULL);
+ }
+
+ {
+ std::string input = "hello world";
+ uint64_t out[2] = {0, 0};
+ murmur_hash3_x64_128(input.data(), input.size(), 0, out);
+ EXPECT_TRUE(out[0] == 5998619086395760910ULL && out[1] ==
12364428806279881649ULL);
+ }
+
+ {
+ std::string input = "hello world";
+ uint64_t out = 0;
+ murmur_hash3_x64_64_shared(input.data(), input.size(), 0, &out);
+ EXPECT_EQ(out, 5998619086395760910ULL);
+ }
+
+ {
+ std::string input = "hello";
+ uint64_t out = 0;
+ murmur_hash3_x64_64(input.data(), input.size(), 0, &out);
+ EXPECT_EQ(out, static_cast<uint64_t>(-3215607508166160593LL));
+ }
+
+ {
+ std::string input = "";
+ uint64_t h1 = 0, h2 = 0;
+ murmur_hash3_x64_process(input.data(), input.size(), h1, h2);
+ EXPECT_EQ(h1, 0ULL);
+ EXPECT_EQ(h2, 0ULL);
+ }
+}
+
} // namespace doris::vectorized
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinScalarFunctions.java
b/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinScalarFunctions.java
index 54d40c546e5..1d290dc283e 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinScalarFunctions.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/catalog/BuiltinScalarFunctions.java
@@ -353,6 +353,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.scalar.MultiMatchAny
import
org.apache.doris.nereids.trees.expressions.functions.scalar.MultiSearchAllPositions;
import
org.apache.doris.nereids.trees.expressions.functions.scalar.MurmurHash332;
import
org.apache.doris.nereids.trees.expressions.functions.scalar.MurmurHash364;
+import
org.apache.doris.nereids.trees.expressions.functions.scalar.MurmurHash364V2;
import org.apache.doris.nereids.trees.expressions.functions.scalar.Negative;
import org.apache.doris.nereids.trees.expressions.functions.scalar.NextDay;
import org.apache.doris.nereids.trees.expressions.functions.scalar.NgramSearch;
@@ -882,6 +883,7 @@ public class BuiltinScalarFunctions implements
FunctionHelper {
scalar(MultiSearchAllPositions.class,
"multi_search_all_positions"),
scalar(MurmurHash332.class, "murmur_hash3_32"),
scalar(MurmurHash364.class, "murmur_hash3_64"),
+ scalar(MurmurHash364V2.class, "murmur_hash3_64_v2"),
scalar(Negative.class, "negative"),
scalar(NextDay.class, "next_day"),
scalar(NonNullable.class, "non_nullable"),
@@ -1062,7 +1064,7 @@ public class BuiltinScalarFunctions implements
FunctionHelper {
scalar(WeeksSub.class, "weeks_sub"),
scalar(WidthBucket.class, "width_bucket"),
scalar(XxHash32.class, "xxhash_32"),
- scalar(XxHash64.class, "xxhash_64"),
+ scalar(XxHash64.class, "xxhash_64", "xxhash3_64"),
scalar(Xor.class, "xor"),
scalar(XpathString.class, "xpath_string"),
scalar(Year.class, "year"),
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MurmurHash364V2.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MurmurHash364V2.java
new file mode 100644
index 00000000000..61b30bf8f30
--- /dev/null
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/functions/scalar/MurmurHash364V2.java
@@ -0,0 +1,75 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+package org.apache.doris.nereids.trees.expressions.functions.scalar;
+
+import org.apache.doris.catalog.FunctionSignature;
+import org.apache.doris.nereids.trees.expressions.Expression;
+import
org.apache.doris.nereids.trees.expressions.functions.ExplicitlyCastableSignature;
+import org.apache.doris.nereids.trees.expressions.functions.PropagateNullable;
+import org.apache.doris.nereids.trees.expressions.visitor.ExpressionVisitor;
+import org.apache.doris.nereids.types.BigIntType;
+import org.apache.doris.nereids.types.StringType;
+import org.apache.doris.nereids.types.VarcharType;
+import org.apache.doris.nereids.util.ExpressionUtils;
+
+import com.google.common.base.Preconditions;
+import com.google.common.collect.ImmutableList;
+
+import java.util.List;
+
+/**
+ * ScalarFunction 'murmur_hash3_64_v2'. This class is generated by
GenerateFunction.
+ */
+public class MurmurHash364V2 extends ScalarFunction
+ implements ExplicitlyCastableSignature, PropagateNullable {
+ public static final List<FunctionSignature> SIGNATURES = ImmutableList.of(
+
FunctionSignature.ret(BigIntType.INSTANCE).varArgs(VarcharType.SYSTEM_DEFAULT),
+
FunctionSignature.ret(BigIntType.INSTANCE).varArgs(StringType.INSTANCE)
+ );
+
+ /**
+ * constructor with 1 or more arguments.
+ */
+ public MurmurHash364V2(Expression arg, Expression... varArgs) {
+ super("murmur_hash3_64_v2", ExpressionUtils.mergeArguments(arg,
varArgs));
+ }
+
+ /** constructor for withChildren and reuse signature */
+ private MurmurHash364V2(ScalarFunctionParams functionParams) {
+ super(functionParams);
+ }
+
+ /**
+ * withChildren.
+ */
+ @Override
+ public MurmurHash364V2 withChildren(List<Expression> children) {
+ Preconditions.checkArgument(!children.isEmpty());
+ return new MurmurHash364V2(getFunctionParams(children));
+ }
+
+ @Override
+ public List<FunctionSignature> getSignatures() {
+ return SIGNATURES;
+ }
+
+ @Override
+ public <R, C> R accept(ExpressionVisitor<R, C> visitor, C context) {
+ return visitor.visitMurmurHash364V2(this, context);
+ }
+}
diff --git
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ScalarFunctionVisitor.java
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ScalarFunctionVisitor.java
index 7f823c53fad..8e7943fd71a 100644
---
a/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ScalarFunctionVisitor.java
+++
b/fe/fe-core/src/main/java/org/apache/doris/nereids/trees/expressions/visitor/ScalarFunctionVisitor.java
@@ -356,6 +356,7 @@ import
org.apache.doris.nereids.trees.expressions.functions.scalar.MultiMatchAny
import
org.apache.doris.nereids.trees.expressions.functions.scalar.MultiSearchAllPositions;
import
org.apache.doris.nereids.trees.expressions.functions.scalar.MurmurHash332;
import
org.apache.doris.nereids.trees.expressions.functions.scalar.MurmurHash364;
+import
org.apache.doris.nereids.trees.expressions.functions.scalar.MurmurHash364V2;
import org.apache.doris.nereids.trees.expressions.functions.scalar.Negative;
import org.apache.doris.nereids.trees.expressions.functions.scalar.NextDay;
import org.apache.doris.nereids.trees.expressions.functions.scalar.NgramSearch;
@@ -1781,6 +1782,10 @@ public interface ScalarFunctionVisitor<R, C> {
return visitScalarFunction(murmurHash364, context);
}
+ default R visitMurmurHash364V2(MurmurHash364V2 murmurHash364V2, C context)
{
+ return visitScalarFunction(murmurHash364V2, context);
+ }
+
default R visitXxHash32(XxHash32 xxHash32, C context) {
return visitScalarFunction(xxHash32, context);
}
diff --git
a/regression-test/data/query_p0/sql_functions/hash_functions/test_hash_function.out
b/regression-test/data/query_p0/sql_functions/hash_functions/test_hash_function.out
index 984075ddeff..e4d755e029e 100644
---
a/regression-test/data/query_p0/sql_functions/hash_functions/test_hash_function.out
+++
b/regression-test/data/query_p0/sql_functions/hash_functions/test_hash_function.out
@@ -17,6 +17,18 @@
-- !sql --
3583109472027628045
+-- !mmh3_64_v2_1 --
+\N
+
+-- !mmh3_64_v2_2 --
+4038800892574899471
+
+-- !mmh3_64_v2_3 --
+5998619086395760910
+
+-- !mmh3_64_v2_4 --
+3669213779466221743
+
-- !sql --
\N
diff --git
a/regression-test/suites/query_p0/sql_functions/hash_functions/test_hash_function.groovy
b/regression-test/suites/query_p0/sql_functions/hash_functions/test_hash_function.groovy
index d547e9fb287..74acd20a998 100644
---
a/regression-test/suites/query_p0/sql_functions/hash_functions/test_hash_function.groovy
+++
b/regression-test/suites/query_p0/sql_functions/hash_functions/test_hash_function.groovy
@@ -26,6 +26,13 @@ suite("test_hash_function", "arrow_flight_sql") {
qt_sql "SELECT murmur_hash3_64(\"hello\");"
qt_sql "SELECT murmur_hash3_64(\"hello\", \"world\");"
+ // Keep the results same with `mmh3.hash64` in python or `murmur3.Sum64`
in go
+ // Please dont auto genOut for this test
+ qt_mmh3_64_v2_1 "SELECT MURMUR_HASH3_64_V2(NULL);"
+ qt_mmh3_64_v2_2 "SELECT MURMUR_HASH3_64_V2('1000209601_1756808272');"
+ qt_mmh3_64_v2_3 "SELECT MURMUR_HASH3_64_V2('hello world');"
+ qt_mmh3_64_v2_4 "SELECT MURMUR_HASH3_64_V2('apache doris');"
+
qt_sql "SELECT xxhash_32(null);"
qt_sql "SELECT xxhash_32(\"hello\");"
qt_sql "SELECT xxhash_32(\"hello\", \"world\");"
@@ -33,4 +40,16 @@ suite("test_hash_function", "arrow_flight_sql") {
qt_sql "SELECT xxhash_64(null);"
qt_sql "SELECT xxhash_64(\"hello\");"
qt_sql "SELECT xxhash_64(\"hello\", \"world\");"
+
+ def xxhash_res = sql "SELECT xxhash_64(null);"
+ def xxhash3_res = sql "SELECT xxhash3_64(null);"
+ assertEquals(xxhash_res, xxhash3_res);
+
+ xxhash_res = sql "SELECT xxhash_64(\"hello\");"
+ xxhash3_res = sql "SELECT xxhash3_64(\"hello\");"
+ assertEquals(xxhash_res, xxhash3_res);
+
+ xxhash_res = sql "SELECT xxhash_64(\"hello\", \"world\");"
+ xxhash3_res = sql "SELECT xxhash3_64(\"hello\", \"world\");"
+ assertEquals(xxhash_res, xxhash3_res);
}
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
