style: auto-fix clang-format issues

wanpengfei-git · wanpengfei-git · commit d514f60350c6 · 2026-06-16T01:13:04.000Z
diff --git a/be/src/column/binary_column.cpp b/be/src/column/binary_column.cpp
@@ -130,9 +130,10 @@ void BinaryColumnBase<T>::append(const Column& src, size_t offset, size_t count)
 }
 
 template <typename T>
-__attribute__((noinline)) void BinaryColumnBase<T>::_append_selective_general(
-        const BinaryColumnBase<T>& src_column, const uint32_t* indexes, uint32_t size, size_t prev_num_offsets,
-        uint64_t dst_begin) {
+__attribute__((noinline)) void BinaryColumnBase<T>::_append_selective_general(const BinaryColumnBase<T>& src_column,
+                                                                              const uint32_t* indexes, uint32_t size,
+                                                                              size_t prev_num_offsets,
+                                                                              uint64_t dst_begin) {
     auto& bytes = get_bytes();
     const auto& src_offsets = src_column.get_offset();
 
@@ -387,8 +388,8 @@ void BinaryColumnBase<T>::append_value_multiple_times(const Column& src, uint32_
         for (size_t i = 0; i < size; ++i) {
             const uint32_t row_idx = index;
             const uint64_t row_size = src_offset_data[row_idx + 1] - src_offset_data[row_idx];
-            strings::memcpy_inlined(dest_bytes + _offsets[cur_row_count + i],
-                                    src_bytes + src_offset_data[row_idx], row_size);
+            strings::memcpy_inlined(dest_bytes + _offsets[cur_row_count + i], src_bytes + src_offset_data[row_idx],
+                                    row_size);
         }
     });
 
@@ -434,7 +435,6 @@ StatusOr<MutableColumnPtr> BinaryColumnBase<T>::replicate(const Buffer<uint32_t>
                 pos += bytes_size;
                 dst_offset_data[j + 1] = static_cast<DstValue>(pos);
             }
-
         }
     });
 
@@ -850,16 +850,17 @@ void BinaryColumnBase<T>::update_rows(const Column& src, const uint32_t* indexes
             auto& bytes = get_bytes();
             auto* dest_bytes = bytes.data();
             const uint8_t* src_bytes = src_column._data_base();
-            Offsets::visit_storage_pair(dst_offsets_ref, src_offsets_ref, [&](const auto& dst_buf,
-                                                                              const auto& src_buf) {
-                const auto* __restrict dst_offsets = dst_buf.data();
-                const auto* __restrict src_offsets = src_buf.data();
-                for (size_t i = 0; i < replace_num; ++i) {
-                    const size_t src_offset = src_offsets[i];
-                    const size_t str_size = src_offsets[i + 1] - src_offset;
-                    strings::memcpy_inlined(dest_bytes + dst_offsets[indexes[i]], src_bytes + src_offset, str_size);
-                }
-            });
+            Offsets::visit_storage_pair(dst_offsets_ref, src_offsets_ref,
+                                        [&](const auto& dst_buf, const auto& src_buf) {
+                                            const auto* __restrict dst_offsets = dst_buf.data();
+                                            const auto* __restrict src_offsets = src_buf.data();
+                                            for (size_t i = 0; i < replace_num; ++i) {
+                                                const size_t src_offset = src_offsets[i];
+                                                const size_t str_size = src_offsets[i + 1] - src_offset;
+                                                strings::memcpy_inlined(dest_bytes + dst_offsets[indexes[i]],
+                                                                        src_bytes + src_offset, str_size);
+                                            }
+                                        });
             return;
         }
     }
