This is an automated email from the ASF dual-hosted git repository.
zclllyybb pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new a5b43fb2a4a [followup](BE) rename assume_mutable to assert_mutable
(#63557)
a5b43fb2a4a is described below
commit a5b43fb2a4ac9852a0b371f8f9d017e96b4d7aea
Author: zclllyybb <[email protected]>
AuthorDate: Sat May 23 17:11:16 2026 +0800
[followup](BE) rename assume_mutable to assert_mutable (#63557)
followup https://github.com/apache/doris/pull/63001. we changed the
actual meaning of `assume_mutable`
---
be/benchmark/benchmark_column_view.hpp | 2 +-
be/src/core/AGENTS.md | 4 ++--
be/src/core/block/block.cpp | 16 +++++++--------
be/src/core/column/column_map.cpp | 2 +-
be/src/core/column/column_nullable.cpp | 2 +-
be/src/core/column/column_nullable.h | 4 ++--
be/src/core/cow.h | 16 +++++++--------
be/src/exec/common/util.hpp | 2 +-
.../exec/operator/aggregation_source_operator.cpp | 2 +-
be/src/exec/operator/assert_num_rows_operator.cpp | 2 +-
.../distinct_streaming_aggregation_operator.cpp | 4 ++--
be/src/exec/operator/hashjoin_build_sink.cpp | 4 ++--
.../operator/join/process_hash_table_probe_impl.h | 2 +-
.../operator/nested_loop_join_probe_operator.h | 2 +-
be/src/exec/operator/operator.cpp | 4 ++--
be/src/exec/rowid_fetcher.cpp | 2 +-
be/src/exec/sort/sorter.cpp | 4 ++--
.../exprs/aggregate/aggregate_function_null_v2.h | 4 ++--
.../function/array/function_array_aggregation.cpp | 12 +++++------
.../array/function_array_with_constant.cpp | 2 +-
be/src/exprs/function/cast/cast_to_variant.h | 8 ++++----
be/src/exprs/function/dictionary_util.h | 2 +-
.../function/function_other_types_to_date.cpp | 22 ++++++++++----------
.../exprs/function/function_variadic_arguments.h | 6 +++---
be/src/exprs/function/function_variant_element.cpp | 6 +++---
.../exprs/lambda_function/varray_map_function.cpp | 4 ++--
.../exprs/lambda_function/varray_sort_function.cpp | 2 +-
be/src/exprs/runtime_filter_expr.cpp | 2 +-
be/src/exprs/vexpr_context.cpp | 4 ++--
be/src/exprs/vtopn_pred.h | 2 +-
be/src/format/json/new_json_reader.cpp | 14 ++++++-------
be/src/format/orc/vorc_reader.cpp | 6 +++---
be/src/format/parquet/parquet_column_convert.h | 6 +++---
be/src/format/parquet/vparquet_column_reader.cpp | 22 ++++++++++----------
be/src/format/parquet/vparquet_column_reader.h | 2 +-
be/src/format/parquet/vparquet_group_reader.cpp | 6 +++---
be/src/format/table/table_format_reader.h | 2 +-
be/src/storage/iterator/olap_data_convertor.h | 2 +-
be/src/storage/iterator/vcollect_iterator.cpp | 2 +-
.../storage/iterator/vertical_merge_iterator.cpp | 4 ++--
be/src/storage/iterator/vgeneric_iterators.cpp | 2 +-
be/src/storage/partial_update_info.cpp | 2 +-
be/src/storage/schema_change/schema_change.cpp | 10 ++++-----
be/src/storage/segment/segment_iterator.cpp | 4 ++--
be/src/storage/segment/segment_iterator.h | 2 +-
.../segment/variant/variant_column_reader.cpp | 2 +-
.../segment/variant/variant_column_writer_impl.cpp | 2 +-
be/src/storage/segment/vertical_segment_writer.cpp | 4 ++--
be/src/storage/segment/virtual_column_iterator.cpp | 2 +-
be/test/core/block/column_test.cpp | 6 +++---
be/test/core/column/column_array_test.cpp | 24 +++++++++++-----------
.../column_check_const_only_in_top_level_test.cpp | 4 ++--
be/test/core/column/column_ip_test.cpp | 8 ++++----
be/test/core/column/column_variant_test.cpp | 10 ++++-----
be/test/core/data_type/data_type_array_test.cpp | 2 +-
.../data_type_serde/data_type_serde_csv_test.cpp | 2 +-
be/test/core/value/jsonb_value_test2.cpp | 8 ++++----
be/test/exec/column_type_convert_test.cpp | 8 ++++----
be/test/exec/common/schema_util_test.cpp | 2 +-
be/test/exprs/aggregate/agg_collect_test.cpp | 4 ++--
.../function/function_variant_element_test.cpp | 2 +-
.../format/native/native_reader_writer_test.cpp | 22 ++++++++++----------
be/test/format/orc/orc_read_lines.cpp | 2 +-
be/test/format/orc/orc_reader_fill_data_test.cpp | 12 +++++------
be/test/format/parquet/parquet_read_lines.cpp | 2 +-
be/test/format/parquet/parquet_thrift_test.cpp | 6 +++---
.../iterator/vertical_merge_iterator_test.cpp | 4 ++--
.../segment/variant_stats_calculator_test.cpp | 2 +-
68 files changed, 188 insertions(+), 188 deletions(-)
diff --git a/be/benchmark/benchmark_column_view.hpp
b/be/benchmark/benchmark_column_view.hpp
index 02ce3294b5b..891a4340081 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 8578a7e1ff3..b31c1afad0d 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 99c8ece8b51..c556eb3242c 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<uint32_t>&
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<uint32_t>& 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<uint32_t>& 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<uint32_t>& 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<ColumnUInt8*>(mutable_holder.get());
@@ -980,7 +980,7 @@ Status Block::filter_block(Block* block, const
std::vector<uint32_t>& 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<size_t>& 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 7ad4cb522ef..399f558caf5 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<IColumn::Ptr&>(keys_column) = k_arr->get_data_ptr();
static_cast<IColumn::Ptr&>(offsets_column) = k_arr->get_offsets_ptr();
static_cast<IColumn::Ptr&>(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<const IColumn::Ptr&>(offsets_column)->size();
}
diff --git a/be/src/core/column/column_nullable.cpp
b/be/src/core/column/column_nullable.cpp
index ed6f5865543..03674fb0917 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<ColumnNullable*>(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<IColumn*>(
static_cast<const
WrappedPtr&>(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 025e3797673..769c0a0a05f 100644
--- a/be/src/core/column/column_nullable.h
+++ b/be/src/core/column/column_nullable.h
@@ -278,7 +278,7 @@ public:
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 @@ public:
}
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<ColumnUInt8&,
TypeCheckOnRelease::DISABLE>(*_null_map);
}
diff --git a/be/src/core/cow.h b/be/src/core/cow.h
index 4fb6059a1fc..afa0cab3d5b 100644
--- a/be/src/core/cow.h
+++ b/be/src/core/cow.h
@@ -309,7 +309,7 @@ protected:
if (this->use_count() > 1) {
return derived()->clone();
} else {
- return assume_mutable();
+ return assert_mutable();
}
}
@@ -320,17 +320,17 @@ public:
// 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<COW*>(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&>(*derived());
}
@@ -351,13 +351,13 @@ protected:
: value(std::forward<std::initializer_list<U>>(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<T>&() const { return value; }
operator immutable_ptr<T>&() { return value; }
diff --git a/be/src/exec/common/util.hpp b/be/src/exec/common/util.hpp
index 477005f709d..2b6eb69c7bf 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<ColumnConst*>(column.get())->get_data_column_ptr()->assume_mutable());
+
assert_cast<ColumnConst*>(column.get())->get_data_column_ptr()->assert_mutable());
} else if (column->has_null()) {
auto* nullable = assert_cast<ColumnNullable*>(column.get());
auto* __restrict data =
assert_cast<ColumnUInt8*>(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 05e6a30c612..0699d6a6002 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 0013eb294af..290ed763ed6 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 92c11cf2896..e6a26904913 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 3071e5e5322..0a523138b46 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<ColumnNullable*>(column->assume_mutable().get())
+
assert_cast<ColumnNullable*>(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<ColumnNullable*>(column->assume_mutable().get())
+ assert_cast<ColumnNullable*>(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 bcc4408906b..8e4e0131ffe 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<JoinOpType>::do_other_join_conjuncts(Block* output_
output_block->insert({std::move(filter_column),
std::make_shared<DataTypeUInt8>(), ""});
uint8_t* __restrict filter_column_ptr =
assert_cast<ColumnUInt8&>(
-
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 9313331fc69..890b6e2cbe1 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 @@ public:
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 6f7bd22539a..d03f75306d5 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 4322842792b..66dbbfcaf39 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<segment_v2::rowid_t> row_ids {
static_cast<segment_v2::rowid_t>(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 686cca97e84..9b2ecd60953 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<const
ColumnConst*>(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 a3b513d6014..881478e2812 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 @@ public:
auto& nullable_col = assert_cast<ColumnNullable&>(*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 @@ public:
if constexpr (result_is_nullable) {
auto& dst_nullable_col = assert_cast<ColumnNullable&>(*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 dbcf438e419..9bed157223a 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<ColumnNullable&>(res_column->assume_mutable_ref()).reserve(offsets.size());
+
assert_cast<ColumnNullable&>(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<operation, ResultType> {
ColumnPtr res_column = create_column_func(column);
res_column = make_nullable(res_column);
-
assert_cast<ColumnNullable&>(res_column->assume_mutable_ref()).reserve(offsets.size());
+
assert_cast<ColumnNullable&>(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<operation, ResultType>
{
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 224f0a1282f..b1e513fbb15 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 @@ public:
}
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 3aebb66212a..6c6ed1743fc 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<ColumnNullable&>(*col_to->assume_mutable())
+ assert_cast<ColumnNullable&>(*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 d60bedb56ea..87e6603a866 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 002112993fe..bc24d76df27 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<TYPE_DATEV2>(
context, ldata, loffsets,
specific_char_column->get_data_at(0),
result_null_map,
-
static_cast<ColumnDateV2*>(res->assume_mutable().get())->get_data());
+
static_cast<ColumnDateV2*>(res->assert_mutable().get())->get_data());
} else {
execute_impl<TYPE_DATEV2>(
context, ldata, loffsets, rdata, roffsets,
result_null_map,
-
static_cast<ColumnDateV2*>(res->assume_mutable().get())->get_data());
+
static_cast<ColumnDateV2*>(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<TYPE_DATETIMEV2>(
context, ldata, loffsets,
specific_char_column->get_data_at(0),
result_null_map,
-
static_cast<ColumnDateTimeV2*>(res->assume_mutable().get())->get_data());
+
static_cast<ColumnDateTimeV2*>(res->assert_mutable().get())->get_data());
} else {
execute_impl<TYPE_DATETIMEV2>(
context, ldata, loffsets, rdata, roffsets,
result_null_map,
-
static_cast<ColumnDateTimeV2*>(res->assume_mutable().get())->get_data());
+
static_cast<ColumnDateTimeV2*>(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<ColumnDateV2*>(res_column->assume_mutable().get())->get_data());
+
static_cast<ColumnDateV2*>(res_column->assert_mutable().get())->get_data());
} else {
execute_impl(
year_col->get_data(), dayofyear_col->get_data(),
result_null_map,
-
static_cast<ColumnDateV2*>(res_column->assume_mutable().get())->get_data());
+
static_cast<ColumnDateV2*>(res_column->assert_mutable().get())->get_data());
}
// Wrap result in nullable column only if input has nullable arguments
@@ -542,7 +542,7 @@ private:
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<const
ColumnType*>(datetime_column.get())->get_data();
- auto& res =
static_cast<ColumnType*>(result_column->assume_mutable().get())->get_data();
+ auto& res =
static_cast<ColumnType*>(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 @@ public:
res_column = ColumnDate::create(input_rows_count);
_execute<VecDateTimeValue>(
input_rows_count, data_col->get_data(), result_null_map,
-
static_cast<ColumnDateTime*>(res_column->assume_mutable().get())->get_data());
+
static_cast<ColumnDateTime*>(res_column->assert_mutable().get())->get_data());
} else {
res_column = ColumnDateV2::create(input_rows_count);
_execute<DateV2Value<DateV2ValueType>>(
input_rows_count, data_col->get_data(), result_null_map,
-
static_cast<ColumnDateV2*>(res_column->assume_mutable().get())->get_data());
+
static_cast<ColumnDateV2*>(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<ResultColumnType*>(res_column->assume_mutable().get())->get_data(),
+
static_cast<ResultColumnType*>(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<ResultColumnType*>(res_column->assume_mutable().get())->get_data(),
+
static_cast<ResultColumnType*>(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 aaf518697c1..02f96d36546 100644
--- a/be/src/exprs/function/function_variadic_arguments.h
+++ b/be/src/exprs/function/function_variadic_arguments.h
@@ -61,17 +61,17 @@ public:
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 cef269c6135..4736342f4ee 100644
--- a/be/src/exprs/function/function_variant_element.cpp
+++ b/be/src/exprs/function/function_variant_element.cpp
@@ -263,9 +263,9 @@ private:
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 @@ private:
}
*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 4a95a1df262..79fbb5f5dfd 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 @@ public:
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 @@ public:
} 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 9f0191753f3..29fe56b0476 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 @@ public:
NullMap* temp_nullmap_data[2] = {nullptr, nullptr};
for (int i = 0; i < 2; i++) {
auto* temp_column = assert_cast<ColumnNullable*>(
-
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 9a58421553c..e335e8ed4da 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<ColumnConst>(*filter_column)) {
diff --git a/be/src/exprs/vexpr_context.cpp b/be/src/exprs/vexpr_context.cpp
index 9ad6182fc97..c8ca10ab048 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 13b136c7027..526787bccc6 100644
--- a/be/src/exprs/vtopn_pred.h
+++ b/be/src/exprs/vtopn_pred.h
@@ -118,7 +118,7 @@ public:
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 90a4bd65b22..cc5208b7c30 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<false>(
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<const
DataTypeMap*>(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<const
DataTypeMap*>(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<ColumnNullable*>(
-
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<ColumnBitmap*>(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<ColumnNullable*>(
-
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<ColumnBitmap*>(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 70c4d4affaf..47eb9a23f4f 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 9206ea285ac..6a4d8f39835 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<ColumnNullable*>(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<ColumnNullable*>(dst_column->assume_mutable().get());
+ auto* dst_nullable =
assert_cast<ColumnNullable*>(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 @@ public:
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 1deffec6a04..d5861a231d4 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<IN_COLLECTION,
OFFSET_INDEX>::_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<ColumnNullable*>(mutable_column.get());
data_column = nullable_column->get_nested_column_ptr();
@@ -374,7 +374,7 @@ Status ScalarColumnReader<IN_COLLECTION,
OFFSET_INDEX>::_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<IN_COLLECTION,
OFFSET_INDEX>::_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<ColumnNullable*>(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<IN_COLLECTION,
OFFSET_INDEX>::_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<uint16_t> 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<ColumnNullable*>(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<ColumnNullable*>(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<ColumnNullable*>(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<ColumnNullable*>(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 8673361eb46..9f01f4f6324 100644
--- a/be/src/format/parquet/vparquet_column_reader.h
+++ b/be/src/format/parquet/vparquet_column_reader.h
@@ -483,7 +483,7 @@ public:
// 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 a346fa91585..016fc4eb9d7 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 ed5b414aa44..efe7c1f901e 100644
--- a/be/src/format/table/table_format_reader.h
+++ b/be/src/format/table/table_format_reader.h
@@ -111,7 +111,7 @@ public:
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 82376ac890c..8909a400601 100644
--- a/be/src/storage/iterator/olap_data_convertor.h
+++ b/be/src/storage/iterator/olap_data_convertor.h
@@ -180,7 +180,7 @@ private:
static ColumnPtr clone_and_padding(const ColumnString* input, size_t
padding_length) {
auto column = ColumnString::create();
- auto padded_column =
assert_cast<ColumnString*>(column->assume_mutable().get());
+ auto padded_column =
assert_cast<ColumnString*>(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 1c895416831..32df10c933d 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 07b3c957653..f061c5e9f95 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 17729857a32..19efea82d5a 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 a9861aa6ce9..4adbd834251 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 9cd6cd702a9..be8d7b2d395 100644
--- a/be/src/storage/schema_change/schema_change.cpp
+++ b/be/src/storage/schema_change/schema_change.cpp
@@ -170,14 +170,14 @@ public:
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 @@ public:
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<ColumnNullable*>(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 8ac492769ea..4c232a913b1 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<ColumnId>& 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 5105d050da1..60dc043ad76 100644
--- a/be/src/storage/segment/segment_iterator.h
+++ b/be/src/storage/segment/segment_iterator.h
@@ -267,7 +267,7 @@ private:
&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 e7913785274..512841ec649 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 01d01f8c51f..4d9fd6a9966 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<ColumnNullable&>(*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 fdd84bef48c..68fa8acd1ed 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<OlapBlockDataConvertor>();
diff --git a/be/src/storage/segment/virtual_column_iterator.cpp
b/be/src/storage/segment/virtual_column_iterator.cpp
index 3c905705add..b85be18ebe2 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<ColumnNothing>(*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 69af3ca5bc8..662f74f6f02 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<ColumnInt64*>(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<ColumnInt64*>(cloned.get());
diff --git a/be/test/core/column/column_array_test.cpp
b/be/test/core/column/column_array_test.cpp
index 68a175d3c85..163fdfe87be 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<ColumnArray>(
- 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<ColumnArray>(
- 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<ColumnArray>(
- 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<ColumnArray>(
- 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<ColumnArray>(
- 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<ColumnArray>(
- 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<ColumnArray>(remove_nullable(cloned->assume_mutable()).get());
+
check_and_get_column<ColumnArray>(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 8e2bb7d8c70..957a7d6284d 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<DataTypeInt32>({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 05cf6034ed3..871a0a2641a 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 71f007a73c1..c35f0d52790 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<ColumnVariant*>(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 819bf33f227..d867cb77b13 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 84bce05751a..a9e59922b79 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<const ColumnStruct&>(
static_cast<const
ColumnNullable&>(*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 5b8af2458b0..10fb996362c 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 f336a245568..2b88ea9228e 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<ColumnNullable&>(*mutable_dst);
auto& nested_col =
static_cast<ColumnDate&>(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<ColumnNullable&>(*mutable_dst);
auto& nested_col =
static_cast<ColumnDateV2&>(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<ColumnNullable&>(*mutable_dst);
auto& nested_col =
static_cast<ColumnDateTime&>(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<ColumnNullable&>(*mutable_dst);
auto& nested_col =
static_cast<ColumnDateTimeV2&>(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 3599036fe2f..05b9f14ab8c 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 d5394ab86c4..94e0d40eb77 100644
--- a/be/test/exprs/aggregate/agg_collect_test.cpp
+++ b/be/test/exprs/aggregate/agg_collect_test.cpp
@@ -148,14 +148,14 @@ public:
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 98265fda3fa..1a8d6985167 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<ColumnString*>(index_column_ptr->assume_mutable().get());
+
assert_cast<ColumnString*>(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 0f387215582..3d8e9bf8f63 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<ColumnArray&>(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<ColumnMap&>(nested).get_keys();
auto& values = assert_cast<ColumnMap&>(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<PrimitiveType::TYPE_INT>(
static_cast<int32_t>(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<ColumnArray&>(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<PrimitiveType::TYPE_INT>(static_cast<int32_t>(10)));
@@ -1098,8 +1098,8 @@ static Block create_all_types_test_block() {
auto& keys = assert_cast<ColumnMap&>(nested).get_keys();
auto& values = assert_cast<ColumnMap&>(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<PrimitiveType::TYPE_VARCHAR>(std::string("key1")));
mutable_values->insert(
@@ -1130,8 +1130,8 @@ static Block create_all_types_test_block() {
auto& struct_col = assert_cast<ColumnStruct&>(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<PrimitiveType::TYPE_INT>(static_cast<int32_t>(999)));
diff --git a/be/test/format/orc/orc_read_lines.cpp
b/be/test/format/orc/orc_read_lines.cpp
index c920e091821..550e9ac28a6 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 84ba8af9da3..dd1d0d2a595 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<false>(
"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<false>("test_long_with_null", xx,
data_type, const_node,
@@ -204,7 +204,7 @@ TEST_F(OrcReaderFillDataTest, ComplexTypeConversionTest) {
std::vector<DataTypePtr> {
std::make_shared<DataTypeArray>(std::make_shared<DataTypeInt32>())},
std::vector<std::string> {"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<false>("test",
doris_column,
doris_struct_type, const_node,
@@ -290,7 +290,7 @@ TEST_F(OrcReaderFillDataTest, ComplexTypeConversionTest) {
std::vector<DataTypePtr> {std::make_shared<DataTypeInt32>(),
std::make_shared<DataTypeInt32>()},
std::vector<std::string> {"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<false>("test",
doris_column,
doris_struct_type, const_node,
@@ -375,7 +375,7 @@ TEST_F(OrcReaderFillDataTest, ComplexTypeConversionTest) {
auto doris_struct_type = std::make_shared<DataTypeStruct>(
std::vector<DataTypePtr>
{std::make_shared<DataTypeDecimal64>(18, 5)},
std::vector<std::string> {"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<false>("test",
doris_column,
@@ -488,7 +488,7 @@ TEST_F(OrcReaderFillDataTest, ComplexTypeConversionTest) {
auto doris_struct_type =
std::make_shared<DataTypeMap>(std::make_shared<DataTypeInt32>(),
std::make_shared<DataTypeFloat32>());
- 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<false>("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 7ca86957d49..9dc6ba41a2f 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<std::string>
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 4bbe6dc09e4..0fe101db598 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<ColumnNullable*>(doris_column->assume_mutable().get());
+ auto* nullable_column =
assert_cast<ColumnNullable*>(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<ColumnNullable*>(src_column->assume_mutable().get());
+ auto* nullable_column =
assert_cast<ColumnNullable*>(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 942721c85d9..2fabcb69e38 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 @@ protected:
// 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 @@ protected:
// 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 66c3050370c..1f5143ca422 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<DataTypeNullable>(std::make_shared<DataTypeString>()),
"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<DataTypeMap>(std::make_shared<DataTypeString>(),
std::make_shared<DataTypeString>()),
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
