branch-4.0: [Improvement](function) optimize trivial function deserialize_and_merge_vec #58882 (#59439)

github-actions[bot] · BiteTheDDDDt · web-flow · commit ef65dcedb4e8 · 2026-01-05T17:05:10.000+08:00
Cherry-picked from #58882 --------- Co-authored-by: Pxl <xl@selectdb.com>
diff --git a/be/src/vec/aggregate_functions/aggregate_function.h b/be/src/vec/aggregate_functions/aggregate_function.h
@@ -27,13 +27,11 @@
 #include "common/status.h"
 #include "util/defer_op.h"
 #include "vec/columns/column_complex.h"
+#include "vec/columns/column_fixed_length_object.h"
 #include "vec/columns/column_string.h"
 #include "vec/common/assert_cast.h"
 #include "vec/common/hash_table/phmap_fwd_decl.h"
 #include "vec/common/string_buffer.hpp"
-#include "vec/core/block.h"
-#include "vec/core/column_numbers.h"
-#include "vec/core/field.h"
 #include "vec/core/types.h"
 #include "vec/data_types/data_type_nullable.h"
 #include "vec/data_types/data_type_string.h"
@@ -110,7 +108,7 @@ class IAggregateFunction {
     virtual void reset(AggregateDataPtr place) const = 0;
 
     /// It is not necessary to delete data.
-    virtual bool has_trivial_destructor() const = 0;
+    virtual bool is_trivial() const = 0;
 
     /// Get `sizeof` of structure with data.
     virtual size_t size_of_data() const = 0;
@@ -641,7 +639,7 @@ class IAggregateFunctionDataHelper : public IAggregateFunctionHelper<Derived> {
 
     void destroy(AggregateDataPtr __restrict place) const noexcept override { data(place).~Data(); }
 
-    bool has_trivial_destructor() const override { return std::is_trivially_destructible_v<Data>; }
+    bool is_trivial() const override { return false; }
 
     size_t size_of_data() const override { return sizeof(Data); }
 
diff --git a/be/src/vec/aggregate_functions/aggregate_function_avg.h b/be/src/vec/aggregate_functions/aggregate_function_avg.h
@@ -147,6 +147,8 @@ class AggregateFunctionAvg<T, TResult, Data> final
         }
     }
 
+    bool is_trivial() const override { return true; }
+
     template <bool is_add>
     NO_SANITIZE_UNDEFINED void update_value(AggregateDataPtr __restrict place,
                                             const IColumn** columns, ssize_t row_num) const {
@@ -271,15 +273,13 @@ class AggregateFunctionAvg<T, TResult, Data> final
                                    AggregateDataPtr rhs, const IColumn* column, Arena& arena,
                                    const size_t num_rows) const override {
         this->deserialize_from_column(rhs, *column, arena, num_rows);
-        DEFER({ this->destroy_vec(rhs, num_rows); });
         this->merge_vec(places, offset, rhs, arena, num_rows);
     }
 
     void deserialize_and_merge_vec_selected(const AggregateDataPtr* places, size_t offset,
                                             AggregateDataPtr rhs, const IColumn* column,
                                             Arena& arena, const size_t num_rows) const override {
         this->deserialize_from_column(rhs, *column, arena, num_rows);
-        DEFER({ this->destroy_vec(rhs, num_rows); });
         this->merge_vec_selected(places, offset, rhs, arena, num_rows);
     }
 
diff --git a/be/src/vec/aggregate_functions/aggregate_function_foreach.h b/be/src/vec/aggregate_functions/aggregate_function_foreach.h
@@ -158,8 +158,8 @@ class AggregateFunctionForEach : public IAggregateFunctionDataHelper<AggregateFu
         }
     }
 
-    bool has_trivial_destructor() const override {
-        return std::is_trivially_destructible_v<Data> && nested_function->has_trivial_destructor();
+    bool is_trivial() const override {
+        return std::is_trivial_v<Data> && nested_function->is_trivial();
     }
 
     void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
diff --git a/be/src/vec/aggregate_functions/aggregate_function_null.h b/be/src/vec/aggregate_functions/aggregate_function_null.h
@@ -23,13 +23,16 @@
 #include <glog/logging.h>
 
 #include <array>
+#include <memory>
 
+#include "common/exception.h"
 #include "common/logging.h"
 #include "common/status.h"
 #include "vec/aggregate_functions/aggregate_function.h"
 #include "vec/aggregate_functions/aggregate_function_distinct.h"
 #include "vec/columns/column_nullable.h"
 #include "vec/common/assert_cast.h"
+#include "vec/common/string_buffer.hpp"
 #include "vec/core/types.h"
 #include "vec/data_types/data_type_nullable.h"
 
@@ -161,9 +164,7 @@ class AggregateFunctionNullBaseInline : public IAggregateFunctionHelper<Derived>
         nested_function->reset(nested_place(place));
     }
 