@@ -968,9 +969,9 @@ size_t BinaryColumnBase<T>::filter_range(const Filter& filter, size_t from, size
                 // set offsets, try vectorized
                 for (int i = 0; i < batch_nums; ++i) {
                     // TODO: performance, all sub one same offset ?
-                    offset_data[result_offset + i + 1] =
-                            offset_data[result_offset + i] + offset_data[start_offset + i + 1] -
-                            offset_data[start_offset + i];
+                    offset_data[result_offset + i + 1] = offset_data[result_offset + i] +
+                                                         offset_data[start_offset + i + 1] -
+                                                         offset_data[start_offset + i];
                 }
 
                 result_offset += batch_nums;
@@ -1156,9 +1157,11 @@ void BinaryColumnBase<T>::deserialize_and_append_batch(Buffer<Slice>& srcs, size
 }
 
 template <typename Offset>
-__attribute__((noinline)) static void serialize_binary_batch_nullable_impl(
-        uint8_t* dst, uint32_t* __restrict sizes, size_t chunk_size, uint32_t max_one_row_size,
-        const uint8_t* __restrict null_masks, const uint8_t* __restrict base, const Offset* __restrict offsets_data) {
+__attribute__((noinline)) static void serialize_binary_batch_nullable_impl(uint8_t* dst, uint32_t* __restrict sizes,
+                                                                           size_t chunk_size, uint32_t max_one_row_size,
+                                                                           const uint8_t* __restrict null_masks,
+                                                                           const uint8_t* __restrict base,
+                                                                           const Offset* __restrict offsets_data) {
     uint8_t* row = dst;
     for (size_t i = 0; i < chunk_size; ++i) {
         uint8_t* pos = row + sizes[i];
@@ -1380,9 +1383,8 @@ Status BinaryColumnBase<T>::capacity_limit_reached() const {
                                                                column_name,
                                                                std::to_string(Column::MAX_LARGE_CAPACITY_LIMIT)));
     } else if (_offsets.size() >= Column::MAX_CAPACITY_LIMIT) {
-        return Status::CapacityLimitExceed(strings::Substitute("Total row count of $0 exceed the limit: $1",
-                                                               column_name,
-                                                               std::to_string(Column::MAX_CAPACITY_LIMIT)));
+        return Status::CapacityLimitExceed(strings::Substitute(
+                "Total row count of $0 exceed the limit: $1", column_name, std::to_string(Column::MAX_CAPACITY_LIMIT)));
     }
     return Status::OK();
 }
diff --git a/be/src/column/binary_column.h b/be/src/column/binary_column.h
@@ -255,9 +255,7 @@ class BinaryColumnBase final : public CowFactory<ColumnFactory<Column, BinaryCol
 
     void append_default() override { _offsets.emplace_back(_bytes.size()); }
 
-    void append_default(size_t count) override {
-        _offsets.append_empty_values(count);
-    }
+    void append_default(size_t count) override { _offsets.append_empty_values(count); }
 
     StatusOr<MutableColumnPtr> replicate(const Buffer<uint32_t>& offsets) override;
 
diff --git a/be/src/column/column_hash/column_hash.cpp b/be/src/column/column_hash/column_hash.cpp
@@ -248,8 +248,8 @@ class ColumnHashVisitor final : public ColumnVisitorAdapter<ColumnHashVisitor<Ha
                 auto len = offset_data[idx + 1] - offset_data[idx];
                 // For empty strings, don't modify the hash (hash with 0 bytes preserves the seed)
                 if (len > 0) {
-                    *slot_ptr = HashFunction::hash(bytes.data() + offset_data[idx], static_cast<int32_t>(len),
-                                                   *slot_ptr);
+                    *slot_ptr =
+                            HashFunction::hash(bytes.data() + offset_data[idx], static_cast<int32_t>(len), *slot_ptr);
                 }
             });
         });
diff --git a/be/src/exprs/agg/group_concat.h b/be/src/exprs/agg/group_concat.h
@@ -250,14 +250,14 @@ class GroupConcatAggregateFunction final
                     auto& offsets = dst_column->get_offset();
                     offsets.resize_uninitialized(chunk_size + 1, new_size);
 
