This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch branch-4.1
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/branch-4.1 by this push:
new cc42474de02 branch-4.1: [followup](BE) rename assume_mutable to
assert_mutable #63557 (#64887)
cc42474de02 is described below
commit cc42474de02c6121e50129a951b317d0187e0a74
Author: zclllyybb <[email protected]>
AuthorDate: Sat Jun 27 00:01:40 2026 +0800
branch-4.1: [followup](BE) rename assume_mutable to assert_mutable #63557
(#64887)
pick https://github.com/apache/doris/pull/63557
---
be/src/core/block/block.cpp | 12 +++++------
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 +++++++--------
.../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 | 2 +-
be/src/exprs/vruntimefilter_wrapper.cpp | 2 +-
be/src/format/parquet/parquet_column_convert.h | 2 +-
be/src/format/parquet/vparquet_column_reader.cpp | 22 ++++++++++----------
be/src/storage/iterator/olap_data_convertor.h | 2 +-
.../storage/iterator/vertical_merge_iterator.cpp | 4 ++--
be/src/storage/iterator/vgeneric_iterators.cpp | 2 +-
.../segment/variant/variant_column_reader.cpp | 2 +-
.../segment/variant/variant_column_writer_impl.cpp | 2 +-
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 ++--
.../variant/variant_stats_calculator_test.cpp | 2 +-
42 files changed, 135 insertions(+), 135 deletions(-)
diff --git a/be/src/core/block/block.cpp b/be/src/core/block/block.cpp
index b0c59bb0c09..b42f0bf5f75 100644
--- a/be/src/core/block/block.cpp
+++ b/be/src/core/block/block.cpp
@@ -814,7 +814,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();
}
@@ -829,7 +829,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();
}
@@ -892,14 +892,14 @@ 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();
}
continue;
}
if (column->is_exclusive()) {
- 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={}, "
@@ -928,7 +928,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);
}
@@ -957,7 +957,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());
diff --git a/be/src/core/column/column_map.cpp
b/be/src/core/column/column_map.cpp
index 77096499b26..4825bd0d812 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 d83af621752..148fbb0dcf8 100644
--- a/be/src/core/column/column_nullable.cpp
+++ b/be/src/core/column/column_nullable.cpp
@@ -457,7 +457,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 d8c5e837bfa..d1bf9749e57 100644
--- a/be/src/core/column/column_nullable.h
+++ b/be/src/core/column/column_nullable.h
@@ -272,7 +272,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();
@@ -380,7 +380,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 3d3b1d35541..567682d1ac0 100644
--- a/be/src/core/cow.h
+++ b/be/src/core/cow.h
@@ -310,7 +310,7 @@ protected:
if (this->use_count() > 1) {
return derived()->clone();
} else {
- return assume_mutable();
+ return assert_mutable();
}
}
@@ -321,17 +321,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());
}
@@ -352,13 +352,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/exprs/aggregate/aggregate_function_null_v2.h
b/be/src/exprs/aggregate/aggregate_function_null_v2.h
index e3ea5d31e70..8038bb38c60 100644
--- a/be/src/exprs/aggregate/aggregate_function_null_v2.h
+++ b/be/src/exprs/aggregate/aggregate_function_null_v2.h
@@ -215,7 +215,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();
@@ -274,7 +274,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 6fa48017ee2..cc1ec65c100 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 c141bdf7526..0ff8fbe1954 100644
--- a/be/src/exprs/function/array/function_array_with_constant.cpp
+++ b/be/src/exprs/function/array/function_array_with_constant.cpp
@@ -100,7 +100,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 124fdb7471c..8b95aca904f 100644
--- a/be/src/exprs/function/cast/cast_to_variant.h
+++ b/be/src/exprs/function/cast/cast_to_variant.h
@@ -95,7 +95,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;
@@ -107,7 +107,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
@@ -124,10 +124,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 3311c915cc3..e005887e556 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 fd0c966d2fa..d934ee77bc9 100644
--- a/be/src/exprs/lambda_function/varray_map_function.cpp
+++ b/be/src/exprs/lambda_function/varray_map_function.cpp
@@ -241,7 +241,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/vruntimefilter_wrapper.cpp
b/be/src/exprs/vruntimefilter_wrapper.cpp
index f3241b0adce..074c580614d 100644
--- a/be/src/exprs/vruntimefilter_wrapper.cpp
+++ b/be/src/exprs/vruntimefilter_wrapper.cpp
@@ -124,7 +124,7 @@ Status VRuntimeFilterWrapper::execute_filter(VExprContext*
context, const Block*
// 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/format/parquet/parquet_column_convert.h
b/be/src/format/parquet/parquet_column_convert.h
index c4d5122d4c9..56c97a6fc70 100644
--- a/be/src/format/parquet/parquet_column_convert.h
+++ b/be/src/format/parquet/parquet_column_convert.h
@@ -293,7 +293,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 517a4fc0a99..cd1d3a1350f 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;
@@ -657,7 +657,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();
@@ -665,7 +665,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(
@@ -713,7 +713,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();
@@ -721,7 +721,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(
@@ -790,7 +790,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();
@@ -798,7 +798,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(
@@ -987,7 +987,7 @@ Status StructColumnReader::read_column_data(
auto& doris_type =
const_cast<DataTypePtr&>(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/storage/iterator/olap_data_convertor.h
b/be/src/storage/iterator/olap_data_convertor.h
index 5d600003d68..a23369f569e 100644
--- a/be/src/storage/iterator/olap_data_convertor.h
+++ b/be/src/storage/iterator/olap_data_convertor.h
@@ -182,7 +182,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/vertical_merge_iterator.cpp
b/be/src/storage/iterator/vertical_merge_iterator.cpp
index d4d96f274dc..1df2b6c4bc4 100644
--- a/be/src/storage/iterator/vertical_merge_iterator.cpp
+++ b/be/src/storage/iterator/vertical_merge_iterator.cpp
@@ -333,7 +333,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();
@@ -356,7 +356,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 9a343e25dad..3fb2b360712 100644
--- a/be/src/storage/iterator/vgeneric_iterators.cpp
+++ b/be/src/storage/iterator/vgeneric_iterators.cpp
@@ -172,7 +172,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/segment/variant/variant_column_reader.cpp
b/be/src/storage/segment/variant/variant_column_reader.cpp
index df3bca3195a..23c4e8574d6 100644
--- a/be/src/storage/segment/variant/variant_column_reader.cpp
+++ b/be/src/storage/segment/variant/variant_column_reader.cpp
@@ -1574,7 +1574,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 ce9891d13c5..1d6b663286a 100644
--- a/be/src/storage/segment/variant/variant_column_writer_impl.cpp
+++ b/be/src/storage/segment/variant/variant_column_writer_impl.cpp
@@ -1567,7 +1567,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/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 08200f22bb0..ab0984a02b2 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);
}
@@ -638,7 +638,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();
@@ -649,7 +649,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)
@@ -658,15 +658,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
@@ -735,7 +735,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()) {
@@ -753,7 +753,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());
@@ -777,7 +777,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);
@@ -812,7 +812,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);
@@ -836,10 +836,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 ee65d780d06..b01a5a28535 100644
--- a/be/test/core/column/column_variant_test.cpp
+++ b/be/test/core/column/column_variant_test.cpp
@@ -1286,7 +1286,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) {
@@ -3189,21 +3189,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 6197016c8ee..68876a22bfe 100644
--- a/be/test/exec/common/schema_util_test.cpp
+++ b/be/test/exec/common/schema_util_test.cpp
@@ -1420,7 +1420,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 47bffcaa476..e0b2ee16c97 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 fa6238b884d..24e9bd1d6e2 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 f1ece335987..66f883a41a5 100644
--- a/be/test/format/orc/orc_read_lines.cpp
+++ b/be/test/format/orc/orc_read_lines.cpp
@@ -154,7 +154,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 cb8d21560d5..2a5bb8f1598 100644
--- a/be/test/format/parquet/parquet_read_lines.cpp
+++ b/be/test/format/parquet/parquet_read_lines.cpp
@@ -168,7 +168,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/variant/variant_stats_calculator_test.cpp
b/be/test/storage/variant/variant_stats_calculator_test.cpp
index 3ca422957ae..7cbb0682ad8 100644
--- a/be/test/storage/variant/variant_stats_calculator_test.cpp
+++ b/be/test/storage/variant/variant_stats_calculator_test.cpp
@@ -356,7 +356,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]