-    bool has_trivial_destructor() const override {
-        return nested_function->has_trivial_destructor();
-    }
+    bool is_trivial() const override { return false; }
 
     size_t size_of_data() const override { return prefix_size + nested_function->size_of_data(); }
 
@@ -177,11 +178,10 @@ class AggregateFunctionNullBaseInline : public IAggregateFunctionHelper<Derived>
 
     void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,
                Arena& arena) const override {
-        if (result_is_nullable && get_flag(rhs)) {
+        if (get_flag(rhs)) {
             set_flag(place);
+            nested_function->merge(nested_place(place), nested_place(rhs), arena);
         }
-
-        nested_function->merge(nested_place(place), nested_place(rhs), arena);
     }
 
     void serialize(ConstAggregateDataPtr __restrict place, BufferWritable& buf) const override {
@@ -206,6 +206,83 @@ class AggregateFunctionNullBaseInline : public IAggregateFunctionHelper<Derived>
         }
     }
 
+    void deserialize_and_merge_vec(const AggregateDataPtr* places, size_t offset,
+                                   AggregateDataPtr rhs, const IColumn* column, Arena& arena,
+                                   const size_t num_rows) const override {
+        if (nested_function->is_trivial()) {
+            BufferReadable buf({column->get_data_at(0).data, 0});
+            size_t size_of_data = this->size_of_data();
+            if constexpr (result_is_nullable) {
+                for (int i = 0; i != num_rows; ++i) {
+                    buf.read_binary(*(bool*)(rhs + size_of_data * i));
+                    if (get_flag(rhs + size_of_data * i)) {
+                        nested_function->deserialize(nested_place(rhs + size_of_data * i), buf,
+                                                     arena);
+                    }
+                }
+                for (size_t i = 0; i != num_rows; ++i) {
+                    if (get_flag(rhs + size_of_data * i)) {
+                        set_flag(places[i] + offset);
+                        nested_function->merge(nested_place(places[i] + offset),
+                                               nested_place(rhs + size_of_data * i), arena);
+                    }
+                }
+            } else {
+                for (size_t i = 0; i != num_rows; ++i) {
+                    nested_function->deserialize(rhs + size_of_data * i, buf, arena);
+                }
+                for (size_t i = 0; i != num_rows; ++i) {
+                    nested_function->merge(places[i] + offset, rhs + size_of_data * i, arena);
+                }
+            }
+        } else {
+            IAggregateFunctionHelper<Derived>::deserialize_and_merge_vec(places, offset, rhs,
+                                                                         column, arena, num_rows);
+        }
+    }
+
+    void deserialize_and_merge_vec_selected(const AggregateDataPtr* places, size_t offset,
+                                            AggregateDataPtr rhs, const IColumn* column,
+                                            Arena& arena, const size_t num_rows) const override {
+        if (nested_function->is_trivial()) {
+            BufferReadable buf({column->get_data_at(0).data, 0});
+            size_t size_of_data = this->size_of_data();
+            if constexpr (result_is_nullable) {
+                for (int i = 0; i != num_rows; ++i) {
+                    if (!places[i]) {
+                        continue;
+                    }
+                    buf.read_binary(*(bool*)(rhs + size_of_data * i));
+                    if (get_flag(rhs + size_of_data * i)) {
+                        nested_function->deserialize(nested_place(rhs + size_of_data * i), buf,
+                                                     arena);
+                    }
+                }
+                for (size_t i = 0; i != num_rows; ++i) {
+                    if (places[i] && get_flag(rhs + size_of_data * i)) {
+                        set_flag(places[i] + offset);
+                        nested_function->merge(nested_place(places[i] + offset),
+                                               nested_place(rhs + size_of_data * i), arena);
+                    }
+                }
+            } else {
+                for (size_t i = 0; i != num_rows; ++i) {
+                    if (places[i]) {
+                        nested_function->deserialize(rhs + size_of_data * i, buf, arena);
+                    }
+                }
+                for (size_t i = 0; i != num_rows; ++i) {
+                    if (places[i]) {
+                        nested_function->merge(places[i] + offset, rhs + size_of_data * i, arena);
+                    }
+                }
+            }
+        } else {
+            IAggregateFunctionHelper<Derived>::deserialize_and_merge_vec_selected(
+                    places, offset, rhs, column, arena, num_rows);
+        }
+    }
+
     void deserialize_and_merge(AggregateDataPtr __restrict place, AggregateDataPtr __restrict rhs,
                                BufferReadable& buf, Arena& arena) const override {
         bool flag = true;
diff --git a/be/src/vec/aggregate_functions/aggregate_function_state_union.h b/be/src/vec/aggregate_functions/aggregate_function_state_union.h
@@ -101,7 +101,7 @@ class AggregateStateUnion : public IAggregateFunctionHelper<AggregateStateUnion>
         _function->destroy(place);
     }
 