-                    Offsets::visit_storage_pair(offsets, column_value->get_offset(),
-                                                [&](auto& offsets_buf, const auto& value_offsets) {
-                        column_sep->get_offset().visit_storage([&](const auto& sep_offsets) {
-                            serialize_column_sep_values(bytes, old_size, chunk_size, offsets_buf, value_offsets,
-                                                        column_value->get_string_begin(), sep_offsets,
-                                                        column_sep->get_string_begin());
-                        });
-                    });
+                    Offsets::visit_storage_pair(
+                            offsets, column_value->get_offset(), [&](auto& offsets_buf, const auto& value_offsets) {
+                                column_sep->get_offset().visit_storage([&](const auto& sep_offsets) {
+                                    serialize_column_sep_values(bytes, old_size, chunk_size, offsets_buf, value_offsets,
+                                                                column_value->get_string_begin(), sep_offsets,
+                                                                column_sep->get_string_begin());
+                                });
+                            });
                     DCHECK_EQ(old_size, new_size);
                 }
             } else {
@@ -271,12 +271,12 @@ class GroupConcatAggregateFunction final
                     auto& offsets = dst_column->get_offset();
                     offsets.resize_uninitialized(chunk_size + 1, new_size);
 
-                    Offsets::visit_storage_pair(offsets, column_value->get_offset(),
-                                                [&](auto& offsets_buf, const auto& value_offsets) {
-                        serialize_const_sep_values(bytes, old_size, chunk_size, offsets_buf, value_offsets,
-                                                   column_value->get_string_begin(), sep.get_data(),
-                                                   static_cast<uint32_t>(sep.size));
-                    });
+                    Offsets::visit_storage_pair(
+                            offsets, column_value->get_offset(), [&](auto& offsets_buf, const auto& value_offsets) {
+                                serialize_const_sep_values(bytes, old_size, chunk_size, offsets_buf, value_offsets,
+                                                           column_value->get_string_begin(), sep.get_data(),
+                                                           static_cast<uint32_t>(sep.size));
+                            });
                     DCHECK_EQ(old_size, new_size);
                 }
             }
@@ -297,11 +297,11 @@ class GroupConcatAggregateFunction final
                 auto& offsets = dst_column->get_offset();
                 offsets.resize_uninitialized(chunk_size + 1, new_size);
 
-                Offsets::visit_storage_pair(offsets, column_value->get_offset(),
-                                            [&](auto& offsets_buf, const auto& value_offsets) {
-                    serialize_const_sep_values(bytes, old_size, chunk_size, offsets_buf, value_offsets,
-                                               column_value->get_string_begin(), sep, size_sep);
-                });
+                Offsets::visit_storage_pair(
+                        offsets, column_value->get_offset(), [&](auto& offsets_buf, const auto& value_offsets) {
+                            serialize_const_sep_values(bytes, old_size, chunk_size, offsets_buf, value_offsets,
+                                                       column_value->get_string_begin(), sep, size_sep);
+                        });
                 DCHECK_EQ(old_size, new_size);
             }
         }
diff --git a/be/src/exprs/cast_expr.cpp b/be/src/exprs/cast_expr.cpp
@@ -1474,13 +1474,13 @@ DEFINE_INT_CAST_TO_STRING(TYPE_BIGINT, TYPE_VARCHAR);
             for (int i = 0; i < size; ++i) {                                                                \
                 r1[i].to_string(dst + off, MAX_LEN);                                                        \
                 off += MAX_LEN;                                                                             \
-                offset.set(i + 1, off);                                                 \
+                offset.set(i + 1, off);                                                                     \
             }                                                                                               \
         } else {                                                                                            \
             for (int i = 0; i < size; ++i) {                                                                \
                 int len = r1[i].to_string(dst + off, MAX_LEN);                                              \
                 if (LIKELY(len > 0)) off += len;                                                            \
-                offset.set(i + 1, off);                                                 \
+                offset.set(i + 1, off);                                                                     \
             }                                                                                               \
         }                                                                                                   \
         bytes.resize(off);                                                                                  \
diff --git a/be/src/exprs/string_functions.cpp b/be/src/exprs/string_functions.cpp
@@ -279,8 +279,8 @@ static inline void ascii_substr(const BinaryColumn* src, Bytes* bytes, Offsets*
         for (size_t i = 0; i < size; ++i) {
             auto s = src->get_slice(i);
             ascii_substr_per_slice<off_is_negative, allow_out_of_left_bound>(
-                    &s, off, len, binary_column_empty_op_fast<DstOffset>,
-                    binary_column_non_empty_op_fast<DstOffset>, bytes, dst_offset_data, i);
+                    &s, off, len, binary_column_empty_op_fast<DstOffset>, binary_column_non_empty_op_fast<DstOffset>,
+                    bytes, dst_offset_data, i);
         }
     });
 }
