diff --git a/be/cmake/thirdparty.cmake b/be/cmake/thirdparty.cmake
index 207c92a2607364..9bb7b8ba748769 100644
--- a/be/cmake/thirdparty.cmake
+++ b/be/cmake/thirdparty.cmake
@@ -68,6 +68,7 @@ add_thirdparty(curl)
 add_thirdparty(lz4)
 add_thirdparty(thrift)
 add_thirdparty(thriftnb)
+add_thirdparty(crc32c)
 
 add_thirdparty(libevent_core LIBNAME "lib/libevent_core.a")
 add_thirdparty(libevent_openssl LIBNAME "lib/libevent_openssl.a")
diff --git a/be/src/cloud/delete_bitmap_file_reader.cpp b/be/src/cloud/delete_bitmap_file_reader.cpp
index e693b1cb5b5622..20b5f19f31c84f 100644
--- a/be/src/cloud/delete_bitmap_file_reader.cpp
+++ b/be/src/cloud/delete_bitmap_file_reader.cpp
@@ -21,7 +21,6 @@
 #include "common/status.h"
 #include "io/fs/file_reader.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 
 namespace doris {
 #include "common/compile_check_begin.h"
@@ -117,7 +116,7 @@ Status DeleteBitmapFileReader::read(DeleteBitmapPB& delete_bitmap) {
             offset, {checksum_len_buf, DeleteBitmapFileWriter::CHECKSUM_SIZE}, &bytes_read));
     offset += DeleteBitmapFileWriter::CHECKSUM_SIZE;
     uint32_t checksum = decode_fixed32_le(checksum_len_buf);
