diff --git a/dbms/src/Columns/ColumnAggregateFunction.h b/dbms/src/Columns/ColumnAggregateFunction.h
index 4859c94bed4..e53ecb89ee2 100644
--- a/dbms/src/Columns/ColumnAggregateFunction.h
+++ b/dbms/src/Columns/ColumnAggregateFunction.h
@@ -165,36 +165,37 @@ class ColumnAggregateFunction final : public COWPtrHelper<IColumn, ColumnAggrega
 
     const char * deserializeAndInsertFromArena(const char * src_arena, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */, const TiDB::TiDBCollatorPtr & /* collator */)
-        const override
-    {
-        throw Exception("Method countSerializeByteSize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
-    }
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & /* byte_size */) const override
+    void countSerializeByteSizeUnique(
+        PaddedPODArray<size_t> & /* byte_size */,
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeFast is not supported for " + getName(),
+            "Method countSerializeByteSizeUnique is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */) const override
+    {
+        throw Exception("Method countSerializeByteSize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+    }
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* offsets */,
         const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
+            "Method countSerializeByteSizeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* offsets */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArrayFast is not supported for " + getName(),
+            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -202,17 +203,17 @@ class ColumnAggregateFunction final : public COWPtrHelper<IColumn, ColumnAggrega
         const TiDB::TiDBCollatorPtr & /* collator */,
         String * /* sort_key_container */) const override
     {
-        throw Exception("Method batchSerialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method serializeToPosUnique is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeFast(
+    void serializeToPos(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
         bool /* has_null */) const override
     {
-        throw Exception("Method batchSerializeFast is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method serializeToPos is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -222,10 +223,10 @@ class ColumnAggregateFunction final : public COWPtrHelper<IColumn, ColumnAggrega
         String * /* sort_key_container */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArray is not supported for " + getName(),
+            "Method serializeToPosUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -233,39 +234,39 @@ class ColumnAggregateFunction final : public COWPtrHelper<IColumn, ColumnAggrega
         const IColumn::Offsets & /* offsets */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArrayFast is not supported for " + getName(),
+            "Method serializeToPosForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchDeserialize(
+    void batchDeserializeUnique(
         PaddedPODArray<const char *> & /* pos */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */) override
     {
-        throw Exception("Method batchDeserialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method batchDeserializeUnique is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchDeserializeFast(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) override
+    void batchDeserialize(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) override
     {
-        throw Exception("Method batchDeserializeFast is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method batchDeserialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArray is not supported for " + getName(),
+            "Method batchDeserializeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArrayFast is not supported for " + getName(),
+            "Method batchDeserializeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
diff --git a/dbms/src/Columns/ColumnArray.cpp b/dbms/src/Columns/ColumnArray.cpp
index 78eec68b0fd..ef3b0460fc8 100644
--- a/dbms/src/Columns/ColumnArray.cpp
+++ b/dbms/src/Columns/ColumnArray.cpp
@@ -218,13 +218,14 @@ const char * ColumnArray::deserializeAndInsertFromArena(const char * pos, const
     return pos;
 }
 
-void ColumnArray::countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
-    const
+void ColumnArray::countSerializeByteSizeUnique(
+    PaddedPODArray<size_t> & byte_size,
+    const TiDB::TiDBCollatorPtr & collator) const
 {
     countSerializeByteSizeImpl<false>(byte_size, collator);
 }
 
-void ColumnArray::countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const
+void ColumnArray::countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const
 {
     countSerializeByteSizeImpl<true>(byte_size, nullptr);
 }
@@ -251,12 +252,12 @@ void ColumnArray::countSerializeByteSizeImpl(PaddedPODArray<size_t> & byte_size,
         byte_size[i] += sizeof(UInt32);
 
     if constexpr (is_fast)
-        getData().countSerializeByteSizeForColumnArrayFast(byte_size, getOffsets());
+        getData().countSerializeByteSizeForColumnArray(byte_size, getOffsets());
     else
-        getData().countSerializeByteSizeForColumnArray(byte_size, getOffsets(), collator);
+        getData().countSerializeByteSizeUniqueForColumnArray(byte_size, getOffsets(), collator);
 }
 
-void ColumnArray::batchSerialize(
+void ColumnArray::serializeToPosUnique(
     PaddedPODArray<char *> & pos,
     size_t start,
     size_t length,
@@ -270,7 +271,7 @@ void ColumnArray::batchSerialize(
         batchSerializeImpl<false, false>(pos, start, length, collator, sort_key_container);
 }
 
-void ColumnArray::batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
+void ColumnArray::serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
 {
     if (has_null)
         batchSerializeImpl<true, true>(pos, start, length, nullptr, nullptr);
@@ -289,7 +290,7 @@ void ColumnArray::batchSerializeImpl(
     RUNTIME_CHECK_MSG(length <= pos.size(), "length({}) > size of pos({})", length, pos.size());
     RUNTIME_CHECK_MSG(start + length <= size(), "start({}) + length({}) > size of column({})", start, length, size());
 
-    /// countSerializeByteSize has already checked that the size of one element is not greater than UINT32_MAX
+    /// countSerializeByteSizeUnique has already checked that the size of one element is not greater than UINT32_MAX
     for (size_t i = 0; i < length; ++i)
     {
         if constexpr (has_null)
@@ -303,13 +304,19 @@ void ColumnArray::batchSerializeImpl(
     }
 
     if constexpr (is_fast)
-        getData().batchSerializeForColumnArrayFast(pos, start, length, has_null, getOffsets());
+        getData().serializeToPosForColumnArray(pos, start, length, has_null, getOffsets());
     else
-        getData()
-            .batchSerializeForColumnArray(pos, start, length, has_null, getOffsets(), collator, sort_key_container);
+        getData().serializeToPosUniqueForColumnArray(
+            pos,
+            start,
+            length,
+            has_null,
+            getOffsets(),
+            collator,
+            sort_key_container);
 }
 
-void ColumnArray::batchDeserialize(
+void ColumnArray::batchDeserializeUnique(
     PaddedPODArray<const char *> & pos,
     bool use_nt_align_buffer,
     const TiDB::TiDBCollatorPtr & collator)
@@ -317,7 +324,7 @@ void ColumnArray::batchDeserialize(
     batchDeserializeImpl<false>(pos, use_nt_align_buffer, collator);
 }
 
-void ColumnArray::batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer)
+void ColumnArray::batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer)
 {
     batchDeserializeImpl<true>(pos, use_nt_align_buffer, nullptr);
 }
@@ -342,9 +349,9 @@ void ColumnArray::batchDeserializeImpl(
     }
 
     if constexpr (is_fast)
-        getData().batchDeserializeForColumnArrayFast(pos, offsets, use_nt_align_buffer);
+        getData().batchDeserializeForColumnArray(pos, offsets, use_nt_align_buffer);
     else
-        getData().batchDeserializeForColumnArray(pos, offsets, use_nt_align_buffer, collator);
+        getData().batchDeserializeUniqueForColumnArray(pos, offsets, use_nt_align_buffer, collator);
 }
 
 void ColumnArray::flushNTAlignBuffer()
diff --git a/dbms/src/Columns/ColumnArray.h b/dbms/src/Columns/ColumnArray.h
index bcfd309b6bd..1de7b54b16c 100644
--- a/dbms/src/Columns/ColumnArray.h
+++ b/dbms/src/Columns/ColumnArray.h
@@ -99,38 +99,38 @@ class ColumnArray final : public COWPtrHelper<IColumn, ColumnArray>
         String &) const override;
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+    void countSerializeByteSizeUnique(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
         const override;
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const override;
+    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override;
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* array_offsets */,
         const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
+            "Method countSerializeByteSizeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* array_offsets */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArrayFast is not supported for " + getName(),
+            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
         bool has_null,
         const TiDB::TiDBCollatorPtr & collator,
         String * sort_key_container) const override;
-    void batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
+    void serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -140,10 +140,10 @@ class ColumnArray final : public COWPtrHelper<IColumn, ColumnArray>
         String * /* sort_key_container */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArray is not supported for " + getName(),
+            "Method serializeToPosUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -151,33 +151,33 @@ class ColumnArray final : public COWPtrHelper<IColumn, ColumnArray>
         const IColumn::Offsets & /* array_offsets */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArrayFast is not supported for " + getName(),
+            "Method serializeToPosForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchDeserialize(
+    void batchDeserializeUnique(
         PaddedPODArray<const char *> & pos,
         bool use_nt_align_buffer,
         const TiDB::TiDBCollatorPtr & collator) override;
-    void batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
+    void batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArray is not supported for " + getName(),
+            "Method batchDeserializeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArrayFast is not supported for " + getName(),
+            "Method batchDeserializeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
diff --git a/dbms/src/Columns/ColumnConst.h b/dbms/src/Columns/ColumnConst.h
index a9da47e7264..283fd0293d7 100644
--- a/dbms/src/Columns/ColumnConst.h
+++ b/dbms/src/Columns/ColumnConst.h
@@ -112,37 +112,38 @@ class ColumnConst final : public COWPtrHelper<IColumn, ColumnConst>
         return res;
     }
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */, const TiDB::TiDBCollatorPtr & /* collator */)
-        const override
-    {
-        throw Exception("Method countSerializeByteSize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
-    }
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & /* byte_size */) const override
+    void countSerializeByteSizeUnique(
+        PaddedPODArray<size_t> & /* byte_size */,
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeFast is not supported for " + getName(),
+            "Method countSerializeByteSizeUnique is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
+    void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */) const override
+    {
+        throw Exception("Method countSerializeByteSize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+    }
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* array_offsets */,
         const TiDB::TiDBCollatorPtr & /* collaotr */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
+            "Method countSerializeByteSizeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* array_offsets */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArrayFast is not supported for " + getName(),
+            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -150,18 +151,18 @@ class ColumnConst final : public COWPtrHelper<IColumn, ColumnConst>
         const TiDB::TiDBCollatorPtr & /* collator */,
         String * /* sort_key_container */) const override
     {
-        throw Exception("Method batchSerialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method serializeToPosUnique is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeFast(
+    void serializeToPos(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
         bool /* has_null */) const override
     {
-        throw Exception("Method batchSerializeFast is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method serializeToPos is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -171,10 +172,10 @@ class ColumnConst final : public COWPtrHelper<IColumn, ColumnConst>
         String * /* sort_key_container */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArray is not supported for " + getName(),
+            "Method serializeToPosUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -182,39 +183,39 @@ class ColumnConst final : public COWPtrHelper<IColumn, ColumnConst>
         const IColumn::Offsets & /* array_offsets */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArrayFast is not supported for " + getName(),
+            "Method serializeToPosForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchDeserialize(
+    void batchDeserializeUnique(
         PaddedPODArray<const char *> & /* pos */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */) override
     {
-        throw Exception("Method batchDeserialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method batchDeserializeUnique is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchDeserializeFast(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) override
+    void batchDeserialize(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) override
     {
-        throw Exception("Method batchDeserializeFast is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method batchDeserialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArray is not supported for " + getName(),
+            "Method batchDeserializeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArrayFast is not supported for " + getName(),
+            "Method batchDeserializeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
diff --git a/dbms/src/Columns/ColumnDecimal.h b/dbms/src/Columns/ColumnDecimal.h
index 8560ff09fb9..13e3f6d01c0 100644
--- a/dbms/src/Columns/ColumnDecimal.h
+++ b/dbms/src/Columns/ColumnDecimal.h
@@ -172,30 +172,30 @@ class ColumnDecimal final : public COWPtrHelper<ColumnVectorHelper, ColumnDecima
         String &) const override;
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr &) const override
+    void countSerializeByteSizeUnique(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr &) const override
     {
         countSerializeByteSizeImpl<false>(byte_size);
     }
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const override
+    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override
     {
         countSerializeByteSizeImpl<true>(byte_size);
     }
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
         const TiDB::TiDBCollatorPtr &) const override
     {
         countSerializeByteSizeForColumnArrayImpl<false>(byte_size, array_offsets);
     }
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets) const override
     {
         countSerializeByteSizeForColumnArrayImpl<true>(byte_size, array_offsets);
     }
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -208,7 +208,7 @@ class ColumnDecimal final : public COWPtrHelper<ColumnVectorHelper, ColumnDecima
         else
             batchSerializeImpl</*has_null=*/false, /*is_fast=*/false>(pos, start, length);
     }
-    void batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override
+    void serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override
     {
         if (has_null)
             batchSerializeImpl</*has_null=*/true, /*is_fast=*/true>(pos, start, length);
@@ -216,7 +216,7 @@ class ColumnDecimal final : public COWPtrHelper<ColumnVectorHelper, ColumnDecima
             batchSerializeImpl</*has_null=*/false, /*is_fast=*/true>(pos, start, length);
     }
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -230,7 +230,7 @@ class ColumnDecimal final : public COWPtrHelper<ColumnVectorHelper, ColumnDecima
         else
             batchSerializeForColumnArrayImpl</*has_null=*/false, /*is_fast=*/false>(pos, start, length, array_offsets);
     }
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -243,17 +243,19 @@ class ColumnDecimal final : public COWPtrHelper<ColumnVectorHelper, ColumnDecima
             batchSerializeForColumnArrayImpl</*has_null=*/false, /*is_fast=*/true>(pos, start, length, array_offsets);
     }
 
-    void batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer, const TiDB::TiDBCollatorPtr &)
-        override
+    void batchDeserializeUnique(
+        PaddedPODArray<const char *> & pos,
+        bool use_nt_align_buffer,
+        const TiDB::TiDBCollatorPtr &) override
     {
         batchDeserializeImpl<false>(pos, use_nt_align_buffer);
     }
-    void batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override
+    void batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override
     {
         batchDeserializeImpl<true>(pos, use_nt_align_buffer);
     }
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer,
@@ -261,7 +263,7 @@ class ColumnDecimal final : public COWPtrHelper<ColumnVectorHelper, ColumnDecima
     {
         batchDeserializeForColumnArrayImpl<false>(pos, array_offsets, use_nt_align_buffer);
     }
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer) override
diff --git a/dbms/src/Columns/ColumnFixedString.cpp b/dbms/src/Columns/ColumnFixedString.cpp
index 407acbfdb47..a527d168c9e 100644
--- a/dbms/src/Columns/ColumnFixedString.cpp
+++ b/dbms/src/Columns/ColumnFixedString.cpp
@@ -133,7 +133,7 @@ const char * ColumnFixedString::deserializeAndInsertFromArena(const char * pos,
     return pos + n;
 }
 
-void ColumnFixedString::countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const
+void ColumnFixedString::countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const
 {
     RUNTIME_CHECK_MSG(byte_size.size() == size(), "size of byte_size({}) != column size({})", byte_size.size(), size());
 
@@ -142,7 +142,7 @@ void ColumnFixedString::countSerializeByteSizeFast(PaddedPODArray<size_t> & byte
         byte_size[i] += n;
 }
 
-void ColumnFixedString::countSerializeByteSizeForColumnArrayFast(
+void ColumnFixedString::countSerializeByteSizeForColumnArray(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets) const
 {
@@ -157,8 +157,7 @@ void ColumnFixedString::countSerializeByteSizeForColumnArrayFast(
         byte_size[i] += n * (array_offsets[i] - array_offsets[i - 1]);
 }
 
-void ColumnFixedString::batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null)
-    const
+void ColumnFixedString::serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
 {
     if (has_null)
         batchSerializeImpl<true>(pos, start, length);
@@ -184,7 +183,7 @@ void ColumnFixedString::batchSerializeImpl(PaddedPODArray<char *> & pos, size_t
     }
 }
 
-void ColumnFixedString::batchSerializeForColumnArrayFast(
+void ColumnFixedString::serializeToPosForColumnArray(
     PaddedPODArray<char *> & pos,
     size_t start,
     size_t length,
@@ -232,7 +231,7 @@ void ColumnFixedString::batchSerializeForColumnArrayImpl(
 }
 
 /// TODO: optimize by using align_buffer
-void ColumnFixedString::batchDeserializeFast(PaddedPODArray<const char *> & pos, bool /* use_nt_align_buffer */)
+void ColumnFixedString::batchDeserialize(PaddedPODArray<const char *> & pos, bool /* use_nt_align_buffer */)
 {
     size_t size = pos.size();
     size_t old_char_size = chars.size();
@@ -245,7 +244,7 @@ void ColumnFixedString::batchDeserializeFast(PaddedPODArray<const char *> & pos,
     }
 }
 
-void ColumnFixedString::batchDeserializeForColumnArrayFast(
+void ColumnFixedString::batchDeserializeForColumnArray(
     PaddedPODArray<const char *> & pos,
     const IColumn::Offsets & array_offsets,
     bool /* use_nt_align_buffer */)
diff --git a/dbms/src/Columns/ColumnFixedString.h b/dbms/src/Columns/ColumnFixedString.h
index f3e3e80b92e..70a870c406e 100644
--- a/dbms/src/Columns/ColumnFixedString.h
+++ b/dbms/src/Columns/ColumnFixedString.h
@@ -115,31 +115,34 @@ class ColumnFixedString final : public COWPtrHelper<IColumn, ColumnFixedString>
 
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+    void countSerializeByteSizeUnique(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
         const override
     {
         // collator->sortKey() will change the string length, which may exceeds n.
-        RUNTIME_CHECK_MSG(!collator, "{} doesn't support countSerializeByteSize when collator is not null", getName());
-        countSerializeByteSizeFast(byte_size);
+        RUNTIME_CHECK_MSG(
+            !collator,
+            "{} doesn't support countSerializeByteSizeUnique when collator is not null",
+            getName());
+        countSerializeByteSize(byte_size);
     }
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const override;
+    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override;
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
         const TiDB::TiDBCollatorPtr & collator) const override
     {
         RUNTIME_CHECK_MSG(
             !collator,
-            "{} doesn't support countSerializeByteSizeForColumnArray when collator is not null",
+            "{} doesn't support countSerializeByteSizeUniqueForColumnArray when collator is not null",
             getName());
-        countSerializeByteSizeForColumnArrayFast(byte_size, array_offsets);
+        countSerializeByteSizeForColumnArray(byte_size, array_offsets);
     }
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets) const override;
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -147,12 +150,12 @@ class ColumnFixedString final : public COWPtrHelper<IColumn, ColumnFixedString>
         const TiDB::TiDBCollatorPtr & collator,
         String *) const override
     {
-        RUNTIME_CHECK_MSG(!collator, "{} doesn't support batchSerialize when collator is not null", getName());
-        batchSerializeFast(pos, start, length, has_null);
+        RUNTIME_CHECK_MSG(!collator, "{} doesn't support serializeToPosUnique when collator is not null", getName());
+        serializeToPos(pos, start, length, has_null);
     }
-    void batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
+    void serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -163,28 +166,28 @@ class ColumnFixedString final : public COWPtrHelper<IColumn, ColumnFixedString>
     {
         RUNTIME_CHECK_MSG(
             !collator,
-            "{} doesn't support batchSerializeForColumnArray when collator is not null",
+            "{} doesn't support serializeToPosUniqueForColumnArray when collator is not null",
             getName());
-        batchSerializeForColumnArrayFast(pos, start, length, has_null, array_offsets);
+        serializeToPosForColumnArray(pos, start, length, has_null, array_offsets);
     }
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
         bool has_null,
         const IColumn::Offsets & array_offsets) const override;
 
-    void batchDeserialize(
+    void batchDeserializeUnique(
         PaddedPODArray<const char *> & pos,
         bool use_nt_align_buffer,
         const TiDB::TiDBCollatorPtr & collator) override
     {
-        RUNTIME_CHECK_MSG(!collator, "{} doesn't support batchDeserialize when collator is not null", getName());
-        batchDeserializeFast(pos, use_nt_align_buffer);
+        RUNTIME_CHECK_MSG(!collator, "{} doesn't support batchDeserializeUnique when collator is not null", getName());
+        batchDeserialize(pos, use_nt_align_buffer);
     }
-    void batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
+    void batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer,
@@ -192,11 +195,11 @@ class ColumnFixedString final : public COWPtrHelper<IColumn, ColumnFixedString>
     {
         RUNTIME_CHECK_MSG(
             !collator,
-            "{} doesn't support batchDeserializeForColumnArray when collator is not null",
+            "{} doesn't support batchDeserializeUniqueForColumnArray when collator is not null",
             getName());
-        batchDeserializeForColumnArrayFast(pos, array_offsets, use_nt_align_buffer);
+        batchDeserializeForColumnArray(pos, array_offsets, use_nt_align_buffer);
     }
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer) override;
diff --git a/dbms/src/Columns/ColumnFunction.h b/dbms/src/Columns/ColumnFunction.h
index 675fe8224ad..1a4d4dc4588 100644
--- a/dbms/src/Columns/ColumnFunction.h
+++ b/dbms/src/Columns/ColumnFunction.h
@@ -120,37 +120,38 @@ class ColumnFunction final : public COWPtrHelper<IColumn, ColumnFunction>
         throw Exception("Cannot deserialize to " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */, const TiDB::TiDBCollatorPtr & /* collator */)
-        const override
-    {
-        throw Exception("Method countSerializeByteSize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
-    }
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & /* byte_size */) const override
+    void countSerializeByteSizeUnique(
+        PaddedPODArray<size_t> & /* byte_size */,
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeFast is not supported for " + getName(),
+            "Method countSerializeByteSizeUnique is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
+    void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */) const override
+    {
+        throw Exception("Method countSerializeByteSize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+    }
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* offsets */,
         const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
+            "Method countSerializeByteSizeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* offsets */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArrayFast is not supported for " + getName(),
+            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -158,18 +159,18 @@ class ColumnFunction final : public COWPtrHelper<IColumn, ColumnFunction>
         const TiDB::TiDBCollatorPtr & /* collator */,
         String * /*sort_key_container */) const override
     {
-        throw Exception("Method batchSerialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method serializeToPosUnique is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeFast(
+    void serializeToPos(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
         bool /* has_null */) const override
     {
-        throw Exception("Method batchSerializeFast is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method serializeToPos is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -179,10 +180,10 @@ class ColumnFunction final : public COWPtrHelper<IColumn, ColumnFunction>
         String * /* sort_key_container */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArray is not supported for " + getName(),
+            "Method serializeToPosUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -190,39 +191,39 @@ class ColumnFunction final : public COWPtrHelper<IColumn, ColumnFunction>
         const IColumn::Offsets & /* array_offsets */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArrayFast is not supported for " + getName(),
+            "Method serializeToPosForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchDeserialize(
+    void batchDeserializeUnique(
         PaddedPODArray<const char *> & /* pos */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */) override
     {
-        throw Exception("Method batchDeserialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method batchDeserializeUnique is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchDeserializeFast(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) override
+    void batchDeserialize(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) override
     {
-        throw Exception("Method batchDeserializeFast is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method batchDeserialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArray is not supported for " + getName(),
+            "Method batchDeserializeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArrayFast is not supported for " + getName(),
+            "Method batchDeserializeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
diff --git a/dbms/src/Columns/ColumnNullable.cpp b/dbms/src/Columns/ColumnNullable.cpp
index a57ebb24498..ad3f81b1e24 100644
--- a/dbms/src/Columns/ColumnNullable.cpp
+++ b/dbms/src/Columns/ColumnNullable.cpp
@@ -282,35 +282,36 @@ const char * ColumnNullable::deserializeAndInsertFromArena(const char * pos, con
     return pos;
 }
 
-void ColumnNullable::countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
-    const
+void ColumnNullable::countSerializeByteSizeUnique(
+    PaddedPODArray<size_t> & byte_size,
+    const TiDB::TiDBCollatorPtr & collator) const
 {
-    getNullMapColumn().countSerializeByteSize(byte_size, collator);
-    getNestedColumn().countSerializeByteSize(byte_size, collator);
+    getNullMapColumn().countSerializeByteSizeUnique(byte_size, collator);
+    getNestedColumn().countSerializeByteSizeUnique(byte_size, collator);
 }
-void ColumnNullable::countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const
+void ColumnNullable::countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const
 {
-    getNullMapColumn().countSerializeByteSizeFast(byte_size);
-    getNestedColumn().countSerializeByteSizeFast(byte_size);
+    getNullMapColumn().countSerializeByteSize(byte_size);
+    getNestedColumn().countSerializeByteSize(byte_size);
 }
 
-void ColumnNullable::countSerializeByteSizeForColumnArray(
+void ColumnNullable::countSerializeByteSizeUniqueForColumnArray(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets,
     const TiDB::TiDBCollatorPtr & collator) const
 {
-    getNullMapColumn().countSerializeByteSizeForColumnArray(byte_size, array_offsets, collator);
-    getNestedColumn().countSerializeByteSizeForColumnArray(byte_size, array_offsets, collator);
+    getNullMapColumn().countSerializeByteSizeUniqueForColumnArray(byte_size, array_offsets, collator);
+    getNestedColumn().countSerializeByteSizeUniqueForColumnArray(byte_size, array_offsets, collator);
 }
-void ColumnNullable::countSerializeByteSizeForColumnArrayFast(
+void ColumnNullable::countSerializeByteSizeForColumnArray(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets) const
 {
-    getNullMapColumn().countSerializeByteSizeForColumnArrayFast(byte_size, array_offsets);
-    getNestedColumn().countSerializeByteSizeForColumnArrayFast(byte_size, array_offsets);
+    getNullMapColumn().countSerializeByteSizeForColumnArray(byte_size, array_offsets);
+    getNestedColumn().countSerializeByteSizeForColumnArray(byte_size, array_offsets);
 }
 
-void ColumnNullable::batchSerialize(
+void ColumnNullable::serializeToPosUnique(
     PaddedPODArray<char *> & pos,
     size_t start,
     size_t length,
@@ -318,16 +319,16 @@ void ColumnNullable::batchSerialize(
     const TiDB::TiDBCollatorPtr & collator,
     String * sort_key_container) const
 {
-    getNullMapColumn().batchSerialize(pos, start, length, has_null, collator, sort_key_container);
-    getNestedColumn().batchSerialize(pos, start, length, has_null, collator, sort_key_container);
+    getNullMapColumn().serializeToPosUnique(pos, start, length, has_null, collator, sort_key_container);
+    getNestedColumn().serializeToPosUnique(pos, start, length, has_null, collator, sort_key_container);
 }
-void ColumnNullable::batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
+void ColumnNullable::serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
 {
-    getNullMapColumn().batchSerializeFast(pos, start, length, has_null);
-    getNestedColumn().batchSerializeFast(pos, start, length, has_null);
+    getNullMapColumn().serializeToPos(pos, start, length, has_null);
+    getNestedColumn().serializeToPos(pos, start, length, has_null);
 }
 
-void ColumnNullable::batchSerializeForColumnArray(
+void ColumnNullable::serializeToPosUniqueForColumnArray(
     PaddedPODArray<char *> & pos,
     size_t start,
     size_t length,
@@ -337,51 +338,51 @@ void ColumnNullable::batchSerializeForColumnArray(
     String * sort_key_container) const
 {
     getNullMapColumn()
-        .batchSerializeForColumnArray(pos, start, length, has_null, array_offsets, collator, sort_key_container);
+        .serializeToPosUniqueForColumnArray(pos, start, length, has_null, array_offsets, collator, sort_key_container);
     getNestedColumn()
-        .batchSerializeForColumnArray(pos, start, length, has_null, array_offsets, collator, sort_key_container);
+        .serializeToPosUniqueForColumnArray(pos, start, length, has_null, array_offsets, collator, sort_key_container);
 }
-void ColumnNullable::batchSerializeForColumnArrayFast(
+void ColumnNullable::serializeToPosForColumnArray(
     PaddedPODArray<char *> & pos,
     size_t start,
     size_t length,
     bool has_null,
     const IColumn::Offsets & array_offsets) const
 {
-    getNullMapColumn().batchSerializeForColumnArrayFast(pos, start, length, has_null, array_offsets);
-    getNestedColumn().batchSerializeForColumnArrayFast(pos, start, length, has_null, array_offsets);
+    getNullMapColumn().serializeToPosForColumnArray(pos, start, length, has_null, array_offsets);
+    getNestedColumn().serializeToPosForColumnArray(pos, start, length, has_null, array_offsets);
 }
 
-void ColumnNullable::batchDeserialize(
+void ColumnNullable::batchDeserializeUnique(
     PaddedPODArray<const char *> & pos,
     bool use_nt_align_buffer,
     const TiDB::TiDBCollatorPtr & collator)
 {
-    getNullMapColumn().batchDeserialize(pos, use_nt_align_buffer, collator);
-    getNestedColumn().batchDeserialize(pos, use_nt_align_buffer, collator);
+    getNullMapColumn().batchDeserializeUnique(pos, use_nt_align_buffer, collator);
+    getNestedColumn().batchDeserializeUnique(pos, use_nt_align_buffer, collator);
 }
-void ColumnNullable::batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer)
+void ColumnNullable::batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer)
 {
-    getNullMapColumn().batchDeserializeFast(pos, use_nt_align_buffer);
-    getNestedColumn().batchDeserializeFast(pos, use_nt_align_buffer);
+    getNullMapColumn().batchDeserialize(pos, use_nt_align_buffer);
+    getNestedColumn().batchDeserialize(pos, use_nt_align_buffer);
 }
 
-void ColumnNullable::batchDeserializeForColumnArray(
+void ColumnNullable::batchDeserializeUniqueForColumnArray(
     PaddedPODArray<const char *> & pos,
     const IColumn::Offsets & array_offsets,
     bool use_nt_align_buffer,
     const TiDB::TiDBCollatorPtr & collator)
 {
-    getNullMapColumn().batchDeserializeForColumnArray(pos, array_offsets, use_nt_align_buffer, collator);
-    getNestedColumn().batchDeserializeForColumnArray(pos, array_offsets, use_nt_align_buffer, collator);
+    getNullMapColumn().batchDeserializeUniqueForColumnArray(pos, array_offsets, use_nt_align_buffer, collator);
+    getNestedColumn().batchDeserializeUniqueForColumnArray(pos, array_offsets, use_nt_align_buffer, collator);
 }
-void ColumnNullable::batchDeserializeForColumnArrayFast(
+void ColumnNullable::batchDeserializeForColumnArray(
     PaddedPODArray<const char *> & pos,
     const IColumn::Offsets & array_offsets,
     bool use_nt_align_buffer)
 {
-    getNullMapColumn().batchDeserializeForColumnArrayFast(pos, array_offsets, use_nt_align_buffer);
-    getNestedColumn().batchDeserializeForColumnArrayFast(pos, array_offsets, use_nt_align_buffer);
+    getNullMapColumn().batchDeserializeForColumnArray(pos, array_offsets, use_nt_align_buffer);
+    getNestedColumn().batchDeserializeForColumnArray(pos, array_offsets, use_nt_align_buffer);
 }
 
 void ColumnNullable::flushNTAlignBuffer()
diff --git a/dbms/src/Columns/ColumnNullable.h b/dbms/src/Columns/ColumnNullable.h
index 188b4d62be9..722e1bde839 100644
--- a/dbms/src/Columns/ColumnNullable.h
+++ b/dbms/src/Columns/ColumnNullable.h
@@ -78,28 +78,28 @@ class ColumnNullable final : public COWPtrHelper<IColumn, ColumnNullable>
         String &) const override;
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+    void countSerializeByteSizeUnique(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
         const override;
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const override;
+    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override;
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
         const TiDB::TiDBCollatorPtr & collator) const override;
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets) const override;
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
         bool has_null,
         const TiDB::TiDBCollatorPtr & collator,
         String * sort_key_container) const override;
-    void batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
+    void serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -107,25 +107,25 @@ class ColumnNullable final : public COWPtrHelper<IColumn, ColumnNullable>
         const IColumn::Offsets & array_offsets,
         const TiDB::TiDBCollatorPtr & collator,
         String * sort_key_container) const override;
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
         bool has_null,
         const IColumn::Offsets & array_offsets) const override;
 
-    void batchDeserialize(
+    void batchDeserializeUnique(
         PaddedPODArray<const char *> & pos,
         bool use_nt_align_buffer,
         const TiDB::TiDBCollatorPtr & collator) override;
-    void batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
+    void batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer,
         const TiDB::TiDBCollatorPtr & collator) override;
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer) override;
diff --git a/dbms/src/Columns/ColumnString.cpp b/dbms/src/Columns/ColumnString.cpp
index 47af8e1c085..c4747521635 100644
--- a/dbms/src/Columns/ColumnString.cpp
+++ b/dbms/src/Columns/ColumnString.cpp
@@ -481,8 +481,9 @@ void ColumnString::getPermutationWithCollationImpl(
     }
 }
 
-void ColumnString::countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
-    const
+void ColumnString::countSerializeByteSizeUnique(
+    PaddedPODArray<size_t> & byte_size,
+    const TiDB::TiDBCollatorPtr & collator) const
 {
     if likely (collator != nullptr)
         countSerializeByteSizeImpl<true>(byte_size, collator);
@@ -490,7 +491,7 @@ void ColumnString::countSerializeByteSize(PaddedPODArray<size_t> & byte_size, co
         countSerializeByteSizeImpl<false>(byte_size, nullptr);
 }
 
-void ColumnString::countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const
+void ColumnString::countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const
 {
     countSerializeByteSizeImpl<false>(byte_size, nullptr);
 }
@@ -534,7 +535,7 @@ void ColumnString::countSerializeByteSizeImpl(
     }
 }
 
-void ColumnString::countSerializeByteSizeForColumnArray(
+void ColumnString::countSerializeByteSizeUniqueForColumnArray(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets,
     const TiDB::TiDBCollatorPtr & collator) const
@@ -545,7 +546,7 @@ void ColumnString::countSerializeByteSizeForColumnArray(
         countSerializeByteSizeForColumnArrayImpl<false>(byte_size, array_offsets, nullptr);
 }
 
-void ColumnString::countSerializeByteSizeForColumnArrayFast(
+void ColumnString::countSerializeByteSizeForColumnArray(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets) const
 {
@@ -604,7 +605,7 @@ void ColumnString::countSerializeByteSizeForColumnArrayImpl(
     }
 }
 
-void ColumnString::batchSerialize(
+void ColumnString::serializeToPosUnique(
     PaddedPODArray<char *> & pos,
     size_t start,
     size_t length,
@@ -638,7 +639,7 @@ void ColumnString::batchSerialize(
     }
 }
 
-void ColumnString::batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
+void ColumnString::serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
 {
     if (has_null)
         batchSerializeImpl</*has_null=*/true, /*has_collator=*/false>(pos, start, length, nullptr, nullptr);
@@ -659,7 +660,7 @@ void ColumnString::batchSerializeImpl(
     if constexpr (has_collator)
         RUNTIME_CHECK(collator && sort_key_container);
 
-    /// countSerializeByteSize has already checked that the size of one element is not greater than UINT32_MAX
+    /// countSerializeByteSizeUnique has already checked that the size of one element is not greater than UINT32_MAX
     for (size_t i = 0; i < length; ++i)
     {
         if constexpr (has_null)
@@ -683,7 +684,7 @@ void ColumnString::batchSerializeImpl(
     }
 }
 
-void ColumnString::batchSerializeForColumnArray(
+void ColumnString::serializeToPosUniqueForColumnArray(
     PaddedPODArray<char *> & pos,
     size_t start,
     size_t length,
@@ -732,7 +733,7 @@ void ColumnString::batchSerializeForColumnArray(
     }
 }
 
-void ColumnString::batchSerializeForColumnArrayFast(
+void ColumnString::serializeToPosForColumnArray(
     PaddedPODArray<char *> & pos,
     size_t start,
     size_t length,
@@ -779,7 +780,7 @@ void ColumnString::batchSerializeForColumnArrayImpl(
         array_offsets.back(),
         size());
 
-    /// countSerializeByteSizeForColumnArray has already checked that the size of one element is not greater than UINT32_MAX
+    /// countSerializeByteSizeUniqueForColumnArray has already checked that the size of one element is not greater than UINT32_MAX
     if constexpr (has_collator)
     {
         RUNTIME_CHECK(collator && sort_key_container);
@@ -828,7 +829,7 @@ void ColumnString::batchSerializeForColumnArrayImpl(
     }
 }
 
-void ColumnString::batchDeserialize(
+void ColumnString::batchDeserializeUnique(
     PaddedPODArray<const char *> & pos,
     bool use_nt_align_buffer,
     const TiDB::TiDBCollatorPtr & collator)
@@ -839,7 +840,7 @@ void ColumnString::batchDeserialize(
         batchDeserializeImpl<false>(pos, use_nt_align_buffer);
 }
 
-void ColumnString::batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer)
+void ColumnString::batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer)
 {
     batchDeserializeImpl<false>(pos, use_nt_align_buffer);
 }
@@ -966,7 +967,7 @@ void ColumnString::batchDeserializeImpl(PaddedPODArray<const char *> & pos, bool
     }
 }
 
-void ColumnString::batchDeserializeForColumnArray(
+void ColumnString::batchDeserializeUniqueForColumnArray(
     PaddedPODArray<const char *> & pos,
     const IColumn::Offsets & array_offsets,
     bool use_nt_align_buffer,
@@ -978,7 +979,7 @@ void ColumnString::batchDeserializeForColumnArray(
         batchDeserializeForColumnArrayImpl<false>(pos, array_offsets, use_nt_align_buffer);
 }
 
-void ColumnString::batchDeserializeForColumnArrayFast(
+void ColumnString::batchDeserializeForColumnArray(
     PaddedPODArray<const char *> & pos,
     const IColumn::Offsets & array_offsets,
     bool use_nt_align_buffer)
diff --git a/dbms/src/Columns/ColumnString.h b/dbms/src/Columns/ColumnString.h
index 87205ae06a5..9b3302c5bd9 100644
--- a/dbms/src/Columns/ColumnString.h
+++ b/dbms/src/Columns/ColumnString.h
@@ -283,28 +283,28 @@ class ColumnString final : public COWPtrHelper<IColumn, ColumnString>
         return pos + string_size;
     }
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+    void countSerializeByteSizeUnique(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
         const override;
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const override;
+    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override;
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
         const TiDB::TiDBCollatorPtr & collator) const override;
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets) const override;
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
         bool has_null,
         const TiDB::TiDBCollatorPtr & collator,
         String * sort_key_container) const override;
-    void batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
+    void serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -312,25 +312,25 @@ class ColumnString final : public COWPtrHelper<IColumn, ColumnString>
         const IColumn::Offsets & array_offsets,
         const TiDB::TiDBCollatorPtr & collator,
         String * sort_key_container) const override;
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
         bool has_null,
         const IColumn::Offsets & array_offsets) const override;
 
-    void batchDeserialize(
+    void batchDeserializeUnique(
         PaddedPODArray<const char *> & pos,
         bool use_nt_align_buffer,
         const TiDB::TiDBCollatorPtr & collator) override;
-    void batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
+    void batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer,
         const TiDB::TiDBCollatorPtr & collator) override;
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer) override;
diff --git a/dbms/src/Columns/ColumnTuple.h b/dbms/src/Columns/ColumnTuple.h
index f6b742872e9..083c08517bb 100644
--- a/dbms/src/Columns/ColumnTuple.h
+++ b/dbms/src/Columns/ColumnTuple.h
@@ -95,35 +95,35 @@ class ColumnTuple final : public COWPtrHelper<IColumn, ColumnTuple>
         String &) const override;
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+    void countSerializeByteSizeUnique(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
         const override
     {
         for (const auto & column : columns)
-            column->countSerializeByteSize(byte_size, collator);
+            column->countSerializeByteSizeUnique(byte_size, collator);
     }
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const override
+    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override
     {
         for (const auto & column : columns)
-            column->countSerializeByteSizeFast(byte_size);
+            column->countSerializeByteSize(byte_size);
     }
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
         const TiDB::TiDBCollatorPtr & collator) const override
     {
         for (const auto & column : columns)
-            column->countSerializeByteSizeForColumnArray(byte_size, array_offsets, collator);
+            column->countSerializeByteSizeUniqueForColumnArray(byte_size, array_offsets, collator);
     }
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets) const override
     {
         for (const auto & column : columns)
-            column->countSerializeByteSizeForColumnArrayFast(byte_size, array_offsets);
+            column->countSerializeByteSizeForColumnArray(byte_size, array_offsets);
     }
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -132,15 +132,15 @@ class ColumnTuple final : public COWPtrHelper<IColumn, ColumnTuple>
         String * sort_key_container) const override
     {
         for (const auto & column : columns)
-            column->batchSerialize(pos, start, length, has_null, collator, sort_key_container);
+            column->serializeToPosUnique(pos, start, length, has_null, collator, sort_key_container);
     }
-    void batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override
+    void serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override
     {
         for (const auto & column : columns)
-            column->batchSerializeFast(pos, start, length, has_null);
+            column->serializeToPos(pos, start, length, has_null);
     }
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -150,7 +150,7 @@ class ColumnTuple final : public COWPtrHelper<IColumn, ColumnTuple>
         String * sort_key_container) const override
     {
         for (const auto & column : columns)
-            column->batchSerializeForColumnArray(
+            column->serializeToPosUniqueForColumnArray(
                 pos,
                 start,
                 length,
@@ -159,7 +159,7 @@ class ColumnTuple final : public COWPtrHelper<IColumn, ColumnTuple>
                 collator,
                 sort_key_container);
     }
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -167,24 +167,24 @@ class ColumnTuple final : public COWPtrHelper<IColumn, ColumnTuple>
         const IColumn::Offsets & array_offsets) const override
     {
         for (const auto & column : columns)
-            column->batchSerializeForColumnArrayFast(pos, start, length, has_null, array_offsets);
+            column->serializeToPosForColumnArray(pos, start, length, has_null, array_offsets);
     }
 
-    void batchDeserialize(
+    void batchDeserializeUnique(
         PaddedPODArray<const char *> & pos,
         bool use_nt_align_buffer,
         const TiDB::TiDBCollatorPtr & collator) override
     {
         for (auto & column : columns)
-            column->assumeMutableRef().batchDeserialize(pos, use_nt_align_buffer, collator);
+            column->assumeMutableRef().batchDeserializeUnique(pos, use_nt_align_buffer, collator);
     }
-    void batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override
+    void batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override
     {
         for (auto & column : columns)
-            column->assumeMutableRef().batchDeserializeFast(pos, use_nt_align_buffer);
+            column->assumeMutableRef().batchDeserialize(pos, use_nt_align_buffer);
     }
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer,
@@ -192,15 +192,15 @@ class ColumnTuple final : public COWPtrHelper<IColumn, ColumnTuple>
     {
         for (auto & column : columns)
             column->assumeMutableRef()
-                .batchDeserializeForColumnArray(pos, array_offsets, use_nt_align_buffer, collator);
+                .batchDeserializeUniqueForColumnArray(pos, array_offsets, use_nt_align_buffer, collator);
     }
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer) override
     {
         for (auto & column : columns)
-            column->assumeMutableRef().batchDeserializeForColumnArrayFast(pos, array_offsets, use_nt_align_buffer);
+            column->assumeMutableRef().batchDeserializeForColumnArray(pos, array_offsets, use_nt_align_buffer);
     }
 
     void flushNTAlignBuffer() override
diff --git a/dbms/src/Columns/ColumnVector.cpp b/dbms/src/Columns/ColumnVector.cpp
index 97d9e55b17b..7c0aa1e22bb 100644
--- a/dbms/src/Columns/ColumnVector.cpp
+++ b/dbms/src/Columns/ColumnVector.cpp
@@ -59,7 +59,7 @@ StringRef ColumnVector<T>::serializeValueIntoArena(
 }
 
 template <typename T>
-void ColumnVector<T>::countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const
+void ColumnVector<T>::countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const
 {
     RUNTIME_CHECK_MSG(byte_size.size() == size(), "size of byte_size({}) != column size({})", byte_size.size(), size());
 
@@ -69,7 +69,7 @@ void ColumnVector<T>::countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_s
 }
 
 template <typename T>
-void ColumnVector<T>::countSerializeByteSizeForColumnArrayFast(
+void ColumnVector<T>::countSerializeByteSizeForColumnArray(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets) const
 {
@@ -85,7 +85,7 @@ void ColumnVector<T>::countSerializeByteSizeForColumnArrayFast(
 }
 
 template <typename T>
-void ColumnVector<T>::batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
+void ColumnVector<T>::serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
 {
     if (has_null)
         batchSerializeImpl<true>(pos, start, length);
@@ -113,7 +113,7 @@ void ColumnVector<T>::batchSerializeImpl(PaddedPODArray<char *> & pos, size_t st
 }
 
 template <typename T>
-void ColumnVector<T>::batchSerializeForColumnArrayFast(
+void ColumnVector<T>::serializeToPosForColumnArray(
     PaddedPODArray<char *> & pos,
     size_t start,
     size_t length,
@@ -172,9 +172,7 @@ void ColumnVector<T>::batchSerializeForColumnArrayImpl(
 }
 
 template <typename T>
-void ColumnVector<T>::batchDeserializeFast(
-    PaddedPODArray<const char *> & pos,
-    bool use_nt_align_buffer [[maybe_unused]])
+void ColumnVector<T>::batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer [[maybe_unused]])
 {
     size_t prev_size = data.size();
     size_t size = pos.size();
@@ -267,7 +265,7 @@ void ColumnVector<T>::batchDeserializeFast(
 }
 
 template <typename T>
-void ColumnVector<T>::batchDeserializeForColumnArrayFast(
+void ColumnVector<T>::batchDeserializeForColumnArray(
     PaddedPODArray<const char *> & pos,
     const IColumn::Offsets & array_offsets,
     bool use_nt_align_buffer [[maybe_unused]])
diff --git a/dbms/src/Columns/ColumnVector.h b/dbms/src/Columns/ColumnVector.h
index 26e197fcfb1..d07fafc5470 100644
--- a/dbms/src/Columns/ColumnVector.h
+++ b/dbms/src/Columns/ColumnVector.h
@@ -327,24 +327,24 @@ class ColumnVector final : public COWPtrHelper<ColumnVectorHelper, ColumnVector<
         return pos + sizeof(T);
     }
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr &) const override
+    void countSerializeByteSizeUnique(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr &) const override
     {
-        countSerializeByteSizeFast(byte_size);
+        countSerializeByteSize(byte_size);
     }
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & byte_size) const override;
+    void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override;
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
         const TiDB::TiDBCollatorPtr &) const override
     {
-        countSerializeByteSizeForColumnArrayFast(byte_size, array_offsets);
+        countSerializeByteSizeForColumnArray(byte_size, array_offsets);
     }
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets) const override;
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -352,11 +352,11 @@ class ColumnVector final : public COWPtrHelper<ColumnVectorHelper, ColumnVector<
         const TiDB::TiDBCollatorPtr &,
         String *) const override
     {
-        batchSerializeFast(pos, start, length, has_null);
+        serializeToPos(pos, start, length, has_null);
     }
-    void batchSerializeFast(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
+    void serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const override;
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
@@ -365,31 +365,33 @@ class ColumnVector final : public COWPtrHelper<ColumnVectorHelper, ColumnVector<
         const TiDB::TiDBCollatorPtr &,
         String *) const override
     {
-        batchSerializeForColumnArrayFast(pos, start, length, has_null, array_offsets);
+        serializeToPosForColumnArray(pos, start, length, has_null, array_offsets);
     }
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & pos,
         size_t start,
         size_t length,
         bool has_null,
         const IColumn::Offsets & array_offsets) const override;
 
-    void batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer, const TiDB::TiDBCollatorPtr &)
-        override
+    void batchDeserializeUnique(
+        PaddedPODArray<const char *> & pos,
+        bool use_nt_align_buffer,
+        const TiDB::TiDBCollatorPtr &) override
     {
-        batchDeserializeFast(pos, use_nt_align_buffer);
+        batchDeserialize(pos, use_nt_align_buffer);
     }
-    void batchDeserializeFast(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
+    void batchDeserialize(PaddedPODArray<const char *> & pos, bool use_nt_align_buffer) override;
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer,
         const TiDB::TiDBCollatorPtr &) override
     {
-        batchDeserializeForColumnArrayFast(pos, array_offsets, use_nt_align_buffer);
+        batchDeserializeForColumnArray(pos, array_offsets, use_nt_align_buffer);
     }
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & pos,
         const IColumn::Offsets & array_offsets,
         bool use_nt_align_buffer) override;
diff --git a/dbms/src/Columns/IColumn.h b/dbms/src/Columns/IColumn.h
index c8be0cb08f2..8eb0527f1e6 100644
--- a/dbms/src/Columns/IColumn.h
+++ b/dbms/src/Columns/IColumn.h
@@ -238,21 +238,21 @@ class IColumn : public COWPtr<IColumn>
 
     /// Count the serialize byte size and added to the byte_size.
     /// The byte_size.size() must be equal to the column size.
-    virtual void countSerializeByteSize(
+    virtual void countSerializeByteSizeUnique(
         PaddedPODArray<size_t> & /* byte_size */,
         const TiDB::TiDBCollatorPtr & /* collator */) const
         = 0;
-    virtual void countSerializeByteSizeFast(PaddedPODArray<size_t> & /* byte_size */) const = 0;
+    virtual void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */) const = 0;
 
     /// Count the serialize byte size and added to the byte_size called by ColumnArray.
     /// array_offsets is the offsets of ColumnArray.
     /// The byte_size.size() must be equal to the array_offsets.size().
-    virtual void countSerializeByteSizeForColumnArray(
+    virtual void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const Offsets & /* array_offsets */,
         const TiDB::TiDBCollatorPtr & /* collator */) const
         = 0;
-    virtual void countSerializeByteSizeForColumnArrayFast(
+    virtual void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const Offsets & /* array_offsets */) const
         = 0;
@@ -262,7 +262,7 @@ class IColumn : public COWPtr<IColumn>
     /// Note:
     /// 1. The pos.size() must be greater than or equal to length.
     /// 2. If has_null is true, then the pos[i] could be nullptr, which means the i-th element does not need to be serialized.
-    virtual void batchSerialize(
+    virtual void serializeToPosUnique(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -270,7 +270,7 @@ class IColumn : public COWPtr<IColumn>
         const TiDB::TiDBCollatorPtr & /* collator */,
         String * /* sort_key_container */) const
         = 0;
-    virtual void batchSerializeFast(
+    virtual void serializeToPos(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -280,7 +280,7 @@ class IColumn : public COWPtr<IColumn>
     /// Serialize data of column from start to start + length into pointer of pos and forward each pos[i] to the end of
     /// serialized data.
     /// Only called by ColumnArray.
-    virtual void batchSerializeForColumnArray(
+    virtual void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -289,7 +289,7 @@ class IColumn : public COWPtr<IColumn>
         const TiDB::TiDBCollatorPtr & /* collator */,
         String * /* sort_key_container */) const
         = 0;
-    virtual void batchSerializeForColumnArrayFast(
+    virtual void serializeToPosForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -311,28 +311,28 @@ class IColumn : public COWPtr<IColumn>
     ///     while (xxx)
     ///     {
     ///         for (auto & column_ptr : mutable_columns)
-    ///             column_ptr->batchDeserialize(pos, align_buffer, true);
+    ///             column_ptr->batchDeserializeUnique(pos, align_buffer, true);
     ///     }
     ///     for (auto & column_ptr : mutable_columns)
     ///         column_ptr->flushNTAlignBuffer();
-    virtual void batchDeserialize(
+    virtual void batchDeserializeUnique(
         PaddedPODArray<const char *> & /* pos */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */)
         = 0;
-    virtual void batchDeserializeFast(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) = 0;
+    virtual void batchDeserialize(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) = 0;
 
     /// Deserialize and insert data from pos and forward each pos[i] to the end of serialized data.
     /// Only called by ColumnArray.
     /// array_offsets is the offsets of ColumnArray.
     /// The last pos.size() elements of array_offsets can be used to get the length of elements from each pos.
-    virtual void batchDeserializeForColumnArray(
+    virtual void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */)
         = 0;
-    virtual void batchDeserializeForColumnArrayFast(
+    virtual void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */)
diff --git a/dbms/src/Columns/IColumnDummy.h b/dbms/src/Columns/IColumnDummy.h
index 064bd148375..5c7dbe98ce2 100644
--- a/dbms/src/Columns/IColumnDummy.h
+++ b/dbms/src/Columns/IColumnDummy.h
@@ -88,37 +88,38 @@ class IColumnDummy : public IColumn
         return pos;
     }
 
-    void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */, const TiDB::TiDBCollatorPtr & /* collator */)
-        const override
-    {
-        throw Exception("Method countSerializeByteSize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
-    }
-    void countSerializeByteSizeFast(PaddedPODArray<size_t> & /* byte_size */) const override
+    void countSerializeByteSizeUnique(
+        PaddedPODArray<size_t> & /* byte_size */,
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeFast is not supported for " + getName(),
+            "Method countSerializeByteSizeUnique is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
+    void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */) const override
+    {
+        throw Exception("Method countSerializeByteSize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+    }
 
-    void countSerializeByteSizeForColumnArray(
+    void countSerializeByteSizeUniqueForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* array_offsets */,
         const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
+            "Method countSerializeByteSizeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void countSerializeByteSizeForColumnArrayFast(
+    void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* array_offsets */) const override
     {
         throw Exception(
-            "Method countSerializeByteSizeForColumnArrayFast is not supported for " + getName(),
+            "Method countSerializeByteSizeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchSerialize(
+    void serializeToPosUnique(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -126,18 +127,18 @@ class IColumnDummy : public IColumn
         const TiDB::TiDBCollatorPtr & /* collator */,
         String * /* sort_key_container */) const override
     {
-        throw Exception("Method batchSerialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method serializeToPosUnique is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeFast(
+    void serializeToPos(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
         bool /* has_null */) const override
     {
-        throw Exception("Method batchSerializeFast is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method serializeToPos is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchSerializeForColumnArray(
+    void serializeToPosUniqueForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -147,10 +148,10 @@ class IColumnDummy : public IColumn
         String * /* sort_key_container */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArray is not supported for " + getName(),
+            "Method serializeToPosUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchSerializeForColumnArrayFast(
+    void serializeToPosForColumnArray(
         PaddedPODArray<char *> & /* pos */,
         size_t /* start */,
         size_t /* length */,
@@ -158,39 +159,39 @@ class IColumnDummy : public IColumn
         const IColumn::Offsets & /* array_offsets */) const override
     {
         throw Exception(
-            "Method batchSerializeForColumnArrayFast is not supported for " + getName(),
+            "Method serializeToPosForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchDeserialize(
+    void batchDeserializeUnique(
         PaddedPODArray<const char *> & /* pos */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */) override
     {
-        throw Exception("Method batchDeserialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method batchDeserializeUnique is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchDeserializeFast(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) override
+    void batchDeserialize(PaddedPODArray<const char *> & /* pos */, bool /* use_nt_align_buffer */) override
     {
-        throw Exception("Method batchDeserializeFast is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
+        throw Exception("Method batchDeserialize is not supported for " + getName(), ErrorCodes::NOT_IMPLEMENTED);
     }
 
-    void batchDeserializeForColumnArray(
+    void batchDeserializeUniqueForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */,
         const TiDB::TiDBCollatorPtr & /* collator */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArray is not supported for " + getName(),
+            "Method batchDeserializeUniqueForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
-    void batchDeserializeForColumnArrayFast(
+    void batchDeserializeForColumnArray(
         PaddedPODArray<const char *> & /* pos */,
         const IColumn::Offsets & /* array_offsets */,
         bool /* use_nt_align_buffer */) override
     {
         throw Exception(
-            "Method batchDeserializeForColumnArrayFast is not supported for " + getName(),
+            "Method batchDeserializeForColumnArray is not supported for " + getName(),
             ErrorCodes::NOT_IMPLEMENTED);
     }
 
diff --git a/dbms/src/Columns/tests/gtest_column_serialize_deserialize.cpp b/dbms/src/Columns/tests/gtest_column_serialize_deserialize.cpp
index d032d511f18..565c00088a3 100644
--- a/dbms/src/Columns/tests/gtest_column_serialize_deserialize.cpp
+++ b/dbms/src/Columns/tests/gtest_column_serialize_deserialize.cpp
@@ -39,9 +39,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         for (size_t i = 0; i < column_ptr->size(); ++i)
             byte_size[i] = i;
         if (is_fast)
-            column_ptr->countSerializeByteSizeFast(byte_size);
+            column_ptr->countSerializeByteSize(byte_size);
         else
-            column_ptr->countSerializeByteSize(byte_size, collator);
+            column_ptr->countSerializeByteSizeUnique(byte_size, collator);
         ASSERT_EQ(byte_size.size(), result_byte_size.size());
         for (size_t i = 0; i < byte_size.size(); ++i)
             ASSERT_EQ(byte_size[i], i + result_byte_size[i]);
@@ -60,9 +60,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         for (size_t i = 0; i < column_array->size(); ++i)
             byte_size[i] = i;
         if (is_fast)
-            column_array->countSerializeByteSizeFast(byte_size);
+            column_array->countSerializeByteSize(byte_size);
         else
-            column_array->countSerializeByteSize(byte_size, collator);
+            column_array->countSerializeByteSizeUnique(byte_size, collator);
         ASSERT_EQ(byte_size.size(), result_byte_size.size());
         for (size_t i = 0; i < byte_size.size(); ++i)
             ASSERT_EQ(byte_size[i], sizeof(UInt32) + i + result_byte_size[i]);
@@ -184,9 +184,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         PaddedPODArray<size_t> byte_size;
         byte_size.resize_fill_zero(column_ptr->size());
         if (is_fast)
-            column_ptr->countSerializeByteSizeFast(byte_size);
+            column_ptr->countSerializeByteSize(byte_size);
         else
-            column_ptr->countSerializeByteSize(byte_size, collator);
+            column_ptr->countSerializeByteSizeUnique(byte_size, collator);
         size_t total_size = 0;
         for (const auto size : byte_size)
             total_size += size;
@@ -202,17 +202,17 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         for (const auto * ptr : pos)
             ori_pos.push_back(ptr);
         if (is_fast)
-            column_ptr->batchSerializeFast(pos, 0, byte_size.size() / 2, false);
+            column_ptr->serializeToPos(pos, 0, byte_size.size() / 2, false);
         else
-            column_ptr->batchSerialize(pos, 0, byte_size.size() / 2, false, collator, sort_key_container);
+            column_ptr->serializeToPosUnique(pos, 0, byte_size.size() / 2, false, collator, sort_key_container);
 
         auto new_col_ptr = column_ptr->cloneEmpty();
         if (use_nt_align_buffer)
             new_col_ptr->reserveAlign(byte_size.size(), FULL_VECTOR_SIZE_AVX2);
         if (is_fast)
-            new_col_ptr->batchDeserializeFast(ori_pos, use_nt_align_buffer);
+            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer);
         else
-            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer, collator);
+            new_col_ptr->batchDeserializeUnique(ori_pos, use_nt_align_buffer, collator);
 
         current_size = 0;
         pos.clear();
@@ -226,9 +226,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         for (const auto * ptr : pos)
             ori_pos.push_back(ptr);
         if (is_fast)
-            column_ptr->batchSerializeFast(pos, byte_size.size() / 2, byte_size.size() - byte_size.size() / 2, true);
+            column_ptr->serializeToPos(pos, byte_size.size() / 2, byte_size.size() - byte_size.size() / 2, true);
         else
-            column_ptr->batchSerialize(
+            column_ptr->serializeToPosUnique(
                 pos,
                 byte_size.size() / 2,
                 byte_size.size() - byte_size.size() / 2,
@@ -239,9 +239,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         ori_pos.resize(ori_pos.size() - 1);
 
         if (is_fast)
-            new_col_ptr->batchDeserializeFast(ori_pos, use_nt_align_buffer);
+            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer);
         else
-            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer, collator);
+            new_col_ptr->batchDeserializeUnique(ori_pos, use_nt_align_buffer, collator);
 
         current_size = 0;
         pos.clear();
@@ -254,14 +254,14 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         for (const auto * ptr : pos)
             ori_pos.push_back(ptr);
         if (is_fast)
-            column_ptr->batchSerializeFast(pos, 0, byte_size.size(), true);
+            column_ptr->serializeToPos(pos, 0, byte_size.size(), true);
         else
-            column_ptr->batchSerialize(pos, 0, byte_size.size(), true, collator, sort_key_container);
+            column_ptr->serializeToPosUnique(pos, 0, byte_size.size(), true, collator, sort_key_container);
 
         if (is_fast)
-            new_col_ptr->batchDeserializeFast(ori_pos, use_nt_align_buffer);
+            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer);
         else
-            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer, collator);
+            new_col_ptr->batchDeserializeUnique(ori_pos, use_nt_align_buffer, collator);
         if (use_nt_align_buffer)
             new_col_ptr->flushNTAlignBuffer();
 
@@ -288,9 +288,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         PaddedPODArray<size_t> byte_size;
         byte_size.resize_fill_zero(column_ptr->size());
         if (is_fast)
-            column_ptr->countSerializeByteSizeFast(byte_size);
+            column_ptr->countSerializeByteSize(byte_size);
         else
-            column_ptr->countSerializeByteSize(byte_size, collator);
+            column_ptr->countSerializeByteSizeUnique(byte_size, collator);
         size_t total_size = 0;
         for (const auto size : byte_size)
             total_size += size;
@@ -307,9 +307,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         for (const auto * ptr : pos)
             ori_pos.push_back(ptr);
         if (is_fast)
-            column_ptr->batchSerializeFast(pos, 0, byte_size.size() / 2, true);
+            column_ptr->serializeToPos(pos, 0, byte_size.size() / 2, true);
         else
-            column_ptr->batchSerialize(pos, 0, byte_size.size() / 2, true, collator, sort_key_container);
+            column_ptr->serializeToPosUnique(pos, 0, byte_size.size() / 2, true, collator, sort_key_container);
         pos.resize(pos.size() - 1);
         ori_pos.resize(ori_pos.size() - 1);
 
@@ -317,9 +317,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         if (use_nt_align_buffer)
             new_col_ptr->reserveAlign(byte_size.size(), FULL_VECTOR_SIZE_AVX2);
         if (is_fast)
-            new_col_ptr->batchDeserializeFast(ori_pos, use_nt_align_buffer);
+            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer);
         else
-            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer, collator);
+            new_col_ptr->batchDeserializeUnique(ori_pos, use_nt_align_buffer, collator);
 
         current_size = 0;
         pos.clear();
@@ -333,9 +333,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
             ori_pos.push_back(ptr);
         if (is_fast)
             column_ptr
-                ->batchSerializeFast(pos, byte_size.size() / 2 - 1, byte_size.size() - byte_size.size() / 2 + 1, false);
+                ->serializeToPos(pos, byte_size.size() / 2 - 1, byte_size.size() - byte_size.size() / 2 + 1, false);
         else
-            column_ptr->batchSerialize(
+            column_ptr->serializeToPosUnique(
                 pos,
                 byte_size.size() / 2 - 1,
                 byte_size.size() - byte_size.size() / 2 + 1,
@@ -343,9 +343,9 @@ class TestColumnSerializeDeserialize : public ::testing::Test
                 collator,
                 sort_key_container);
         if (is_fast)
-            new_col_ptr->batchDeserializeFast(ori_pos, use_nt_align_buffer);
+            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer);
         else
-            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer, collator);
+            new_col_ptr->batchDeserializeUnique(ori_pos, use_nt_align_buffer, collator);
 
         current_size = 0;
         pos.clear();
@@ -358,14 +358,14 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         for (const auto * ptr : pos)
             ori_pos.push_back(ptr);
         if (is_fast)
-            column_ptr->batchSerializeFast(pos, 0, byte_size.size(), true);
+            column_ptr->serializeToPos(pos, 0, byte_size.size(), true);
         else
-            column_ptr->batchSerialize(pos, 0, byte_size.size(), true, collator, sort_key_container);
+            column_ptr->serializeToPosUnique(pos, 0, byte_size.size(), true, collator, sort_key_container);
 
         if (is_fast)
-            new_col_ptr->batchDeserializeFast(ori_pos, use_nt_align_buffer);
+            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer);
         else
-            new_col_ptr->batchDeserialize(ori_pos, use_nt_align_buffer, collator);
+            new_col_ptr->batchDeserializeUnique(ori_pos, use_nt_align_buffer, collator);
         if (use_nt_align_buffer)
             new_col_ptr->flushNTAlignBuffer();