-    bool has_trivial_destructor() const override { return _function->has_trivial_destructor(); }
+    bool is_trivial() const override { return false; }
 
     size_t size_of_data() const override { return _function->size_of_data(); }
 
diff --git a/be/src/vec/aggregate_functions/aggregate_function_sum.h b/be/src/vec/aggregate_functions/aggregate_function_sum.h
@@ -102,6 +102,8 @@ class AggregateFunctionSum<T, TResult, Data> final
         }
     }
 
+    bool is_trivial() const override { return true; }
+
     void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,
              Arena&) const override {
         const auto& column =
@@ -192,15 +194,13 @@ class AggregateFunctionSum<T, TResult, Data> final
                                    AggregateDataPtr rhs, const IColumn* column, Arena& arena,
                                    const size_t num_rows) const override {
         this->deserialize_from_column(rhs, *column, arena, num_rows);
-        DEFER({ this->destroy_vec(rhs, num_rows); });
         this->merge_vec(places, offset, rhs, arena, num_rows);
     }
 
     void deserialize_and_merge_vec_selected(const AggregateDataPtr* places, size_t offset,
                                             AggregateDataPtr rhs, const IColumn* column,
                                             Arena& arena, const size_t num_rows) const override {
         this->deserialize_from_column(rhs, *column, arena, num_rows);
-        DEFER({ this->destroy_vec(rhs, num_rows); });
         this->merge_vec_selected(places, offset, rhs, arena, num_rows);
     }
 