-    uint32_t computed_checksum = crc32c::Value(delete_bitmap_buf.data(), delete_bitmap_len);
+    uint32_t computed_checksum = crc32c::Crc32c(delete_bitmap_buf.data(), delete_bitmap_len);
     if (computed_checksum != checksum) {
         return Status::InternalError("delete bitmap checksum failed from file=" + _path +
                                      ", computed checksum=" + std::to_string(computed_checksum) +
diff --git a/be/src/cloud/delete_bitmap_file_writer.cpp b/be/src/cloud/delete_bitmap_file_writer.cpp
index 5244d4dad7c77d..e1e5df23404a14 100644
--- a/be/src/cloud/delete_bitmap_file_writer.cpp
+++ b/be/src/cloud/delete_bitmap_file_writer.cpp
@@ -17,8 +17,9 @@
 
 #include "cloud/delete_bitmap_file_writer.h"
 
+#include <crc32c/crc32c.h>
+
 #include "io/fs/file_writer.h"
-#include "util/crc32c.h"
 
 namespace doris {
 #include "common/compile_check_begin.h"
@@ -86,7 +87,7 @@ Status DeleteBitmapFileWriter::write(const DeleteBitmapPB& delete_bitmap) {
 
     // 3. write checksum
     uint8_t checksum_buf[CHECKSUM_SIZE];
-    uint32_t checksum = crc32c::Value(content.data(), delete_bitmap_len);
+    uint32_t checksum = crc32c::Crc32c(content.data(), delete_bitmap_len);
     encode_fixed32_le(checksum_buf, checksum);
     RETURN_IF_ERROR(_file_writer->append({checksum_buf, CHECKSUM_SIZE}));
     return Status::OK();
diff --git a/be/src/exec/lzo_decompressor.cpp b/be/src/exec/lzo_decompressor.cpp
index a4decce3ac156d..42bff1a08b5811 100644
--- a/be/src/exec/lzo_decompressor.cpp
+++ b/be/src/exec/lzo_decompressor.cpp
@@ -15,12 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <crc32c/crc32c.h>
+
 #include "common/cast_set.h"
 #include "common/logging.h"
 #include "exec/decompressor.h"
 #include "olap/utils.h"
 #include "orc/Exceptions.hh"
-#include "util/crc32c.h"
 
 namespace orc {
 /**
@@ -317,7 +318,7 @@ Status LzopDecompressor::parse_header_info(uint8_t* input, size_t input_len,
     uint32_t computed_checksum;
     if (_header_info.header_checksum_type == CHECK_CRC32) {
         computed_checksum = CRC32_INIT_VALUE;
-        computed_checksum = crc32c::Extend(computed_checksum, (const char*)header, cur - header);
+        computed_checksum = crc32c::Extend(computed_checksum, (const uint8_t*)header, cur - header);
     } else {
         computed_checksum = ADLER32_INIT_VALUE;
         computed_checksum = olap_adler32(computed_checksum, (const char*)header, cur - header);
@@ -366,7 +367,7 @@ Status LzopDecompressor::checksum(LzoChecksum type, const std::string& source, u
     case CHECK_NONE:
         return Status::OK();
     case CHECK_CRC32:
-        computed_checksum = crc32c::Extend(CRC32_INIT_VALUE, (const char*)ptr, len);
+        computed_checksum = crc32c::Extend(CRC32_INIT_VALUE, (const uint8_t*)ptr, len);
         break;
     case CHECK_ADLER:
         computed_checksum = olap_adler32(ADLER32_INIT_VALUE, (const char*)ptr, len);
diff --git a/be/src/exprs/block_bloom_filter.hpp b/be/src/exprs/block_bloom_filter.hpp
index 8c7e6a2d8c2b08..1e045fb48fc930 100644
--- a/be/src/exprs/block_bloom_filter.hpp
+++ b/be/src/exprs/block_bloom_filter.hpp
@@ -20,13 +20,14 @@
 
 #pragma once
 
+#include <crc32c/crc32c.h>
+
 #include "vec/common/string_ref.h"
 #ifdef __AVX2__
 #include <immintrin.h>
 #endif
 
 #include "common/status.h"
-#include "util/hash_util.hpp"
 #include "util/slice.h"
 
 namespace butil {
@@ -74,7 +75,7 @@ class BlockBloomFilter {
     // Same as above with convenience of hashing the key.
     void insert(const StringRef& key) noexcept {
         if (key.data) {
-            insert(HashUtil::crc_hash(key.data, uint32_t(key.size), _hash_seed));
+            insert(crc32c::Extend(_hash_seed, (const uint8_t*)key.data, uint32_t(key.size)));
         }
     }
 
@@ -118,7 +119,7 @@ class BlockBloomFilter {
     // Same as above with convenience of hashing the key.
     bool find(const StringRef& key) const noexcept {
         if (key.data) {
-            return find(HashUtil::crc_hash(key.data, uint32_t(key.size), _hash_seed));
+            return find(crc32c::Extend(_hash_seed, (const uint8_t*)key.data, uint32_t(key.size)));
         }
         return false;
     }
diff --git a/be/src/io/cache/cache_lru_dumper.cpp b/be/src/io/cache/cache_lru_dumper.cpp
index 64bbed44c1ce4c..1e4a3c2e0ce397 100644
--- a/be/src/io/cache/cache_lru_dumper.cpp
+++ b/be/src/io/cache/cache_lru_dumper.cpp
@@ -17,10 +17,11 @@
 
 #include "io/cache/cache_lru_dumper.h"
 
+#include <crc32c/crc32c.h>
+
 #include "io/cache/block_file_cache.h"
 #include "io/cache/lru_queue_recorder.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 #include "vec/common/endian.h"
 
 namespace doris::io {
@@ -186,7 +187,7 @@ Status CacheLRUDumper::flush_current_group(std::ofstream& out, std::string& file
     ::doris::io::cache::EntryGroupOffsetSizePb* group_info = _dump_meta.add_group_offset_size();
     group_info->set_offset(group_start);
     group_info->set_size(serialized.size());
-    uint32_t checksum = crc32c::Value(serialized.data(), serialized.size());
+    uint32_t checksum = crc32c::Crc32c(serialized.data(), serialized.size());
     group_info->set_checksum(checksum);
 
     // Reset for next group
@@ -417,7 +418,7 @@ Status CacheLRUDumper::parse_one_lru_entry(std::ifstream& in, std::string& filen
         std::string group_serialized(group_info.size(), '\0');
         in.read(&group_serialized[0], group_serialized.size());
         RETURN_IF_ERROR(check_ifstream_status(in, filename));
-        uint32_t checksum = crc32c::Value(group_serialized.data(), group_serialized.size());
+        uint32_t checksum = crc32c::Crc32c(group_serialized.data(), group_serialized.size());
         if (checksum != group_info.checksum()) {
             std::string warn_msg =
                     fmt::format("restore lru failed as checksum not match, file={}", filename);
diff --git a/be/src/io/cache/file_cache_lru_tool.cpp b/be/src/io/cache/file_cache_lru_tool.cpp
index ce843c563b5f50..42a316b774039f 100644
--- a/be/src/io/cache/file_cache_lru_tool.cpp
+++ b/be/src/io/cache/file_cache_lru_tool.cpp
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <crc32c/crc32c.h>
 #include <gflags/gflags.h>
 
 #include <fstream>
@@ -27,7 +28,6 @@
 #include "io/cache/file_cache_common.h"
 #include "io/cache/lru_queue_recorder.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 
 using namespace doris;
 
@@ -177,7 +177,7 @@ Status parse_one_lru_entry(std::ifstream& in, std::string& filename, io::UInt128
         std::string group_serialized(group_info.size(), '\0');
         in.read(&group_serialized[0], group_serialized.size());
         RETURN_IF_ERROR(check_ifstream_status(in, filename));
-        uint32_t checksum = crc32c::Value(group_serialized.data(), group_serialized.size());
+        uint32_t checksum = crc32c::Crc32c(group_serialized.data(), group_serialized.size());
         if (checksum != group_info.checksum()) {
             std::string warn_msg =
                     fmt::format("restore lru failed as checksum not match, file={}", filename);
diff --git a/be/src/io/fs/s3_file_bufferpool.cpp b/be/src/io/fs/s3_file_bufferpool.cpp
index f1f90ea7f2ef06..0a23a1bc19065f 100644
--- a/be/src/io/fs/s3_file_bufferpool.cpp
+++ b/be/src/io/fs/s3_file_bufferpool.cpp
@@ -18,6 +18,7 @@
 #include "s3_file_bufferpool.h"
 
 #include <bvar/bvar.h>
+#include <crc32c/crc32c.h>
 
 #include <chrono>
 #include <memory>
@@ -100,7 +101,7 @@ Status UploadFileBuffer::append_data(const Slice& data) {
                                       data.get_size());
     std::memcpy((void*)(_inner_data->data().get_data() + _size), data.get_data(), data.get_size());
     _size += data.get_size();
-    _crc_value = crc32c::Extend(_crc_value, data.get_data(), data.get_size());
+    _crc_value = crc32c::Extend(_crc_value, (const uint8_t*)data.get_data(), data.get_size());
     return Status::OK();
 }
 
@@ -146,7 +147,7 @@ std::string_view FileBuffer::get_string_view_data() const {
 
 void UploadFileBuffer::on_upload() {
     _stream_ptr = std::make_shared<StringViewStream>(_inner_data->data().get_data(), _size);
-    if (_crc_value != crc32c::Value(_inner_data->data().get_data(), _size)) {
+    if (_crc_value != crc32c::Crc32c(_inner_data->data().get_data(), _size)) {
         DCHECK(false);
         set_status(Status::IOError("Buffer checksum not match"));
         return;
diff --git a/be/src/io/fs/s3_file_bufferpool.h b/be/src/io/fs/s3_file_bufferpool.h
index 1b552850ae3af8..efe53dd622ab9b 100644
--- a/be/src/io/fs/s3_file_bufferpool.h
+++ b/be/src/io/fs/s3_file_bufferpool.h
@@ -17,6 +17,8 @@
 
 #pragma once
 
+#include <crc32c/crc32c.h>
+
 #include <condition_variable>
 #include <cstdint>
 #include <fstream>
@@ -27,7 +29,6 @@
 
 #include "common/status.h"
 #include "io/cache/file_block.h"
-#include "util/crc32c.h"
 #include "util/slice.h"
 #include "util/threadpool.h"
 
diff --git a/be/src/olap/base_tablet.cpp b/be/src/olap/base_tablet.cpp
index 4ad411262ed879..021708284be15b 100644
--- a/be/src/olap/base_tablet.cpp
+++ b/be/src/olap/base_tablet.cpp
@@ -18,6 +18,7 @@
 #include "olap/base_tablet.h"
 
 #include <bthread/mutex.h>
+#include <crc32c/crc32c.h>
 #include <fmt/format.h>
 #include <rapidjson/prettywriter.h>
 
@@ -48,7 +49,6 @@
 #include "olap/txn_manager.h"
 #include "service/point_query_executor.h"
 #include "util/bvar_helper.h"
-#include "util/crc32c.h"
 #include "util/debug_points.h"
 #include "util/doris_metrics.h"
 #include "util/key_util.h"
@@ -2024,7 +2024,7 @@ Status BaseTablet::calc_file_crc(uint32_t* crc_value, int64_t start_version, int
             return st;
         }
         // crc_value is calculated based on the crc_value of each rowset.
-        *crc_value = crc32c::Extend(*crc_value, reinterpret_cast<const char*>(&rs_crc_value),
+        *crc_value = crc32c::Extend(*crc_value, reinterpret_cast<const uint8_t*>(&rs_crc_value),
                                     sizeof(rs_crc_value));
         *file_count += rs_file_count;
     }
diff --git a/be/src/olap/rowset/beta_rowset.cpp b/be/src/olap/rowset/beta_rowset.cpp
index 3765ac24220314..e6b1beb7208fa3 100644
--- a/be/src/olap/rowset/beta_rowset.cpp
+++ b/be/src/olap/rowset/beta_rowset.cpp
@@ -17,6 +17,7 @@
 
 #include "olap/rowset/beta_rowset.h"
 
+#include <crc32c/crc32c.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fmt/format.h>
@@ -46,7 +47,6 @@
 #include "olap/segment_loader.h"
 #include "olap/tablet_schema.h"
 #include "olap/utils.h"
-#include "util/crc32c.h"
 #include "util/debug_points.h"
 #include "util/doris_metrics.h"
 
@@ -731,7 +731,7 @@ Status BetaRowset::calc_file_crc(uint32_t* crc_value, int64_t* file_count) {
     // 3. calculate the crc_value based on all_file_md5
     DCHECK(file_paths.size() == all_file_md5.size());
     for (auto& i : all_file_md5) {
-        *crc_value = crc32c::Extend(*crc_value, i.data(), i.size());
+        *crc_value = crc32c::Extend(*crc_value, (const uint8_t*)i.data(), i.size());
     }
 
     return Status::OK();
diff --git a/be/src/olap/rowset/segment_v2/page_io.cpp b/be/src/olap/rowset/segment_v2/page_io.cpp
index 141eb81e2984c8..dc6d887d182b62 100644
--- a/be/src/olap/rowset/segment_v2/page_io.cpp
+++ b/be/src/olap/rowset/segment_v2/page_io.cpp
@@ -17,6 +17,7 @@
 
 #include "olap/rowset/segment_v2/page_io.h"
 
+#include <crc32c/crc32c.h>
 #include <gen_cpp/segment_v2.pb.h>
 #include <stdint.h>
 
@@ -41,7 +42,6 @@
 #include "olap/rowset/segment_v2/page_handle.h"
 #include "util/block_compression.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 #include "util/faststring.h"
 #include "util/runtime_profile.h"
 
@@ -103,7 +103,10 @@ Status PageIO::write_page(io::FileWriter* writer, const std::vector<Slice>& body
 
     // checksum
     uint8_t checksum_buf[sizeof(uint32_t)];
-    uint32_t checksum = crc32c::Value(page);
+    uint32_t checksum = 0;
+    for (const auto& slice : page) {
+        checksum = crc32c::Extend(checksum, (const uint8_t*)slice.data, slice.size);
+    }
     encode_fixed32_le(checksum_buf, checksum);
     page.emplace_back(checksum_buf, sizeof(uint32_t));
 
@@ -175,7 +178,7 @@ Status PageIO::read_and_decompress_page_(const PageReadOptions& opts, PageHandle
 
     if (opts.verify_checksum) {
         uint32_t expect = decode_fixed32_le((uint8_t*)page_slice.data + page_slice.size - 4);
-        uint32_t actual = crc32c::Value(page_slice.data, page_slice.size - 4);
+        uint32_t actual = crc32c::Crc32c(page_slice.data, page_slice.size - 4);
         // here const_cast is used for testing.
         InjectionContext ctx = {&actual, const_cast<PageReadOptions*>(&opts)};
         (void)ctx;
diff --git a/be/src/olap/rowset/segment_v2/segment.cpp b/be/src/olap/rowset/segment_v2/segment.cpp
index b150dec5226c98..53c4b2d4f4eb3c 100644
--- a/be/src/olap/rowset/segment_v2/segment.cpp
+++ b/be/src/olap/rowset/segment_v2/segment.cpp
@@ -17,6 +17,7 @@
 
 #include "olap/rowset/segment_v2/segment.h"
 
+#include <crc32c/crc32c.h>
 #include <gen_cpp/Descriptors_types.h>
 #include <gen_cpp/PlanNodes_types.h>
 #include <gen_cpp/olap_file.pb.h>
@@ -66,7 +67,6 @@
 #include "runtime/runtime_predicate.h"
 #include "runtime/runtime_state.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 #include "util/slice.h" // Slice
 #include "vec/columns/column.h"
 #include "vec/common/schema_util.h"
@@ -469,7 +469,7 @@ Status Segment::_parse_footer(std::shared_ptr<SegmentFooterPB>& footer,
 
     // validate footer PB's checksum
     uint32_t expect_checksum = decode_fixed32_le(fixed_buf + 4);
-    uint32_t actual_checksum = crc32c::Value(footer_buf.data(), footer_buf.size());
+    uint32_t actual_checksum = crc32c::Crc32c(footer_buf.data(), footer_buf.size());
     if (actual_checksum != expect_checksum) {
         Status st = _write_error_file(file_size, file_size - 12 - footer_length, bytes_read,
                                       footer_buf.data(), io_ctx);
diff --git a/be/src/olap/rowset/segment_v2/segment_writer.cpp b/be/src/olap/rowset/segment_v2/segment_writer.cpp
index fee2bc94b60113..2118b949144604 100644
--- a/be/src/olap/rowset/segment_v2/segment_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/segment_writer.cpp
@@ -24,6 +24,8 @@
 #include <algorithm>
 
 // IWYU pragma: no_include <opentelemetry/common/threadlocal.h>
+#include <crc32c/crc32c.h>
+
 #include "cloud/config.h"
 #include "common/cast_set.h"
 #include "common/compiler_util.h" // IWYU pragma: keep
@@ -62,7 +64,6 @@
 #include "runtime/memory/mem_tracker.h"
 #include "service/point_query_executor.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 #include "util/faststring.h"
 #include "util/key_util.h"
 #include "util/simd/bits.h"
@@ -1160,7 +1161,7 @@ Status SegmentWriter::_write_footer() {
     // footer's size
     put_fixed32_le(&fixed_buf, cast_set<uint32_t>(footer_buf.size()));
     // footer's checksum
-    uint32_t checksum = crc32c::Value(footer_buf.data(), footer_buf.size());
+    uint32_t checksum = crc32c::Crc32c(footer_buf.data(), footer_buf.size());
     put_fixed32_le(&fixed_buf, checksum);
     // Append magic number. we don't write magic number in the header because
     // that will need an extra seek when reading
diff --git a/be/src/olap/rowset/segment_v2/vertical_segment_writer.cpp b/be/src/olap/rowset/segment_v2/vertical_segment_writer.cpp
index f9cc984a3702af..80c8f78e093b43 100644
--- a/be/src/olap/rowset/segment_v2/vertical_segment_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/vertical_segment_writer.cpp
@@ -17,6 +17,7 @@
 
 #include "olap/rowset/segment_v2/vertical_segment_writer.h"
 
+#include <crc32c/crc32c.h>
 #include <gen_cpp/olap_file.pb.h>
 #include <gen_cpp/segment_v2.pb.h>
 #include <parallel_hashmap/phmap.h>
@@ -63,7 +64,6 @@
 #include "runtime/memory/mem_tracker.h"
 #include "service/point_query_executor.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 #include "util/debug_points.h"
 #include "util/faststring.h"
 #include "util/key_util.h"
@@ -1359,7 +1359,7 @@ Status VerticalSegmentWriter::_write_footer() {
     // footer's size
     put_fixed32_le(&fixed_buf, cast_set<uint32_t>(footer_buf.size()));
     // footer's checksum
-    uint32_t checksum = crc32c::Value(footer_buf.data(), footer_buf.size());
+    uint32_t checksum = crc32c::Crc32c(footer_buf.data(), footer_buf.size());
     put_fixed32_le(&fixed_buf, checksum);
     // Append magic number. we don't write magic number in the header because
     // that will need an extra seek when reading
diff --git a/be/src/olap/wal/wal_reader.cpp b/be/src/olap/wal/wal_reader.cpp
index ded3adcd78f884..af30480851e9fe 100644
--- a/be/src/olap/wal/wal_reader.cpp
+++ b/be/src/olap/wal/wal_reader.cpp
@@ -17,6 +17,8 @@
 
 #include "olap/wal/wal_reader.h"
 
+#include <crc32c/crc32c.h>
+
 #include <string_view>
 #include <utility>
 
@@ -25,7 +27,6 @@
 #include "io/fs/file_system.h"
 #include "io/fs/path.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 #include "util/string_util.h"
 #include "wal_writer.h"
 
@@ -145,7 +146,7 @@ Status WalReader::read_header(uint32_t& version, std::string& col_ids) {
 }
 
 Status WalReader::_check_checksum(const char* binary, size_t size, uint32_t checksum) {
-    uint32_t computed_checksum = crc32c::Value(binary, size);
+    uint32_t computed_checksum = crc32c::Crc32c(binary, size);
     if (LIKELY(computed_checksum == checksum)) {
         return Status::OK();
     }
diff --git a/be/src/olap/wal/wal_writer.cpp b/be/src/olap/wal/wal_writer.cpp
index 385aef5245b64d..5a69e636d16db4 100644
--- a/be/src/olap/wal/wal_writer.cpp
+++ b/be/src/olap/wal/wal_writer.cpp
@@ -17,6 +17,7 @@
 
 #include "olap/wal/wal_writer.h"
 
+#include <crc32c/crc32c.h>
 #include <gen_cpp/AgentService_types.h>
 #include <gen_cpp/FrontendService_types.h>
 
@@ -29,7 +30,6 @@
 #include "io/fs/path.h"
 #include "olap/storage_engine.h"
 #include "olap/wal/wal_manager.h"
-#include "util/crc32c.h"
 #include "util/thrift_rpc_helper.h"
 
 namespace doris {
@@ -124,7 +124,7 @@ Status WalWriter::append_blocks(const PBlockArray& blocks) {
         offset += block_length;
 
         uint8_t checksum_buf[sizeof(uint32_t)];
-        uint32_t checksum = crc32c::Value(content.data(), block_length);
+        uint32_t checksum = crc32c::Crc32c(content.data(), block_length);
         encode_fixed32_le(checksum_buf, checksum);
         RETURN_IF_ERROR(_file_writer->append({checksum_buf, sizeof(uint32_t)}));
         offset += CHECKSUM_SIZE;
diff --git a/be/src/pipeline/dependency.h b/be/src/pipeline/dependency.h
index 569e4ea89f599c..626e174045b7df 100644
--- a/be/src/pipeline/dependency.h
+++ b/be/src/pipeline/dependency.h
@@ -708,7 +708,7 @@ struct SetSharedState : public BasicSharedState {
 
 enum class ExchangeType : uint8_t {
     NOOP = 0,
-    // Shuffle data by Crc32HashPartitioner<LocalExchangeChannelIds>.
+    // Shuffle data by Crc32CHashPartitioner
     HASH_SHUFFLE = 1,
     // Round-robin passthrough data blocks.
     PASSTHROUGH = 2,
diff --git a/be/src/pipeline/exec/exchange_sink_operator.cpp b/be/src/pipeline/exec/exchange_sink_operator.cpp
index b27bef6a0b3cdd..a0312b6d968b1e 100644
--- a/be/src/pipeline/exec/exchange_sink_operator.cpp
+++ b/be/src/pipeline/exec/exchange_sink_operator.cpp
@@ -120,13 +120,18 @@ Status ExchangeSinkLocalState::init(RuntimeState* state, LocalSinkStateInfo& inf
 
     if (_part_type == TPartitionType::HASH_PARTITIONED) {
         _partition_count = channels.size();
-        _partitioner =
-                std::make_unique<vectorized::Crc32HashPartitioner<vectorized::ShuffleChannelIds>>(
-                        channels.size());
+        if (_state->query_options().__isset.enable_new_shuffle_hash_method &&
+            _state->query_options().enable_new_shuffle_hash_method) {
+            _partitioner = std::make_unique<vectorized::Crc32CHashPartitioner>(channels.size());
+        } else {
+            _partitioner = std::make_unique<
+                    vectorized::Crc32HashPartitioner<vectorized::ShuffleChannelIds>>(
+                    channels.size());
+        }
         RETURN_IF_ERROR(_partitioner->init(p._texprs));
         RETURN_IF_ERROR(_partitioner->prepare(state, p._row_desc));
         custom_profile()->add_info_string(
-                "Partitioner", fmt::format("Crc32HashPartitioner({})", _partition_count));
+                "Partitioner", fmt::format("Crc32CHashPartitioner({})", _partition_count));
     } else if (_part_type == TPartitionType::BUCKET_SHFFULE_HASH_PARTITIONED) {
         _partition_count = channels.size();
         _partitioner =
diff --git a/be/src/pipeline/exec/operator.h b/be/src/pipeline/exec/operator.h
index baf0c48cd4859d..df51f51283b56b 100644
--- a/be/src/pipeline/exec/operator.h
+++ b/be/src/pipeline/exec/operator.h
@@ -613,7 +613,7 @@ class DataSinkOperatorXBase : public OperatorBase {
     virtual Status init(const TPlanNode& tnode, RuntimeState* state);
 
     Status init(const TDataSink& tsink) override;
-    [[nodiscard]] virtual Status init(ExchangeType type, const int num_buckets,
+    [[nodiscard]] virtual Status init(RuntimeState* state, ExchangeType type, const int num_buckets,
                                       const bool use_global_hash_shuffle,
                                       const std::map<int, int>& shuffle_idx_to_instance_idx) {
         return Status::InternalError("init() is only implemented in local exchange!");
diff --git a/be/src/pipeline/local_exchange/local_exchange_sink_operator.cpp b/be/src/pipeline/local_exchange/local_exchange_sink_operator.cpp
index 494e638be527ca..8b76900bfdb519 100644
--- a/be/src/pipeline/local_exchange/local_exchange_sink_operator.cpp
+++ b/be/src/pipeline/local_exchange/local_exchange_sink_operator.cpp
@@ -17,6 +17,8 @@
 
 #include "pipeline/local_exchange/local_exchange_sink_operator.h"
 
+#include <memory>
+
 #include "pipeline/local_exchange/local_exchanger.h"
 #include "vec/runtime/partitioner.h"
 #include "vec/sink/vdata_stream_sender.h"
@@ -35,8 +37,8 @@ std::vector<Dependency*> LocalExchangeSinkLocalState::dependencies() const {
     return deps;
 }
 
-Status LocalExchangeSinkOperatorX::init(ExchangeType type, const int num_buckets,
-                                        const bool use_global_hash_shuffle,
+Status LocalExchangeSinkOperatorX::init(RuntimeState* state, ExchangeType type,
+                                        const int num_buckets, const bool use_global_hash_shuffle,
                                         const std::map<int, int>& shuffle_idx_to_instance_idx) {
     _name = "LOCAL_EXCHANGE_SINK_OPERATOR(" + get_exchange_type_name(type) + ")";
     _type = type;
@@ -54,13 +56,20 @@ Status LocalExchangeSinkOperatorX::init(ExchangeType type, const int num_buckets
                 _shuffle_idx_to_instance_idx[i] = i;
             }
         }
-        _partitioner.reset(new vectorized::Crc32HashPartitioner<vectorized::ShuffleChannelIds>(
-                _num_partitions));
+        if (state->query_options().__isset.enable_new_shuffle_hash_method &&
+            state->query_options().enable_new_shuffle_hash_method) {
+            _partitioner = std::make_unique<vectorized::Crc32CHashPartitioner>(_num_partitions);
+        } else {
+            _partitioner = std::make_unique<
+                    vectorized::Crc32HashPartitioner<vectorized::ShuffleChannelIds>>(
+                    _num_partitions);
+        }
         RETURN_IF_ERROR(_partitioner->init(_texprs));
     } else if (_type == ExchangeType::BUCKET_HASH_SHUFFLE) {
         DCHECK_GT(num_buckets, 0);
-        _partitioner.reset(
-                new vectorized::Crc32HashPartitioner<vectorized::ShuffleChannelIds>(num_buckets));
+        _partitioner =
+                std::make_unique<vectorized::Crc32HashPartitioner<vectorized::ShuffleChannelIds>>(
+                        num_buckets);
         RETURN_IF_ERROR(_partitioner->init(_texprs));
     }
     return Status::OK();
diff --git a/be/src/pipeline/local_exchange/local_exchange_sink_operator.h b/be/src/pipeline/local_exchange/local_exchange_sink_operator.h
index 7f4b46724cca59..c4723a9f5127b7 100644
--- a/be/src/pipeline/local_exchange/local_exchange_sink_operator.h
+++ b/be/src/pipeline/local_exchange/local_exchange_sink_operator.h
@@ -68,17 +68,6 @@ class LocalExchangeSinkLocalState final : public PipelineXSinkLocalState<LocalEx
     int _channel_id = 0;
 };
 
-// A single 32-bit division on a recent x64 processor has a throughput of one instruction every six cycles with a latency of 26 cycles.
-// In contrast, a multiplication has a throughput of one instruction every cycle and a latency of 3 cycles.
-// So we prefer to this algorithm instead of modulo.
-// Reference: https://lemire.me/blog/2016/06/27/a-fast-alternative-to-the-modulo-reduction/
-struct LocalExchangeChannelIds {
-    static constexpr auto SHIFT_BITS = 32;
-    uint32_t operator()(uint32_t l, uint32_t r) {
-        return ((uint64_t)l * (uint64_t)r) >> SHIFT_BITS;
-    }
-};
-
 class LocalExchangeSinkOperatorX final : public DataSinkOperatorX<LocalExchangeSinkLocalState> {
 public:
     using Base = DataSinkOperatorX<LocalExchangeSinkLocalState>;
@@ -108,7 +97,8 @@ class LocalExchangeSinkOperatorX final : public DataSinkOperatorX<LocalExchangeS
         return Status::InternalError("{} should not init with TPlanNode", Base::_name);
     }
 
-    Status init(ExchangeType type, const int num_buckets, const bool use_global_hash_shuffle,
+    Status init(RuntimeState* state, ExchangeType type, const int num_buckets,
+                const bool use_global_hash_shuffle,
                 const std::map<int, int>& shuffle_idx_to_instance_idx) override;
 
     Status prepare(RuntimeState* state) override;
diff --git a/be/src/pipeline/pipeline_fragment_context.cpp b/be/src/pipeline/pipeline_fragment_context.cpp
index 6f909e95e5fe80..29ef3daad0b671 100644
--- a/be/src/pipeline/pipeline_fragment_context.cpp
+++ b/be/src/pipeline/pipeline_fragment_context.cpp
@@ -756,8 +756,9 @@ Status PipelineFragmentContext::_add_local_exchange_impl(
         data_distribution.distribution_type = ExchangeType::HASH_SHUFFLE;
     }
     RETURN_IF_ERROR(new_pip->set_sink(sink));
-    RETURN_IF_ERROR(new_pip->sink()->init(data_distribution.distribution_type, num_buckets,
-                                          use_global_hash_shuffle, shuffle_idx_to_instance_idx));
+    RETURN_IF_ERROR(new_pip->sink()->init(_runtime_state.get(), data_distribution.distribution_type,
+                                          num_buckets, use_global_hash_shuffle,
+                                          shuffle_idx_to_instance_idx));
 
     // 2. Create and initialize LocalExchangeSharedState.
     std::shared_ptr<LocalExchangeSharedState> shared_state =
diff --git a/be/src/tools/meta_tool.cpp b/be/src/tools/meta_tool.cpp
index d0caf0d1ddab6d..1900a9a10d3251 100644
--- a/be/src/tools/meta_tool.cpp
+++ b/be/src/tools/meta_tool.cpp
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#include <crc32c/crc32c.h>
 #include <gen_cpp/olap_file.pb.h>
 #include <gen_cpp/segment_v2.pb.h>
 #include <gflags/gflags.h>
@@ -37,7 +38,6 @@
 #include "olap/tablet_meta.h"
 #include "olap/tablet_meta_manager.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 
 using doris::DataDir;
 using doris::StorageEngine;
@@ -263,7 +263,7 @@ Status get_segment_footer(doris::io::FileReader* file_reader, SegmentFooterPB* f
 
     // validate footer PB's checksum
     uint32_t expect_checksum = doris::decode_fixed32_le(fixed_buf + 4);
-    uint32_t actual_checksum = doris::crc32c::Value(footer_buf.data(), footer_buf.size());
+    uint32_t actual_checksum = crc32c::Crc32c(footer_buf.data(), footer_buf.size());
     if (actual_checksum != expect_checksum) {
         return Status::Corruption(
                 "Bad segment file {}: footer checksum not match, actual={} vs expect={}", file_name,
diff --git a/be/src/util/crc32c.cpp b/be/src/util/crc32c.cpp
deleted file mode 100644
index 7ad31e7f22657f..00000000000000
--- a/be/src/util/crc32c.cpp
+++ /dev/null
@@ -1,274 +0,0 @@
-// 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.
-
-// the following code are modified from RocksDB:
-// https://github.com/facebook/rocksdb/blob/master/util/crc32c.cc
-
-// IWYU pragma: no_include <crc32intrin.h>
-#include <stddef.h>
-#include <stdint.h>
-
-#include "util/coding.h"
-
-namespace doris {
-namespace crc32c {
-
-static const uint32_t table0_[256] = {
-        0x00000000, 0xf26b8303, 0xe13b70f7, 0x1350f3f4, 0xc79a971f, 0x35f1141c, 0x26a1e7e8,
-        0xd4ca64eb, 0x8ad958cf, 0x78b2dbcc, 0x6be22838, 0x9989ab3b, 0x4d43cfd0, 0xbf284cd3,
-        0xac78bf27, 0x5e133c24, 0x105ec76f, 0xe235446c, 0xf165b798, 0x030e349b, 0xd7c45070,
-        0x25afd373, 0x36ff2087, 0xc494a384, 0x9a879fa0, 0x68ec1ca3, 0x7bbcef57, 0x89d76c54,
-        0x5d1d08bf, 0xaf768bbc, 0xbc267848, 0x4e4dfb4b, 0x20bd8ede, 0xd2d60ddd, 0xc186fe29,
-        0x33ed7d2a, 0xe72719c1, 0x154c9ac2, 0x061c6936, 0xf477ea35, 0xaa64d611, 0x580f5512,
-        0x4b5fa6e6, 0xb93425e5, 0x6dfe410e, 0x9f95c20d, 0x8cc531f9, 0x7eaeb2fa, 0x30e349b1,
-        0xc288cab2, 0xd1d83946, 0x23b3ba45, 0xf779deae, 0x05125dad, 0x1642ae59, 0xe4292d5a,
-        0xba3a117e, 0x4851927d, 0x5b016189, 0xa96ae28a, 0x7da08661, 0x8fcb0562, 0x9c9bf696,
-        0x6ef07595, 0x417b1dbc, 0xb3109ebf, 0xa0406d4b, 0x522bee48, 0x86e18aa3, 0x748a09a0,
-        0x67dafa54, 0x95b17957, 0xcba24573, 0x39c9c670, 0x2a993584, 0xd8f2b687, 0x0c38d26c,
-        0xfe53516f, 0xed03a29b, 0x1f682198, 0x5125dad3, 0xa34e59d0, 0xb01eaa24, 0x42752927,
-        0x96bf4dcc, 0x64d4cecf, 0x77843d3b, 0x85efbe38, 0xdbfc821c, 0x2997011f, 0x3ac7f2eb,
-        0xc8ac71e8, 0x1c661503, 0xee0d9600, 0xfd5d65f4, 0x0f36e6f7, 0x61c69362, 0x93ad1061,
-        0x80fde395, 0x72966096, 0xa65c047d, 0x5437877e, 0x4767748a, 0xb50cf789, 0xeb1fcbad,
-        0x197448ae, 0x0a24bb5a, 0xf84f3859, 0x2c855cb2, 0xdeeedfb1, 0xcdbe2c45, 0x3fd5af46,
-        0x7198540d, 0x83f3d70e, 0x90a324fa, 0x62c8a7f9, 0xb602c312, 0x44694011, 0x5739b3e5,
-        0xa55230e6, 0xfb410cc2, 0x092a8fc1, 0x1a7a7c35, 0xe811ff36, 0x3cdb9bdd, 0xceb018de,
-        0xdde0eb2a, 0x2f8b6829, 0x82f63b78, 0x709db87b, 0x63cd4b8f, 0x91a6c88c, 0x456cac67,
-        0xb7072f64, 0xa457dc90, 0x563c5f93, 0x082f63b7, 0xfa44e0b4, 0xe9141340, 0x1b7f9043,
-        0xcfb5f4a8, 0x3dde77ab, 0x2e8e845f, 0xdce5075c, 0x92a8fc17, 0x60c37f14, 0x73938ce0,
-        0x81f80fe3, 0x55326b08, 0xa759e80b, 0xb4091bff, 0x466298fc, 0x1871a4d8, 0xea1a27db,
-        0xf94ad42f, 0x0b21572c, 0xdfeb33c7, 0x2d80b0c4, 0x3ed04330, 0xccbbc033, 0xa24bb5a6,
-        0x502036a5, 0x4370c551, 0xb11b4652, 0x65d122b9, 0x97baa1ba, 0x84ea524e, 0x7681d14d,
-        0x2892ed69, 0xdaf96e6a, 0xc9a99d9e, 0x3bc21e9d, 0xef087a76, 0x1d63f975, 0x0e330a81,
-        0xfc588982, 0xb21572c9, 0x407ef1ca, 0x532e023e, 0xa145813d, 0x758fe5d6, 0x87e466d5,
-        0x94b49521, 0x66df1622, 0x38cc2a06, 0xcaa7a905, 0xd9f75af1, 0x2b9cd9f2, 0xff56bd19,
-        0x0d3d3e1a, 0x1e6dcdee, 0xec064eed, 0xc38d26c4, 0x31e6a5c7, 0x22b65633, 0xd0ddd530,
-        0x0417b1db, 0xf67c32d8, 0xe52cc12c, 0x1747422f, 0x49547e0b, 0xbb3ffd08, 0xa86f0efc,
-        0x5a048dff, 0x8ecee914, 0x7ca56a17, 0x6ff599e3, 0x9d9e1ae0, 0xd3d3e1ab, 0x21b862a8,
-        0x32e8915c, 0xc083125f, 0x144976b4, 0xe622f5b7, 0xf5720643, 0x07198540, 0x590ab964,
-        0xab613a67, 0xb831c993, 0x4a5a4a90, 0x9e902e7b, 0x6cfbad78, 0x7fab5e8c, 0x8dc0dd8f,
-        0xe330a81a, 0x115b2b19, 0x020bd8ed, 0xf0605bee, 0x24aa3f05, 0xd6c1bc06, 0xc5914ff2,
-        0x37faccf1, 0x69e9f0d5, 0x9b8273d6, 0x88d28022, 0x7ab90321, 0xae7367ca, 0x5c18e4c9,
-        0x4f48173d, 0xbd23943e, 0xf36e6f75, 0x0105ec76, 0x12551f82, 0xe03e9c81, 0x34f4f86a,
-        0xc69f7b69, 0xd5cf889d, 0x27a40b9e, 0x79b737ba, 0x8bdcb4b9, 0x988c474d, 0x6ae7c44e,
-        0xbe2da0a5, 0x4c4623a6, 0x5f16d052, 0xad7d5351};
-static const uint32_t table1_[256] = {
-        0x00000000, 0x13a29877, 0x274530ee, 0x34e7a899, 0x4e8a61dc, 0x5d28f9ab, 0x69cf5132,
-        0x7a6dc945, 0x9d14c3b8, 0x8eb65bcf, 0xba51f356, 0xa9f36b21, 0xd39ea264, 0xc03c3a13,
-        0xf4db928a, 0xe7790afd, 0x3fc5f181, 0x2c6769f6, 0x1880c16f, 0x0b225918, 0x714f905d,
-        0x62ed082a, 0x560aa0b3, 0x45a838c4, 0xa2d13239, 0xb173aa4e, 0x859402d7, 0x96369aa0,
-        0xec5b53e5, 0xfff9cb92, 0xcb1e630b, 0xd8bcfb7c, 0x7f8be302, 0x6c297b75, 0x58ced3ec,
-        0x4b6c4b9b, 0x310182de, 0x22a31aa9, 0x1644b230, 0x05e62a47, 0xe29f20ba, 0xf13db8cd,
-        0xc5da1054, 0xd6788823, 0xac154166, 0xbfb7d911, 0x8b507188, 0x98f2e9ff, 0x404e1283,
-        0x53ec8af4, 0x670b226d, 0x74a9ba1a, 0x0ec4735f, 0x1d66eb28, 0x298143b1, 0x3a23dbc6,
-        0xdd5ad13b, 0xcef8494c, 0xfa1fe1d5, 0xe9bd79a2, 0x93d0b0e7, 0x80722890, 0xb4958009,
-        0xa737187e, 0xff17c604, 0xecb55e73, 0xd852f6ea, 0xcbf06e9d, 0xb19da7d8, 0xa23f3faf,
-        0x96d89736, 0x857a0f41, 0x620305bc, 0x71a19dcb, 0x45463552, 0x56e4ad25, 0x2c896460,
-        0x3f2bfc17, 0x0bcc548e, 0x186eccf9, 0xc0d23785, 0xd370aff2, 0xe797076b, 0xf4359f1c,
-        0x8e585659, 0x9dface2e, 0xa91d66b7, 0xbabffec0, 0x5dc6f43d, 0x4e646c4a, 0x7a83c4d3,
-        0x69215ca4, 0x134c95e1, 0x00ee0d96, 0x3409a50f, 0x27ab3d78, 0x809c2506, 0x933ebd71,
-        0xa7d915e8, 0xb47b8d9f, 0xce1644da, 0xddb4dcad, 0xe9537434, 0xfaf1ec43, 0x1d88e6be,
-        0x0e2a7ec9, 0x3acdd650, 0x296f4e27, 0x53028762, 0x40a01f15, 0x7447b78c, 0x67e52ffb,
-        0xbf59d487, 0xacfb4cf0, 0x981ce469, 0x8bbe7c1e, 0xf1d3b55b, 0xe2712d2c, 0xd69685b5,
-        0xc5341dc2, 0x224d173f, 0x31ef8f48, 0x050827d1, 0x16aabfa6, 0x6cc776e3, 0x7f65ee94,
-        0x4b82460d, 0x5820de7a, 0xfbc3faf9, 0xe861628e, 0xdc86ca17, 0xcf245260, 0xb5499b25,
-        0xa6eb0352, 0x920cabcb, 0x81ae33bc, 0x66d73941, 0x7575a136, 0x419209af, 0x523091d8,
-        0x285d589d, 0x3bffc0ea, 0x0f186873, 0x1cbaf004, 0xc4060b78, 0xd7a4930f, 0xe3433b96,
-        0xf0e1a3e1, 0x8a8c6aa4, 0x992ef2d3, 0xadc95a4a, 0xbe6bc23d, 0x5912c8c0, 0x4ab050b7,
-        0x7e57f82e, 0x6df56059, 0x1798a91c, 0x043a316b, 0x30dd99f2, 0x237f0185, 0x844819fb,
-        0x97ea818c, 0xa30d2915, 0xb0afb162, 0xcac27827, 0xd960e050, 0xed8748c9, 0xfe25d0be,
-        0x195cda43, 0x0afe4234, 0x3e19eaad, 0x2dbb72da, 0x57d6bb9f, 0x447423e8, 0x70938b71,
-        0x63311306, 0xbb8de87a, 0xa82f700d, 0x9cc8d894, 0x8f6a40e3, 0xf50789a6, 0xe6a511d1,
-        0xd242b948, 0xc1e0213f, 0x26992bc2, 0x353bb3b5, 0x01dc1b2c, 0x127e835b, 0x68134a1e,
-        0x7bb1d269, 0x4f567af0, 0x5cf4e287, 0x04d43cfd, 0x1776a48a, 0x23910c13, 0x30339464,
-        0x4a5e5d21, 0x59fcc556, 0x6d1b6dcf, 0x7eb9f5b8, 0x99c0ff45, 0x8a626732, 0xbe85cfab,
-        0xad2757dc, 0xd74a9e99, 0xc4e806ee, 0xf00fae77, 0xe3ad3600, 0x3b11cd7c, 0x28b3550b,
-        0x1c54fd92, 0x0ff665e5, 0x759baca0, 0x663934d7, 0x52de9c4e, 0x417c0439, 0xa6050ec4,
-        0xb5a796b3, 0x81403e2a, 0x92e2a65d, 0xe88f6f18, 0xfb2df76f, 0xcfca5ff6, 0xdc68c781,
-        0x7b5fdfff, 0x68fd4788, 0x5c1aef11, 0x4fb87766, 0x35d5be23, 0x26772654, 0x12908ecd,
-        0x013216ba, 0xe64b1c47, 0xf5e98430, 0xc10e2ca9, 0xd2acb4de, 0xa8c17d9b, 0xbb63e5ec,
-        0x8f844d75, 0x9c26d502, 0x449a2e7e, 0x5738b609, 0x63df1e90, 0x707d86e7, 0x0a104fa2,
-        0x19b2d7d5, 0x2d557f4c, 0x3ef7e73b, 0xd98eedc6, 0xca2c75b1, 0xfecbdd28, 0xed69455f,
-        0x97048c1a, 0x84a6146d, 0xb041bcf4, 0xa3e32483};
-static const uint32_t table2_[256] = {
-        0x00000000, 0xa541927e, 0x4f6f520d, 0xea2ec073, 0x9edea41a, 0x3b9f3664, 0xd1b1f617,
-        0x74f06469, 0x38513ec5, 0x9d10acbb, 0x773e6cc8, 0xd27ffeb6, 0xa68f9adf, 0x03ce08a1,
-        0xe9e0c8d2, 0x4ca15aac, 0x70a27d8a, 0xd5e3eff4, 0x3fcd2f87, 0x9a8cbdf9, 0xee7cd990,
-        0x4b3d4bee, 0xa1138b9d, 0x045219e3, 0x48f3434f, 0xedb2d131, 0x079c1142, 0xa2dd833c,
-        0xd62de755, 0x736c752b, 0x9942b558, 0x3c032726, 0xe144fb14, 0x4405696a, 0xae2ba919,
-        0x0b6a3b67, 0x7f9a5f0e, 0xdadbcd70, 0x30f50d03, 0x95b49f7d, 0xd915c5d1, 0x7c5457af,
-        0x967a97dc, 0x333b05a2, 0x47cb61cb, 0xe28af3b5, 0x08a433c6, 0xade5a1b8, 0x91e6869e,
-        0x34a714e0, 0xde89d493, 0x7bc846ed, 0x0f382284, 0xaa79b0fa, 0x40577089, 0xe516e2f7,
-        0xa9b7b85b, 0x0cf62a25, 0xe6d8ea56, 0x43997828, 0x37691c41, 0x92288e3f, 0x78064e4c,
-        0xdd47dc32, 0xc76580d9, 0x622412a7, 0x880ad2d4, 0x2d4b40aa, 0x59bb24c3, 0xfcfab6bd,
-        0x16d476ce, 0xb395e4b0, 0xff34be1c, 0x5a752c62, 0xb05bec11, 0x151a7e6f, 0x61ea1a06,
-        0xc4ab8878, 0x2e85480b, 0x8bc4da75, 0xb7c7fd53, 0x12866f2d, 0xf8a8af5e, 0x5de93d20,
-        0x29195949, 0x8c58cb37, 0x66760b44, 0xc337993a, 0x8f96c396, 0x2ad751e8, 0xc0f9919b,
-        0x65b803e5, 0x1148678c, 0xb409f5f2, 0x5e273581, 0xfb66a7ff, 0x26217bcd, 0x8360e9b3,
-        0x694e29c0, 0xcc0fbbbe, 0xb8ffdfd7, 0x1dbe4da9, 0xf7908dda, 0x52d11fa4, 0x1e704508,
-        0xbb31d776, 0x511f1705, 0xf45e857b, 0x80aee112, 0x25ef736c, 0xcfc1b31f, 0x6a802161,
-        0x56830647, 0xf3c29439, 0x19ec544a, 0xbcadc634, 0xc85da25d, 0x6d1c3023, 0x8732f050,
-        0x2273622e, 0x6ed23882, 0xcb93aafc, 0x21bd6a8f, 0x84fcf8f1, 0xf00c9c98, 0x554d0ee6,
-        0xbf63ce95, 0x1a225ceb, 0x8b277743, 0x2e66e53d, 0xc448254e, 0x6109b730, 0x15f9d359,
-        0xb0b84127, 0x5a968154, 0xffd7132a, 0xb3764986, 0x1637dbf8, 0xfc191b8b, 0x595889f5,
-        0x2da8ed9c, 0x88e97fe2, 0x62c7bf91, 0xc7862def, 0xfb850ac9, 0x5ec498b7, 0xb4ea58c4,
-        0x11abcaba, 0x655baed3, 0xc01a3cad, 0x2a34fcde, 0x8f756ea0, 0xc3d4340c, 0x6695a672,
-        0x8cbb6601, 0x29faf47f, 0x5d0a9016, 0xf84b0268, 0x1265c21b, 0xb7245065, 0x6a638c57,
-        0xcf221e29, 0x250cde5a, 0x804d4c24, 0xf4bd284d, 0x51fcba33, 0xbbd27a40, 0x1e93e83e,
-        0x5232b292, 0xf77320ec, 0x1d5de09f, 0xb81c72e1, 0xccec1688, 0x69ad84f6, 0x83834485,
-        0x26c2d6fb, 0x1ac1f1dd, 0xbf8063a3, 0x55aea3d0, 0xf0ef31ae, 0x841f55c7, 0x215ec7b9,
-        0xcb7007ca, 0x6e3195b4, 0x2290cf18, 0x87d15d66, 0x6dff9d15, 0xc8be0f6b, 0xbc4e6b02,
-        0x190ff97c, 0xf321390f, 0x5660ab71, 0x4c42f79a, 0xe90365e4, 0x032da597, 0xa66c37e9,
-        0xd29c5380, 0x77ddc1fe, 0x9df3018d, 0x38b293f3, 0x7413c95f, 0xd1525b21, 0x3b7c9b52,
-        0x9e3d092c, 0xeacd6d45, 0x4f8cff3b, 0xa5a23f48, 0x00e3ad36, 0x3ce08a10, 0x99a1186e,
-        0x738fd81d, 0xd6ce4a63, 0xa23e2e0a, 0x077fbc74, 0xed517c07, 0x4810ee79, 0x04b1b4d5,
-        0xa1f026ab, 0x4bdee6d8, 0xee9f74a6, 0x9a6f10cf, 0x3f2e82b1, 0xd50042c2, 0x7041d0bc,
-        0xad060c8e, 0x08479ef0, 0xe2695e83, 0x4728ccfd, 0x33d8a894, 0x96993aea, 0x7cb7fa99,
-        0xd9f668e7, 0x9557324b, 0x3016a035, 0xda386046, 0x7f79f238, 0x0b899651, 0xaec8042f,
-        0x44e6c45c, 0xe1a75622, 0xdda47104, 0x78e5e37a, 0x92cb2309, 0x378ab177, 0x437ad51e,
-        0xe63b4760, 0x0c158713, 0xa954156d, 0xe5f54fc1, 0x40b4ddbf, 0xaa9a1dcc, 0x0fdb8fb2,
-        0x7b2bebdb, 0xde6a79a5, 0x3444b9d6, 0x91052ba8};
-static const uint32_t table3_[256] = {
-        0x00000000, 0xdd45aab8, 0xbf672381, 0x62228939, 0x7b2231f3, 0xa6679b4b, 0xc4451272,
-        0x1900b8ca, 0xf64463e6, 0x2b01c95e, 0x49234067, 0x9466eadf, 0x8d665215, 0x5023f8ad,
-        0x32017194, 0xef44db2c, 0xe964b13d, 0x34211b85, 0x560392bc, 0x8b463804, 0x924680ce,
-        0x4f032a76, 0x2d21a34f, 0xf06409f7, 0x1f20d2db, 0xc2657863, 0xa047f15a, 0x7d025be2,
-        0x6402e328, 0xb9474990, 0xdb65c0a9, 0x06206a11, 0xd725148b, 0x0a60be33, 0x6842370a,
-        0xb5079db2, 0xac072578, 0x71428fc0, 0x136006f9, 0xce25ac41, 0x2161776d, 0xfc24ddd5,
-        0x9e0654ec, 0x4343fe54, 0x5a43469e, 0x8706ec26, 0xe524651f, 0x3861cfa7, 0x3e41a5b6,
-        0xe3040f0e, 0x81268637, 0x5c632c8f, 0x45639445, 0x98263efd, 0xfa04b7c4, 0x27411d7c,
-        0xc805c650, 0x15406ce8, 0x7762e5d1, 0xaa274f69, 0xb327f7a3, 0x6e625d1b, 0x0c40d422,
-        0xd1057e9a, 0xaba65fe7, 0x76e3f55f, 0x14c17c66, 0xc984d6de, 0xd0846e14, 0x0dc1c4ac,
-        0x6fe34d95, 0xb2a6e72d, 0x5de23c01, 0x80a796b9, 0xe2851f80, 0x3fc0b538, 0x26c00df2,
-        0xfb85a74a, 0x99a72e73, 0x44e284cb, 0x42c2eeda, 0x9f874462, 0xfda5cd5b, 0x20e067e3,
-        0x39e0df29, 0xe4a57591, 0x8687fca8, 0x5bc25610, 0xb4868d3c, 0x69c32784, 0x0be1aebd,
-        0xd6a40405, 0xcfa4bccf, 0x12e11677, 0x70c39f4e, 0xad8635f6, 0x7c834b6c, 0xa1c6e1d4,
-        0xc3e468ed, 0x1ea1c255, 0x07a17a9f, 0xdae4d027, 0xb8c6591e, 0x6583f3a6, 0x8ac7288a,
-        0x57828232, 0x35a00b0b, 0xe8e5a1b3, 0xf1e51979, 0x2ca0b3c1, 0x4e823af8, 0x93c79040,
-        0x95e7fa51, 0x48a250e9, 0x2a80d9d0, 0xf7c57368, 0xeec5cba2, 0x3380611a, 0x51a2e823,
-        0x8ce7429b, 0x63a399b7, 0xbee6330f, 0xdcc4ba36, 0x0181108e, 0x1881a844, 0xc5c402fc,
-        0xa7e68bc5, 0x7aa3217d, 0x52a0c93f, 0x8fe56387, 0xedc7eabe, 0x30824006, 0x2982f8cc,
-        0xf4c75274, 0x96e5db4d, 0x4ba071f5, 0xa4e4aad9, 0x79a10061, 0x1b838958, 0xc6c623e0,
-        0xdfc69b2a, 0x02833192, 0x60a1b8ab, 0xbde41213, 0xbbc47802, 0x6681d2ba, 0x04a35b83,
-        0xd9e6f13b, 0xc0e649f1, 0x1da3e349, 0x7f816a70, 0xa2c4c0c8, 0x4d801be4, 0x90c5b15c,
-        0xf2e73865, 0x2fa292dd, 0x36a22a17, 0xebe780af, 0x89c50996, 0x5480a32e, 0x8585ddb4,
-        0x58c0770c, 0x3ae2fe35, 0xe7a7548d, 0xfea7ec47, 0x23e246ff, 0x41c0cfc6, 0x9c85657e,
-        0x73c1be52, 0xae8414ea, 0xcca69dd3, 0x11e3376b, 0x08e38fa1, 0xd5a62519, 0xb784ac20,
-        0x6ac10698, 0x6ce16c89, 0xb1a4c631, 0xd3864f08, 0x0ec3e5b0, 0x17c35d7a, 0xca86f7c2,
-        0xa8a47efb, 0x75e1d443, 0x9aa50f6f, 0x47e0a5d7, 0x25c22cee, 0xf8878656, 0xe1873e9c,
-        0x3cc29424, 0x5ee01d1d, 0x83a5b7a5, 0xf90696d8, 0x24433c60, 0x4661b559, 0x9b241fe1,
-        0x8224a72b, 0x5f610d93, 0x3d4384aa, 0xe0062e12, 0x0f42f53e, 0xd2075f86, 0xb025d6bf,
-        0x6d607c07, 0x7460c4cd, 0xa9256e75, 0xcb07e74c, 0x16424df4, 0x106227e5, 0xcd278d5d,
-        0xaf050464, 0x7240aedc, 0x6b401616, 0xb605bcae, 0xd4273597, 0x09629f2f, 0xe6264403,
-        0x3b63eebb, 0x59416782, 0x8404cd3a, 0x9d0475f0, 0x4041df48, 0x22635671, 0xff26fcc9,
-        0x2e238253, 0xf36628eb, 0x9144a1d2, 0x4c010b6a, 0x5501b3a0, 0x88441918, 0xea669021,
-        0x37233a99, 0xd867e1b5, 0x05224b0d, 0x6700c234, 0xba45688c, 0xa345d046, 0x7e007afe,
-        0x1c22f3c7, 0xc167597f, 0xc747336e, 0x1a0299d6, 0x782010ef, 0xa565ba57, 0xbc65029d,
-        0x6120a825, 0x0302211c, 0xde478ba4, 0x31035088, 0xec46fa30, 0x8e647309, 0x5321d9b1,
-        0x4a21617b, 0x9764cbc3, 0xf54642fa, 0x2803e842};
-
-// Used to fetch a naturally-aligned 32-bit word in little endian byte-order
-static inline uint32_t LE_LOAD32(const uint8_t* p) {
-    return decode_fixed32_le(p);
-}
-
-#if defined(__SSE4_2__) && (defined(__LP64__) || defined(_WIN64))
-static inline uint64_t LE_LOAD64(const uint8_t* p) {
-    return decode_fixed64_le(p);
-}
-#endif
-
-[[maybe_unused]] static inline void Slow_CRC32(uint64_t* l, uint8_t const** p) {
-    uint32_t c = static_cast<uint32_t>(*l ^ LE_LOAD32(*p));
-    *p += 4;
-    *l = table3_[c & 0xff] ^ table2_[(c >> 8) & 0xff] ^ table1_[(c >> 16) & 0xff] ^
-         table0_[c >> 24];
-    // DO it twice.
-    c = static_cast<uint32_t>(*l ^ LE_LOAD32(*p));
-    *p += 4;
-    *l = table3_[c & 0xff] ^ table2_[(c >> 8) & 0xff] ^ table1_[(c >> 16) & 0xff] ^
-         table0_[c >> 24];
-}
-
-static inline void Fast_CRC32(uint64_t* l, uint8_t const** p) {
-#if defined(__SSE4_2__) || defined(__aarch64__)
-#if (defined(__LP64__) || defined(_WIN64)) && !defined(__aarch64__)
-    *l = _mm_crc32_u64(*l, LE_LOAD64(*p));
-    *p += 8;
-#else
-    *l = _mm_crc32_u32(static_cast<unsigned int>(*l), LE_LOAD32(*p));
-    *p += 4;
-    *l = _mm_crc32_u32(static_cast<unsigned int>(*l), LE_LOAD32(*p));
-    *p += 4;
-#endif
-#else
-    Slow_CRC32(l, p);
-#endif
-}
-
-template <void (*CRC32)(uint64_t*, uint8_t const**)>
-uint32_t ExtendImpl(uint32_t crc, const char* buf, size_t size) {
-    const uint8_t* p = reinterpret_cast<const uint8_t*>(buf);
-    const uint8_t* e = p + size;
-    uint64_t l = crc ^ 0xffffffffu;
-
-// Align n to (1 << m) byte boundary
-#define CRC_ALIGN(n, m) ((n + ((1 << m) - 1)) & ~((1 << m) - 1))
-
-#define STEP1                      \
-    do {                           \
-        int c = (l & 0xff) ^ *p++; \
-        l = table0_[c] ^ (l >> 8); \
-    } while (0)
-
-    // Point x at first 16-byte aligned byte in string.  This might be
-    // just past the end of the string.
-    const uintptr_t pval = reinterpret_cast<uintptr_t>(p);
-    const uint8_t* x = reinterpret_cast<const uint8_t*>(CRC_ALIGN(pval, 4));
-    if (x <= e) {
-        // Process bytes until finished or p is 16-byte aligned
-        while (p != x) {
-            STEP1;
-        }
-    }
-    // Process bytes 16 at a time
-    while ((e - p) >= 16) {
-        CRC32(&l, &p);
-        CRC32(&l, &p);
-    }
-    // Process bytes 8 at a time
-    while ((e - p) >= 8) {
-        CRC32(&l, &p);
-    }
-    // Process the last few bytes
-    while (p != e) {
-        STEP1;
-    }
-#undef STEP1
-#undef CRC_ALIGN
-    return static_cast<uint32_t>(l ^ 0xffffffffu);
-}
-
-uint32_t Extend(uint32_t crc, const char* buf, size_t size) {
-#if defined(__SSE4_2__) || defined(__aarch64__)
-    return ExtendImpl<Fast_CRC32>(crc, buf, size);
-#else
-    return ExtendImpl<Slow_CRC32>(crc, buf, size);
-#endif
-}
-
-} // namespace crc32c
-} // namespace doris
diff --git a/be/src/util/crc32c.h b/be/src/util/crc32c.h
deleted file mode 100644
index 0e12fe3961d264..00000000000000
--- a/be/src/util/crc32c.h
+++ /dev/null
@@ -1,53 +0,0 @@
-// 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.
-
-// the following code are modified from RocksDB:
-// https://github.com/facebook/rocksdb/blob/master/util/crc32c.h
-
-#pragma once
-
-#include <stddef.h>
-#include <stdint.h>
-
-#include <vector>
-
-#include "util/slice.h"
-
-namespace doris {
-namespace crc32c {
-
-// Return the crc32c of concat(A, data[0,n-1]) where init_crc is the
-// crc32c of some string A.  Extend() is often used to maintain the
-// crc32c of a stream of data.
-extern uint32_t Extend(uint32_t init_crc, const char* data, size_t n);
-
-// Return the crc32c of data[0,n-1]
-inline uint32_t Value(const char* data, size_t n) {
-    return Extend(0, data, n);
-}
-
-// Return the crc32c of data content in all slices
-inline uint32_t Value(const std::vector<Slice>& slices) {
-    uint32_t crc = 0;
-    for (auto& slice : slices) {
-        crc = Extend(crc, slice.get_data(), slice.get_size());
-    }
-    return crc;
-}
-
-} // namespace crc32c
-} // namespace doris
diff --git a/be/src/util/hash_util.hpp b/be/src/util/hash_util.hpp
index 8f799a18a46ddf..359d9951fc1807 100644
--- a/be/src/util/hash_util.hpp
+++ b/be/src/util/hash_util.hpp
@@ -20,6 +20,7 @@
 
 #pragma once
 
+#include <crc32c/crc32c.h>
 #include <gen_cpp/Types_types.h>
 #include <xxh3.h>
 #include <zlib.h>
@@ -48,7 +49,27 @@ class HashUtil {
         return (uint32_t)crc32(hash, (const unsigned char*)(&INT_VALUE), 4);
     }
 
-#if defined(__SSE4_2__) || defined(__aarch64__)
+    template <typename T>
+    static uint32_t crc32c_fixed(const T& value, uint32_t hash) {
+        if constexpr (sizeof(T) == 1) {
+            return _mm_crc32_u8(hash, *reinterpret_cast<const uint8_t*>(&value));
+        } else if constexpr (sizeof(T) == 2) {
+            return _mm_crc32_u16(hash, *reinterpret_cast<const uint16_t*>(&value));
+        } else if constexpr (sizeof(T) == 4) {
+            return _mm_crc32_u32(hash, *reinterpret_cast<const uint32_t*>(&value));
+        } else if constexpr (sizeof(T) == 8) {
+            return (uint32_t)_mm_crc32_u64(hash, *reinterpret_cast<const uint64_t*>(&value));
+        } else {
+            return crc32c_extend(hash, (const uint8_t*)&value, sizeof(T));
+        }
+    }
+
+    static uint32_t crc32c_null(uint32_t hash) {
+        // null is treat as 0 when hash
+        static const int INT_VALUE = 0;
+        return crc32c_fixed(INT_VALUE, hash);
+    }
+
     // Compute the Crc32 hash for data using SSE4 instructions.  The input hash parameter is
     // the current hash/seed value.
     // This should only be called if SSE is supported.
@@ -58,6 +79,8 @@ class HashUtil {
     // NOTE: Any changes made to this function need to be reflected in Codegen::GetHashFn.
     // TODO: crc32 hashes with different seeds do not result in different hash functions.
     // The resulting hashes are correlated.
+    // ATTN: prefer do not use this function anymore, use crc32c::Extend instead
+    // This function is retained because it is not certain whether there are compatibility issues with historical data.
     static uint32_t crc_hash(const void* data, uint32_t bytes, uint32_t hash) {
         if (!CpuInfo::is_supported(CpuInfo::SSE4_2)) {
             return zlib_crc_hash(data, bytes, hash);
@@ -116,11 +139,6 @@ class HashUtil {
 
         return converter.u64;
     }
-#else
-    static uint32_t crc_hash(const void* data, uint32_t bytes, uint32_t hash) {
-        return zlib_crc_hash(data, bytes, hash);
-    }
-#endif
 
     // refer to https://github.com/apache/commons-codec/blob/master/src/main/java/org/apache/commons/codec/digest/MurmurHash3.java
     static const uint32_t MURMUR3_32_SEED = 104729;
diff --git a/be/src/vec/columns/column.h b/be/src/vec/columns/column.h
index 82921e1bd2b6de..cc456b7ec18a41 100644
--- a/be/src/vec/columns/column.h
+++ b/be/src/vec/columns/column.h
@@ -400,6 +400,19 @@ class IColumn : public COW<IColumn> {
                                "Method update_crc_with_value is not supported for " + get_name());
     }
 
+    virtual void update_crc32c_batch(uint32_t* __restrict hashes,
+                                     const uint8_t* __restrict null_map) const {
+        throw doris::Exception(ErrorCode::NOT_IMPLEMENTED_ERROR,
+                               "Method update_crc32c_batch is not supported for " + get_name());
+    }
+
+    // use range for one hash value to avoid virtual function call in loop
+    virtual void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                                      const uint8_t* __restrict null_map) const {
+        throw doris::Exception(ErrorCode::NOT_IMPLEMENTED_ERROR,
+                               "Method update_crc32c_single is not supported for " + get_name());
+    }
+
     /** Removes elements that don't match the filter.
       * Is used in WHERE and HAVING operations.
       * If result_size_hint > 0, then makes advance reserve(result_size_hint) for the result column;
@@ -646,6 +659,9 @@ class IColumn : public COW<IColumn> {
     // usage: nested_column.replace_column_null_data(nested_null_map.data())
     // only wrok on column_vector and column column decimal, there will be no behavior when other columns type call this method
     virtual void replace_column_null_data(const uint8_t* __restrict null_map) {}
+    // whether support replace null data, default return false
+    // column_vector and column_decimal override this method to return true
+    virtual bool support_replace_column_null_data() const { return false; }
 
     // For float/double types, replace -0.0 with 0.0, set NaN to quiet NaN,
     // used to ensure data hash equality for -0.0 and +0.0, e.g. aggregate and join
diff --git a/be/src/vec/columns/column_array.cpp b/be/src/vec/columns/column_array.cpp
index aa90bed29ab2c6..aaf925576f27c9 100644
--- a/be/src/vec/columns/column_array.cpp
+++ b/be/src/vec/columns/column_array.cpp
@@ -426,6 +426,50 @@ void ColumnArray::update_crcs_with_value(uint32_t* __restrict hash, PrimitiveTyp
     }
 }
 
+void ColumnArray::update_crc32c_batch(uint32_t* __restrict hashes,
+                                      const uint8_t* __restrict null_map) const {
+    auto s = size();
+    if (null_map) {
+        for (size_t i = 0; i < s; ++i) {
+            if (null_map[i] == 0) {
+                update_crc32c_single(i, i + 1, hashes[i], nullptr);
+            }
+        }
+    } else {
+        for (size_t i = 0; i < s; ++i) {
+            update_crc32c_single(i, i + 1, hashes[i], nullptr);
+        }
+    }
+}
+
+void ColumnArray::update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                                       const uint8_t* __restrict null_map) const {
+    const auto& offsets_column = get_offsets();
+    if (null_map) {
+        for (size_t i = start; i < end; ++i) {
+            if (null_map[i] == 0) {
+                size_t elem_size = offsets_column[i] - offsets_column[i - 1];
+                if (elem_size == 0) {
+                    hash = HashUtil::crc32c_null(hash);
+                } else {
+                    get_data().update_crc32c_single(offsets_column[i - 1], offsets_column[i], hash,
+                                                    nullptr);
+                }
+            }
+        }
+    } else {
+        for (size_t i = start; i < end; ++i) {
+            size_t elem_size = offsets_column[i] - offsets_column[i - 1];
+            if (elem_size == 0) {
+                hash = HashUtil::crc32c_null(hash);
+            } else {
+                get_data().update_crc32c_single(offsets_column[i - 1], offsets_column[i], hash,
+                                                nullptr);
+            }
+        }
+    }
+}
+
 void ColumnArray::insert(const Field& x) {
     DCHECK_EQ(x.get_type(), PrimitiveType::TYPE_ARRAY);
     if (x.is_null()) {
diff --git a/be/src/vec/columns/column_array.h b/be/src/vec/columns/column_array.h
index 0232c9f03f07e4..8ba4f37fef0a0b 100644
--- a/be/src/vec/columns/column_array.h
+++ b/be/src/vec/columns/column_array.h
@@ -149,6 +149,11 @@ class ColumnArray final : public COWHelper<IColumn, ColumnArray> {
     void update_crcs_with_value(uint32_t* __restrict hash, PrimitiveType type, uint32_t rows,
                                 uint32_t offset = 0,
                                 const uint8_t* __restrict null_data = nullptr) const override;
+    void update_crc32c_batch(uint32_t* __restrict hashes,
+                             const uint8_t* __restrict null_map) const override;
+
+    void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                              const uint8_t* __restrict null_map) const override;
 
     void insert_range_from(const IColumn& src, size_t start, size_t length) override;
     void insert_range_from_ignore_overflow(const IColumn& src, size_t start,
diff --git a/be/src/vec/columns/column_complex.h b/be/src/vec/columns/column_complex.h
index 17906c5fa25d9f..c4f47596ae5372 100644
--- a/be/src/vec/columns/column_complex.h
+++ b/be/src/vec/columns/column_complex.h
@@ -192,6 +192,8 @@ class ColumnComplexType final : public COWHelper<IColumn, ColumnComplexType<T>>
         __builtin_unreachable();
     }
 
+    /// Do NOT remove these following two functions,
+    /// There are used by some `EngineChecksumTask::_compute_checksum()`.
     // maybe we do not need to impl the function
     void update_hash_with_value(size_t n, SipHash& hash) const override {
         // TODO add hash function
diff --git a/be/src/vec/columns/column_decimal.cpp b/be/src/vec/columns/column_decimal.cpp
index dcf40f5bf8ab31..1d93ed42602036 100644
--- a/be/src/vec/columns/column_decimal.cpp
+++ b/be/src/vec/columns/column_decimal.cpp
@@ -20,6 +20,7 @@
 
 #include "vec/columns/column_decimal.h"
 
+#include <crc32c/crc32c.h>
 #include <fmt/format.h>
 
 #include <limits>
@@ -162,6 +163,40 @@ void ColumnDecimal<T>::update_crcs_with_value(uint32_t* __restrict hashes, Primi
     }
 }
 
+template <PrimitiveType T>
+void ColumnDecimal<T>::update_crc32c_batch(uint32_t* __restrict hashes,
+                                           const uint8_t* __restrict null_map) const {
+    auto s = size();
+    if (null_map) {
+        for (size_t i = 0; i < s; ++i) {
+            if (null_map[i] == 0) {
+                hashes[i] = HashUtil::crc32c_fixed(data[i], hashes[i]);
+            }
+        }
+    } else {
+        for (size_t i = 0; i < s; ++i) {
+            hashes[i] = HashUtil::crc32c_fixed(data[i], hashes[i]);
+        }
+    }
+}
+
+template <PrimitiveType T>
+void ColumnDecimal<T>::update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                                            const uint8_t* __restrict null_map) const {
+    auto s = size();
+    if (null_map) {
+        for (size_t i = 0; i < s; ++i) {
+            if (null_map[i] == 0) {
+                hash = HashUtil::crc32c_fixed(data[i], hash);
+            }
+        }
+    } else {
+        for (size_t i = 0; i < s; ++i) {
+            hash = HashUtil::crc32c_fixed(data[i], hash);
+        }
+    }
+}
+
 template <PrimitiveType T>
 void ColumnDecimal<T>::update_xxHash_with_value(size_t start, size_t end, uint64_t& hash,
                                                 const uint8_t* __restrict null_data) const {
diff --git a/be/src/vec/columns/column_decimal.h b/be/src/vec/columns/column_decimal.h
index 34a4e8e1bf5d04..2778582a62eaff 100644
--- a/be/src/vec/columns/column_decimal.h
+++ b/be/src/vec/columns/column_decimal.h
@@ -173,6 +173,12 @@ class ColumnDecimal final : public COWHelper<IColumn, ColumnDecimal<T>> {
                                 uint32_t offset,
                                 const uint8_t* __restrict null_data) const override;
 
+    void update_crc32c_batch(uint32_t* __restrict hashes,
+                             const uint8_t* __restrict null_map) const override;
+
+    void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                              const uint8_t* __restrict null_map) const override;
+
     void update_xxHash_with_value(size_t start, size_t end, uint64_t& hash,
                                   const uint8_t* __restrict null_data) const override;
     void update_crc_with_value(size_t start, size_t end, uint32_t& hash,
@@ -222,6 +228,8 @@ class ColumnDecimal final : public COWHelper<IColumn, ColumnDecimal<T>> {
 
     void replace_column_null_data(const uint8_t* __restrict null_map) override;
 
+    bool support_replace_column_null_data() const override { return true; }
+
     void sort_column(const ColumnSorter* sorter, EqualFlags& flags, IColumn::Permutation& perms,
                      EqualRange& range, bool last_column) const override;
 
diff --git a/be/src/vec/columns/column_dictionary.h b/be/src/vec/columns/column_dictionary.h
index a2ff3e781412ad..2659ec38a82f0e 100644
--- a/be/src/vec/columns/column_dictionary.h
+++ b/be/src/vec/columns/column_dictionary.h
@@ -345,7 +345,8 @@ class ColumnDictI32 final : public COWHelper<IColumn, ColumnDictI32> {
                 if (type == FieldType::OLAP_FIELD_TYPE_CHAR) {
                     len = strnlen(sv.data, sv.size);
                 }
-                uint32_t hash_val = HashUtil::crc_hash(sv.data, static_cast<uint32_t>(len), 0);
+                uint32_t hash_val =
+                        crc32c::Extend(0, (const uint8_t*)sv.data, static_cast<uint32_t>(len));
                 _hash_values[code] = hash_val;
                 _compute_hash_value_flags[code] = 1;
                 return _hash_values[code];
diff --git a/be/src/vec/columns/column_dummy.h b/be/src/vec/columns/column_dummy.h
index 8b7ce9e3d0a0c4..700ed09fbf4261 100644
--- a/be/src/vec/columns/column_dummy.h
+++ b/be/src/vec/columns/column_dummy.h
@@ -153,6 +153,8 @@ class IColumnDummy : public IColumn {
         __builtin_unreachable();
     }
 
+    // dummy column do not need to hash, so these functions are empty
+    // do not throw exception
     void update_hash_with_value(size_t n, SipHash& hash) const override {}
 
     void update_hashes_with_value(uint64_t* __restrict hashes,
@@ -168,6 +170,12 @@ class IColumnDummy : public IColumn {
     void update_crc_with_value(size_t start, size_t end, uint32_t& hash,
                                const uint8_t* __restrict null_data) const override {}
 
+    void update_crc32c_batch(uint32_t* __restrict hashes,
+                             const uint8_t* __restrict null_map) const override {}
+
+    void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                              const uint8_t* __restrict null_map) const override {}
+
 protected:
     size_t s;
 };
diff --git a/be/src/vec/columns/column_map.cpp b/be/src/vec/columns/column_map.cpp
index 793aa0563f846e..3e8fb87abd26a0 100644
--- a/be/src/vec/columns/column_map.cpp
+++ b/be/src/vec/columns/column_map.cpp
@@ -398,6 +398,50 @@ void ColumnMap::update_crcs_with_value(uint32_t* __restrict hash, PrimitiveType
     }
 }
 
+void ColumnMap::update_crc32c_batch(uint32_t* __restrict hashes,
+                                    const uint8_t* __restrict null_map) const {
+    auto s = size();
+    if (null_map) {
+        for (size_t i = 0; i < s; ++i) {
+            if (null_map[i] == 0) {
+                update_crc32c_single(i, i + 1, hashes[i], nullptr);
+            }
+        }
+    } else {
+        for (size_t i = 0; i < s; ++i) {
+            update_crc32c_single(i, i + 1, hashes[i], nullptr);
+        }
+    }
+}
+
+void ColumnMap::update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                                     const uint8_t* __restrict null_map) const {
+    const auto& offsets = get_offsets();
+    if (null_map) {
+        for (size_t i = start; i < end; ++i) {
+            if (null_map[i] == 0) {
+                size_t kv_size = offsets[i] - offsets[i - 1];
+                if (kv_size == 0) {
+                    hash = HashUtil::crc32c_null(hash);
+                } else {
+                    get_keys().update_crc32c_single(offsets[i - 1], offsets[i], hash, nullptr);
+                    get_values().update_crc32c_single(offsets[i - 1], offsets[i], hash, nullptr);
+                }
+            }
+        }
+    } else {
+        for (size_t i = start; i < end; ++i) {
+            size_t kv_size = offsets[i] - offsets[i - 1];
+            if (kv_size == 0) {
+                hash = HashUtil::crc32c_null(hash);
+            } else {
+                get_keys().update_crc32c_single(offsets[i - 1], offsets[i], hash, nullptr);
+                get_values().update_crc32c_single(offsets[i - 1], offsets[i], hash, nullptr);
+            }
+        }
+    }
+}
+
 void ColumnMap::insert_range_from(const IColumn& src, size_t start, size_t length) {
     if (length == 0) {
         return;
diff --git a/be/src/vec/columns/column_map.h b/be/src/vec/columns/column_map.h
index 1db06d80f30a16..6dd9abf24919f7 100644
--- a/be/src/vec/columns/column_map.h
+++ b/be/src/vec/columns/column_map.h
@@ -166,6 +166,12 @@ class ColumnMap final : public COWHelper<IColumn, ColumnMap> {
                                 uint32_t offset = 0,
                                 const uint8_t* __restrict null_data = nullptr) const override;
 
+    void update_crc32c_batch(uint32_t* __restrict hashes,
+                             const uint8_t* __restrict null_map) const override;
+
+    void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                              const uint8_t* __restrict null_map) const override;
+
     /******************** keys and values ***************/
     const ColumnPtr& get_keys_ptr() const { return keys_column; }
     ColumnPtr& get_keys_ptr() { return keys_column; }
diff --git a/be/src/vec/columns/column_nullable.cpp b/be/src/vec/columns/column_nullable.cpp
index f34667ff3cae48..51784ab6d11270 100644
--- a/be/src/vec/columns/column_nullable.cpp
+++ b/be/src/vec/columns/column_nullable.cpp
@@ -114,6 +114,41 @@ void ColumnNullable::update_crcs_with_value(uint32_t* __restrict hashes, doris::
     }
 }
 
+void ColumnNullable::update_crc32c_batch(uint32_t* __restrict hashes,
+                                         const uint8_t* __restrict null_map) const {
+    DCHECK(null_map == nullptr);
+    const auto* __restrict real_null_data =
+            assert_cast<const ColumnUInt8&>(get_null_map_column()).get_data().data();
+    if (_nested_column->support_replace_column_null_data()) {
+        // nullmap process is slow, replace null data to default value to avoid nullmap process
+        _nested_column->assume_mutable()->replace_column_null_data(real_null_data);
+        _nested_column->update_crc32c_batch(hashes, nullptr);
+    } else {
+        auto s = size();
+        for (int i = 0; i < s; ++i) {
+            if (real_null_data[i] != 0) {
+                hashes[i] = HashUtil::crc32c_null(hashes[i]);
+            }
+        }
+        _nested_column->update_crc32c_batch(hashes, real_null_data);
+    }
+}
+
+void ColumnNullable::update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                                          const uint8_t* __restrict null_map) const {
+    DCHECK(null_map == nullptr);
+    const auto* __restrict real_null_data =
+            assert_cast<const ColumnUInt8&>(get_null_map_column()).get_data().data();
+    constexpr int NULL_VALUE = 0;
+    auto s = size();
+    for (int i = 0; i < s; ++i) {
+        if (real_null_data[i] != 0) {
+            hash = HashUtil::crc32c_fixed(NULL_VALUE, hash);
+        }
+    }
+    _nested_column->update_crc32c_single(start, end, hash, real_null_data);
+}
+
 void ColumnNullable::update_hashes_with_value(uint64_t* __restrict hashes,
                                               const uint8_t* __restrict null_data) const {
     DCHECK(null_data == nullptr);
diff --git a/be/src/vec/columns/column_nullable.h b/be/src/vec/columns/column_nullable.h
index f611e64c807ecc..38886fb90f9d92 100644
--- a/be/src/vec/columns/column_nullable.h
+++ b/be/src/vec/columns/column_nullable.h
@@ -229,6 +229,11 @@ class ColumnNullable final : public COWHelper<IColumn, ColumnNullable> {
     void update_crcs_with_value(uint32_t* __restrict hash, PrimitiveType type, uint32_t rows,
                                 uint32_t offset,
                                 const uint8_t* __restrict null_data) const override;
+    void update_crc32c_batch(uint32_t* __restrict hashes,
+                             const uint8_t* __restrict null_map) const override;
+
+    void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                              const uint8_t* __restrict null_map) const override;
     void update_hashes_with_value(uint64_t* __restrict hashes,
                                   const uint8_t* __restrict null_data) const override;
 
diff --git a/be/src/vec/columns/column_string.cpp b/be/src/vec/columns/column_string.cpp
index 4d3ee6bd3e3f41..6c54fdde98eb00 100644
--- a/be/src/vec/columns/column_string.cpp
+++ b/be/src/vec/columns/column_string.cpp
@@ -20,6 +20,8 @@
 
 #include "vec/columns/column_string.h"
 
+#include <crc32c/crc32c.h>
+
 #include <algorithm>
 #include <boost/iterator/iterator_facade.hpp>
 #include <cstring>
@@ -318,6 +320,44 @@ void ColumnStr<T>::update_crcs_with_value(uint32_t* __restrict hashes, doris::Pr
     }
 }
 
+template <typename T>
+void ColumnStr<T>::update_crc32c_batch(uint32_t* __restrict hashes,
+                                       const uint8_t* __restrict null_map) const {
+    auto s = size();
+    if (null_map) {
+        for (size_t i = 0; i < s; i++) {
+            if (null_map[i] == 0) {
+                auto data_ref = get_data_at(i);
+                hashes[i] =
+                        crc32c_extend(hashes[i], (const uint8_t*)(data_ref.data), data_ref.size);
+            }
+        }
+    } else {
+        for (size_t i = 0; i < s; i++) {
+            auto data_ref = get_data_at(i);
+            hashes[i] = crc32c_extend(hashes[i], (const uint8_t*)(data_ref.data), data_ref.size);
+        }
+    }
+}
+
+template <typename T>
+void ColumnStr<T>::update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                                        const uint8_t* __restrict null_map) const {
+    if (null_map) {
+        for (size_t i = start; i < end; i++) {
+            if (null_map[i] == 0) {
+                auto data_ref = get_data_at(i);
+                hash = crc32c_extend(hash, (const uint8_t*)(data_ref.data), data_ref.size);
+            }
+        }
+    } else {
+        for (size_t i = start; i < end; i++) {
+            auto data_ref = get_data_at(i);
+            hash = crc32c_extend(hash, (const uint8_t*)(data_ref.data), data_ref.size);
+        }
+    }
+}
+
 template <typename T>
 ColumnPtr ColumnStr<T>::filter(const IColumn::Filter& filt, ssize_t result_size_hint) const {
     if constexpr (std::is_same_v<UInt32, T>) {
diff --git a/be/src/vec/columns/column_string.h b/be/src/vec/columns/column_string.h
index cd80ca00546b64..a45308e0e84142 100644
--- a/be/src/vec/columns/column_string.h
+++ b/be/src/vec/columns/column_string.h
@@ -429,6 +429,12 @@ class ColumnStr final : public COWHelper<IColumn, ColumnStr<T>> {
                                 uint32_t offset,
                                 const uint8_t* __restrict null_data) const override;
 
+    void update_crc32c_batch(uint32_t* __restrict hashes,
+                             const uint8_t* __restrict null_map) const override;
+
+    void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                              const uint8_t* __restrict null_map) const override;
+
     void update_hashes_with_value(uint64_t* __restrict hashes,
                                   const uint8_t* __restrict null_data) const override {
         auto s = size();
diff --git a/be/src/vec/columns/column_struct.cpp b/be/src/vec/columns/column_struct.cpp
index 137d8bc0404b56..a34eca67d5b6b8 100644
--- a/be/src/vec/columns/column_struct.cpp
+++ b/be/src/vec/columns/column_struct.cpp
@@ -257,6 +257,20 @@ void ColumnStruct::update_crcs_with_value(uint32_t* __restrict hash, PrimitiveTy
     }
 }
 
+void ColumnStruct::update_crc32c_batch(uint32_t* __restrict hashes,
+                                       const uint8_t* __restrict null_map) const {
+    for (const auto& column : columns) {
+        column->update_crc32c_batch(hashes, nullptr);
+    }
+}
+
+void ColumnStruct::update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                                        const uint8_t* __restrict null_map) const {
+    for (const auto& column : columns) {
+        column->update_crc32c_single(start, end, hash, nullptr);
+    }
+}
+
 void ColumnStruct::insert_indices_from(const IColumn& src, const uint32_t* indices_begin,
                                        const uint32_t* indices_end) {
     const auto& src_concrete = assert_cast<const ColumnStruct&>(src);
diff --git a/be/src/vec/columns/column_struct.h b/be/src/vec/columns/column_struct.h
index cd461e3f588931..b0817cb1a34954 100644
--- a/be/src/vec/columns/column_struct.h
+++ b/be/src/vec/columns/column_struct.h
@@ -125,6 +125,12 @@ class ColumnStruct final : public COWHelper<IColumn, ColumnStruct> {
                                 uint32_t offset = 0,
                                 const uint8_t* __restrict null_data = nullptr) const override;
 
+    void update_crc32c_batch(uint32_t* __restrict hashes,
+                             const uint8_t* __restrict null_map) const override;
+
+    void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                              const uint8_t* __restrict null_map) const override;
+
     void insert_indices_from(const IColumn& src, const uint32_t* indices_begin,
                              const uint32_t* indices_end) override;
 
diff --git a/be/src/vec/columns/column_variant.cpp b/be/src/vec/columns/column_variant.cpp
index 24bbd5f9464717..9c8ffb48df3c64 100644
--- a/be/src/vec/columns/column_variant.cpp
+++ b/be/src/vec/columns/column_variant.cpp
@@ -2117,6 +2117,19 @@ void ColumnVariant::update_crc_with_value(size_t start, size_t end, uint32_t& ha
     });
 }
 