diff --git a/be/src/formats/parquet/encoding_plain.h b/be/src/formats/parquet/encoding_plain.h
@@ -577,14 +577,15 @@ class FLBAPlainDecoder final : public Decoder {
         offsets.resize_uninitialized(count + prev_offsets, final_offset);
         {
             // fill offset columns
-            offsets.visit_storage([prev_offsets, count, is_nulls, type_length = _type_length, offset](auto& offsets_buf) mutable {
-                using OffsetValue = typename std::decay_t<decltype(offsets_buf)>::value_type;
-                auto* dst_offsets = offsets_buf.data() + prev_offsets;
-                for (size_t i = 0; i < count; ++i) {
-                    offset += is_nulls[i] ? 0 : type_length;
-                    dst_offsets[i] = static_cast<OffsetValue>(offset);
-                }
-            });
+            offsets.visit_storage(
+                    [prev_offsets, count, is_nulls, type_length = _type_length, offset](auto& offsets_buf) mutable {
+                        using OffsetValue = typename std::decay_t<decltype(offsets_buf)>::value_type;
+                        auto* dst_offsets = offsets_buf.data() + prev_offsets;
+                        for (size_t i = 0; i < count; ++i) {
+                            offset += is_nulls[i] ? 0 : type_length;
+                            dst_offsets[i] = static_cast<OffsetValue>(offset);
+                        }
+                    });
         }
         DCHECK_EQ(binary_column->get_bytes().size(), binary_column->get_offset().back());
 
diff --git a/be/src/storage/chunk_helper.cpp b/be/src/storage/chunk_helper.cpp
@@ -385,8 +385,6 @@ bool ChunkPipelineAccumulator::is_finished() const {
     return _finalized && _out_chunk == nullptr && _in_chunk == nullptr;
 }
 
-
-
 CommonExprEvalScopeGuard::CommonExprEvalScopeGuard(const ChunkPtr& chunk,
                                                    const std::map<SlotId, ExprContext*>& common_expr_ctxs)
         : _chunk(chunk), _common_expr_ctxs(common_expr_ctxs) {}
diff --git a/be/src/storage/rowset/binary_plain_page.cpp b/be/src/storage/rowset/binary_plain_page.cpp
@@ -251,8 +251,7 @@ bool BinaryPlainPageDecoder<Type>::append_range(uint32_t idx, uint32_t end, Colu
             }
 
             for (uint32_t i = end - 1; i < end; i++) {
-                const uint64_t current_offset =
-                        begin_offset + static_cast<uint64_t>(offset(i + 1) - page_data_offset);
+                const uint64_t current_offset = begin_offset + static_cast<uint64_t>(offset(i + 1) - page_data_offset);
                 *dst_offsets++ = static_cast<OffsetValue>(current_offset);
             }
         });
diff --git a/be/src/udf/java/java_native_method.cpp b/be/src/udf/java/java_native_method.cpp
@@ -52,9 +52,8 @@ class GetColumnAddrVistor : public ColumnVisitorAdapter<GetColumnAddrVistor> {
             column_offsets.size() > java_max_buffer_size / sizeof(uint32_t)) {
             return Status::NotSupported("Java UDF does not support BinaryColumn with large offsets or bytes");
         }
-        column_offsets.visit_storage([&](const auto& offsets) {
-            _jarr[_idx++] = reinterpret_cast<int64_t>(offsets.data());
-        });
+        column_offsets.visit_storage(
+                [&](const auto& offsets) { _jarr[_idx++] = reinterpret_cast<int64_t>(offsets.data()); });
         _jarr[_idx++] = reinterpret_cast<int64_t>(column.get_immutable_bytes().data());
         return Status::OK();
     }