diff --git a/be/src/vec/common/string_buffer.hpp b/be/src/vec/common/string_buffer.hpp
@@ -256,7 +256,8 @@ class BufferReadable {
     template <typename Type>
     void read_binary(Type& x) {
         static_assert(std::is_standard_layout_v<Type>);
-        read(reinterpret_cast<char*>(&x), sizeof(x));
+        memcpy_fixed<Type>(reinterpret_cast<char*>(&x), _data);
+        _data += sizeof(x);
     }
 
     template <typename Type>
diff --git a/be/src/vec/exec/format/table/paimon_jni_reader.cpp b/be/src/vec/exec/format/table/paimon_jni_reader.cpp
@@ -22,6 +22,7 @@
 #include "runtime/descriptors.h"
 #include "runtime/runtime_state.h"
 #include "runtime/types.h"
+#include "vec/core/block.h"
 #include "vec/core/types.h"
 namespace doris {
 class RuntimeProfile;
diff --git a/be/test/vec/olap/jsonb_value_test.cpp b/be/test/vec/olap/jsonb_value_test.cpp
@@ -23,6 +23,7 @@
 #include "gtest/gtest_pred_impl.h"
 #include "vec/columns/column_string.h"
 #include "vec/common/string_ref.h"
+#include "vec/core/block.h"
 #include "vec/core/columns_with_type_and_name.h"
 #include "vec/data_types/serde/data_type_serde.h"
 #include "vec/olap/olap_data_convertor.h"

Original file line number	Diff line number	Diff line change
`@@ -147,6 +147,8 @@ class AggregateFunctionAvg<T, TResult, Data> final`
`147`	`147`	`}`
`148`	`148`	`}`
`149`	`149`
	`150`	`+ bool is_trivial() const override { return true; }`
	`151`	`+`
`150`	`152`	`template <bool is_add>`
`151`	`153`	`NO_SANITIZE_UNDEFINED void update_value(AggregateDataPtr __restrict place,`
`152`	`154`	`const IColumn** columns, ssize_t row_num) const {`
`@@ -271,15 +273,13 @@ class AggregateFunctionAvg<T, TResult, Data> final`
`271`	`273`	`AggregateDataPtr rhs, const IColumn* column, Arena& arena,`
`272`	`274`	`const size_t num_rows) const override {`
`273`	`275`	`this->deserialize_from_column(rhs, *column, arena, num_rows);`
`274`		`- DEFER({ this->destroy_vec(rhs, num_rows); });`
`275`	`276`	`this->merge_vec(places, offset, rhs, arena, num_rows);`
`276`	`277`	`}`
`277`	`278`
`278`	`279`	`void deserialize_and_merge_vec_selected(const AggregateDataPtr* places, size_t offset,`
`279`	`280`	`AggregateDataPtr rhs, const IColumn* column,`
`280`	`281`	`Arena& arena, const size_t num_rows) const override {`
`281`	`282`	`this->deserialize_from_column(rhs, *column, arena, num_rows);`
`282`		`- DEFER({ this->destroy_vec(rhs, num_rows); });`
`283`	`283`	`this->merge_vec_selected(places, offset, rhs, arena, num_rows);`
`284`	`284`	`}`
`285`	`285`
Original file line number	Diff line number	Diff line change
`@@ -158,8 +158,8 @@ class AggregateFunctionForEach : public IAggregateFunctionDataHelper<AggregateFu`
`158`	`158`	`}`
`159`	`159`	`}`
`160`	`160`
`161`		`- bool has_trivial_destructor() const override {`
`162`		`- return std::is_trivially_destructible_v<Data> && nested_function->has_trivial_destructor();`
	`161`	`+ bool is_trivial() const override {`
	`162`	`+ return std::is_trivial_v<Data> && nested_function->is_trivial();`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs,`
Original file line number	Diff line number	Diff line change
`@@ -101,7 +101,7 @@ class AggregateStateUnion : public IAggregateFunctionHelper<AggregateStateUnion>`
`101`	`101`	`_function->destroy(place);`
`102`	`102`	`}`
`103`	`103`
`104`		`- bool has_trivial_destructor() const override { return _function->has_trivial_destructor(); }`
	`104`	`+ bool is_trivial() const override { return false; }`
`105`	`105`
`106`	`106`	`size_t size_of_data() const override { return _function->size_of_data(); }`
`107`	`107`
Original file line number	Diff line number	Diff line change
`@@ -102,6 +102,8 @@ class AggregateFunctionSum<T, TResult, Data> final`
`102`	`102`	`}`
`103`	`103`	`}`
`104`	`104`
	`105`	`+ bool is_trivial() const override { return true; }`
	`106`	`+`
`105`	`107`	`void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num,`
`106`	`108`	`Arena&) const override {`
`107`	`109`	`const auto& column =`
`@@ -192,15 +194,13 @@ class AggregateFunctionSum<T, TResult, Data> final`
`192`	`194`	`AggregateDataPtr rhs, const IColumn* column, Arena& arena,`
`193`	`195`	`const size_t num_rows) const override {`
`194`	`196`	`this->deserialize_from_column(rhs, *column, arena, num_rows);`
`195`		`- DEFER({ this->destroy_vec(rhs, num_rows); });`
`196`	`197`	`this->merge_vec(places, offset, rhs, arena, num_rows);`
`197`	`198`	`}`
`198`	`199`
`199`	`200`	`void deserialize_and_merge_vec_selected(const AggregateDataPtr* places, size_t offset,`
`200`	`201`	`AggregateDataPtr rhs, const IColumn* column,`
`201`	`202`	`Arena& arena, const size_t num_rows) const override {`
`202`	`203`	`this->deserialize_from_column(rhs, *column, arena, num_rows);`
`203`		`- DEFER({ this->destroy_vec(rhs, num_rows); });`
`204`	`204`	`this->merge_vec_selected(places, offset, rhs, arena, num_rows);`
`205`	`205`	`}`
`206`	`206`
Original file line number	Diff line number	Diff line change
`@@ -256,7 +256,8 @@ class BufferReadable {`
`256`	`256`	`template <typename Type>`
`257`	`257`	`void read_binary(Type& x) {`
`258`	`258`	`static_assert(std::is_standard_layout_v<Type>);`
`259`		`- read(reinterpret_cast<char*>(&x), sizeof(x));`
	`259`	`+ memcpy_fixed<Type>(reinterpret_cast<char*>(&x), _data);`
	`260`	`+ _data += sizeof(x);`
`260`	`261`	`}`
`261`	`262`
`262`	`263`	`template <typename Type>`