diff --git a/be/benchmark/benchmark_column_view.hpp b/be/benchmark/benchmark_column_view.hpp index 02ce3294b5b46a..891a4340081f4d 100644 --- a/be/benchmark/benchmark_column_view.hpp +++ b/be/benchmark/benchmark_column_view.hpp @@ -61,7 +61,7 @@ static ColumnPtr make_const_column() { } static ColumnPtr make_nullable_column() { - return ColumnNullable::create(make_plain_column()->assume_mutable(), + return ColumnNullable::create(make_plain_column()->assert_mutable(), ColumnUInt8::create(NUM_ROWS, 0)); } diff --git a/be/src/core/AGENTS.md b/be/src/core/AGENTS.md index 8578a7e1ff3e30..b31c1afad0dd73 100644 --- a/be/src/core/AGENTS.md +++ b/be/src/core/AGENTS.md @@ -15,8 +15,8 @@ Vectorized columns (`IColumn`) use intrusive-reference-counted copy-on-write. ### Checkpoints - [ ] Exclusive ownership guaranteed before `mutate()` on hot paths? Shared ownership triggers deep copy -- [ ] `assume_mutable_ref()` used only when exclusive ownership is already guaranteed? -- [ ] After `Block::mutate_columns()`, columns put back with `set_columns()`? +- [ ] `assert_mutable()` used only when exclusive ownership is already guaranteed? +- [ ] If you need to modify the data within a `Block`, have you correctly used `ScopedMutableBlock`? - [ ] `convert_to_full_column_if_const()` materializes only `ColumnConst`; ordinary columns may return shared storage? ## Type System and Serialization diff --git a/be/src/core/block/block.cpp b/be/src/core/block/block.cpp index 99c8ece8b512e1..c556eb3242c57d 100644 --- a/be/src/core/block/block.cpp +++ b/be/src/core/block/block.cpp @@ -816,7 +816,7 @@ void Block::clear_column_data(int64_t column_size) { for (auto& d : data) { if (d.column) { if (d.column->is_exclusive()) { - d.column->assume_mutable()->clear(); + d.column->assert_mutable()->clear(); } else { d.column = d.column->clone_empty(); } @@ -831,7 +831,7 @@ void Block::clear_column_data(const std::vector& columns_to_clear) { auto& column = data[col].column; if (column) { if (column->is_exclusive()) { - column->assume_mutable()->clear(); + column->assert_mutable()->clear(); } else { column = column->clone_empty(); } @@ -894,7 +894,7 @@ void Block::filter_block_internal(Block* block, const std::vector& col } if (count == 0) { if (column->is_exclusive()) { - column->assume_mutable()->clear(); + column->assert_mutable()->clear(); } else { column = column->clone_empty(); } @@ -902,7 +902,7 @@ void Block::filter_block_internal(Block* block, const std::vector& col } if (column->is_exclusive()) { // COW: safe to mutate in-place since we have exclusive ownership - const auto result_size = column->assume_mutable()->filter(filter); + const auto result_size = column->assert_mutable()->filter(filter); if (result_size != count) [[unlikely]] { throw Exception(ErrorCode::INTERNAL_ERROR, "result_size not equal with filter_size, result_size={}, " @@ -932,7 +932,7 @@ void Block::filter_block_internal(Block* block, const IColumn::Filter& filter) { for (int i = 0; i < block->columns(); ++i) { auto& column = block->get_by_position(i).column; if (column->is_exclusive()) { - column->assume_mutable()->filter(filter); + column->assert_mutable()->filter(filter); } else { column = column->filter(filter, count); } @@ -961,7 +961,7 @@ Status Block::filter_block(Block* block, const std::vector& columns_to MutableColumnPtr mutable_holder = nested_column->use_count() == 1 - ? nested_column->assume_mutable() + ? nested_column->assert_mutable() : nested_column->clone_resized(nested_column->size()); auto* concrete_column = assert_cast(mutable_holder.get()); @@ -980,7 +980,7 @@ Status Block::filter_block(Block* block, const std::vector& columns_to for (const auto& col : columns_to_filter) { auto& column = block->get_by_position(col).column; if (column->is_exclusive()) { - column->assume_mutable()->clear(); + column->assert_mutable()->clear(); } else { column = column->clone_empty(); } @@ -1263,7 +1263,7 @@ void Block::shrink_char_type_column_suffix_zero(const std::vector& char_ if (idx < data.size()) { auto& col_and_name = this->get_by_position(idx); if (col_and_name.column->is_exclusive()) { - col_and_name.column->assume_mutable()->shrink_padding_chars(); + col_and_name.column->assert_mutable()->shrink_padding_chars(); } else { auto mutable_col = std::move(*col_and_name.column).mutate(); mutable_col->shrink_padding_chars(); diff --git a/be/src/core/column/column_map.cpp b/be/src/core/column/column_map.cpp index 7ad4cb522ef9d5..399f558caf5bba 100644 --- a/be/src/core/column/column_map.cpp +++ b/be/src/core/column/column_map.cpp @@ -573,7 +573,7 @@ size_t ColumnMap::filter(const Filter& filter) { static_cast(keys_column) = k_arr->get_data_ptr(); static_cast(offsets_column) = k_arr->get_offsets_ptr(); static_cast(values_column) = v_arr->get_data_ptr(); - // Use const access to avoid assume_mutable_ref() on the just-written-back offsets_column + // Use const access to avoid assert_mutable_ref() on the just-written-back offsets_column // (k_arr still holds a ref, so use_count > 1 until k_arr goes out of scope) return static_cast(offsets_column)->size(); } diff --git a/be/src/core/column/column_nullable.cpp b/be/src/core/column/column_nullable.cpp index ed6f5865543621..03674fb09177bd 100644 --- a/be/src/core/column/column_nullable.cpp +++ b/be/src/core/column/column_nullable.cpp @@ -438,7 +438,7 @@ size_t ColumnNullable::filter(const Filter& filter) { Status ColumnNullable::filter_by_selector(const uint16_t* sel, size_t sel_size, IColumn* col_ptr) { auto* nullable_col_ptr = assert_cast(col_ptr); - // Access the nested column via const path to avoid assume_mutable_ref (which requires + // Access the nested column via const path to avoid assert_mutable_ref (which requires // exclusive ownership). The output col_ptr was just created, so its nested column is exclusive. IColumn* nest_col_raw = const_cast( static_cast(nullable_col_ptr->_nested_column).get()); diff --git a/be/src/core/column/column_nullable.h b/be/src/core/column/column_nullable.h index 025e37976732e3..769c0a0a05ffe8 100644 --- a/be/src/core/column/column_nullable.h +++ b/be/src/core/column/column_nullable.h @@ -278,7 +278,7 @@ class ColumnNullable final : public COWHelper { const ColumnPtr& get_nested_column_ptr() const { return _nested_column; } - MutableColumnPtr get_nested_column_ptr() { return _nested_column->assume_mutable(); } + MutableColumnPtr get_nested_column_ptr() { return _nested_column->assert_mutable(); } void clear() override { _null_map->clear(); @@ -386,7 +386,7 @@ class ColumnNullable final : public COWHelper { } const NullMap& get_null_map_data() const { return get_null_map_column().get_data(); } - MutableColumnPtr get_null_map_column_ptr() { return _null_map->assume_mutable(); } + MutableColumnPtr get_null_map_column_ptr() { return _null_map->assert_mutable(); } ColumnUInt8& get_null_map_column() { return assert_cast(*_null_map); } diff --git a/be/src/core/cow.h b/be/src/core/cow.h index 4fb6059a1fc111..afa0cab3d5b582 100644 --- a/be/src/core/cow.h +++ b/be/src/core/cow.h @@ -309,7 +309,7 @@ class COW { if (this->use_count() > 1) { return derived()->clone(); } else { - return assume_mutable(); + return assert_mutable(); } } @@ -320,17 +320,17 @@ class COW { // uniquely owned. This does not detach shared owners; use a type-specific // COW entry point (for example IColumn::mutate) when the pointer may be // shared. - MutablePtr assume_mutable() const { + MutablePtr assert_mutable() const { if (this->use_count() > 1) { - throw Exception(ErrorCode::INTERNAL_ERROR, "COW::assume_mutable: use_count() > 1"); + throw Exception(ErrorCode::INTERNAL_ERROR, "COW::assert_mutable: use_count() > 1"); } return const_cast(this)->get_ptr(); } - // Reference variant of assume_mutable(), with the same ownership contract. - Derived& assume_mutable_ref() const { + // Reference variant of assert_mutable(), with the same ownership contract. + Derived& assert_mutable_ref() const { if (this->use_count() > 1) { - throw Exception(ErrorCode::INTERNAL_ERROR, "COW::assume_mutable: use_count() > 1"); + throw Exception(ErrorCode::INTERNAL_ERROR, "COW::assert_mutable: use_count() > 1"); } return const_cast(*derived()); } @@ -351,13 +351,13 @@ class COW { : value(std::forward>(arg)) {} const T* get() const { return value.get(); } - T* get() { return &value->assume_mutable_ref(); } + T* get() { return &value->assert_mutable_ref(); } const T* operator->() const { return get(); } T* operator->() { return get(); } const T& operator*() const { return *value; } - T& operator*() { return value->assume_mutable_ref(); } + T& operator*() { return value->assert_mutable_ref(); } operator const immutable_ptr&() const { return value; } operator immutable_ptr&() { return value; } diff --git a/be/src/exec/common/util.hpp b/be/src/exec/common/util.hpp index 477005f709d003..2b6eb69c7bf0a6 100644 --- a/be/src/exec/common/util.hpp +++ b/be/src/exec/common/util.hpp @@ -247,7 +247,7 @@ inline void change_null_to_true(MutableColumnPtr column, ColumnPtr argument = nu size_t rows = column->size(); if (is_column_const(*column)) { change_null_to_true( - assert_cast(column.get())->get_data_column_ptr()->assume_mutable()); + assert_cast(column.get())->get_data_column_ptr()->assert_mutable()); } else if (column->has_null()) { auto* nullable = assert_cast(column.get()); auto* __restrict data = assert_cast(nullable->get_nested_column_ptr().get()) diff --git a/be/src/exec/operator/aggregation_source_operator.cpp b/be/src/exec/operator/aggregation_source_operator.cpp index 05e6a30c612249..0699d6a60026f8 100644 --- a/be/src/exec/operator/aggregation_source_operator.cpp +++ b/be/src/exec/operator/aggregation_source_operator.cpp @@ -546,7 +546,7 @@ Status AggLocalState::_get_without_key_result(RuntimeState* state, Block* block, // unless `count`, other aggregate function dispose empty set should be null // so here check the children row return ptr = make_nullable(ptr, shared_state.input_num_rows == 0); - columns[i] = ptr->assume_mutable(); + columns[i] = ptr->assert_mutable(); } } } diff --git a/be/src/exec/operator/assert_num_rows_operator.cpp b/be/src/exec/operator/assert_num_rows_operator.cpp index 0013eb294affc1..290ed763ed62f8 100644 --- a/be/src/exec/operator/assert_num_rows_operator.cpp +++ b/be/src/exec/operator/assert_num_rows_operator.cpp @@ -91,7 +91,7 @@ Status AssertNumRowsOperatorX::pull(doris::RuntimeState* state, Block* block, bo auto& type = block->get_by_position(i).type; type = make_nullable(type); column = type->create_column(); - column->assume_mutable()->insert_default(); + column->assert_mutable()->insert_default(); } assert_res = true; } diff --git a/be/src/exec/operator/distinct_streaming_aggregation_operator.cpp b/be/src/exec/operator/distinct_streaming_aggregation_operator.cpp index 92c11cf2896154..e6a26904913500 100644 --- a/be/src/exec/operator/distinct_streaming_aggregation_operator.cpp +++ b/be/src/exec/operator/distinct_streaming_aggregation_operator.cpp @@ -207,7 +207,7 @@ Status DistinctStreamingAggLocalState::_distinct_pre_agg_with_serialized_key( // swap the column directly, to solve Check failed: d.column->use_count() == 1 (2 vs. 1) for (int i = 0; i < key_size; ++i) { auto output_column = out_block->get_by_position(i).column; - out_block->replace_by_position(i, key_columns[i]->assume_mutable()); + out_block->replace_by_position(i, key_columns[i]->assert_mutable()); in_block->replace_by_position(result_idxs[i], output_column); } } else { @@ -240,7 +240,7 @@ Status DistinctStreamingAggLocalState::_distinct_pre_agg_with_serialized_key( ColumnsWithTypeAndName columns_with_schema; for (int i = 0; i < key_size; ++i) { if (_stop_emplace_flag) { - columns_with_schema.emplace_back(key_columns[i]->assume_mutable(), + columns_with_schema.emplace_back(key_columns[i]->assert_mutable(), _probe_expr_ctxs[i]->root()->data_type(), _probe_expr_ctxs[i]->root()->expr_name()); } else { diff --git a/be/src/exec/operator/hashjoin_build_sink.cpp b/be/src/exec/operator/hashjoin_build_sink.cpp index 3071e5e53225e5..0a523138b46914 100644 --- a/be/src/exec/operator/hashjoin_build_sink.cpp +++ b/be/src/exec/operator/hashjoin_build_sink.cpp @@ -195,7 +195,7 @@ size_t HashJoinBuildSinkLocalState::get_reserve_mem_size(RuntimeState* state, bo // first row is mocked for (int i = 0; i < block.columns(); i++) { auto [column, is_const] = unpack_if_const(block.safe_get_by_position(i).column); - assert_cast(column->assume_mutable().get()) + assert_cast(column->assert_mutable().get()) ->get_null_map_column() .get_data() .data()[0] = 1; @@ -590,7 +590,7 @@ Status HashJoinBuildSinkLocalState::process_build_block(RuntimeState* state, Blo // first row is mocked for (int i = 0; i < block.columns(); i++) { auto [column, is_const] = unpack_if_const(block.safe_get_by_position(i).column); - assert_cast(column->assume_mutable().get()) + assert_cast(column->assert_mutable().get()) ->get_null_map_column() .get_data() .data()[0] = 1; diff --git a/be/src/exec/operator/join/process_hash_table_probe_impl.h b/be/src/exec/operator/join/process_hash_table_probe_impl.h index bcc4408906bf54..8e4e0131ffe12f 100644 --- a/be/src/exec/operator/join/process_hash_table_probe_impl.h +++ b/be/src/exec/operator/join/process_hash_table_probe_impl.h @@ -880,7 +880,7 @@ Status ProcessHashTableProbe::do_other_join_conjuncts(Block* output_ output_block->insert({std::move(filter_column), std::make_shared(), ""}); uint8_t* __restrict filter_column_ptr = assert_cast( - output_block->get_by_position(result_column_id).column->assume_mutable_ref()) + output_block->get_by_position(result_column_id).column->assert_mutable_ref()) .get_data() .data(); diff --git a/be/src/exec/operator/nested_loop_join_probe_operator.h b/be/src/exec/operator/nested_loop_join_probe_operator.h index 9313331fc697d6..890b6e2cbe1c7a 100644 --- a/be/src/exec/operator/nested_loop_join_probe_operator.h +++ b/be/src/exec/operator/nested_loop_join_probe_operator.h @@ -50,7 +50,7 @@ class NestedLoopJoinProbeLocalState final for (size_t i = 0; i < column_to_keep; ++i) { \ auto& column = block->get_by_position(i).column; \ if (column->is_exclusive()) { \ - column->assume_mutable()->clear(); \ + column->assert_mutable()->clear(); \ } else { \ column = column->clone_empty(); \ } \ diff --git a/be/src/exec/operator/operator.cpp b/be/src/exec/operator/operator.cpp index 6f7bd22539aaeb..d03f75306d5a8a 100644 --- a/be/src/exec/operator/operator.cpp +++ b/be/src/exec/operator/operator.cpp @@ -348,14 +348,14 @@ Status OperatorXBase::do_projections(RuntimeState* state, Block* origin_block, null_column.get_null_map_column().get_data().resize_fill(rows, 0); bytes_usage += null_column.allocated_bytes(); } else { - to = make_nullable(from, false)->assume_mutable(); + to = make_nullable(from, false)->assert_mutable(); } } else { if (_keep_origin || !from->is_exclusive()) { to->insert_range_from(*from, 0, rows); bytes_usage += from->allocated_bytes(); } else { - to = from->assume_mutable(); + to = from->assert_mutable(); } } }; diff --git a/be/src/exec/rowid_fetcher.cpp b/be/src/exec/rowid_fetcher.cpp index 4322842792b9f6..66dbbfcaf39050 100644 --- a/be/src/exec/rowid_fetcher.cpp +++ b/be/src/exec/rowid_fetcher.cpp @@ -495,7 +495,7 @@ Status RowIdStorageReader::read_by_rowids(const PMultiGetRequest& request, for (int x = 0; x < slots.size(); ++x) { std::vector row_ids { static_cast(row_loc.ordinal_id())}; - MutableColumnPtr column = result_block.get_by_position(x).column->assume_mutable(); + MutableColumnPtr column = result_block.get_by_position(x).column->assert_mutable(); IteratorKey iterator_key {.tablet_id = tablet->tablet_id(), .rowset_id = rowset_id, .segment_id = row_loc.segment_id(), diff --git a/be/src/exec/sort/sorter.cpp b/be/src/exec/sort/sorter.cpp index 686cca97e84e1c..9b2ecd60953c54 100644 --- a/be/src/exec/sort/sorter.cpp +++ b/be/src/exec/sort/sorter.cpp @@ -251,12 +251,12 @@ Status FullSorter::append_block(Block* block) { << " type1: " << data[i].type->get_name() << " type2: " << arrival_data[i].type->get_name() << " i: " << i; if (is_column_const(*arrival_data[i].column)) { - data[i].column->assume_mutable()->insert_many_from( + data[i].column->assert_mutable()->insert_many_from( assert_cast(arrival_data[i].column.get()) ->get_data_column(), 0, sz); } else { - data[i].column->assume_mutable()->insert_range_from(*arrival_data[i].column, 0, sz); + data[i].column->assert_mutable()->insert_range_from(*arrival_data[i].column, 0, sz); } } block->clear_column_data(); diff --git a/be/src/exprs/aggregate/aggregate_function_null_v2.h b/be/src/exprs/aggregate/aggregate_function_null_v2.h index a3b513d6014116..881478e28121f0 100644 --- a/be/src/exprs/aggregate/aggregate_function_null_v2.h +++ b/be/src/exprs/aggregate/aggregate_function_null_v2.h @@ -214,7 +214,7 @@ class AggregateFunctionNullBaseInlineV2 : public IAggregateFunctionHelper(*dst); auto& nested_col = nullable_col.get_nested_column(); auto& null_map = nullable_col.get_null_map_data(); - MutableColumnPtr nested_col_ptr = nested_col.assume_mutable(); + MutableColumnPtr nested_col_ptr = nested_col.assert_mutable(); null_map.resize(num_rows); uint8_t* __restrict null_map_data = null_map.data(); @@ -273,7 +273,7 @@ class AggregateFunctionNullBaseInlineV2 : public IAggregateFunctionHelper(*dst); - MutableColumnPtr nested_col_ptr = dst_nullable_col.get_nested_column().assume_mutable(); + MutableColumnPtr nested_col_ptr = dst_nullable_col.get_nested_column().assert_mutable(); dst_nullable_col.get_null_map_column().insert_range_from( src_nullable_col->get_null_map_column(), 0, num_rows); nested_function->serialize_to_column(nested_places, 0, nested_col_ptr, num_rows); diff --git a/be/src/exprs/function/array/function_array_aggregation.cpp b/be/src/exprs/function/array/function_array_aggregation.cpp index dbcf438e4194ce..9bed157223adb1 100644 --- a/be/src/exprs/function/array/function_array_aggregation.cpp +++ b/be/src/exprs/function/array/function_array_aggregation.cpp @@ -216,7 +216,7 @@ struct ArrayAggregateImpl { ColumnPtr res_column = create_column_func(column); res_column = make_nullable(res_column); - assert_cast(res_column->assume_mutable_ref()).reserve(offsets.size()); + assert_cast(res_column->assert_mutable_ref()).reserve(offsets.size()); auto function = Function::create(type, {.is_window_function = false, .column_names = {}}); auto guard = AggregateFunctionGuard(function.get()); @@ -228,13 +228,13 @@ struct ArrayAggregateImpl { auto end = offsets[i]; bool is_empty = (start == end); if (is_empty) { - res_column->assume_mutable()->insert_default(); + res_column->assert_mutable()->insert_default(); continue; } function->reset(guard.data()); function->add_batch_range(start, end - 1, guard.data(), columns, arena, data->is_nullable()); - function->insert_result_into(guard.data(), res_column->assume_mutable_ref()); + function->insert_result_into(guard.data(), res_column->assert_mutable_ref()); } res_ptr = std::move(res_column); return true; @@ -440,7 +440,7 @@ struct ArrayAggregateImplDecimalV3 { ColumnPtr res_column = create_column_func(column); res_column = make_nullable(res_column); - assert_cast(res_column->assume_mutable_ref()).reserve(offsets.size()); + assert_cast(res_column->assert_mutable_ref()).reserve(offsets.size()); auto function = Function::create(type, result_type, {.is_window_function = false, .column_names = {}}); @@ -453,13 +453,13 @@ struct ArrayAggregateImplDecimalV3 { auto end = offsets[i]; bool is_empty = (start == end); if (is_empty) { - res_column->assume_mutable()->insert_default(); + res_column->assert_mutable()->insert_default(); continue; } function->reset(guard.data()); function->add_batch_range(start, end - 1, guard.data(), columns, arena, data->is_nullable()); - function->insert_result_into(guard.data(), res_column->assume_mutable_ref()); + function->insert_result_into(guard.data(), res_column->assert_mutable_ref()); } res_ptr = std::move(res_column); return true; diff --git a/be/src/exprs/function/array/function_array_with_constant.cpp b/be/src/exprs/function/array/function_array_with_constant.cpp index 224f0a1282fdce..b1e513fbb155b5 100644 --- a/be/src/exprs/function/array/function_array_with_constant.cpp +++ b/be/src/exprs/function/array/function_array_with_constant.cpp @@ -99,7 +99,7 @@ class FunctionArrayWithConstant : public IFunction { } auto clone = value->clone_empty(); clone->reserve(input_rows_count); - clone->assume_mutable()->insert_indices_from(*value, array_sizes.data(), + clone->assert_mutable()->insert_indices_from(*value, array_sizes.data(), array_sizes.data() + offset); if (!clone->is_nullable()) { clone = ColumnNullable::create(std::move(clone), ColumnUInt8::create(clone->size(), 0)); diff --git a/be/src/exprs/function/cast/cast_to_variant.h b/be/src/exprs/function/cast/cast_to_variant.h index 3aebb66212a44a..6c6ed1743fcdf0 100644 --- a/be/src/exprs/function/cast/cast_to_variant.h +++ b/be/src/exprs/function/cast/cast_to_variant.h @@ -94,7 +94,7 @@ inline Status cast_from_variant_impl(FunctionContext* context, Block& block, Status st = wrapper(new_context.get(), tmp_block, {0}, 1, input_rows_count, nullptr); if (!st.ok()) { // Fill with default values, which is null - col_to->assume_mutable()->insert_many_defaults(input_rows_count); + col_to->assert_mutable()->insert_many_defaults(input_rows_count); col_to = make_nullable(col_to, true); } else { col_to = tmp_block.get_by_position(1).column; @@ -106,7 +106,7 @@ inline Status cast_from_variant_impl(FunctionContext* context, Block& block, } } else { if (variant.only_have_default_values()) { - col_to->assume_mutable()->insert_many_defaults(input_rows_count); + col_to->assert_mutable()->insert_many_defaults(input_rows_count); col_to = make_nullable(col_to, true); } else if (is_string_type(data_type_to->get_primitive_type())) { // serialize to string @@ -118,10 +118,10 @@ inline Status cast_from_variant_impl(FunctionContext* context, Block& block, } else if (!data_type_to->is_nullable() && !is_string_type(data_type_to->get_primitive_type())) { // other types - col_to->assume_mutable()->insert_many_defaults(input_rows_count); + col_to->assert_mutable()->insert_many_defaults(input_rows_count); col_to = make_nullable(col_to, true); } else { - assert_cast(*col_to->assume_mutable()) + assert_cast(*col_to->assert_mutable()) .insert_many_defaults(input_rows_count); } } diff --git a/be/src/exprs/function/dictionary_util.h b/be/src/exprs/function/dictionary_util.h index d60bedb56eaa62..87e6603a8663e5 100644 --- a/be/src/exprs/function/dictionary_util.h +++ b/be/src/exprs/function/dictionary_util.h @@ -60,7 +60,7 @@ Status inline check_dict_input_data(ColumnsWithTypeAndName& key_data, // Similar to the filter_block_internal function in block.cpp auto filter_column = [&](ColumnPtr& column) { if (column->is_exclusive()) { - column->assume_mutable()->filter(filter); + column->assert_mutable()->filter(filter); } else { column = column->filter(filter, count); } diff --git a/be/src/exprs/function/function_other_types_to_date.cpp b/be/src/exprs/function/function_other_types_to_date.cpp index 002112993fea85..bc24d76df278ea 100644 --- a/be/src/exprs/function/function_other_types_to_date.cpp +++ b/be/src/exprs/function/function_other_types_to_date.cpp @@ -147,11 +147,11 @@ struct StrToDate { execute_impl_const_right( context, ldata, loffsets, specific_char_column->get_data_at(0), result_null_map, - static_cast(res->assume_mutable().get())->get_data()); + static_cast(res->assert_mutable().get())->get_data()); } else { execute_impl( context, ldata, loffsets, rdata, roffsets, result_null_map, - static_cast(res->assume_mutable().get())->get_data()); + static_cast(res->assert_mutable().get())->get_data()); } } else { DCHECK(block.get_by_position(result).type->get_primitive_type() == TYPE_DATETIMEV2); @@ -161,11 +161,11 @@ struct StrToDate { execute_impl_const_right( context, ldata, loffsets, specific_char_column->get_data_at(0), result_null_map, - static_cast(res->assume_mutable().get())->get_data()); + static_cast(res->assert_mutable().get())->get_data()); } else { execute_impl( context, ldata, loffsets, rdata, roffsets, result_null_map, - static_cast(res->assume_mutable().get())->get_data()); + static_cast(res->assert_mutable().get())->get_data()); } } @@ -298,11 +298,11 @@ struct MakeDateImpl { if (col_const[1]) { execute_impl_right_const( year_col->get_data(), dayofyear_col->get_element(0), result_null_map, - static_cast(res_column->assume_mutable().get())->get_data()); + static_cast(res_column->assert_mutable().get())->get_data()); } else { execute_impl( year_col->get_data(), dayofyear_col->get_data(), result_null_map, - static_cast(res_column->assume_mutable().get())->get_data()); + static_cast(res_column->assert_mutable().get())->get_data()); } // Wrap result in nullable column only if input has nullable arguments @@ -542,7 +542,7 @@ struct DateTrunc { static void execute_impl_right_const(const ColumnPtr& datetime_column, ColumnPtr& result_column, size_t input_rows_count, const cctz::time_zone& timezone) { auto& data = static_cast(datetime_column.get())->get_data(); - auto& res = static_cast(result_column->assume_mutable().get())->get_data(); + auto& res = static_cast(result_column->assert_mutable().get())->get_data(); for (size_t i = 0; i < input_rows_count; ++i) { auto dt = data[i]; // datetime_trunc only raise only when dt invalid which is impossible. so we dont throw error better. @@ -612,12 +612,12 @@ class FromDays : public IFunction { res_column = ColumnDate::create(input_rows_count); _execute( input_rows_count, data_col->get_data(), result_null_map, - static_cast(res_column->assume_mutable().get())->get_data()); + static_cast(res_column->assert_mutable().get())->get_data()); } else { res_column = ColumnDateV2::create(input_rows_count); _execute>( input_rows_count, data_col->get_data(), result_null_map, - static_cast(res_column->assume_mutable().get())->get_data()); + static_cast(res_column->assert_mutable().get())->get_data()); } // Wrap result in nullable column only if input has nullable arguments @@ -1055,7 +1055,7 @@ struct LastDayImpl { auto res_column = ResultColumnType::create(input_rows_count); execute_straight( input_rows_count, data_col->get_data(), - static_cast(res_column->assume_mutable().get())->get_data(), + static_cast(res_column->assert_mutable().get())->get_data(), result_null_map); if (is_nullable) { @@ -1130,7 +1130,7 @@ struct ToMondayImpl { auto res_column = ResultColumnType::create(input_rows_count); execute_straight( input_rows_count, data_col->get_data(), - static_cast(res_column->assume_mutable().get())->get_data(), + static_cast(res_column->assert_mutable().get())->get_data(), result_null_map); if (is_nullable) { diff --git a/be/src/exprs/function/function_variadic_arguments.h b/be/src/exprs/function/function_variadic_arguments.h index aaf518697c1e37..02f96d36546056 100644 --- a/be/src/exprs/function/function_variadic_arguments.h +++ b/be/src/exprs/function/function_variadic_arguments.h @@ -61,17 +61,17 @@ class FunctionVariadicArgumentsBase : public IFunction { column->reserve(input_rows_count); if (arguments.empty()) { - RETURN_IF_ERROR(Impl::empty_apply(column->assume_mutable_ref(), input_rows_count)); + RETURN_IF_ERROR(Impl::empty_apply(column->assert_mutable_ref(), input_rows_count)); } else { const ColumnWithTypeAndName& first_col = block.get_by_position(arguments[0]); RETURN_IF_ERROR(Impl::first_apply(first_col.type.get(), first_col.column.get(), - input_rows_count, column->assume_mutable_ref())); + input_rows_count, column->assert_mutable_ref())); for (size_t i = 1; i < arguments.size(); ++i) { const ColumnWithTypeAndName& col = block.get_by_position(arguments[i]); RETURN_IF_ERROR(Impl::combine_apply(col.type.get(), col.column.get(), input_rows_count, - column->assume_mutable_ref())); + column->assert_mutable_ref())); } } diff --git a/be/src/exprs/function/function_variant_element.cpp b/be/src/exprs/function/function_variant_element.cpp index cef269c613519f..4736342f4eeed3 100644 --- a/be/src/exprs/function/function_variant_element.cpp +++ b/be/src/exprs/function/function_variant_element.cpp @@ -263,9 +263,9 @@ class FunctionVariantElement : public IFunction { if (src.empty()) { *result = ColumnVariant::create(src.max_subcolumns_count(), src.enable_doc_mode()); // src subcolumns empty but src row count may not be 0 - (*result)->assume_mutable()->insert_many_defaults(src.size()); + (*result)->assert_mutable()->insert_many_defaults(src.size()); // ColumnVariant should be finalized before parsing, finalize maybe modify original column structure - (*result)->assume_mutable()->finalize(); + (*result)->assert_mutable()->finalize(); return Status::OK(); } if (src.is_scalar_variant() && is_string_type(src.get_root_type()->get_primitive_type())) { @@ -290,7 +290,7 @@ class FunctionVariantElement : public IFunction { } *result = ColumnVariant::create(src.max_subcolumns_count(), src.enable_doc_mode(), type, std::move(result_column)); - (*result)->assume_mutable()->finalize(); + (*result)->assert_mutable()->finalize(); return Status::OK(); } else { auto mutable_src = src.clone_finalized(); diff --git a/be/src/exprs/lambda_function/varray_map_function.cpp b/be/src/exprs/lambda_function/varray_map_function.cpp index 4a95a1df2625b7..79fbb5f5dfdbb1 100644 --- a/be/src/exprs/lambda_function/varray_map_function.cpp +++ b/be/src/exprs/lambda_function/varray_map_function.cpp @@ -230,7 +230,7 @@ class ArrayMapFunction : public LambdaFunction { bool mem_reuse = lambda_block.mem_reuse(); for (int i = 0; i < column_size; i++) { if (mem_reuse) { - columns[i] = lambda_block.get_by_position(i).column->assume_mutable(); + columns[i] = lambda_block.get_by_position(i).column->assert_mutable(); } else { if (_contains_column_id(output_slot_ref_indexs, i) || i >= gap) { // TODO: maybe could create const column, so not insert_many_from when extand data @@ -239,7 +239,7 @@ class ArrayMapFunction : public LambdaFunction { } else { columns[i] = data_types[i] ->create_column_const_with_default_value(0) - ->assume_mutable(); + ->assert_mutable(); } } } diff --git a/be/src/exprs/lambda_function/varray_sort_function.cpp b/be/src/exprs/lambda_function/varray_sort_function.cpp index 9f0191753f3dcc..29fe56b04767e9 100644 --- a/be/src/exprs/lambda_function/varray_sort_function.cpp +++ b/be/src/exprs/lambda_function/varray_sort_function.cpp @@ -142,7 +142,7 @@ class ArraySortFunction : public LambdaFunction { NullMap* temp_nullmap_data[2] = {nullptr, nullptr}; for (int i = 0; i < 2; i++) { auto* temp_column = assert_cast( - lambda_block.get_by_position(i).column->assume_mutable().get()); + lambda_block.get_by_position(i).column->assert_mutable().get()); temp_data[i] = temp_column->get_nested_column_ptr(); auto& null_map_col = temp_column->get_null_map_column(); temp_nullmap_data[i] = &null_map_col.get_data(); diff --git a/be/src/exprs/runtime_filter_expr.cpp b/be/src/exprs/runtime_filter_expr.cpp index 9a58421553c9ea..e335e8ed4da1e7 100644 --- a/be/src/exprs/runtime_filter_expr.cpp +++ b/be/src/exprs/runtime_filter_expr.cpp @@ -121,7 +121,7 @@ Status RuntimeFilterExpr::execute_filter(VExprContext* context, const Block* blo // bloom filter will handle null aware inside itself if (_null_aware && TExprNodeType::BLOOM_PRED != node_type()) { DCHECK(arg_column); - change_null_to_true(filter_column->assume_mutable(), arg_column); + change_null_to_true(filter_column->assert_mutable(), arg_column); } if (const auto* const_column = check_and_get_column(*filter_column)) { diff --git a/be/src/exprs/vexpr_context.cpp b/be/src/exprs/vexpr_context.cpp index 9ad6182fc97875..c8ca10ab04869e 100644 --- a/be/src/exprs/vexpr_context.cpp +++ b/be/src/exprs/vexpr_context.cpp @@ -329,7 +329,7 @@ Status VExprContext::execute_conjuncts_and_filter_block(const VExprContextSPtrs& for (auto& col : columns_to_filter) { auto& column = block->get_by_position(col).column; if (column->is_exclusive()) { - column->assume_mutable()->clear(); + column->assert_mutable()->clear(); } else { column = column->clone_empty(); } @@ -372,7 +372,7 @@ Status VExprContext::execute_conjuncts_and_filter_block(const VExprContextSPtrs& for (auto& col : columns_to_filter) { auto& column = block->get_by_position(col).column; if (column->is_exclusive()) { - column->assume_mutable()->clear(); + column->assert_mutable()->clear(); } else { column = column->clone_empty(); } diff --git a/be/src/exprs/vtopn_pred.h b/be/src/exprs/vtopn_pred.h index 13b136c7027195..526787bccc65dc 100644 --- a/be/src/exprs/vtopn_pred.h +++ b/be/src/exprs/vtopn_pred.h @@ -118,7 +118,7 @@ class VTopNPred : public VExpr { result_column = std::move(temp_block.get_by_position(num_columns_without_result).column); if (is_nullable() && _predicate->nulls_first()) { // null values ​​are always not filtered - change_null_to_true(result_column->assume_mutable()); + change_null_to_true(result_column->assert_mutable()); } DCHECK_EQ(result_column->size(), count); return Status::OK(); diff --git a/be/src/format/json/new_json_reader.cpp b/be/src/format/json/new_json_reader.cpp index 90a4bd65b22813..cc5208b7c30bf0 100644 --- a/be/src/format/json/new_json_reader.cpp +++ b/be/src/format/json/new_json_reader.cpp @@ -1026,7 +1026,7 @@ Status NewJsonReader::_simdjson_set_column_value(simdjson::ondemand::object* val } } simdjson::ondemand::value val = field.value(); - auto* column_ptr = block.get_by_position(column_index).column->assume_mutable().get(); + auto* column_ptr = block.get_by_position(column_index).column->assert_mutable().get(); RETURN_IF_ERROR(_simdjson_write_data_to_column( val, slot_descs[column_index]->type(), column_ptr, slot_descs[column_index]->col_name(), _serdes[column_index], valid)); @@ -1066,7 +1066,7 @@ Status NewJsonReader::_simdjson_set_column_value(simdjson::ondemand::object* val } auto* slot_desc = slot_descs[i]; - auto* column_ptr = block.get_by_position(i).column->assume_mutable().get(); + auto* column_ptr = block.get_by_position(i).column->assert_mutable().get(); // Quick path to insert default value, instead of using default values in the value map. if (!_should_process_skip_bitmap_col() && @@ -1274,7 +1274,7 @@ Status NewJsonReader::_simdjson_write_data_to_column(simdjson::ondemand::value& RETURN_IF_ERROR(f(member_value.unescaped_key(), assert_cast(remove_nullable(type_desc).get()) ->get_key_type(), - map_column_ptr->get_keys_ptr()->assume_mutable()->get_ptr().get(), + map_column_ptr->get_keys_ptr()->assert_mutable()->get_ptr().get(), sub_serdes[0], _serde_options, valid)); simdjson::ondemand::value field_value = member_value.value(); @@ -1282,7 +1282,7 @@ Status NewJsonReader::_simdjson_write_data_to_column(simdjson::ondemand::value& field_value, assert_cast(remove_nullable(type_desc).get()) ->get_value_type(), - map_column_ptr->get_values_ptr()->assume_mutable()->get_ptr().get(), + map_column_ptr->get_values_ptr()->assert_mutable()->get_ptr().get(), column_name + ".value", sub_serdes[1], valid)); field_count++; } @@ -1504,7 +1504,7 @@ Status NewJsonReader::_simdjson_write_columns_by_jsonpath( for (size_t i = 0; i < slot_descs.size(); i++) { auto* slot_desc = slot_descs[i]; - auto* column_ptr = block.get_by_position(i).column->assume_mutable().get(); + auto* column_ptr = block.get_by_position(i).column->assert_mutable().get(); simdjson::ondemand::value json_value; Status st; if (i < _parsed_jsonpaths.size()) { @@ -1614,7 +1614,7 @@ Status NewJsonReader::_fill_missing_column(SlotDescriptor* slot_desc, DataTypeSe void NewJsonReader::_append_empty_skip_bitmap_value(Block& block, size_t cur_row_count) { auto* skip_bitmap_nullable_col_ptr = assert_cast( - block.get_by_position(skip_bitmap_col_idx).column->assume_mutable().get()); + block.get_by_position(skip_bitmap_col_idx).column->assert_mutable().get()); auto* skip_bitmap_col_ptr = assert_cast(skip_bitmap_nullable_col_ptr->get_nested_column_ptr().get()); DCHECK(skip_bitmap_nullable_col_ptr->size() == cur_row_count); @@ -1629,7 +1629,7 @@ void NewJsonReader::_set_skip_bitmap_mark(SlotDescriptor* slot_desc, IColumn* co // we record the missing column's column unique id in skip bitmap // to indicate which columns need to do the alignment process auto* skip_bitmap_nullable_col_ptr = assert_cast( - block.get_by_position(skip_bitmap_col_idx).column->assume_mutable().get()); + block.get_by_position(skip_bitmap_col_idx).column->assert_mutable().get()); auto* skip_bitmap_col_ptr = assert_cast(skip_bitmap_nullable_col_ptr->get_nested_column_ptr().get()); DCHECK(skip_bitmap_col_ptr->size() == cur_row_count + 1); diff --git a/be/src/format/orc/vorc_reader.cpp b/be/src/format/orc/vorc_reader.cpp index 70c4d4affaf44e..47eb9a23f4fae6 100644 --- a/be/src/format/orc/vorc_reader.cpp +++ b/be/src/format/orc/vorc_reader.cpp @@ -2251,7 +2251,7 @@ Status OrcReader::_orc_column_to_doris_column( } doris_column = IColumn::mutate(std::move(doris_column)); - auto converted_column = doris_column->assume_mutable(); + auto converted_column = doris_column->assert_mutable(); if (converted_column->is_nullable()) { const size_t new_rows = remove_nullable(resolved_column)->size(); align_orc_null_map(resolved_column, @@ -3088,7 +3088,7 @@ Status OrcReader::on_string_dicts_loaded( if (dict_pos != 0) { // VExprContext.execute has an optimization, the filtering is executed when block->rows() > 0 // The following process may be tricky and time-consuming, but we have no other way. - temp_block.get_by_position(0).column->assume_mutable()->resize(dict_value_column_size); + temp_block.get_by_position(0).column->assert_mutable()->resize(dict_value_column_size); } IColumn::Filter result_filter(temp_block.rows(), 1); bool can_filter_all; @@ -3096,7 +3096,7 @@ Status OrcReader::on_string_dicts_loaded( &can_filter_all)); if (dict_pos != 0) { // We have to clean the first column to insert right data. - temp_block.get_by_position(0).column->assume_mutable()->clear(); + temp_block.get_by_position(0).column->assert_mutable()->clear(); } // If can_filter_all = true, can filter this stripe. diff --git a/be/src/format/parquet/parquet_column_convert.h b/be/src/format/parquet/parquet_column_convert.h index 9206ea285ac101..6a4d8f39835f80 100644 --- a/be/src/format/parquet/parquet_column_convert.h +++ b/be/src/format/parquet/parquet_column_convert.h @@ -198,7 +198,7 @@ struct ConvertParams { inline IColumn* get_mutable_inner_column(ColumnPtr& column) { column = IColumn::mutate(std::move(column)); - auto mutable_column = column->assume_mutable(); + auto mutable_column = column->assert_mutable(); if (mutable_column->is_nullable()) { return &assert_cast(mutable_column.get())->get_nested_column(); } @@ -238,7 +238,7 @@ inline void align_null_map(ColumnPtr& src_column, ColumnPtr& dst_column, size_t } dst_column = IColumn::mutate(std::move(dst_column)); - auto* dst_nullable = assert_cast(dst_column->assume_mutable().get()); + auto* dst_nullable = assert_cast(dst_column->assert_mutable().get()); auto& dst_null_map = dst_nullable->get_null_map_column(); const size_t expected_rows = old_null_map_size + new_rows; if (dst_null_map.size() == expected_rows) { @@ -369,7 +369,7 @@ class PhysicalToLogicalConverter { const size_t dst_old_rows = get_mutable_inner_column_size(dst_logical_col); const size_t dst_old_null_map_size = get_null_map_size_or_inner_column_size(dst_logical_col); - auto converted_column = dst_logical_col->assume_mutable(); + auto converted_column = dst_logical_col->assert_mutable(); RETURN_IF_ERROR(_logical_converter->convert(src_logical_column, converted_column)); const size_t dst_new_rows = get_mutable_inner_column_size(dst_logical_col) - dst_old_rows; align_null_map(src_logical_column, dst_logical_col, dst_old_null_map_size, dst_new_rows, diff --git a/be/src/format/parquet/vparquet_column_reader.cpp b/be/src/format/parquet/vparquet_column_reader.cpp index 1deffec6a04633..d5861a231d49e1 100644 --- a/be/src/format/parquet/vparquet_column_reader.cpp +++ b/be/src/format/parquet/vparquet_column_reader.cpp @@ -331,7 +331,7 @@ Status ScalarColumnReader::_read_values(size_t num_ doris_column = IColumn::mutate(std::move(doris_column)); if (doris_column->is_nullable()) { SCOPED_RAW_TIMER(&_decode_null_map_time); - auto mutable_column = doris_column->assume_mutable(); + auto mutable_column = doris_column->assert_mutable(); auto* nullable_column = assert_cast(mutable_column.get()); data_column = nullable_column->get_nested_column_ptr(); @@ -374,7 +374,7 @@ Status ScalarColumnReader::_read_values(size_t num_ if (_chunk_reader->max_def_level() > 0) { return Status::Corruption("Not nullable column has null values in parquet file"); } - data_column = doris_column->assume_mutable(); + data_column = doris_column->assert_mutable(); } if (null_map.size() == 0) { size_t remaining = num_values; @@ -413,7 +413,7 @@ Status ScalarColumnReader::_read_nested_column( doris_column = IColumn::mutate(std::move(doris_column)); if (doris_column->is_nullable()) { SCOPED_RAW_TIMER(&_decode_null_map_time); - auto mutable_column = doris_column->assume_mutable(); + auto mutable_column = doris_column->assert_mutable(); auto* nullable_column = assert_cast(mutable_column.get()); data_column = nullable_column->get_nested_column_ptr(); map_data_column = &(nullable_column->get_null_map_data()); @@ -421,7 +421,7 @@ Status ScalarColumnReader::_read_nested_column( if (_field_schema->data_type->is_nullable()) { return Status::Corruption("Not nullable column has null values in parquet file"); } - data_column = doris_column->assume_mutable(); + data_column = doris_column->assert_mutable(); } std::vector null_map; @@ -662,7 +662,7 @@ Status ArrayColumnReader::read_column_data( NullMap* null_map_ptr = nullptr; doris_column = IColumn::mutate(std::move(doris_column)); if (doris_column->is_nullable()) { - auto mutable_column = doris_column->assume_mutable(); + auto mutable_column = doris_column->assert_mutable(); auto* nullable_column = assert_cast(mutable_column.get()); null_map_ptr = &nullable_column->get_null_map_data(); data_column = nullable_column->get_nested_column_ptr(); @@ -670,7 +670,7 @@ Status ArrayColumnReader::read_column_data( if (_field_schema->data_type->is_nullable()) { return Status::Corruption("Not nullable column has null values in parquet file"); } - data_column = doris_column->assume_mutable(); + data_column = doris_column->assert_mutable(); } if (type->get_primitive_type() != PrimitiveType::TYPE_ARRAY) { return Status::Corruption( @@ -718,7 +718,7 @@ Status MapColumnReader::read_column_data( NullMap* null_map_ptr = nullptr; doris_column = IColumn::mutate(std::move(doris_column)); if (doris_column->is_nullable()) { - auto mutable_column = doris_column->assume_mutable(); + auto mutable_column = doris_column->assert_mutable(); auto* nullable_column = assert_cast(mutable_column.get()); null_map_ptr = &nullable_column->get_null_map_data(); data_column = nullable_column->get_nested_column_ptr(); @@ -726,7 +726,7 @@ Status MapColumnReader::read_column_data( if (_field_schema->data_type->is_nullable()) { return Status::Corruption("Not nullable column has null values in parquet file"); } - data_column = doris_column->assume_mutable(); + data_column = doris_column->assert_mutable(); } if (remove_nullable(type)->get_primitive_type() != PrimitiveType::TYPE_MAP) { return Status::Corruption( @@ -795,7 +795,7 @@ Status StructColumnReader::read_column_data( NullMap* null_map_ptr = nullptr; doris_column = IColumn::mutate(std::move(doris_column)); if (doris_column->is_nullable()) { - auto mutable_column = doris_column->assume_mutable(); + auto mutable_column = doris_column->assert_mutable(); auto* nullable_column = assert_cast(mutable_column.get()); null_map_ptr = &nullable_column->get_null_map_data(); data_column = nullable_column->get_nested_column_ptr(); @@ -803,7 +803,7 @@ Status StructColumnReader::read_column_data( if (_field_schema->data_type->is_nullable()) { return Status::Corruption("Not nullable column has null values in parquet file"); } - data_column = doris_column->assume_mutable(); + data_column = doris_column->assert_mutable(); } if (type->get_primitive_type() != PrimitiveType::TYPE_STRUCT) { return Status::Corruption( @@ -992,7 +992,7 @@ Status StructColumnReader::read_column_data( auto& doris_type = doris_struct_type->get_element(idx); DCHECK(doris_type->is_nullable()); doris_field = IColumn::mutate(std::move(doris_field)); - auto mutable_column = doris_field->assume_mutable(); + auto mutable_column = doris_field->assert_mutable(); auto* nullable_column = static_cast(mutable_column.get()); nullable_column->insert_many_defaults(missing_column_sz); } diff --git a/be/src/format/parquet/vparquet_column_reader.h b/be/src/format/parquet/vparquet_column_reader.h index 8673361eb46dd6..9f01f4f63243b0 100644 --- a/be/src/format/parquet/vparquet_column_reader.h +++ b/be/src/format/parquet/vparquet_column_reader.h @@ -483,7 +483,7 @@ class SkipReadingReader : public ParquetColumnReader { // Simulate reading without actually reading data // Fill with default/null values based on column type doris_column = IColumn::mutate(std::move(doris_column)); - MutableColumnPtr data_column = doris_column->assume_mutable(); + MutableColumnPtr data_column = doris_column->assert_mutable(); if (real_column_size > 0) { if (doris_column->is_nullable()) { diff --git a/be/src/format/parquet/vparquet_group_reader.cpp b/be/src/format/parquet/vparquet_group_reader.cpp index a346fa91585d6e..016fc4eb9d72b7 100644 --- a/be/src/format/parquet/vparquet_group_reader.cpp +++ b/be/src/format/parquet/vparquet_group_reader.cpp @@ -912,7 +912,7 @@ Status RowGroupReader::_fill_missing_columns( // call resize because the first column of _src_block_ptr may not be filled by reader, // so _src_block_ptr->rows() may return wrong result, cause the column created by `ctx->execute()` // has only one row. - auto mutable_column = result_column_ptr->assume_mutable(); + auto mutable_column = result_column_ptr->assert_mutable(); mutable_column->resize(rows); // result_column_ptr maybe a ColumnConst, convert it to a normal column result_column_ptr = result_column_ptr->convert_to_full_column_if_const(); @@ -1158,7 +1158,7 @@ Status RowGroupReader::_rewrite_dict_predicates() { if (dict_pos != 0) { // VExprContext.execute has an optimization, the filtering is executed when block->rows() > 0 // The following process may be tricky and time-consuming, but we have no other way. - temp_block.get_by_position(0).column->assume_mutable()->resize(dict_value_column_size); + temp_block.get_by_position(0).column->assert_mutable()->resize(dict_value_column_size); } IColumn::Filter result_filter(temp_block.rows(), 1); bool can_filter_all; @@ -1168,7 +1168,7 @@ Status RowGroupReader::_rewrite_dict_predicates() { } if (dict_pos != 0) { // We have to clean the first column to insert right data. - temp_block.get_by_position(0).column->assume_mutable()->clear(); + temp_block.get_by_position(0).column->assert_mutable()->clear(); } // If can_filter_all = true, can filter this row group. diff --git a/be/src/format/table/table_format_reader.h b/be/src/format/table/table_format_reader.h index ed5b414aa44dc1..efe7c1f901e72b 100644 --- a/be/src/format/table/table_format_reader.h +++ b/be/src/format/table/table_format_reader.h @@ -111,7 +111,7 @@ class TableFormatReader : public GenericReader { ColumnPtr result_column_ptr; RETURN_IF_ERROR(ctx->execute(block, result_column_ptr)); if (result_column_ptr->use_count() == 1) { - auto mutable_column = result_column_ptr->assume_mutable(); + auto mutable_column = result_column_ptr->assert_mutable(); mutable_column->resize(rows); result_column_ptr = result_column_ptr->convert_to_full_column_if_const(); auto origin_column_type = diff --git a/be/src/storage/iterator/olap_data_convertor.h b/be/src/storage/iterator/olap_data_convertor.h index 82376ac890c32a..8909a400601f15 100644 --- a/be/src/storage/iterator/olap_data_convertor.h +++ b/be/src/storage/iterator/olap_data_convertor.h @@ -180,7 +180,7 @@ class OlapBlockDataConvertor { static ColumnPtr clone_and_padding(const ColumnString* input, size_t padding_length) { auto column = ColumnString::create(); - auto padded_column = assert_cast(column->assume_mutable().get()); + auto padded_column = assert_cast(column->assert_mutable().get()); column->offsets.resize(input->size()); column->chars.resize(input->size() * padding_length); diff --git a/be/src/storage/iterator/vcollect_iterator.cpp b/be/src/storage/iterator/vcollect_iterator.cpp index 1c8954168310a0..32df10c933d32d 100644 --- a/be/src/storage/iterator/vcollect_iterator.cpp +++ b/be/src/storage/iterator/vcollect_iterator.cpp @@ -384,7 +384,7 @@ Status VCollectIterator::_topn_next(Block* block) { // create column that is not in mutable_block but in block for (size_t j = mutable_block.columns(); j < block->columns(); ++j) { auto col = block->get_by_position(j).clone_empty(); - mutable_block.mutable_columns().push_back(col.column->assume_mutable()); + mutable_block.mutable_columns().push_back(col.column->assert_mutable()); mutable_block.data_types().push_back(std::move(col.type)); mutable_block.get_names().push_back(std::move(col.name)); } diff --git a/be/src/storage/iterator/vertical_merge_iterator.cpp b/be/src/storage/iterator/vertical_merge_iterator.cpp index 07b3c957653ead..f061c5e9f959ad 100644 --- a/be/src/storage/iterator/vertical_merge_iterator.cpp +++ b/be/src/storage/iterator/vertical_merge_iterator.cpp @@ -332,7 +332,7 @@ Status VerticalMergeIteratorContext::copy_rows(Block* block, size_t count) { ColumnPtr& s_cp = s_col.column; ColumnPtr& d_cp = d_col.column; - d_cp->assume_mutable()->insert_range_from(*s_cp, start, count); + d_cp->assert_mutable()->insert_range_from(*s_cp, start, count); } }); return Status::OK(); @@ -355,7 +355,7 @@ Status VerticalMergeIteratorContext::copy_rows(Block* block, bool advanced) { ColumnPtr& s_cp = s_col.column; ColumnPtr& d_cp = d_col.column; - d_cp->assume_mutable()->insert_range_from(*s_cp, start, _cur_batch_num); + d_cp->assert_mutable()->insert_range_from(*s_cp, start, _cur_batch_num); } }); _cur_batch_num = 0; diff --git a/be/src/storage/iterator/vgeneric_iterators.cpp b/be/src/storage/iterator/vgeneric_iterators.cpp index 17729857a324bd..19efea82d5af3d 100644 --- a/be/src/storage/iterator/vgeneric_iterators.cpp +++ b/be/src/storage/iterator/vgeneric_iterators.cpp @@ -170,7 +170,7 @@ Status VMergeIteratorContext::copy_rows(Block* block, bool advanced) { ColumnPtr& s_cp = s_col.column; ColumnPtr& d_cp = d_col.column; - d_cp->assume_mutable()->insert_range_from(*s_cp, start, _cur_batch_num); + d_cp->assert_mutable()->insert_range_from(*s_cp, start, _cur_batch_num); } }); _cur_batch_num = 0; diff --git a/be/src/storage/partial_update_info.cpp b/be/src/storage/partial_update_info.cpp index a9861aa6ce9171..4adbd834251a42 100644 --- a/be/src/storage/partial_update_info.cpp +++ b/be/src/storage/partial_update_info.cpp @@ -1018,7 +1018,7 @@ Status BlockAggregator::fill_sequence_column(Block* block, size_t num_rows, RETURN_IF_ERROR(read_plan.read_columns_by_plan(_tablet_schema, cids, _writer._rsid_to_rowset, seq_col_block, &read_index, false)); - auto new_seq_col_ptr = tmp_block.get_by_position(0).column->assume_mutable(); + auto new_seq_col_ptr = tmp_block.get_by_position(0).column->assert_mutable(); const auto& old_seq_col_ptr = *seq_col_block.get_by_position(0).column; const auto& cur_seq_col_ptr = *block->get_by_position(_tablet_schema.sequence_col_idx()).column; for (uint32_t block_pos {0}; block_pos < num_rows; block_pos++) { diff --git a/be/src/storage/schema_change/schema_change.cpp b/be/src/storage/schema_change/schema_change.cpp index 9cd6cd702a9900..be8d7b2d395d5f 100644 --- a/be/src/storage/schema_change/schema_change.cpp +++ b/be/src/storage/schema_change/schema_change.cpp @@ -170,14 +170,14 @@ class MultiBlockMerger { if (i == rows - 1 || _cmp.compare(row_refs[i], row_refs[i + 1])) { for (int j = 0; j < key_number; j++) { auto& column_ptr = finalized_block.get_by_position(j).column; - auto column = column_ptr->assume_mutable(); + auto column = column_ptr->assert_mutable(); column->insert_from(*row_ref.get_column(j), row_ref.position); column_ptr = std::move(column); } for (int j = key_number; j < columns; j++) { auto& column_ptr = finalized_block.get_by_position(j).column; - auto column = column_ptr->assume_mutable(); + auto column = column_ptr->assert_mutable(); agg_functions[j - key_number]->insert_result_into( agg_places[j - key_number], *column); column_ptr = std::move(column); @@ -227,7 +227,7 @@ class MultiBlockMerger { for (int idx = 0; idx < columns; idx++) { auto& column_ptr = finalized_block.get_by_position(idx).column; - auto column = column_ptr->assume_mutable(); + auto column = column_ptr->assert_mutable(); for (int j = 0; j < limit; j++) { auto row_ref = pushed_row_refs[i + j]; @@ -377,7 +377,7 @@ Status BlockChanger::change_block(Block* ref_block, Block* new_block) const { } else if (_schema_mapping[idx].ref_column_idx < 0) { // new column, write default value const auto& value = _schema_mapping[idx].default_value; - auto column = new_block->get_by_position(idx).column->assume_mutable(); + auto column = new_block->get_by_position(idx).column->assert_mutable(); if (value.is_null()) { DCHECK(column->is_nullable()); column->insert_many_defaults(row_num); @@ -402,7 +402,7 @@ Status BlockChanger::change_block(Block* ref_block, Block* new_block) const { if (ref_col_nullable != new_col_nullable) { // not nullable to nullable if (new_col_nullable) { - auto mutable_new_col = new_col->assume_mutable(); + auto mutable_new_col = new_col->assert_mutable(); auto* new_nullable_col = assert_cast(mutable_new_col.get()); new_nullable_col->change_nested_column(ref_col); diff --git a/be/src/storage/segment/segment_iterator.cpp b/be/src/storage/segment/segment_iterator.cpp index 8ac492769ea53a..4c232a913b1a48 100644 --- a/be/src/storage/segment/segment_iterator.cpp +++ b/be/src/storage/segment/segment_iterator.cpp @@ -2931,10 +2931,10 @@ Status SegmentIterator::_convert_to_expected_type(const std::vector& c DataTypePtr file_column_type = _storage_name_and_type[i].second; if (!file_column_type->equals(*expected_type)) { ColumnPtr expected; - ColumnPtr original = _current_return_columns[i]->assume_mutable()->get_ptr(); + ColumnPtr original = _current_return_columns[i]->assert_mutable()->get_ptr(); RETURN_IF_ERROR(variant_util::cast_column({original, file_column_type, ""}, expected_type, &expected)); - _current_return_columns[i] = expected->assume_mutable(); + _current_return_columns[i] = expected->assert_mutable(); _converted_column_ids[i] = true; VLOG_DEBUG << fmt::format("Convert {} fom file column type {} to {}, num_rows {}", column_desc->path_info_ptr() == nullptr diff --git a/be/src/storage/segment/segment_iterator.h b/be/src/storage/segment/segment_iterator.h index 5105d050da1872..60dc043ad76ea9 100644 --- a/be/src/storage/segment/segment_iterator.h +++ b/be/src/storage/segment/segment_iterator.h @@ -267,7 +267,7 @@ class SegmentIterator : public RowwiseIterator { &block->get_by_position(block_cid).column)); } else { MutableColumnPtr output_column = - block->get_by_position(block_cid).column->assume_mutable(); + block->get_by_position(block_cid).column->assert_mutable(); RETURN_IF_ERROR(copy_column_data_by_selector(_current_return_columns[cid].get(), output_column, sel_rowid_idx, select_size, _opts.block_row_max)); diff --git a/be/src/storage/segment/variant/variant_column_reader.cpp b/be/src/storage/segment/variant/variant_column_reader.cpp index e7913785274dc1..512841ec649c8e 100644 --- a/be/src/storage/segment/variant/variant_column_reader.cpp +++ b/be/src/storage/segment/variant/variant_column_reader.cpp @@ -1518,7 +1518,7 @@ Status VariantRootColumnIterator::_process_root_column(MutableColumnPtr& dst, auto tmp = ColumnVariant::create(0, obj.enable_doc_mode(), root_column->size()); auto& tmp_obj = *tmp; tmp_obj.add_sub_column({}, std::move(root_column), most_common_type); - // tmp_obj.get_sparse_column()->assume_mutable()->insert_many_defaults(root_column->size()); + // tmp_obj.get_sparse_column()->assert_mutable()->insert_many_defaults(root_column->size()); // merge tmp object column to dst obj.insert_range_from(*tmp, 0, tmp_obj.rows()); diff --git a/be/src/storage/segment/variant/variant_column_writer_impl.cpp b/be/src/storage/segment/variant/variant_column_writer_impl.cpp index 01d01f8c51f203..4d9fd6a9966fc6 100644 --- a/be/src/storage/segment/variant/variant_column_writer_impl.cpp +++ b/be/src/storage/segment/variant/variant_column_writer_impl.cpp @@ -1222,7 +1222,7 @@ Status VariantColumnWriterImpl::_process_root_column(ColumnVariant* ptr, converter->add_column_data_convertor(*_tablet_column); const uint8_t* nullmap = nullptr; // get_root() already returns a MutableColumnPtr; store it to avoid dangling ref and - // to avoid calling assume_mutable() again (which would see use_count>1 and throw). + // to avoid calling assert_mutable() again (which would see use_count>1 and throw). auto root_mut = ptr->get_root(); auto& nullable_column = assert_cast(*root_mut); // Use const access to get the nested column ptr without bumping use_count in the diff --git a/be/src/storage/segment/vertical_segment_writer.cpp b/be/src/storage/segment/vertical_segment_writer.cpp index fdd84bef48c56b..68fa8acd1edc01 100644 --- a/be/src/storage/segment/vertical_segment_writer.cpp +++ b/be/src/storage/segment/vertical_segment_writer.cpp @@ -891,10 +891,10 @@ Status VerticalSegmentWriter::_generate_encoded_default_seq_value(const TabletSc const auto& default_value = info.default_values[idx]; StringRef str {default_value}; RETURN_IF_ERROR(block.get_by_position(0).type->get_serde()->default_from_string( - str, *block.get_by_position(0).column->assume_mutable().get())); + str, *block.get_by_position(0).column->assert_mutable().get())); } else { - block.get_by_position(0).column->assume_mutable()->insert_default(); + block.get_by_position(0).column->assert_mutable()->insert_default(); } DCHECK_EQ(block.rows(), 1); auto olap_data_convertor = std::make_unique(); diff --git a/be/src/storage/segment/virtual_column_iterator.cpp b/be/src/storage/segment/virtual_column_iterator.cpp index 3c905705addbb3..b85be18ebe2f15 100644 --- a/be/src/storage/segment/virtual_column_iterator.cpp +++ b/be/src/storage/segment/virtual_column_iterator.cpp @@ -154,7 +154,7 @@ Status VirtualColumnIterator::read_by_rowids(const rowid_t* rowids, const size_t // Update dst column if (check_and_get_column(*dst)) { VLOG_DEBUG << fmt::format("Dst is nothing column, create new mutable column"); - dst = res_col->assume_mutable(); + dst = res_col->assert_mutable(); } else { dst->insert_range_from(*res_col, 0, res_col->size()); } diff --git a/be/test/core/block/column_test.cpp b/be/test/core/block/column_test.cpp index 69af3ca5bc8563..662f74f6f02fa9 100644 --- a/be/test/core/block/column_test.cpp +++ b/be/test/core/block/column_test.cpp @@ -108,13 +108,13 @@ TEST_F(ColumnTest, CutColumnDecimal64) { TEST_F(ColumnTest, AssumeMutableRequiresExclusiveOwnership) { ColumnPtr column = ColumnInt64::create(); { - auto mutable_column = column->assume_mutable(); + auto mutable_column = column->assert_mutable(); assert_cast(mutable_column.get())->insert_value(1); } ColumnPtr alias = column; - EXPECT_THROW({ (void)column->assume_mutable(); }, doris::Exception); - EXPECT_THROW({ (void)column->assume_mutable_ref(); }, doris::Exception); + EXPECT_THROW({ (void)column->assert_mutable(); }, doris::Exception); + EXPECT_THROW({ (void)column->assert_mutable_ref(); }, doris::Exception); auto cloned = IColumn::mutate(std::move(column)); auto* cloned_int = assert_cast(cloned.get()); diff --git a/be/test/core/column/column_array_test.cpp b/be/test/core/column/column_array_test.cpp index 68a175d3c853aa..163fdfe87bea5f 100644 --- a/be/test/core/column/column_array_test.cpp +++ b/be/test/core/column/column_array_test.cpp @@ -448,7 +448,7 @@ TEST_F(ColumnArrayTest, GetDataAtTest) { TEST_F(ColumnArrayTest, FieldTest) { MutableColumns array_columns_copy; DataTypeSerDeSPtrs serdes_copy; - array_columns_copy.push_back(array_columns[42]->assume_mutable()); + array_columns_copy.push_back(array_columns[42]->assert_mutable()); serdes_copy.push_back(serdes[42]); assert_field_callback(array_columns_copy, serdes_copy); } @@ -643,7 +643,7 @@ TEST_F(ColumnArrayTest, CreateArrayTest) { // - Wrapping shared ColumnConst in ColumnArray violates use_count() assumptions in clear_column_data() for (auto& array_column : array_columns) { const auto* column = check_and_get_column( - remove_nullable(array_column->assume_mutable()).get()); + remove_nullable(array_column->assert_mutable()).get()); auto column_size = column->size(); LOG(INFO) << "column_type: " << column->get_name(); @@ -654,7 +654,7 @@ TEST_F(ColumnArrayTest, CreateArrayTest) { auto const_data = ColumnConst::create(std::move(tmp_data_col), column_size); EXPECT_ANY_THROW({ auto new_array_column = - ColumnArray::create(const_data->assume_mutable(), column->get_offsets_ptr()); + ColumnArray::create(const_data->assert_mutable(), column->get_offsets_ptr()); }); // 2. offsets_column is ColumnConst (violates check_const_only_in_top_level) @@ -663,15 +663,15 @@ TEST_F(ColumnArrayTest, CreateArrayTest) { auto const_offsets = ColumnConst::create(std::move(tmp_offsets_col), column_size); EXPECT_ANY_THROW({ auto new_array_column = - ColumnArray::create(column->get_data_ptr(), const_offsets->assume_mutable()); + ColumnArray::create(column->get_data_ptr(), const_offsets->assert_mutable()); }); // 3. offsets size does not match data size auto tmp_data_col1 = column->get_data_ptr()->clone_resized(2); EXPECT_ANY_THROW({ auto new_array_column = ColumnArray::create( - tmp_data_col1->assume_mutable(), - column->get_offsets_column().clone_resized(1)->assume_mutable()); + tmp_data_col1->assert_mutable(), + column->get_offsets_column().clone_resized(1)->assert_mutable()); }); // Test successful creation with normal columns @@ -740,7 +740,7 @@ TEST_F(ColumnArrayTest, GetNumberOfDimensionsTest) { // test dimension of array for (int i = 0; i < array_columns.size(); i++) { auto column = check_and_get_column( - remove_nullable(array_columns[i]->assume_mutable()).get()); + remove_nullable(array_columns[i]->assert_mutable()).get()); auto check_type = remove_nullable(array_types[i]); auto dimension = 0; while (check_type->get_primitive_type() == TYPE_ARRAY && !check_type->is_nullable()) { @@ -758,7 +758,7 @@ TEST_F(ColumnArrayTest, IsExclusiveTest) { auto callback = [&](const MutableColumns& columns, const DataTypeSerDeSPtrs& serdes) { for (int i = 0; i < columns.size(); i++) { auto column = check_and_get_column( - remove_nullable(columns[i]->assume_mutable()).get()); + remove_nullable(columns[i]->assert_mutable()).get()); auto cloned = columns[i]->clone_resized(1); // test expect true EXPECT_TRUE(column->is_exclusive()); @@ -782,7 +782,7 @@ TEST_F(ColumnArrayTest, MaxArraySizeAsFieldTest) { // in operator[] and get() for (int i = 0; i < array_columns.size(); i++) { auto column = check_and_get_column( - remove_nullable(array_columns[i]->assume_mutable()).get()); + remove_nullable(array_columns[i]->assert_mutable()).get()); auto check_type = remove_nullable(array_types[i]); Field a; column->get(column->size() - 1, a); @@ -817,7 +817,7 @@ TEST_F(ColumnArrayTest, IsDefaultAtTest) { // test is_default_at for (int i = 0; i < array_columns.size(); i++) { auto column = check_and_get_column( - remove_nullable(array_columns[i]->assume_mutable()).get()); + remove_nullable(array_columns[i]->assert_mutable()).get()); auto column_size = column->size(); for (int j = 0; j < column_size; j++) { auto is_default = column->is_default_at(j); @@ -841,10 +841,10 @@ TEST_F(ColumnArrayTest, HasEqualOffsetsTest) { // test has_equal_offsets which more likely used in function, eg: function_array_zip for (int i = 0; i < array_columns.size(); i++) { auto column = check_and_get_column( - remove_nullable(array_columns[i]->assume_mutable()).get()); + remove_nullable(array_columns[i]->assert_mutable()).get()); auto cloned = array_columns[i]->clone_resized(array_columns[i]->size()); auto cloned_arr = - check_and_get_column(remove_nullable(cloned->assume_mutable()).get()); + check_and_get_column(remove_nullable(cloned->assert_mutable()).get()); // test expect true EXPECT_EQ(column->get_offsets().size(), cloned_arr->get_offsets().size()); EXPECT_TRUE(column->has_equal_offsets(*cloned_arr)); diff --git a/be/test/core/column/column_check_const_only_in_top_level_test.cpp b/be/test/core/column/column_check_const_only_in_top_level_test.cpp index 8e2bb7d8c70c90..957a7d6284d7a1 100644 --- a/be/test/core/column/column_check_const_only_in_top_level_test.cpp +++ b/be/test/core/column/column_check_const_only_in_top_level_test.cpp @@ -118,8 +118,8 @@ TEST_F(ColumnCheckConstOnlyInTopLevelTest, ColumnStructWithNonConstElements) { auto int_col2 = ColumnHelper::create_column({4, 5, 6}); MutableColumns columns; - columns.push_back(int_col1->assume_mutable()); - columns.push_back(int_col2->assume_mutable()); + columns.push_back(int_col1->assert_mutable()); + columns.push_back(int_col2->assert_mutable()); // Should not throw EXPECT_NO_THROW({ diff --git a/be/test/core/column/column_ip_test.cpp b/be/test/core/column/column_ip_test.cpp index 05cf6034ed37e5..871a0a2641a18a 100644 --- a/be/test/core/column/column_ip_test.cpp +++ b/be/test/core/column/column_ip_test.cpp @@ -200,8 +200,8 @@ TEST_F(ColumnIPTest, CloneTest) { ip_cols.push_back(std::move(column_ipv4)); ip_cols.push_back(std::move(column_ipv6)); load_data_from_csv(serde, ip_cols, data_files[0], ';', {1, 2}); - assert_clone_empty(ip_cols[0]->assume_mutable_ref()); - assert_clone_empty(ip_cols[1]->assume_mutable_ref()); + assert_clone_empty(ip_cols[0]->assert_mutable_ref()); + assert_clone_empty(ip_cols[1]->assert_mutable_ref()); check_data(ip_cols, serde, ';', {1, 2}, data_files[0], assert_clone_resized_callback); } @@ -257,8 +257,8 @@ TEST_F(ColumnIPTest, PermutationAndSortTest) { ip_cols.push_back(std::move(column_ipv4)); ip_cols.push_back(std::move(column_ipv6)); load_data_from_csv(serde, ip_cols, data_files[1], ';', {1, 2}); - assert_column_permutations(ip_cols[0]->assume_mutable_ref(), dt_ipv4); - assert_column_permutations(ip_cols[1]->assume_mutable_ref(), dt_ipv6); + assert_column_permutations(ip_cols[0]->assert_mutable_ref(), dt_ipv4); + assert_column_permutations(ip_cols[1]->assert_mutable_ref(), dt_ipv6); } TEST_F(ColumnIPTest, FilterTest) { diff --git a/be/test/core/column/column_variant_test.cpp b/be/test/core/column/column_variant_test.cpp index 71f007a73c1615..c35f0d527901d9 100644 --- a/be/test/core/column/column_variant_test.cpp +++ b/be/test/core/column/column_variant_test.cpp @@ -1282,7 +1282,7 @@ TEST_F(ColumnVariantTest, get_data_at) { TEST_F(ColumnVariantTest, replace_column_data) { EXPECT_ANY_THROW( - column_variant->replace_column_data(column_variant->assume_mutable_ref(), 0, 0)); + column_variant->replace_column_data(column_variant->assert_mutable_ref(), 0, 0)); } TEST_F(ColumnVariantTest, serialize_value_into_arena) { @@ -3134,21 +3134,21 @@ TEST_F(ColumnVariantTest, subcolumn_operations_coverage) { col_arr->insert(an); MutableColumnPtr nested_object = ColumnVariant::create( container_variant.max_subcolumns_count(), false, col_arr->get_data().size()); - MutableColumnPtr offset = col_arr->get_offsets_ptr()->assume_mutable(); // [3, 3, 4] + MutableColumnPtr offset = col_arr->get_offsets_ptr()->assert_mutable(); // [3, 3, 4] auto* nested_object_ptr = assert_cast(nested_object.get()); // flatten nested arrays - MutableColumnPtr flattend_column = col_arr->get_data_ptr()->assume_mutable(); + MutableColumnPtr flattend_column = col_arr->get_data_ptr()->assert_mutable(); DataTypePtr flattend_type = DataTypeFactory::instance().create_data_type( FieldType::OLAP_FIELD_TYPE_BIGINT, 0, 0); // add sub path without parent prefix PathInData sub_path("k"); nested_object_ptr->add_sub_column(sub_path, std::move(flattend_column), std::move(flattend_type)); - nested_object = make_nullable(nested_object->get_ptr())->assume_mutable(); + nested_object = make_nullable(nested_object->get_ptr())->assert_mutable(); auto array = make_nullable(ColumnArray::create(std::move(nested_object), std::move(offset))); PathInData path("v.k"); - container_variant.add_sub_column(path, array->assume_mutable(), + container_variant.add_sub_column(path, array->assert_mutable(), container_variant.NESTED_TYPE); container_variant.set_num_rows(3); for (auto subcolumn : container_variant.get_subcolumns()) { diff --git a/be/test/core/data_type/data_type_array_test.cpp b/be/test/core/data_type/data_type_array_test.cpp index 819bf33f227fa2..d867cb77b13158 100644 --- a/be/test/core/data_type/data_type_array_test.cpp +++ b/be/test/core/data_type/data_type_array_test.cpp @@ -465,7 +465,7 @@ TEST_F(DataTypeArrayTest, FromAndToStringTest) { if (i == 13 || i == 31) { continue; } - assert_to_string_from_string_assert(column->assume_mutable(), type); + assert_to_string_from_string_assert(column->assert_mutable(), type); } } diff --git a/be/test/core/data_type_serde/data_type_serde_csv_test.cpp b/be/test/core/data_type_serde/data_type_serde_csv_test.cpp index 84bce05751a061..a9e59922b7996b 100644 --- a/be/test/core/data_type_serde/data_type_serde_csv_test.cpp +++ b/be/test/core/data_type_serde/data_type_serde_csv_test.cpp @@ -512,7 +512,7 @@ TEST(CsvSerde, ComplexTypeSerdeSchemaChangedCsvTest) { DataTypeSerDeSPtr serde = data_type_ptr->get_serde(); Status st = serde->deserialize_one_cell_from_hive_text(*col, slice, formatOptions); EXPECT_EQ(st, Status::OK()); - // Use const access for read-only assertions: avoids assume_mutable_ref() on sub-columns. + // Use const access for read-only assertions: avoids assert_mutable_ref() on sub-columns. const auto& struct_col = static_cast( static_cast(*col.get()).get_nested_column()); EXPECT_EQ(struct_col.get_column(0).get_data_at(0).to_string(), "false"); diff --git a/be/test/core/value/jsonb_value_test2.cpp b/be/test/core/value/jsonb_value_test2.cpp index 5b8af2458b0dfd..10fb996362cc37 100644 --- a/be/test/core/value/jsonb_value_test2.cpp +++ b/be/test/core/value/jsonb_value_test2.cpp @@ -73,7 +73,7 @@ TEST(JsonbValueConvertorTest, JsonbValueValid) { ASSERT_EQ(input->size(), 5); // 2. put column into block - ColumnWithTypeAndName argument(input->assume_mutable(), dataTypeJsonb, "jsonb_column"); + ColumnWithTypeAndName argument(input->assert_mutable(), dataTypeJsonb, "jsonb_column"); Block block; block.insert(argument); @@ -115,7 +115,7 @@ TEST(JsonbValueConvertorTest, JsonbValueValid) { ASSERT_EQ(5, nullable_col->size()); // 2. put column into block - ColumnWithTypeAndName argument1(nullable_col->assume_mutable(), nullable_dataTypeJsonb, + ColumnWithTypeAndName argument1(nullable_col->assert_mutable(), nullable_dataTypeJsonb, "jsonb_column_null"); block.clear(); block.insert(argument1); @@ -175,7 +175,7 @@ TEST(JsonbValueConvertorTest, JsonbValueInvalid) { ASSERT_EQ(input->size(), 5); // 2. put column into block - ColumnWithTypeAndName argument(input->assume_mutable(), dataTypeJsonb, "jsonb_column"); + ColumnWithTypeAndName argument(input->assert_mutable(), dataTypeJsonb, "jsonb_column"); Block block; block.insert(argument); @@ -224,7 +224,7 @@ TEST(JsonbValueConvertorTest, JsonbValueInvalid) { ASSERT_EQ(5, nullable_col->size()); // 2. put column into block - ColumnWithTypeAndName argument1(nullable_col->assume_mutable(), nullable_dataTypeJsonb, + ColumnWithTypeAndName argument1(nullable_col->assert_mutable(), nullable_dataTypeJsonb, "jsonb_column_null"); block.clear(); block.insert(argument1); diff --git a/be/test/exec/column_type_convert_test.cpp b/be/test/exec/column_type_convert_test.cpp index f336a245568cbd..2b88ea9228ef76 100644 --- a/be/test/exec/column_type_convert_test.cpp +++ b/be/test/exec/column_type_convert_test.cpp @@ -1569,7 +1569,7 @@ TEST_F(ColumnTypeConverterTest, TestStringToDateLikeConversions) { src_col->insert_data("bad-date", 8); auto dst_col = nullable_dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); + auto mutable_dst = dst_col->assert_mutable(); auto& nullable_col = static_cast(*mutable_dst); auto& nested_col = static_cast(nullable_col.get_nested_column()); auto& null_map = nullable_col.get_null_map_data(); @@ -1597,7 +1597,7 @@ TEST_F(ColumnTypeConverterTest, TestStringToDateLikeConversions) { src_col->insert_data("bad-datev2", 10); auto dst_col = nullable_dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); + auto mutable_dst = dst_col->assert_mutable(); auto& nullable_col = static_cast(*mutable_dst); auto& nested_col = static_cast(nullable_col.get_nested_column()); auto& null_map = nullable_col.get_null_map_data(); @@ -1623,7 +1623,7 @@ TEST_F(ColumnTypeConverterTest, TestStringToDateLikeConversions) { src_col->insert_data("bad-datetime", 12); auto dst_col = nullable_dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); + auto mutable_dst = dst_col->assert_mutable(); auto& nullable_col = static_cast(*mutable_dst); auto& nested_col = static_cast(nullable_col.get_nested_column()); auto& null_map = nullable_col.get_null_map_data(); @@ -1651,7 +1651,7 @@ TEST_F(ColumnTypeConverterTest, TestStringToDateLikeConversions) { src_col->insert_data("bad-datetimev2", 14); auto dst_col = nullable_dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); + auto mutable_dst = dst_col->assert_mutable(); auto& nullable_col = static_cast(*mutable_dst); auto& nested_col = static_cast(nullable_col.get_nested_column()); auto& null_map = nullable_col.get_null_map_data(); diff --git a/be/test/exec/common/schema_util_test.cpp b/be/test/exec/common/schema_util_test.cpp index 3599036fe2f76e..05b9f14ab8c0c8 100644 --- a/be/test/exec/common/schema_util_test.cpp +++ b/be/test/exec/common/schema_util_test.cpp @@ -1329,7 +1329,7 @@ TEST_F(SchemaUtilTest, TestParseVariantColumnsWithNulls) { auto nullable_string = make_nullable(string_column->get_ptr()); auto variant_column = ColumnVariant::create(10, false); - variant_column->create_root(string_type, nullable_string->assume_mutable()); + variant_column->create_root(string_type, nullable_string->assert_mutable()); auto nullable_variant = make_nullable(variant_column->get_ptr()); block.insert({nullable_variant, variant_type, "nullable_variant"}); diff --git a/be/test/exprs/aggregate/agg_collect_test.cpp b/be/test/exprs/aggregate/agg_collect_test.cpp index d5394ab86c428e..94e0d40eb77c1a 100644 --- a/be/test/exprs/aggregate/agg_collect_test.cpp +++ b/be/test/exprs/aggregate/agg_collect_test.cpp @@ -148,14 +148,14 @@ class VAggCollectTest : public testing::Test { agg_function->merge(place, place2, _agg_arena_pool); auto column_result = ColumnArray::create(std::move(make_nullable(data_types[0]->create_column()))); - agg_function->insert_result_into(place, column_result->assume_mutable_ref()); + agg_function->insert_result_into(place, column_result->assert_mutable_ref()); EXPECT_EQ(column_result->size(), 1); EXPECT_EQ(column_result->get_offsets()[0], is_distinct(fn_name) ? input_nums : 2 * input_nums * _repeated_times); auto column_result2 = ColumnArray::create(std::move(make_nullable(data_types[0]->create_column()))); - agg_function->insert_result_into(place2, column_result2->assume_mutable_ref()); + agg_function->insert_result_into(place2, column_result2->assert_mutable_ref()); EXPECT_EQ(column_result2->size(), 1); EXPECT_EQ(column_result2->get_offsets()[0], is_distinct(fn_name) ? input_nums : input_nums * _repeated_times); diff --git a/be/test/exprs/function/function_variant_element_test.cpp b/be/test/exprs/function/function_variant_element_test.cpp index 98265fda3fa76e..1a8d6985167f28 100644 --- a/be/test/exprs/function/function_variant_element_test.cpp +++ b/be/test/exprs/function/function_variant_element_test.cpp @@ -45,7 +45,7 @@ TEST(function_variant_element_test, extract_from_sparse_column) { ColumnPtr result; ColumnPtr index_column_ptr = ColumnString::create(); auto* index_column_ptr_mutable = - assert_cast(index_column_ptr->assume_mutable().get()); + assert_cast(index_column_ptr->assert_mutable().get()); index_column_ptr_mutable->insert_data("profile", 7); ColumnPtr index_column = ColumnConst::create(index_column_ptr, 1); auto status = diff --git a/be/test/format/native/native_reader_writer_test.cpp b/be/test/format/native/native_reader_writer_test.cpp index 0f38721558217b..3d8e9bf8f63e67 100644 --- a/be/test/format/native/native_reader_writer_test.cpp +++ b/be/test/format/native/native_reader_writer_test.cpp @@ -98,7 +98,7 @@ static void fill_array_column(Block& block, size_t rows) { auto& array_col = assert_cast(nested); auto& offsets = array_col.get_offsets(); auto& data = array_col.get_data(); - auto mutable_data = data.assume_mutable(); + auto mutable_data = data.assert_mutable(); for (size_t i = 0; i < rows; ++i) { if (i % 5 == 0) { @@ -144,8 +144,8 @@ static void fill_map_column(Block& block, size_t rows) { auto& keys = assert_cast(nested).get_keys(); auto& values = assert_cast(nested).get_values(); - auto mutable_keys = keys.assume_mutable(); - auto mutable_values = values.assume_mutable(); + auto mutable_keys = keys.assert_mutable(); + auto mutable_values = values.assert_mutable(); std::string k1 = "k" + std::to_string(i); std::string k2 = "k" + std::to_string(i + 1); @@ -187,8 +187,8 @@ static void fill_struct_column(Block& block, size_t rows) { nullable_col->insert_default(); } else { null_map.push_back(0); - auto mutable_field0 = fields[0]->assume_mutable(); - auto mutable_field1 = fields[1]->assume_mutable(); + auto mutable_field0 = fields[0]->assert_mutable(); + auto mutable_field1 = fields[1]->assert_mutable(); // int field mutable_field0->insert(Field::create_field( static_cast(i * 100))); @@ -495,7 +495,7 @@ TEST_F(NativeReaderWriterTest, round_trip_native_file_large_rows) { for (size_t col = 0; col < src_block.columns(); ++col) { const auto& src_col = *src_block.get_by_position(col).column; const auto& dst_col_holder = *sub_block.get_by_position(col).column; - auto dst_mutable = dst_col_holder.assume_mutable(); + auto dst_mutable = dst_col_holder.assert_mutable(); dst_mutable->insert_range_from(src_col, offset, len); } st = transformer.write(sub_block); @@ -1069,7 +1069,7 @@ static Block create_all_types_test_block() { auto& array_col = assert_cast(nested); auto& offsets = array_col.get_offsets(); auto& data = array_col.get_data(); - auto mutable_data = data.assume_mutable(); + auto mutable_data = data.assert_mutable(); mutable_data->insert( Field::create_field(static_cast(10))); @@ -1098,8 +1098,8 @@ static Block create_all_types_test_block() { auto& keys = assert_cast(nested).get_keys(); auto& values = assert_cast(nested).get_values(); - auto mutable_keys = keys.assume_mutable(); - auto mutable_values = values.assume_mutable(); + auto mutable_keys = keys.assert_mutable(); + auto mutable_values = values.assert_mutable(); mutable_keys->insert(Field::create_field(std::string("key1"))); mutable_values->insert( @@ -1130,8 +1130,8 @@ static Block create_all_types_test_block() { auto& struct_col = assert_cast(nested); const auto& fields = struct_col.get_columns(); - auto mutable_field0 = fields[0]->assume_mutable(); - auto mutable_field1 = fields[1]->assume_mutable(); + auto mutable_field0 = fields[0]->assert_mutable(); + auto mutable_field1 = fields[1]->assert_mutable(); mutable_field0->insert( Field::create_field(static_cast(999))); diff --git a/be/test/format/orc/orc_read_lines.cpp b/be/test/format/orc/orc_read_lines.cpp index c920e091821435..550e9ac28a61a4 100644 --- a/be/test/format/orc/orc_read_lines.cpp +++ b/be/test/format/orc/orc_read_lines.cpp @@ -157,7 +157,7 @@ static void read_orc_line(int64_t line, std::string block_dump, } auto data_type = DataTypeFactory::instance().create_data_type(PrimitiveType::TYPE_VARCHAR, false); - block->insert(ColumnWithTypeAndName(data_type->create_column()->assume_mutable(), data_type, + block->insert(ColumnWithTypeAndName(data_type->create_column()->assert_mutable(), data_type, "row_id")); bool eof = false; diff --git a/be/test/format/orc/orc_reader_fill_data_test.cpp b/be/test/format/orc/orc_reader_fill_data_test.cpp index 84ba8af9da3382..dd1d0d2a595034 100644 --- a/be/test/format/orc/orc_reader_fill_data_test.cpp +++ b/be/test/format/orc/orc_reader_fill_data_test.cpp @@ -83,7 +83,7 @@ TEST_F(OrcReaderFillDataTest, TestFillLongColumn) { TFileRangeDesc range; auto reader = OrcReader::create_unique(params, range, 4064, "", nullptr, nullptr, true); - MutableColumnPtr xx = column->assume_mutable(); + MutableColumnPtr xx = column->assert_mutable(); Status status = reader->_fill_doris_data_column( "test_long", xx, data_type, const_node, orc_type_ptr.get(), batch.get(), values.size()); @@ -109,7 +109,7 @@ TEST_F(OrcReaderFillDataTest, TestFillLongColumnWithNull) { TFileRangeDesc range; auto reader = OrcReader::create_unique(params, range, 4064, "", nullptr, nullptr, true); - MutableColumnPtr xx = column->assume_mutable(); + MutableColumnPtr xx = column->assert_mutable(); Status status = reader->_fill_doris_data_column("test_long_with_null", xx, data_type, const_node, @@ -204,7 +204,7 @@ TEST_F(OrcReaderFillDataTest, ComplexTypeConversionTest) { std::vector { std::make_shared(std::make_shared())}, std::vector {"col1"}); - MutableColumnPtr doris_column = doris_struct_type->create_column()->assume_mutable(); + MutableColumnPtr doris_column = doris_struct_type->create_column()->assert_mutable(); Status status = reader->_fill_doris_data_column("test", doris_column, doris_struct_type, const_node, @@ -290,7 +290,7 @@ TEST_F(OrcReaderFillDataTest, ComplexTypeConversionTest) { std::vector {std::make_shared(), std::make_shared()}, std::vector {"col1", "col2"}); - MutableColumnPtr doris_column = doris_struct_type->create_column()->assume_mutable(); + MutableColumnPtr doris_column = doris_struct_type->create_column()->assert_mutable(); Status status = reader->_fill_doris_data_column("test", doris_column, doris_struct_type, const_node, @@ -375,7 +375,7 @@ TEST_F(OrcReaderFillDataTest, ComplexTypeConversionTest) { auto doris_struct_type = std::make_shared( std::vector {std::make_shared(18, 5)}, std::vector {"col1"}); - MutableColumnPtr doris_column = doris_struct_type->create_column()->assume_mutable(); + MutableColumnPtr doris_column = doris_struct_type->create_column()->assert_mutable(); reader->_decimal_scale_params.resize(0); reader->_decimal_scale_params_index = 0; Status status = reader->_fill_doris_data_column("test", doris_column, @@ -488,7 +488,7 @@ TEST_F(OrcReaderFillDataTest, ComplexTypeConversionTest) { auto doris_struct_type = std::make_shared(std::make_shared(), std::make_shared()); - MutableColumnPtr doris_column = doris_struct_type->create_column()->assume_mutable(); + MutableColumnPtr doris_column = doris_struct_type->create_column()->assert_mutable(); Status status = reader->_fill_doris_data_column("test", doris_column, doris_struct_type, diff --git a/be/test/format/parquet/parquet_read_lines.cpp b/be/test/format/parquet/parquet_read_lines.cpp index 7ca86957d49639..9dc6ba41a2fa40 100644 --- a/be/test/format/parquet/parquet_read_lines.cpp +++ b/be/test/format/parquet/parquet_read_lines.cpp @@ -170,7 +170,7 @@ static void read_parquet_lines(std::vector numeric_types, auto data_type = DataTypeFactory::instance().create_data_type(PrimitiveType::TYPE_VARCHAR, false); - block->insert(ColumnWithTypeAndName(data_type->create_column()->assume_mutable(), data_type, + block->insert(ColumnWithTypeAndName(data_type->create_column()->assert_mutable(), data_type, "row_id")); bool eof = false; diff --git a/be/test/format/parquet/parquet_thrift_test.cpp b/be/test/format/parquet/parquet_thrift_test.cpp index 4bbe6dc09e41e9..0fe101db598138 100644 --- a/be/test/format/parquet/parquet_thrift_test.cpp +++ b/be/test/format/parquet/parquet_thrift_test.cpp @@ -162,7 +162,7 @@ TEST_F(ParquetThriftReaderTest, complex_nested_file) { static int fill_nullable_column(ColumnPtr& doris_column, level_t* definitions, size_t num_values) { CHECK(doris_column->is_nullable()); doris_column = IColumn::mutate(std::move(doris_column)); - auto* nullable_column = assert_cast(doris_column->assume_mutable().get()); + auto* nullable_column = assert_cast(doris_column->assert_mutable().get()); NullMap& map_data = nullable_column->get_null_map_data(); int null_cnt = 0; for (int i = 0; i < num_values; ++i) { @@ -220,11 +220,11 @@ static Status get_column_values(io::FileReaderSPtr file_reader, tparquet::Column if (src_column->is_nullable()) { // fill nullable values fill_nullable_column(src_column, definitions, rows); - auto* nullable_column = assert_cast(src_column->assume_mutable().get()); + auto* nullable_column = assert_cast(src_column->assert_mutable().get()); data_column = nullable_column->get_nested_column_ptr(); } else { src_column = IColumn::mutate(std::move(src_column)); - data_column = src_column->assume_mutable(); + data_column = src_column->assert_mutable(); } FilterMap filter_map; RETURN_IF_ERROR(filter_map.init(nullptr, 0, false)); diff --git a/be/test/storage/iterator/vertical_merge_iterator_test.cpp b/be/test/storage/iterator/vertical_merge_iterator_test.cpp index 942721c85d9ec1..2fabcb69e38f16 100644 --- a/be/test/storage/iterator/vertical_merge_iterator_test.cpp +++ b/be/test/storage/iterator/vertical_merge_iterator_test.cpp @@ -83,7 +83,7 @@ class SparseColumnOptimizationTest : public ::testing::Test { // Simulate copy_rows logic for nullable columns with sparse optimization static void copy_rows_with_optimization(const ColumnNullable* src, size_t start, size_t count, IColumn* dst_col) { - auto* dst_mut = dst_col->assume_mutable().get(); + auto* dst_mut = dst_col->assert_mutable().get(); const size_t non_null_count = count_non_null(src, start, count); @@ -112,7 +112,7 @@ class SparseColumnOptimizationTest : public ::testing::Test { // Original copy_rows logic (direct copy) static void copy_rows_original(const IColumn* src, size_t start, size_t count, IColumn* dst_col) { - dst_col->assume_mutable()->insert_range_from(*src, start, count); + dst_col->assert_mutable()->insert_range_from(*src, start, count); } // Helper to compare two nullable columns diff --git a/be/test/storage/segment/variant_stats_calculator_test.cpp b/be/test/storage/segment/variant_stats_calculator_test.cpp index 66c3050370c6fd..1f5143ca422f8a 100644 --- a/be/test/storage/segment/variant_stats_calculator_test.cpp +++ b/be/test/storage/segment/variant_stats_calculator_test.cpp @@ -312,7 +312,7 @@ TEST_F(VariantStatsCalculatorTest, CalculateVariantStatsWithMultipleColumns) { std::make_shared(std::make_shared()), "sub1"}); auto map_col = create_map_column(); - map_col->assume_mutable()->insert_many_defaults(3); + map_col->assert_mutable()->insert_many_defaults(3); block.insert({std::move(map_col), std::make_shared(std::make_shared(), std::make_shared()),