diff --git a/dbms/src/Columns/ColumnAggregateFunction.h b/dbms/src/Columns/ColumnAggregateFunction.h
index 1c1cd619d67..61b2d8d515a 100644
--- a/dbms/src/Columns/ColumnAggregateFunction.h
+++ b/dbms/src/Columns/ColumnAggregateFunction.h
@@ -167,8 +167,7 @@ class ColumnAggregateFunction final : public COWPtrHelper<IColumn, ColumnAggrega
 
     void countSerializeByteSizeForCmp(
         PaddedPODArray<size_t> & /* byte_size */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const override
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
             "Method countSerializeByteSizeForCmp is not supported for " + getName(),
@@ -181,8 +180,7 @@ class ColumnAggregateFunction final : public COWPtrHelper<IColumn, ColumnAggrega
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* offsets */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const override
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
             "Method countSerializeByteSizeForCmpColumnArray is not supported for " + getName(),
diff --git a/dbms/src/Columns/ColumnArray.cpp b/dbms/src/Columns/ColumnArray.cpp
index d6d2657c402..6fb2d039111 100644
--- a/dbms/src/Columns/ColumnArray.cpp
+++ b/dbms/src/Columns/ColumnArray.cpp
@@ -220,25 +220,21 @@ const char * ColumnArray::deserializeAndInsertFromArena(const char * pos, const
 
 void ColumnArray::countSerializeByteSizeForCmp(
     PaddedPODArray<size_t> & byte_size,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
+    const TiDB::TiDBCollatorPtr & collator) const
 {
-    countSerializeByteSizeImpl<true>(byte_size, collator, nullmap);
+    countSerializeByteSizeImpl<true>(byte_size, collator);
 }
 
 void ColumnArray::countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const
 {
-    countSerializeByteSizeImpl<false>(byte_size, nullptr, nullptr);
+    countSerializeByteSizeImpl<false>(byte_size, nullptr);
 }
 
 template <bool compare_semantics>
-void ColumnArray::countSerializeByteSizeImpl(
-    PaddedPODArray<size_t> & byte_size,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
+void ColumnArray::countSerializeByteSizeImpl(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+    const
 {
     RUNTIME_CHECK_MSG(byte_size.size() == size(), "size of byte_size({}) != column size({})", byte_size.size(), size());
-    assert(!nullmap || (nullmap->size() == size()));
 
     if unlikely (!getOffsets().empty() && getOffsets().back() > UINT32_MAX)
     {
@@ -256,7 +252,7 @@ void ColumnArray::countSerializeByteSizeImpl(
         byte_size[i] += sizeof(UInt32);
 
     if constexpr (compare_semantics)
-        getData().countSerializeByteSizeForCmpColumnArray(byte_size, getOffsets(), collator, nullmap);
+        getData().countSerializeByteSizeForCmpColumnArray(byte_size, getOffsets(), collator);
     else
         getData().countSerializeByteSizeForColumnArray(byte_size, getOffsets());
 }
diff --git a/dbms/src/Columns/ColumnArray.h b/dbms/src/Columns/ColumnArray.h
index 48c3c044ea6..9052890d1fe 100644
--- a/dbms/src/Columns/ColumnArray.h
+++ b/dbms/src/Columns/ColumnArray.h
@@ -45,10 +45,7 @@ class ColumnArray final : public COWPtrHelper<IColumn, ColumnArray>
     ColumnArray(const ColumnArray &) = default;
 
     template <bool compare_semantics>
-    void countSerializeByteSizeImpl(
-        PaddedPODArray<size_t> & byte_size,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const;
+    void countSerializeByteSizeImpl(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator) const;
 
     template <bool has_null, bool compare_semantics, bool has_nullmap>
     void serializeToPosImpl(
@@ -100,17 +97,14 @@ class ColumnArray final : public COWPtrHelper<IColumn, ColumnArray>
         String &) const override;
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSizeForCmp(
-        PaddedPODArray<size_t> & byte_size,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const override;
+    void countSerializeByteSizeForCmp(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+        const override;
     void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override;
 
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* array_offsets */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const override
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
             "Method countSerializeByteSizeForCmpColumnArray is not supported for " + getName(),
diff --git a/dbms/src/Columns/ColumnConst.h b/dbms/src/Columns/ColumnConst.h
index 6d506236116..a2a46c04754 100644
--- a/dbms/src/Columns/ColumnConst.h
+++ b/dbms/src/Columns/ColumnConst.h
@@ -114,8 +114,7 @@ class ColumnConst final : public COWPtrHelper<IColumn, ColumnConst>
 
     void countSerializeByteSizeForCmp(
         PaddedPODArray<size_t> & /* byte_size */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const override
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
             "Method countSerializeByteSizeForCmp is not supported for " + getName(),
@@ -129,8 +128,7 @@ class ColumnConst final : public COWPtrHelper<IColumn, ColumnConst>
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* array_offsets */,
-        const TiDB::TiDBCollatorPtr & /* collaotr */,
-        const NullMap * /* nullmap */) const override
+        const TiDB::TiDBCollatorPtr & /* collaotr */) const override
     {
         throw Exception(
             "Method countSerializeByteSizeForCmpColumnArray is not supported for " + getName(),
diff --git a/dbms/src/Columns/ColumnDecimal.h b/dbms/src/Columns/ColumnDecimal.h
index 91ea2ede0db..ddfacb98bae 100644
--- a/dbms/src/Columns/ColumnDecimal.h
+++ b/dbms/src/Columns/ColumnDecimal.h
@@ -174,10 +174,7 @@ class ColumnDecimal final : public COWPtrHelper<ColumnVectorHelper, ColumnDecima
         String &) const override;
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSizeForCmp(
-        PaddedPODArray<size_t> & byte_size,
-        const TiDB::TiDBCollatorPtr &,
-        const NullMap *) const override
+    void countSerializeByteSizeForCmp(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr &) const override
     {
         countSerializeByteSizeImpl<true>(byte_size, nullptr);
     }
@@ -189,8 +186,7 @@ class ColumnDecimal final : public COWPtrHelper<ColumnVectorHelper, ColumnDecima
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
-        const TiDB::TiDBCollatorPtr &,
-        const NullMap *) const override
+        const TiDB::TiDBCollatorPtr &) const override
     {
         countSerializeByteSizeForColumnArrayImpl<true>(byte_size, array_offsets);
     }
diff --git a/dbms/src/Columns/ColumnFixedString.cpp b/dbms/src/Columns/ColumnFixedString.cpp
index 615d5b68b55..8c808726b68 100644
--- a/dbms/src/Columns/ColumnFixedString.cpp
+++ b/dbms/src/Columns/ColumnFixedString.cpp
@@ -134,33 +134,18 @@ const char * ColumnFixedString::deserializeAndInsertFromArena(const char * pos,
     return pos + n;
 }
 
-template <bool has_nullmap>
-void ColumnFixedString::countSerializeByteSizeImpl(PaddedPODArray<size_t> & byte_size, const NullMap * nullmap) const
+void ColumnFixedString::countSerializeByteSizeImpl(PaddedPODArray<size_t> & byte_size) const
 {
     RUNTIME_CHECK_MSG(byte_size.size() == size(), "size of byte_size({}) != column size({})", byte_size.size(), size());
 
-    assert(!nullmap || nullmap->size() == size());
-
     size_t size = byte_size.size();
     for (size_t i = 0; i < size; ++i)
-    {
-        if constexpr (has_nullmap)
-        {
-            if (DB::isNullAt(*nullmap, i))
-            {
-                byte_size[i] += 1;
-                continue;
-            }
-        }
         byte_size[i] += n;
-    }
 }
 
-template <bool has_nullmap>
 void ColumnFixedString::countSerializeByteSizeForColumnArrayImpl(
     PaddedPODArray<size_t> & byte_size,
-    const IColumn::Offsets & array_offsets,
-    const NullMap * nullmap) const
+    const IColumn::Offsets & array_offsets) const
 {
     RUNTIME_CHECK_MSG(
         byte_size.size() == array_offsets.size(),
@@ -168,21 +153,9 @@ void ColumnFixedString::countSerializeByteSizeForColumnArrayImpl(
         byte_size.size(),
         array_offsets.size());
 
-    assert(!nullmap || nullmap->size() == array_offsets.size());
-
     size_t size = array_offsets.size();
     for (size_t i = 0; i < size; ++i)
-    {
-        if constexpr (has_nullmap)
-        {
-            if (DB::isNullAt(*nullmap, i))
-            {
-                byte_size[i] += array_offsets[i] - array_offsets[i - 1];
-                continue;
-            }
-        }
         byte_size[i] += n * (array_offsets[i] - array_offsets[i - 1]);
-    }
 }
 
 void ColumnFixedString::serializeToPos(PaddedPODArray<char *> & pos, size_t start, size_t length, bool has_null) const
diff --git a/dbms/src/Columns/ColumnFixedString.h b/dbms/src/Columns/ColumnFixedString.h
index 1cd2713542b..b909cf37927 100644
--- a/dbms/src/Columns/ColumnFixedString.h
+++ b/dbms/src/Columns/ColumnFixedString.h
@@ -54,14 +54,11 @@ class ColumnFixedString final : public COWPtrHelper<IColumn, ColumnFixedString>
         , chars(src.chars.begin(), src.chars.end())
         , n(src.n){};
 
-    template <bool has_nullmap>
-    void countSerializeByteSizeImpl(PaddedPODArray<size_t> & byte_size, const NullMap * nullmap) const;
+    void countSerializeByteSizeImpl(PaddedPODArray<size_t> & byte_size) const;
 
-    template <bool has_nullmap>
     void countSerializeByteSizeForColumnArrayImpl(
         PaddedPODArray<size_t> & byte_size,
-        const IColumn::Offsets & array_offsets,
-        const NullMap * nullmap) const;
+        const IColumn::Offsets & array_offsets) const;
 
     template <bool has_null, bool has_nullmap>
     void serializeToPosImpl(PaddedPODArray<char *> & pos, size_t start, size_t length, const NullMap * nullmap) const;
@@ -124,46 +121,37 @@ class ColumnFixedString final : public COWPtrHelper<IColumn, ColumnFixedString>
 
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSizeForCmp(
-        PaddedPODArray<size_t> & byte_size,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const override
+    void countSerializeByteSizeForCmp(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 countSerializeByteSizeForCmp when collator is not null",
             getName());
-        if (nullmap != nullptr)
-            countSerializeByteSizeImpl<true>(byte_size, nullmap);
-        else
-            countSerializeByteSizeImpl<false>(byte_size, nullptr);
+        countSerializeByteSizeImpl(byte_size);
     }
     void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override
     {
-        countSerializeByteSizeImpl<false>(byte_size, nullptr);
+        countSerializeByteSizeImpl(byte_size);
     }
 
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const override
+        const TiDB::TiDBCollatorPtr & collator) const override
     {
         RUNTIME_CHECK_MSG(
             !collator,
             "{} doesn't support countSerializeByteSizeForCmpColumnArray when collator is not null",
             getName());
-        if (nullmap != nullptr)
-            countSerializeByteSizeForColumnArrayImpl<true>(byte_size, array_offsets, nullmap);
-        else
-            countSerializeByteSizeForColumnArrayImpl<false>(byte_size, array_offsets, nullptr);
+        countSerializeByteSizeForColumnArrayImpl(byte_size, array_offsets);
     }
     void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets) const override
     {
-        countSerializeByteSizeForColumnArrayImpl<false>(byte_size, array_offsets, nullptr);
+        countSerializeByteSizeForColumnArrayImpl(byte_size, array_offsets);
     }
 
     void serializeToPosForCmp(
diff --git a/dbms/src/Columns/ColumnFunction.h b/dbms/src/Columns/ColumnFunction.h
index 24fdcb3f1e7..8343ea4d6c5 100644
--- a/dbms/src/Columns/ColumnFunction.h
+++ b/dbms/src/Columns/ColumnFunction.h
@@ -122,8 +122,7 @@ class ColumnFunction final : public COWPtrHelper<IColumn, ColumnFunction>
 
     void countSerializeByteSizeForCmp(
         PaddedPODArray<size_t> & /* byte_size */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const override
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
             "Method countSerializeByteSizeForCmp is not supported for " + getName(),
@@ -137,8 +136,7 @@ class ColumnFunction final : public COWPtrHelper<IColumn, ColumnFunction>
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* offsets */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const override
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
             "Method countSerializeByteSizeForCmpColumnArray is not supported for " + getName(),
diff --git a/dbms/src/Columns/ColumnNullable.cpp b/dbms/src/Columns/ColumnNullable.cpp
index b5e098cd38e..7ae5e4c6ba4 100644
--- a/dbms/src/Columns/ColumnNullable.cpp
+++ b/dbms/src/Columns/ColumnNullable.cpp
@@ -284,21 +284,10 @@ const char * ColumnNullable::deserializeAndInsertFromArena(const char * pos, con
 
 void ColumnNullable::countSerializeByteSizeForCmp(
     PaddedPODArray<size_t> & byte_size,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
+    const TiDB::TiDBCollatorPtr & collator) const
 {
-    if unlikely (nullmap != nullptr)
-    {
-        auto new_nullmap_col = ColumnUInt8::create();
-        DB::mergeNullMap(*nullmap, getNullMapData(), new_nullmap_col->getData());
-        new_nullmap_col->countSerializeByteSizeForCmp(byte_size, collator, nullptr);
-        getNestedColumn().countSerializeByteSizeForCmp(byte_size, collator, &(new_nullmap_col->getData()));
-    }
-    else
-    {
-        getNullMapColumn().countSerializeByteSizeForCmp(byte_size, collator, nullptr);
-        getNestedColumn().countSerializeByteSizeForCmp(byte_size, collator, &getNullMapData());
-    }
+    getNullMapColumn().countSerializeByteSizeForCmp(byte_size, collator);
+    getNestedColumn().countSerializeByteSizeForCmp(byte_size, collator);
 }
 void ColumnNullable::countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const
 {
@@ -309,35 +298,10 @@ void ColumnNullable::countSerializeByteSize(PaddedPODArray<size_t> & byte_size)
 void ColumnNullable::countSerializeByteSizeForCmpColumnArray(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
+    const TiDB::TiDBCollatorPtr & collator) const
 {
-    const auto & nested_nullmap = getNullMapData();
-    assert(nested_nullmap.size() == array_offsets.back());
-    if unlikely (nullmap != nullptr)
-    {
-        assert(nullmap->size() == array_offsets.size());
-        auto new_nullmap_col = ColumnUInt8::create();
-        auto & new_nullmap_data = new_nullmap_col->getData();
-        new_nullmap_data.assign(nested_nullmap);
-        for (size_t i = 0; i < array_offsets.size(); ++i)
-        {
-            if (DB::isNullAt(*nullmap, i))
-            {
-                const auto row_size = array_offsets[i] - array_offsets[i - 1];
-                const auto row_offset = array_offsets[i - 1];
-                for (size_t j = row_offset; j < row_offset + row_size; ++j)
-                    setNullAt(new_nullmap_data, j);
-            }
-        }
-        new_nullmap_col->countSerializeByteSizeForCmpColumnArray(byte_size, array_offsets, collator, nullptr);
-        getNestedColumn().countSerializeByteSizeForCmpColumnArray(byte_size, array_offsets, collator, &new_nullmap_data);
-    }
-    else
-    {
-        getNullMapColumn().countSerializeByteSizeForCmpColumnArray(byte_size, array_offsets, collator, nullptr);
-        getNestedColumn().countSerializeByteSizeForCmpColumnArray(byte_size, array_offsets, collator, &nested_nullmap);
-    }
+    getNullMapColumn().countSerializeByteSizeForCmpColumnArray(byte_size, array_offsets, collator);
+    getNestedColumn().countSerializeByteSizeForCmpColumnArray(byte_size, array_offsets, collator);
 }
 void ColumnNullable::countSerializeByteSizeForColumnArray(
     PaddedPODArray<size_t> & byte_size,
@@ -360,7 +324,8 @@ void ColumnNullable::serializeToPosForCmp(
         auto new_nullmap_col = ColumnUInt8::create();
         DB::mergeNullMap(*nullmap, getNullMapData(), new_nullmap_col->getData());
         getNullMapColumn().serializeToPosForCmp(pos, start, length, nullptr, collator, sort_key_container);
-        getNestedColumn().serializeToPosForCmp(pos, start, length, &(new_nullmap_col->getData()), collator, sort_key_container);
+        getNestedColumn()
+            .serializeToPosForCmp(pos, start, length, &(new_nullmap_col->getData()), collator, sort_key_container);
     }
     else
     {
@@ -402,7 +367,8 @@ void ColumnNullable::serializeToPosForCmpColumnArray(
                     setNullAt(new_nullmap_data, j);
             }
         }
-        new_nullmap_col->serializeToPosForCmpColumnArray(pos, start, length, nullptr, array_offsets, collator, sort_key_container);
+        new_nullmap_col
+            ->serializeToPosForCmpColumnArray(pos, start, length, nullptr, array_offsets, collator, sort_key_container);
         getNestedColumn().serializeToPosForCmpColumnArray(
             pos,
             start,
diff --git a/dbms/src/Columns/ColumnNullable.h b/dbms/src/Columns/ColumnNullable.h
index ba747fe8a8e..ad4abce3916 100644
--- a/dbms/src/Columns/ColumnNullable.h
+++ b/dbms/src/Columns/ColumnNullable.h
@@ -77,17 +77,14 @@ class ColumnNullable final : public COWPtrHelper<IColumn, ColumnNullable>
         String &) const override;
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSizeForCmp(
-        PaddedPODArray<size_t> & byte_size,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const override;
+    void countSerializeByteSizeForCmp(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+        const override;
     void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override;
 
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const override;
+        const TiDB::TiDBCollatorPtr & collator) const override;
     void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets) const override;
diff --git a/dbms/src/Columns/ColumnString.cpp b/dbms/src/Columns/ColumnString.cpp
index 8d54b16ae65..b2ef0e5187e 100644
--- a/dbms/src/Columns/ColumnString.cpp
+++ b/dbms/src/Columns/ColumnString.cpp
@@ -484,62 +484,31 @@ void ColumnString::getPermutationWithCollationImpl(
 
 void ColumnString::countSerializeByteSizeForCmp(
     PaddedPODArray<size_t> & byte_size,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
+    const TiDB::TiDBCollatorPtr & collator) const
 {
     if likely (collator != nullptr)
     {
         if (collator->maxBytesForOneChar() > 1)
-            countSerializeByteSizeNullMap</*compare_semantics=*/true, /*count_code_points=*/true>(
-                byte_size,
-                collator,
-                nullmap);
+            countSerializeByteSizeImpl</*has_collator=*/true, /*count_code_points=*/true>(byte_size, collator);
         else
-            countSerializeByteSizeNullMap</*compare_semantics=*/true, /*count_code_points=*/false>(
-                byte_size,
-                collator,
-                nullmap);
+            countSerializeByteSizeImpl</*has_collator=*/true, /*count_code_points=*/false>(byte_size, collator);
     }
     else
     {
-        countSerializeByteSizeNullMap</*compare_semantics=*/false, /*count_code_points=*/false>(
-            byte_size,
-            nullptr,
-            nullmap);
+        countSerializeByteSizeImpl</*has_collator=*/false, /*count_code_points=*/false>(byte_size, nullptr);
     }
 }
 
-void ColumnString::countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const
-{
-    countSerializeByteSizeNullMap</*compare_semantics=*/false, /*count_code_points=*/false>(
-        byte_size,
-        nullptr,
-        nullptr);
-}
 
-template <bool compare_semantics, bool count_code_points>
-ALWAYS_INLINE inline void ColumnString::countSerializeByteSizeNullMap(
-    PaddedPODArray<size_t> & byte_size,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
+void ColumnString::countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const
 {
-    if (nullmap != nullptr)
-        countSerializeByteSizeImpl<compare_semantics, count_code_points, /*has_nullmap=*/true>(
-            byte_size,
-            collator,
-            nullmap);
-    else
-        countSerializeByteSizeImpl<compare_semantics, count_code_points, /*has_nullmap=*/false>(
-            byte_size,
-            collator,
-            nullptr);
+    countSerializeByteSizeImpl</*has_collator=*/false, /*count_code_points=*/false>(byte_size, nullptr);
 }
 
-template <bool compare_semantics, bool count_code_points, bool has_nullmap>
+template <bool has_collator, bool count_code_points>
 void ColumnString::countSerializeByteSizeImpl(
     PaddedPODArray<size_t> & byte_size,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
+    const TiDB::TiDBCollatorPtr & collator) const
 {
     RUNTIME_CHECK_MSG(byte_size.size() == size(), "size of byte_size({}) != column size({})", byte_size.size(), size());
 
@@ -554,24 +523,15 @@ void ColumnString::countSerializeByteSizeImpl(
                 sizeAt(i));
     }
 
-    if constexpr (compare_semantics)
+    if constexpr (has_collator)
     {
         RUNTIME_CHECK(collator);
-        assert(!has_nullmap || (nullmap && nullmap->size() == size()));
 
         const size_t size = byte_size.size();
         const size_t max_bytes_one_char = collator->maxBytesForOneChar();
         for (size_t i = 0; i < size; ++i)
         {
             assert(sizeAt(i) > 0);
-            if constexpr (has_nullmap)
-            {
-                if (DB::isNullAt(*nullmap, i))
-                {
-                    byte_size[i] += sizeof(UInt32) + 1;
-                    continue;
-                }
-            }
 
             if constexpr (count_code_points)
             {
@@ -587,7 +547,6 @@ void ColumnString::countSerializeByteSizeImpl(
     }
     else
     {
-        assert(!has_nullmap);
         size_t size = byte_size.size();
         for (size_t i = 0; i < size; ++i)
             byte_size[i] += sizeof(UInt32) + sizeAt(i);
@@ -597,30 +556,26 @@ void ColumnString::countSerializeByteSizeImpl(
 void ColumnString::countSerializeByteSizeForCmpColumnArray(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
+    const TiDB::TiDBCollatorPtr & collator) const
 {
     if likely (collator != nullptr)
     {
         if (collator->maxBytesForOneChar() > 1)
-            countSerializeByteSizeForColumnArrayNullMap</*compare_semantics=*/true, /*count_code_points=*/true>(
+            countSerializeByteSizeForColumnArrayImpl</*has_collator=*/true, /*count_code_points=*/true>(
                 byte_size,
                 array_offsets,
-                collator,
-                nullmap);
+                collator);
         else
-            countSerializeByteSizeForColumnArrayNullMap</*compare_semantics=*/true, /*count_code_points=*/false>(
+            countSerializeByteSizeForColumnArrayImpl</*has_collator=*/true, /*count_code_points=*/false>(
                 byte_size,
                 array_offsets,
-                collator,
-                nullmap);
+                collator);
     }
     else
     {
-        countSerializeByteSizeForColumnArrayNullMap</*compare_semantics=*/false, /*count_code_points=*/false>(
+        countSerializeByteSizeForColumnArrayImpl</*has_collator=*/false, /*count_code_points=*/false>(
             byte_size,
             array_offsets,
-            nullptr,
             nullptr);
     }
 }
@@ -629,40 +584,17 @@ void ColumnString::countSerializeByteSizeForColumnArray(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets) const
 {
-    countSerializeByteSizeForColumnArrayNullMap</*compare_semantics=*/false, /*count_code_points=*/false>(
+    countSerializeByteSizeForColumnArrayImpl</*has_collator=*/false, /*count_code_points=*/false>(
         byte_size,
         array_offsets,
-        nullptr,
         nullptr);
 }
 
-template <bool compare_semantics, bool count_code_points>
-void ColumnString::countSerializeByteSizeForColumnArrayNullMap(
-    PaddedPODArray<size_t> & byte_size,
-    const IColumn::Offsets & array_offsets,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
-{
-    if (nullmap != nullptr)
-        countSerializeByteSizeForColumnArrayImpl<compare_semantics, count_code_points, /*has_nullmap=*/true>(
-            byte_size,
-            array_offsets,
-            collator,
-            nullmap);
-    else
-        countSerializeByteSizeForColumnArrayImpl<compare_semantics, count_code_points, /*has_nullmap=*/false>(
-            byte_size,
-            array_offsets,
-            collator,
-            nullptr);
-}
-
-template <bool compare_semantics, bool count_code_points, bool has_nullmap>
+template <bool has_collator, bool count_code_points>
 void ColumnString::countSerializeByteSizeForColumnArrayImpl(
     PaddedPODArray<size_t> & byte_size,
     const IColumn::Offsets & array_offsets,
-    const TiDB::TiDBCollatorPtr & collator,
-    const NullMap * nullmap) const
+    const TiDB::TiDBCollatorPtr & collator) const
 {
     RUNTIME_CHECK_MSG(
         byte_size.size() == array_offsets.size(),
@@ -686,10 +618,9 @@ void ColumnString::countSerializeByteSizeForColumnArrayImpl(
                 sizeAt(i));
     }
 
-    if constexpr (compare_semantics)
+    if constexpr (has_collator)
     {
         RUNTIME_CHECK(collator);
-        assert(!has_nullmap || (nullmap && nullmap->size() == array_offsets.size()));
 
         size_t size = array_offsets.size();
         const auto max_bytes_one_char = collator->maxBytesForOneChar();
@@ -697,11 +628,6 @@ void ColumnString::countSerializeByteSizeForColumnArrayImpl(
         {
             const size_t ele_count = array_offsets[i] - array_offsets[i - 1];
             assert(offsetAt(array_offsets[i]) - offsetAt(array_offsets[i - 1]) >= ele_count);
-            if constexpr (has_nullmap)
-            {
-                if (DB::isNullAt(*nullmap, i))
-                    continue;
-            }
 
             if constexpr (count_code_points)
             {
@@ -725,7 +651,6 @@ void ColumnString::countSerializeByteSizeForColumnArrayImpl(
     }
     else
     {
-        assert(!has_nullmap);
         size_t size = array_offsets.size();
         for (size_t i = 0; i < size; ++i)
             byte_size[i] += sizeof(UInt32) * (array_offsets[i] - array_offsets[i - 1]) + offsetAt(array_offsets[i])
diff --git a/dbms/src/Columns/ColumnString.h b/dbms/src/Columns/ColumnString.h
index 8d9ee722c14..97de1b9cf73 100644
--- a/dbms/src/Columns/ColumnString.h
+++ b/dbms/src/Columns/ColumnString.h
@@ -112,24 +112,14 @@ class ColumnString final : public COWPtrHelper<IColumn, ColumnString>
         PaddedPODArray<size_t> & byte_size,
         const TiDB::TiDBCollatorPtr & collator,
         const NullMap * nullmap) const;
-    template <bool compare_semantics, bool count_code_points, bool has_nullmap>
-    void countSerializeByteSizeImpl(
-        PaddedPODArray<size_t> & byte_size,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const;
-
     template <bool compare_semantics, bool count_code_points>
-    void countSerializeByteSizeForColumnArrayNullMap(
-        PaddedPODArray<size_t> & byte_size,
-        const IColumn::Offsets & array_offsets,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const;
-    template <bool has_collator, bool count_code_points, bool has_nullmap>
+    void countSerializeByteSizeImpl(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator) const;
+
+    template <bool has_collator, bool count_code_points>
     void countSerializeByteSizeForColumnArrayImpl(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const;
+        const TiDB::TiDBCollatorPtr & collator) const;
 
     template <bool has_null, bool has_collator, bool has_nullmap>
     void serializeToPosImplType(
@@ -317,17 +307,14 @@ class ColumnString final : public COWPtrHelper<IColumn, ColumnString>
         return pos + string_size;
     }
 
-    void countSerializeByteSizeForCmp(
-        PaddedPODArray<size_t> & byte_size,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const override;
+    void countSerializeByteSizeForCmp(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+        const override;
     void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override;
 
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const override;
+        const TiDB::TiDBCollatorPtr & collator) const override;
     void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets) const override;
diff --git a/dbms/src/Columns/ColumnTuple.h b/dbms/src/Columns/ColumnTuple.h
index 651a7bfca12..d049fc74ebf 100644
--- a/dbms/src/Columns/ColumnTuple.h
+++ b/dbms/src/Columns/ColumnTuple.h
@@ -95,13 +95,11 @@ class ColumnTuple final : public COWPtrHelper<IColumn, ColumnTuple>
         String &) const override;
     const char * deserializeAndInsertFromArena(const char * pos, const TiDB::TiDBCollatorPtr &) override;
 
-    void countSerializeByteSizeForCmp(
-        PaddedPODArray<size_t> & byte_size,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const override
+    void countSerializeByteSizeForCmp(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr & collator)
+        const override
     {
         for (const auto & column : columns)
-            column->countSerializeByteSizeForCmp(byte_size, collator, nullmap);
+            column->countSerializeByteSizeForCmp(byte_size, collator);
     }
     void countSerializeByteSize(PaddedPODArray<size_t> & byte_size) const override
     {
@@ -112,11 +110,10 @@ class ColumnTuple final : public COWPtrHelper<IColumn, ColumnTuple>
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
-        const TiDB::TiDBCollatorPtr & collator,
-        const NullMap * nullmap) const override
+        const TiDB::TiDBCollatorPtr & collator) const override
     {
         for (const auto & column : columns)
-            column->countSerializeByteSizeForCmpColumnArray(byte_size, array_offsets, collator, nullmap);
+            column->countSerializeByteSizeForCmpColumnArray(byte_size, array_offsets, collator);
     }
     void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & byte_size,
diff --git a/dbms/src/Columns/ColumnVector.h b/dbms/src/Columns/ColumnVector.h
index 344a3d10fbe..307eba1c40c 100644
--- a/dbms/src/Columns/ColumnVector.h
+++ b/dbms/src/Columns/ColumnVector.h
@@ -328,10 +328,7 @@ class ColumnVector final : public COWPtrHelper<ColumnVectorHelper, ColumnVector<
         return pos + sizeof(T);
     }
 
-    void countSerializeByteSizeForCmp(
-        PaddedPODArray<size_t> & byte_size,
-        const TiDB::TiDBCollatorPtr &,
-        const NullMap *) const override
+    void countSerializeByteSizeForCmp(PaddedPODArray<size_t> & byte_size, const TiDB::TiDBCollatorPtr &) const override
     {
         countSerializeByteSize(byte_size);
     }
@@ -340,8 +337,7 @@ class ColumnVector final : public COWPtrHelper<ColumnVectorHelper, ColumnVector<
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & byte_size,
         const IColumn::Offsets & array_offsets,
-        const TiDB::TiDBCollatorPtr &,
-        const NullMap *) const override
+        const TiDB::TiDBCollatorPtr &) const override
     {
         countSerializeByteSizeForColumnArray(byte_size, array_offsets);
     }
diff --git a/dbms/src/Columns/IColumn.h b/dbms/src/Columns/IColumn.h
index e668841edf2..5286e581808 100644
--- a/dbms/src/Columns/IColumn.h
+++ b/dbms/src/Columns/IColumn.h
@@ -259,8 +259,7 @@ class IColumn : public COWPtr<IColumn>
     /// The byte_size.size() must be equal to the column size.
     virtual void countSerializeByteSizeForCmp(
         PaddedPODArray<size_t> & /* byte_size */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const
+        const TiDB::TiDBCollatorPtr & /* collator */) const
         = 0;
     virtual void countSerializeByteSize(PaddedPODArray<size_t> & /* byte_size */) const = 0;
 
@@ -270,8 +269,7 @@ class IColumn : public COWPtr<IColumn>
     virtual void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const Offsets & /* array_offsets */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const
+        const TiDB::TiDBCollatorPtr & /* collator */) const
         = 0;
     virtual void countSerializeByteSizeForColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
diff --git a/dbms/src/Columns/IColumnDummy.h b/dbms/src/Columns/IColumnDummy.h
index 3b0550a9651..250f4bedc14 100644
--- a/dbms/src/Columns/IColumnDummy.h
+++ b/dbms/src/Columns/IColumnDummy.h
@@ -90,8 +90,7 @@ class IColumnDummy : public IColumn
 
     void countSerializeByteSizeForCmp(
         PaddedPODArray<size_t> & /* byte_size */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const override
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
             "Method countSerializeByteSizeForCmp is not supported for " + getName(),
@@ -105,8 +104,7 @@ class IColumnDummy : public IColumn
     void countSerializeByteSizeForCmpColumnArray(
         PaddedPODArray<size_t> & /* byte_size */,
         const IColumn::Offsets & /* array_offsets */,
-        const TiDB::TiDBCollatorPtr & /* collator */,
-        const NullMap * /* nullmap */) const override
+        const TiDB::TiDBCollatorPtr & /* collator */) const override
     {
         throw Exception(
             "Method countSerializeByteSizeForCmpColumnArray is not supported for " + getName(),
diff --git a/dbms/src/Columns/tests/gtest_column_serialize_deserialize.cpp b/dbms/src/Columns/tests/gtest_column_serialize_deserialize.cpp
index d2b0e629aaa..de6f0c5e49d 100644
--- a/dbms/src/Columns/tests/gtest_column_serialize_deserialize.cpp
+++ b/dbms/src/Columns/tests/gtest_column_serialize_deserialize.cpp
@@ -181,9 +181,7 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         }
     }
 
-    static void doTestSerializeAndDeserialize(
-        const ColumnPtr & column_ptr,
-        bool use_nt_align_buffer)
+    static void doTestSerializeAndDeserialize(const ColumnPtr & column_ptr, bool use_nt_align_buffer)
     {
         PaddedPODArray<size_t> byte_size;
         byte_size.resize_fill_zero(column_ptr->size());
@@ -250,9 +248,7 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         ASSERT_COLUMN_EQ(std::move(result_col_ptr), std::move(new_col_ptr));
     }
 
-    static void doTestSerializeAndDeserialize2(
-        const ColumnPtr & column_ptr,
-        bool use_nt_align_buffer)
+    static void doTestSerializeAndDeserialize2(const ColumnPtr & column_ptr, bool use_nt_align_buffer)
     {
         if (column_ptr->size() < 2)
             return;
@@ -293,8 +289,7 @@ class TestColumnSerializeDeserialize : public ::testing::Test
         }
         for (auto * ptr : pos)
             ori_pos.push_back(ptr);
-        column_ptr
-            ->serializeToPos(pos, byte_size.size() / 2 - 1, byte_size.size() - byte_size.size() / 2 + 1, false);
+        column_ptr->serializeToPos(pos, byte_size.size() / 2 - 1, byte_size.size() - byte_size.size() / 2 + 1, false);
         new_col_ptr->deserializeAndInsertFromPos(ori_pos, use_nt_align_buffer);
 
         current_size = 0;
@@ -309,7 +304,7 @@ class TestColumnSerializeDeserialize : public ::testing::Test
             ori_pos.push_back(ptr);
         column_ptr->serializeToPos(pos, 0, byte_size.size(), true);
 
-            new_col_ptr->deserializeAndInsertFromPos(ori_pos, use_nt_align_buffer);
+        new_col_ptr->deserializeAndInsertFromPos(ori_pos, use_nt_align_buffer);
         if (use_nt_align_buffer)
             new_col_ptr->flushNTAlignBuffer();