+void ColumnVariant::update_crc32c_batch(uint32_t* __restrict hashes,
+                                        const uint8_t* __restrict null_map) const {
+    for_each_imutable_column(
+            [&](const ColumnPtr column) { column->update_crc32c_batch(hashes, nullptr); });
+}
+
+void ColumnVariant::update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                                         const uint8_t* __restrict null_map) const {
+    for_each_imutable_column([&](const ColumnPtr column) {
+        column->update_crc32c_single(start, end, hash, nullptr);
+    });
+}
+
 std::string ColumnVariant::debug_string() const {
     std::stringstream res;
     res << get_name() << "(num_row = " << num_rows;
diff --git a/be/src/vec/columns/column_variant.h b/be/src/vec/columns/column_variant.h
index 74cdc69c21f4ce..d5e54e10e75d34 100644
--- a/be/src/vec/columns/column_variant.h
+++ b/be/src/vec/columns/column_variant.h
@@ -499,6 +499,12 @@ class ColumnVariant final : public COWHelper<IColumn, ColumnVariant> {
     void update_crc_with_value(size_t start, size_t end, uint32_t& hash,
                                const uint8_t* __restrict null_data) const override;
 
+    void update_crc32c_batch(uint32_t* __restrict hashes,
+                             const uint8_t* __restrict null_map) const override;
+
+    void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                              const uint8_t* __restrict null_map) const override;
+
     // Not implemented
     StringRef get_data_at(size_t) const override {
         throw doris::Exception(ErrorCode::NOT_IMPLEMENTED_ERROR,
diff --git a/be/src/vec/columns/column_vector.cpp b/be/src/vec/columns/column_vector.cpp
index 3cba6a04e8706f..97d5032c601d6a 100644
--- a/be/src/vec/columns/column_vector.cpp
+++ b/be/src/vec/columns/column_vector.cpp
@@ -20,6 +20,7 @@
 
 #include "vec/columns/column_vector.h"
 
+#include <crc32c/crc32c.h>
 #include <fmt/format.h>
 #include <pdqsort.h>
 
@@ -191,6 +192,52 @@ void ColumnVector<T>::update_crcs_with_value(uint32_t* __restrict hashes, Primit
     }
 }
 
+template <PrimitiveType T>
+uint32_t ColumnVector<T>::_crc32c_hash(uint32_t hash, size_t idx) const {
+    if constexpr (is_date_or_datetime(T)) {
+        char buf[64];
+        const auto& date_val = (const VecDateTimeValue&)data[idx];
+        auto len = date_val.to_buffer(buf);
+        return crc32c_extend(hash, (const uint8_t*)buf, len);
+    } else {
+        return HashUtil::crc32c_fixed(data[idx], hash);
+    }
+}
+
+template <PrimitiveType T>
+void ColumnVector<T>::update_crc32c_batch(uint32_t* __restrict hashes,
+                                          const uint8_t* __restrict null_map) const {
+    auto s = size();
+    if (null_map) {
+        for (size_t i = 0; i < s; ++i) {
+            if (null_map[i] == 0) {
+                hashes[i] = _crc32c_hash(hashes[i], i);
+            }
+        }
+    } else {
+        for (size_t i = 0; i < s; ++i) {
+            hashes[i] = _crc32c_hash(hashes[i], i);
+        }
+    }
+}
+
+template <PrimitiveType T>
+void ColumnVector<T>::update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                                           const uint8_t* __restrict null_map) const {
+    auto s = size();
+    if (null_map) {
+        for (size_t i = 0; i < s; ++i) {
+            if (null_map[i] == 0) {
+                hash = _crc32c_hash(hash, i);
+            }
+        }
+    } else {
+        for (size_t i = 0; i < s; ++i) {
+            hash = _crc32c_hash(hash, i);
+        }
+    }
+}
+
 template <PrimitiveType T>
 struct ColumnVector<T>::less {
     const Self& parent;
diff --git a/be/src/vec/columns/column_vector.h b/be/src/vec/columns/column_vector.h
index 6c2622adf821c6..b417ef259bd31b 100644
--- a/be/src/vec/columns/column_vector.h
+++ b/be/src/vec/columns/column_vector.h
@@ -240,12 +240,19 @@ class ColumnVector final : public COWHelper<IColumn, ColumnVector<T>> {
             }
         }
     }
