style: auto-fix clang-format issues

Author: wanpengfei-git

be/src/connector/deletion_vector/deletion_vector.h

@@ -27,8 +27,7 @@ struct DeletionVectorBuildStats {
 class DeletionVector {
 public:
     DeletionVector(const HdfsScannerContext& ctx)
-            : _deletion_vector_descriptor(ctx.table_specific.deletion_vector_descriptor),
-              _ctx(ctx) {}
+            : _deletion_vector_descriptor(ctx.table_specific.deletion_vector_descriptor), _ctx(ctx) {}
 
     Status fill_row_indexes(const SkipRowsContextPtr& skip_rows_ctx);
     Status deserialized_inline_dv(std::string& encoded_bitmap_data, const SkipRowsContextPtr& skip_rows_ctx);

be/src/connector/hive_connector.cpp

@@ -152,14 +152,14 @@ Status HiveDataSource::open(RuntimeState* state) {
         if (enable_cache_select) {
             // set datacache options for cache select
             _scanner_ctx.datacache_options = DataCacheOptions{.enable_datacache = true,
-                                                                 .enable_cache_select = true,
-                                                                 .enable_populate_datacache = true,
-                                                                 .enable_datacache_async_populate_mode = false,
-                                                                 .enable_datacache_io_adaptor = false,
-                                                                 .modification_time = _scan_range.modification_time,
-                                                                 .datacache_evict_probability = 100,
-                                                                 .datacache_priority = datacache_priority,
-                                                                 .datacache_ttl_seconds = datacache_ttl_seconds};
+                                                              .enable_cache_select = true,
+                                                              .enable_populate_datacache = true,
+                                                              .enable_datacache_async_populate_mode = false,
+                                                              .enable_datacache_io_adaptor = false,
+                                                              .modification_time = _scan_range.modification_time,
+                                                              .datacache_evict_probability = 100,
+                                                              .datacache_priority = datacache_priority,
+                                                              .datacache_ttl_seconds = datacache_ttl_seconds};
         } else if (state->query_options().__isset.enable_scan_datacache &&
                    state->query_options().enable_scan_datacache) {
             // set datacache options for normal query
@@ -220,8 +220,7 @@ Status HiveDataSource::open(RuntimeState* state) {
 #endif
 
     if (state->query_options().__isset.enable_dynamic_prune_scan_range) {
-        _scanner_ctx.options.enable_dynamic_prune_scan_range =
-                state->query_options().enable_dynamic_prune_scan_range;
+        _scanner_ctx.options.enable_dynamic_prune_scan_range = state->query_options().enable_dynamic_prune_scan_range;
     }
     if (state->query_options().__isset.enable_connector_split_io_tasks) {
         _scanner_ctx.options.enable_split_tasks = state->query_options().enable_connector_split_io_tasks;
@@ -644,8 +643,7 @@ void HiveDataSource::_init_counter(RuntimeState* state) {
                 ADD_CHILD_COUNTER(_runtime_profile, "DataCacheWriteCounter", TUnit::UNIT, prefix);
         _scanner_ctx.profile.datacache_write_bytes =
                 ADD_CHILD_COUNTER(_runtime_profile, "DataCacheWriteBytes", TUnit::BYTES, prefix);
-        _scanner_ctx.profile.datacache_write_timer =
-                ADD_CHILD_TIMER(_runtime_profile, "DataCacheWriteTimer", prefix);
+        _scanner_ctx.profile.datacache_write_timer = ADD_CHILD_TIMER(_runtime_profile, "DataCacheWriteTimer", prefix);
         _scanner_ctx.profile.datacache_write_fail_counter =
                 ADD_CHILD_COUNTER(_runtime_profile, "DataCacheWriteFailCounter", TUnit::UNIT, prefix);
         _scanner_ctx.profile.datacache_write_fail_bytes =
@@ -666,8 +664,7 @@ void HiveDataSource::_init_counter(RuntimeState* state) {
         _scanner_ctx.profile.app_io_bytes_read_counter =
                 ADD_CHILD_COUNTER(_runtime_profile, "AppIOBytesRead", TUnit::BYTES, prefix);
         _scanner_ctx.profile.app_io_timer = ADD_CHILD_TIMER(_runtime_profile, "AppIOTime", prefix);
-        _scanner_ctx.profile.app_io_counter =
-                ADD_CHILD_COUNTER(_runtime_profile, "AppIOCounter", TUnit::UNIT, prefix);
+        _scanner_ctx.profile.app_io_counter = ADD_CHILD_COUNTER(_runtime_profile, "AppIOCounter", TUnit::UNIT, prefix);
         _scanner_ctx.profile.fs_bytes_read_counter =
                 ADD_CHILD_COUNTER(_runtime_profile, "FSIOBytesRead", TUnit::BYTES, prefix);
         _scanner_ctx.profile.fs_io_counter = ADD_CHILD_COUNTER(_runtime_profile, "FSIOCounter", TUnit::UNIT, prefix);

be/src/exec/hdfs_scanner/cache_select_scanner.cpp

@@ -95,8 +95,8 @@ Status CacheSelectScanner::_fetch_orc() {
     // resolve columns
     {
         std::unordered_set<std::string> known_column_names;
-        OrcChunkReader::build_column_name_set(&known_column_names, _scanner_ctx.hive_column_names,
-                                              reader->getType(), _scanner_ctx.options.case_sensitive,
+        OrcChunkReader::build_column_name_set(&known_column_names, _scanner_ctx.hive_column_names, reader->getType(),
+                                              _scanner_ctx.options.case_sensitive,
                                               _scanner_ctx.options.orc_use_column_names);
         RETURN_IF_ERROR(_scanner_ctx.update_materialized_columns(known_column_names));
         ASSIGN_OR_RETURN(auto skip, _scanner_ctx.should_skip_by_evaluating_not_existed_slots());

be/src/exec/hdfs_scanner/hdfs_scanner.cpp

@@ -137,8 +137,7 @@ Status HdfsScanner::_build_scanner_context() {
     // ObjectPool, made available via ctx.partition_expr_ctxs.
     for (size_t i = 0; i < _scanner_ctx.partition_slots.size(); i++) {
         int part_col_idx = _scanner_ctx._partition_index_in_hdfs_partition_columns[i];
-        ASSIGN_OR_RETURN(auto partition_value_column,
-                         ctx.partition_expr_ctxs[part_col_idx]->evaluate(nullptr));
+        ASSIGN_OR_RETURN(auto partition_value_column, ctx.partition_expr_ctxs[part_col_idx]->evaluate(nullptr));
         DCHECK(partition_value_column->is_constant());
         partition_values.emplace_back(std::move(partition_value_column));
     }
@@ -147,8 +146,7 @@ Status HdfsScanner::_build_scanner_context() {
     Columns& extended_values = ctx.extended_values;
     for (size_t i = 0; i < _scanner_ctx.extended_col_slots.size(); i++) {
         int extended_col_idx = _scanner_ctx.index_in_extended_columns[i];
-        ASSIGN_OR_RETURN(auto extended_value_column,
-                         ctx.extended_col_expr_ctxs[extended_col_idx]->evaluate(nullptr));
+        ASSIGN_OR_RETURN(auto extended_value_column, ctx.extended_col_expr_ctxs[extended_col_idx]->evaluate(nullptr));
         DCHECK(extended_value_column->is_constant());
         extended_values.emplace_back(std::move(extended_value_column));
     }
@@ -211,8 +209,7 @@ Status HdfsScanner::_build_scanner_context() {
     auto* s = ctx.obj_pool->add(new HdfsScannerPredicateState());
     s->conjuncts_manager = std::make_unique<ScanConjunctsManager>(opts);
     RETURN_IF_ERROR(s->conjuncts_manager->parse_conjuncts());
-    s->predicate_parser =
-            std::make_unique<ConnectorPredicateParser>(&_scanner_ctx.tuple_desc->decoded_slots());
+    s->predicate_parser = std::make_unique<ConnectorPredicateParser>(&_scanner_ctx.tuple_desc->decoded_slots());
     ASSIGN_OR_RETURN(s->predicate_tree,
                      s->conjuncts_manager->get_predicate_tree(s->predicate_parser.get(), s->predicate_free_pool));
     s->runtime_filter_scan_range_pruner = std::make_unique<RuntimeScanRangePruner>(

be/src/exec/hdfs_scanner/hdfs_scanner.h

@@ -25,16 +25,16 @@
 #include "connector/deletion_vector/deletion_bitmap.h"
 #include "exec/olap_scan_prepare.h"
 #include "exec/pipeline/scan/morsel.h"
-#include "storage/column_predicate.h"
-#include "storage/predicate_parser.h"
-#include "storage/predicate_tree/predicate_tree.h"
 #include "exec/pipeline/scan/scan_morsel.h"
 #include "exec/runtime_filter/runtime_filter_probe.h"
 #include "exprs/expr.h"
 #include "exprs/expr_context.h"
 #include "fs/fs.h"
 #include "runtime/descriptors.h"
 #include "runtime/runtime_state_fwd.h"
+#include "storage/column_predicate.h"
+#include "storage/predicate_parser.h"
+#include "storage/predicate_tree/predicate_tree.h"
 
 namespace starrocks {
 
@@ -458,7 +458,6 @@ struct HdfsScannerContext {
     Status evaluate_on_conjunct_ctxs_by_slot(ChunkPtr* chunk, Filter* filter);
 
     void merge_split_tasks();
-
 };
 
 struct OpenFileOptions {

be/src/exec/hdfs_scanner/hdfs_scanner_orc.cpp

@@ -87,8 +87,7 @@ void OrcRowReaderFilter::setWriterTimezone(const std::string& tz) {
 OrcRowReaderFilter::OrcRowReaderFilter(const HdfsScannerContext& scanner_ctx, OrcChunkReader* reader)
         : _scanner_ctx(scanner_ctx), _reader(reader), _writer_tzoffset_in_seconds(reader->tzoffset_in_seconds()) {
     if (_scanner_ctx.min_max_tuple_desc != nullptr) {
-        VLOG_FILE << "OrcRowReaderFilter: min_max_tuple_desc = "
-                  << _scanner_ctx.min_max_tuple_desc->debug_string();
+        VLOG_FILE << "OrcRowReaderFilter: min_max_tuple_desc = " << _scanner_ctx.min_max_tuple_desc->debug_string();
         for (ExprContext* ctx : _scanner_ctx.conjuncts.min_max_ctxs) {
             VLOG_FILE << "OrcRowReaderFilter: min_max_ctx = " << ctx->root()->debug_string();
         }
@@ -402,8 +401,8 @@ Status HdfsOrcScanner::build_io_ranges(ORCHdfsFileStream* file_stream, const std
 
 Status HdfsOrcScanner::resolve_columns(orc::Reader* reader) {
     std::unordered_set<std::string> known_column_names;
-    OrcChunkReader::build_column_name_set(&known_column_names, _scanner_ctx.hive_column_names,
-                                          reader->getType(), _scanner_ctx.options.case_sensitive,
+    OrcChunkReader::build_column_name_set(&known_column_names, _scanner_ctx.hive_column_names, reader->getType(),
+                                          _scanner_ctx.options.case_sensitive,
                                           _scanner_ctx.options.orc_use_column_names);
     RETURN_IF_ERROR(_scanner_ctx.update_materialized_columns(known_column_names));
     ASSIGN_OR_RETURN(auto skip, _scanner_ctx.should_skip_by_evaluating_not_existed_slots());
@@ -448,8 +447,8 @@ Status HdfsOrcScanner::resolve_columns(orc::Reader* reader) {
 Status HdfsOrcScanner::build_split_tasks(orc::Reader* reader, const std::vector<DiskRange>& stripes) {
     // we can split task if we enable split tasks feature and have >= 2 stripes.
     // but if we have splitted tasks before, we don't want to split again, to avoid infinite loop.
-    bool enable_split_tasks = (_scanner_ctx.options.enable_split_tasks && stripes.size() >= 2) &&
-                              (_scanner_ctx.split_context == nullptr);
+    bool enable_split_tasks =
+            (_scanner_ctx.options.enable_split_tasks && stripes.size() >= 2) && (_scanner_ctx.split_context == nullptr);
     if (!enable_split_tasks) return Status::OK();
 
     auto footer = std::make_shared<std::string>(reader->getSerializedFileTail());

be/src/exec/hdfs_scanner/hdfs_scanner_parquet.cpp

@@ -258,8 +258,8 @@ Status HdfsParquetScanner::do_open(RuntimeState* runtime_state) {
     RETURN_IF_ERROR(open_random_access_file());
     // create file reader
     _reader = std::make_shared<parquet::FileReader>(runtime_state->chunk_size(), _file.get(), _file->get_size().value(),
-                                                    _scanner_ctx.datacache_options,
-                                                    _shared_buffered_input_stream.get(), _skip_rows_ctx);
+                                                    _scanner_ctx.datacache_options, _shared_buffered_input_stream.get(),
+                                                    _skip_rows_ctx);
     SCOPED_RAW_TIMER(&_app_stats.reader_init_ns);
     RETURN_IF_ERROR(_reader->init(&_scanner_ctx));
     return Status::OK();

be/src/formats/parquet/group_reader.cpp

@@ -515,8 +515,8 @@ StatusOr<ColumnReaderPtr> GroupReader::_create_column_reader(const GroupReaderPa
             schema_node->type == ColumnType::STRUCT) {
             // Physical VARIANT columns use _get_variant_shredded_hints; this path
             // is for non-virtual VARIANT columns that appear directly in the SELECT list.
-            VariantShreddedReadHints hints = build_variant_shredded_hints(
-                    _param.scanner_ctx->column_access_paths, column.slot_desc->col_name());
+            VariantShreddedReadHints hints =
+                    build_variant_shredded_hints(_param.scanner_ctx->column_access_paths, column.slot_desc->col_name());
             ASSIGN_OR_RETURN(column_reader, ColumnReaderFactory::create_variant_column_reader(_column_reader_opts,
                                                                                               schema_node, hints));
         } else if (column.t_lake_schema_field == nullptr) {

be/test/exec/hdfs_scanner/hdfs_scanner_test.cpp

@@ -119,7 +119,7 @@ THdfsScanRange* HdfsScannerTest::_create_scan_range(const std::string& file, uin
 }
 
 HdfsScannerContext* HdfsScannerTest::_create_param(const std::string& file, THdfsScanRange* range,
-                                                  TupleDescriptor* tuple_desc) {
+                                                   TupleDescriptor* tuple_desc) {
     auto* param = _pool.add(new HdfsScannerContext());
     auto* lazy_column_coalesce_counter = _pool.add(new std::atomic<int32_t>(0));
     param->fs = FileSystem::Default();
@@ -485,7 +485,7 @@ static ExprContext* create_expr_context(ObjectPool* pool, const std::vector<TExp
 }
 
 static void extend_partition_values(ObjectPool* pool, HdfsScannerContext* params, std::vector<ExprContext*>* part_ctxs,
-                                     const std::vector<int64_t>& values) {
+                                    const std::vector<int64_t>& values) {
     std::vector<int> positions;
     for (int i = 0; i < values.size(); i++) {
         int64_t v = values[i];