diff --git a/be/test/udf/java/java_native_method_test.cpp b/be/test/udf/java/java_native_method_test.cpp
@@ -74,9 +74,8 @@ TEST_F(JavaNativeMethodTest, get_addrs_int) {
         const Column* data_column = down_cast<const NullableColumn*>(column.get())->data_column().get();
         const auto* binary_column = down_cast<const BinaryColumn*>(data_column);
         ASSERT_EQ(results[0], (jlong)nullable_column->null_column_data().data());
-        binary_column->get_offset().visit_storage([&](const auto& offsets) {
-            ASSERT_EQ(results[1], (jlong)offsets.data());
-        });
+        binary_column->get_offset().visit_storage(
+                [&](const auto& offsets) { ASSERT_EQ(results[1], (jlong)offsets.data()); });
         ASSERT_EQ(results[2], (jlong)binary_column->get_immutable_bytes().data());
         env->DeleteLocalRef(arr);
     }

Original file line number	Diff line number	Diff line change
`@@ -279,8 +279,8 @@ static inline void ascii_substr(const BinaryColumn* src, Bytes* bytes, Offsets*`
`279`	`279`	`for (size_t i = 0; i < size; ++i) {`
`280`	`280`	`auto s = src->get_slice(i);`
`281`	`281`	`ascii_substr_per_slice<off_is_negative, allow_out_of_left_bound>(`
`282`		`- &s, off, len, binary_column_empty_op_fast<DstOffset>,`
`283`		`- binary_column_non_empty_op_fast<DstOffset>, bytes, dst_offset_data, i);`
	`282`	`+ &s, off, len, binary_column_empty_op_fast<DstOffset>, binary_column_non_empty_op_fast<DstOffset>,`
	`283`	`+ bytes, dst_offset_data, i);`
`284`	`284`	`}`
`285`	`285`	`});`
`286`	`286`	`}`
Original file line number	Diff line number	Diff line change
`@@ -385,8 +385,6 @@ bool ChunkPipelineAccumulator::is_finished() const {`
`385`	`385`	`return _finalized && _out_chunk == nullptr && _in_chunk == nullptr;`
`386`	`386`	`}`
`387`	`387`
`388`		`-`
`389`		`-`
`390`	`388`	`CommonExprEvalScopeGuard::CommonExprEvalScopeGuard(const ChunkPtr& chunk,`
`391`	`389`	`const std::map<SlotId, ExprContext*>& common_expr_ctxs)`
`392`	`390`	`: _chunk(chunk), _common_expr_ctxs(common_expr_ctxs) {}`
Original file line number	Diff line number	Diff line change
`@@ -251,8 +251,7 @@ bool BinaryPlainPageDecoder<Type>::append_range(uint32_t idx, uint32_t end, Colu`
`251`	`251`	`}`
`252`	`252`
`253`	`253`	`for (uint32_t i = end - 1; i < end; i++) {`
`254`		`- const uint64_t current_offset =`
`255`		`- begin_offset + static_cast<uint64_t>(offset(i + 1) - page_data_offset);`
	`254`	`+ const uint64_t current_offset = begin_offset + static_cast<uint64_t>(offset(i + 1) - page_data_offset);`
`256`	`255`	`*dst_offsets++ = static_cast<OffsetValue>(current_offset);`
`257`	`256`	`}`
`258`	`257`	`});`
Original file line number	Diff line number	Diff line change
`@@ -52,9 +52,8 @@ class GetColumnAddrVistor : public ColumnVisitorAdapter<GetColumnAddrVistor> {`
`52`	`52`	`column_offsets.size() > java_max_buffer_size / sizeof(uint32_t)) {`
`53`	`53`	`return Status::NotSupported("Java UDF does not support BinaryColumn with large offsets or bytes");`
`54`	`54`	`}`
`55`		`- column_offsets.visit_storage([&](const auto& offsets) {`
`56`		`- _jarr[_idx++] = reinterpret_cast<int64_t>(offsets.data());`
`57`		`- });`
	`55`	`+ column_offsets.visit_storage(`
	`56`	`+ [&](const auto& offsets) { _jarr[_idx++] = reinterpret_cast<int64_t>(offsets.data()); });`
`58`	`57`	`_jarr[_idx++] = reinterpret_cast<int64_t>(column.get_immutable_bytes().data());`
`59`	`58`	`return Status::OK();`
`60`	`59`	`}`