+
+    void update_crc32c_single(size_t start, size_t end, uint32_t& hash,
+                              const uint8_t* __restrict null_map) const override;
+
     void update_hash_with_value(size_t n, SipHash& hash) const override;
 
     void update_crcs_with_value(uint32_t* __restrict hashes, PrimitiveType type, uint32_t rows,
                                 uint32_t offset,
                                 const uint8_t* __restrict null_data) const override;
 
+    void update_crc32c_batch(uint32_t* __restrict hashes,
+                             const uint8_t* __restrict null_map) const override;
+
     void update_hashes_with_value(uint64_t* __restrict hashes,
                                   const uint8_t* __restrict null_data) const override;
 
@@ -333,6 +340,8 @@ class ColumnVector final : public COWHelper<IColumn, ColumnVector<T>> {
 
     void replace_column_null_data(const uint8_t* __restrict null_map) override;
 
+    bool support_replace_column_null_data() const override { return true; }
+
     void replace_float_special_values() override;
 
     void sort_column(const ColumnSorter* sorter, EqualFlags& flags, IColumn::Permutation& perms,
@@ -357,6 +366,7 @@ class ColumnVector final : public COWHelper<IColumn, ColumnVector<T>> {
     size_t serialize_size_at(size_t row) const override { return sizeof(value_type); }
 
 protected:
+    uint32_t _crc32c_hash(uint32_t hash, size_t idx) const;
     // when run function which need_replace_null_data_to_default, use the value far from 0 to avoid
     // raise errors for null cell.
     static value_type default_value() {
diff --git a/be/src/vec/functions/function_string.h b/be/src/vec/functions/function_string.h
index 67694b2464f93b..354b603f5b03ae 100644
--- a/be/src/vec/functions/function_string.h
+++ b/be/src/vec/functions/function_string.h
@@ -4593,7 +4593,7 @@ class FunctionNgramSearch : public IFunction {
 
     uint32_t sub_str_hash(const char* data, int32_t length) const {
         constexpr static uint32_t seed = 0;
-        return HashUtil::crc_hash(data, length, seed);
+        return crc32c::Extend(seed, (const uint8_t*)data, length);
     }
 
     template <bool column_const>
diff --git a/be/src/vec/runtime/partitioner.cpp b/be/src/vec/runtime/partitioner.cpp
index 367ff2bded2e6b..7e9410fd29f47b 100644
--- a/be/src/vec/runtime/partitioner.cpp
+++ b/be/src/vec/runtime/partitioner.cpp
@@ -18,6 +18,7 @@
 #include "partitioner.h"
 
 #include "common/cast_set.h"
+#include "common/status.h"
 #include "pipeline/local_exchange/local_exchange_sink_operator.h"
 #include "runtime/thread_context.h"
 #include "vec/columns/column_const.h"
@@ -37,10 +38,9 @@ Status Crc32HashPartitioner<ChannelIds>::do_partitioning(RuntimeState* state, Bl
         int result_size = cast_set<int>(_partition_expr_ctxs.size());
         std::vector<int> result(result_size);
 
-        _hash_vals.resize(rows);
-        std::fill(_hash_vals.begin(), _hash_vals.end(), 0);
+        _initialize_hash_vals(rows);
         auto* __restrict hashes = _hash_vals.data();
-        { RETURN_IF_ERROR(_get_partition_column_result(block, result)); }
+        RETURN_IF_ERROR(_get_partition_column_result(block, result));
         for (int j = 0; j < result_size; ++j) {
             const auto& [col, is_const] = unpack_if_const(block->get_by_position(result[j]).column);
             if (is_const) {
@@ -53,7 +53,7 @@ Status Crc32HashPartitioner<ChannelIds>::do_partitioning(RuntimeState* state, Bl
             hashes[i] = ChannelIds()(hashes[i], _partition_count);
         }
 
-        { Block::erase_useless_column(block, column_to_keep); }
+        Block::erase_useless_column(block, column_to_keep);
     }
     return Status::OK();
 }
@@ -70,14 +70,20 @@ template <typename ChannelIds>
 Status Crc32HashPartitioner<ChannelIds>::clone(RuntimeState* state,
                                                std::unique_ptr<PartitionerBase>& partitioner) {
     auto* new_partitioner = new Crc32HashPartitioner<ChannelIds>(cast_set<int>(_partition_count));
+    partitioner.reset(new_partitioner);
+    return _clone_expr_ctxs(state, new_partitioner->_partition_expr_ctxs);
+}
+
+void Crc32CHashPartitioner::_do_hash(const ColumnPtr& column, uint32_t* __restrict result,
+                                     int idx) const {
+    column->update_crc32c_batch(result, nullptr);
+}
 
+Status Crc32CHashPartitioner::clone(RuntimeState* state,
+                                    std::unique_ptr<PartitionerBase>& partitioner) {
+    auto* new_partitioner = new Crc32CHashPartitioner(cast_set<int>(_partition_count));
     partitioner.reset(new_partitioner);
-    new_partitioner->_partition_expr_ctxs.resize(_partition_expr_ctxs.size());
-    for (size_t i = 0; i < _partition_expr_ctxs.size(); i++) {
-        RETURN_IF_ERROR(
-                _partition_expr_ctxs[i]->clone(state, new_partitioner->_partition_expr_ctxs[i]));
-    }
-    return Status::OK();
+    return _clone_expr_ctxs(state, new_partitioner->_partition_expr_ctxs);
 }
 
 template class Crc32HashPartitioner<ShuffleChannelIds>;
diff --git a/be/src/vec/runtime/partitioner.h b/be/src/vec/runtime/partitioner.h
index 29afab157b1972..031a97dc2bd9e2 100644
--- a/be/src/vec/runtime/partitioner.h
+++ b/be/src/vec/runtime/partitioner.h
@@ -17,7 +17,8 @@
 
 #pragma once
 
-#include "util/runtime_profile.h"
+#include <algorithm>
+
 #include "vec/exprs/vexpr.h"
 #include "vec/exprs/vexpr_context.h"
 
@@ -81,7 +82,9 @@ class Crc32HashPartitioner : public PartitionerBase {
     Status do_partitioning(RuntimeState* state, Block* block, bool eos,
                            bool* already_sent) const override;
 
-    ChannelField get_channel_ids() const override { return {_hash_vals.data(), sizeof(uint32_t)}; }
+    ChannelField get_channel_ids() const override {
+        return {.channel_id = _hash_vals.data(), .len = sizeof(uint32_t)};
+    }
 
     Status clone(RuntimeState* state, std::unique_ptr<PartitionerBase>& partitioner) override;
 
@@ -94,7 +97,19 @@ class Crc32HashPartitioner : public PartitionerBase {
         return Status::OK();
     }
 
-    void _do_hash(const ColumnPtr& column, uint32_t* __restrict result, int idx) const;
+    Status _clone_expr_ctxs(RuntimeState* state, VExprContextSPtrs& new_partition_expr_ctxs) const {
+        new_partition_expr_ctxs.resize(_partition_expr_ctxs.size());
+        for (size_t i = 0; i < _partition_expr_ctxs.size(); i++) {
+            RETURN_IF_ERROR(_partition_expr_ctxs[i]->clone(state, new_partition_expr_ctxs[i]));
+        }
+        return Status::OK();
+    }
+
+    virtual void _do_hash(const ColumnPtr& column, uint32_t* __restrict result, int idx) const;
+    virtual void _initialize_hash_vals(size_t rows) const {
+        _hash_vals.resize(rows);
+        std::ranges::fill(_hash_vals, 0);
+    }
 
     VExprContextSPtrs _partition_expr_ctxs;
     mutable std::vector<uint32_t> _hash_vals;
@@ -113,5 +128,44 @@ struct SpillPartitionChannelIds {
         return ((l >> 16) | (l << 16)) % r;
     }
 };
+
+static inline uint32_t crc32c_shuffle_mix(uint32_t h) {
+    // Step 1: fold high entropy into low bits
+    h ^= h >> 16;
+    // Step 2: odd multiplicative scramble (cheap avalanche)
+    h *= 0xA5B35705U;
+    // Step 3: final fold to break remaining linearity
+    h ^= h >> 13;
+    return h;
+}
+
+// use high 16 bits as channel id to avoid conflict with crc32c hash table
+// shuffle hash function same with crc32c hash table(eg join hash table) will lead bad performance
+// hash table offten use low 16 bits as bucket index, so we shift 16 bits to high bits to avoid conflict
+struct ShiftChannelIds {
+    template <typename HashValueType>
+    HashValueType operator()(HashValueType l, size_t r) {
+        return crc32c_shuffle_mix(l) % r;
+    }
+};
+
+class Crc32CHashPartitioner : public Crc32HashPartitioner<ShiftChannelIds> {
+public:
+    Crc32CHashPartitioner(int partition_count)
+            : Crc32HashPartitioner<ShiftChannelIds>(partition_count) {}
+
+    Status clone(RuntimeState* state, std::unique_ptr<PartitionerBase>& partitioner) override;
+
+private:
+    void _do_hash(const ColumnPtr& column, uint32_t* __restrict result, int idx) const override;
+
+    void _initialize_hash_vals(size_t rows) const override {
+        _hash_vals.resize(rows);
+        // use golden ratio to initialize hash values to avoid collision with hash table's hash function
+        constexpr uint32_t CRC32C_SHUFFLE_SEED = 0x9E3779B9U;
+        std::ranges::fill(_hash_vals, CRC32C_SHUFFLE_SEED);
+    }
+};
+
 #include "common/compile_check_end.h"
 } // namespace doris::vectorized
diff --git a/be/test/olap/rowset/segment_v2/column_meta_accessor_test.cpp b/be/test/olap/rowset/segment_v2/column_meta_accessor_test.cpp
index b118968a589128..a1f599cb7070c7 100644
--- a/be/test/olap/rowset/segment_v2/column_meta_accessor_test.cpp
+++ b/be/test/olap/rowset/segment_v2/column_meta_accessor_test.cpp
@@ -17,6 +17,7 @@
 
 #include "olap/rowset/segment_v2/column_meta_accessor.h"
 
+#include <crc32c/crc32c.h>
 #include <gtest/gtest.h>
 
 #include <memory>
@@ -27,7 +28,6 @@
 #include "olap/rowset/segment_v2/segment.h"
 #include "olap/rowset/segment_v2/segment_writer.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 
 using namespace doris;
 using namespace doris::segment_v2;
@@ -52,7 +52,7 @@ Status append_footer_trailer(io::FileWriter* fw, SegmentFooterPB* footer) {
     }
     faststring fixed_buf;
     put_fixed32_le(&fixed_buf, static_cast<uint32_t>(footer_buf.size()));
-    uint32_t checksum = crc32c::Value(footer_buf.data(), footer_buf.size());
+    uint32_t checksum = crc32c::Crc32c(footer_buf.data(), footer_buf.size());
     put_fixed32_le(&fixed_buf, checksum);
     fixed_buf.append("D0R1", 4);
     std::vector<Slice> slices {Slice(footer_buf), Slice(fixed_buf)};
diff --git a/be/test/olap/rowset/segment_v2/external_col_meta_util_test.cpp b/be/test/olap/rowset/segment_v2/external_col_meta_util_test.cpp
index 6b7a4c583c8861..b210a09ec67f7a 100644
--- a/be/test/olap/rowset/segment_v2/external_col_meta_util_test.cpp
+++ b/be/test/olap/rowset/segment_v2/external_col_meta_util_test.cpp
@@ -17,6 +17,8 @@
 
 #include "olap/rowset/segment_v2/external_col_meta_util.h"
 
+#include <crc32c/crc32c.h>
+
 #include <memory>
 #include <string>
 #include <unordered_map>
@@ -31,7 +33,6 @@
 #include "olap/tablet_schema_helper.h"
 #include "olap/types.h"
 #include "util/coding.h"
-#include "util/crc32c.h"
 #include "vec/json/path_in_data.h"
 
 using namespace doris;
@@ -63,7 +64,7 @@ Status append_footer_trailer(io::FileWriter* fw, SegmentFooterPB* footer) {
     // footer size (4 bytes)
     put_fixed32_le(&fixed_buf, static_cast<uint32_t>(footer_buf.size()));
     // footer checksum (4 bytes)
-    uint32_t checksum = crc32c::Value(footer_buf.data(), footer_buf.size());
+    uint32_t checksum = crc32c::Crc32c(footer_buf.data(), footer_buf.size());
     put_fixed32_le(&fixed_buf, checksum);
     // magic number (4 bytes)
     fixed_buf.append("D0R1", 4);
@@ -100,7 +101,7 @@ Status read_footer_from_file(const io::FileReaderSPtr& fr, SegmentFooterPB* foot
                                   footer_length);
     }
     const uint32_t expect_checksum = decode_fixed32_le(fixed_buf + 4);
-    const uint32_t actual_checksum = crc32c::Value(footer_buf.data(), footer_buf.size());
+    const uint32_t actual_checksum = crc32c::Crc32c(footer_buf.data(), footer_buf.size());
     if (actual_checksum != expect_checksum) {
         return Status::Corruption("footer checksum mismatch, actual={}, expect={}", actual_checksum,
                                   expect_checksum);
diff --git a/be/test/util/crc32c_test.cpp b/be/test/util/crc32c_test.cpp
index b20ac7e887e13c..5a6a7faa3a57ea 100644
--- a/be/test/util/crc32c_test.cpp
+++ b/be/test/util/crc32c_test.cpp
@@ -18,8 +18,7 @@
 // the following code are modified from RocksDB:
 // https://github.com/facebook/rocksdb/blob/master/util/crc32c_test.cc
 
-#include "util/crc32c.h"
-
+#include <crc32c/crc32c.h>
 #include <gtest/gtest-message.h>
 #include <gtest/gtest-test-part.h>
 #include <string.h>
@@ -30,9 +29,6 @@
 #include "util/slice.h"
 
 namespace doris {
-namespace crc32c {
-
-class CRC {};
 
 TEST(CRC, StandardResults) {
     // Original Fast_CRC32 tests.
@@ -40,20 +36,20 @@ TEST(CRC, StandardResults) {
     char buf[32];
 
     memset(buf, 0, sizeof(buf));
-    EXPECT_EQ(0x8a9136aaU, Value(buf, sizeof(buf)));
+    EXPECT_EQ(0x8a9136aaU, crc32c::Crc32c(buf, sizeof(buf)));
 
     memset(buf, 0xff, sizeof(buf));
-    EXPECT_EQ(0x62a8ab43U, Value(buf, sizeof(buf)));
+    EXPECT_EQ(0x62a8ab43U, crc32c::Crc32c(buf, sizeof(buf)));
 
     for (int i = 0; i < 32; i++) {
         buf[i] = static_cast<char>(i);
     }
-    EXPECT_EQ(0x46dd794eU, Value(buf, sizeof(buf)));
+    EXPECT_EQ(0x46dd794eU, crc32c::Crc32c(buf, sizeof(buf)));
 
     for (int i = 0; i < 32; i++) {
         buf[i] = static_cast<char>(31 - i);
     }
-    EXPECT_EQ(0x113fdb5cU, Value(buf, sizeof(buf)));
+    EXPECT_EQ(0x113fdb5cU, crc32c::Crc32c(buf, sizeof(buf)));
 
     unsigned char data[48] = {
             0x01, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@@ -61,19 +57,21 @@ TEST(CRC, StandardResults) {
             0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00, 0x18, 0x28, 0x00, 0x00, 0x00,
             0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
     };
-    EXPECT_EQ(0xd9963a56, Value(reinterpret_cast<char*>(data), sizeof(data)));
+    EXPECT_EQ(0xd9963a56, crc32c::Crc32c(reinterpret_cast<char*>(data), sizeof(data)));
 }
 
 TEST(CRC, Values) {
-    EXPECT_NE(Value("a", 1), Value("foo", 3));
+    EXPECT_NE(crc32c::Crc32c(std::string("a")), crc32c::Crc32c(std::string("foo")));
 }
 
 TEST(CRC, Extend) {
-    EXPECT_EQ(Value("hello world", 11), Extend(Value("hello ", 6), "world", 5));
-
-    std::vector<Slice> slices = {Slice("hello "), Slice("world")};
-    EXPECT_EQ(Value("hello world", 11), Value(slices));
+    auto s1 = std::string("hello ");
+    auto s2 = std::string("world");
+    EXPECT_EQ(crc32c::Crc32c(std::string("hello world")),
+              crc32c::Extend(crc32c::Crc32c(s1), (const uint8_t*)s2.data(), s2.size()));
+    std::vector<std::string_view> slices = {s1, s2};
+    EXPECT_EQ(crc32c::Crc32c(std::string("hello world")),
+              crc32c::Extend(crc32c::Crc32c(slices[0]), (const uint8_t*)s2.data(), s2.size()));
 }
 
-} // namespace crc32c
 } // namespace doris
diff --git a/be/test/vec/core/column_complex_test.cpp b/be/test/vec/core/column_complex_test.cpp
index 5f5b20831143a5..a1167c68df5136 100644
--- a/be/test/vec/core/column_complex_test.cpp
+++ b/be/test/vec/core/column_complex_test.cpp
@@ -705,4 +705,24 @@ TEST(ColumnComplexTest, TestErase) {
     EXPECT_EQ(column_test->size(), 4);
 }
 
+TEST(ColumnComplexTest, TestUpdateHashWithValue) {
+    using ColumnTest = ColumnComplexType<TYPE_BITMAP>;
+
+    auto column_test = ColumnTest::create();
+
+    column_test->data.push_back(BitmapValue {});
+    column_test->data.push_back(BitmapValue {});
+    column_test->data.push_back(BitmapValue {});
+    column_test->data.push_back(BitmapValue {});
+    column_test->data.push_back(BitmapValue {});
+
+    SipHash hash;
+    for (size_t i = 0; i < column_test->size(); ++i) {
+        column_test->update_hash_with_value(i, hash);
+    }
+
+    std::vector<uint64_t> hash_values(column_test->size());
+    column_test->update_hashes_with_value(hash_values.data());
+}
+
 } // namespace doris::vectorized
diff --git a/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java b/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java
index 3d18c8633bbade..ba96a4a739e7af 100644
--- a/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java
+++ b/fe/fe-core/src/main/java/org/apache/doris/qe/SessionVariable.java
@@ -307,6 +307,8 @@ public class SessionVariable implements Serializable, Writable {
 
     public static final String ENABLE_PARALLEL_SCAN = "enable_parallel_scan";
 
+    public static final String ENABLE_NEW_SHUFFLE_HASH_METHOD = "enable_new_shuffle_hash_method";
+
     // Force the number of scanners to equal the number of segments in OLAP scan when parallel scan is enabled.
     public static final String OPTIMIZE_INDEX_SCAN_PARALLELISM =
             "optimize_index_scan_parallelism";
@@ -952,6 +954,9 @@ public static double getHotValueThreshold() {
                     "Enable pushing common sub-expressions as virtual columns into OlapScan (experimental)"})
     public boolean experimentalEnableVirtualSlotForCse = false;
 
+    @VariableMgr.VarAttr(name = ENABLE_NEW_SHUFFLE_HASH_METHOD)
+    public boolean enableNewShffleHashMethod = true;
+
     @VariableMgr.VarAttr(name = JDBC_CLICKHOUSE_QUERY_FINAL, needForward = true,
             description = {"是否在查询 ClickHouse JDBC 外部表时，对查询 SQL 添加 FINAL 关键字。",
                     "Whether to add the FINAL keyword to the query SQL when querying ClickHouse JDBC external tables."})
@@ -4785,6 +4790,7 @@ public TQueryOptions toThrift() {
         tResult.setCheckOverflowForDecimal(checkOverflowForDecimal);
         tResult.setFragmentTransmissionCompressionCodec(fragmentTransmissionCompressionCodec.trim().toLowerCase());
         tResult.setEnableLocalExchange(enableLocalExchange);
+        tResult.setEnableNewShuffleHashMethod(enableNewShffleHashMethod);
 
         tResult.setSkipStorageEngineMerge(skipStorageEngineMerge);
 
diff --git a/gensrc/thrift/PaloInternalService.thrift b/gensrc/thrift/PaloInternalService.thrift
index 65ae7e876b455f..62bb7b4b435c81 100644
--- a/gensrc/thrift/PaloInternalService.thrift
+++ b/gensrc/thrift/PaloInternalService.thrift
@@ -178,7 +178,7 @@ struct TQueryOptions {
   // For debug purpose, skip delete predicates when reading data
   50: optional bool skip_delete_predicate = false
 
-  51: optional bool enable_new_shuffle_hash_method // deprecated
+  51: optional bool enable_new_shuffle_hash_method
 
   52: optional i32 be_exec_version = 0