From aa2929e7e6db55c7a7a047e272782816e9626a45 Mon Sep 17 00:00:00 2001 From: zhiqiang Date: Tue, 13 Aug 2024 11:49:31 +0800 Subject: [PATCH] [opt](assert_cast) Make assert cast do type check in release build by default (#39030) * Problem to solve We encountered many issues that ultimately proved to be caused by memory insecurity. These issues are hard to solve, and the final crash log maybe not related to the root problem. * Fix We make `assert_cast` do type check in release build by default. And we can use a template arg `TypeCheckOnRelease::DISABLE` to disable type check in release build. `TypeCheckOnRelease::DISABLE` should be used when user agrees that this function will be called many many times (eg. add method of AggregatedData, which will be called by rows) or you think type safe has already been guaranteed (eg. `assert_cast(this)`. --- be/src/olap/base_tablet.cpp | 4 +- be/src/olap/bloom_filter_predicate.h | 1 + .../aggregate_functions/aggregate_function.h | 109 +++++++++------ ...aggregate_function_approx_count_distinct.h | 7 +- .../aggregate_function_avg.h | 3 +- .../aggregate_function_avg_weighted.h | 6 +- .../aggregate_function_bit.h | 4 +- .../aggregate_function_bitmap.h | 19 ++- .../aggregate_function_bitmap_agg.h | 9 +- .../aggregate_function_collect.h | 42 ++++-- .../aggregate_function_count.h | 4 +- .../aggregate_function_covar.h | 9 +- .../aggregate_function_distinct.h | 4 +- .../aggregate_function_foreach.h | 9 +- ...aggregate_function_group_array_intersect.h | 23 +-- .../aggregate_function_group_concat.h | 10 +- .../aggregate_function_histogram.h | 7 +- .../aggregate_function_hll_union_agg.h | 2 +- .../aggregate_function_map.h | 22 +-- .../aggregate_function_min_max.h | 45 ++++-- .../aggregate_function_min_max_by.h | 3 +- .../aggregate_function_null.h | 7 +- .../aggregate_function_orthogonal_bitmap.h | 21 ++- .../aggregate_function_percentile.h | 131 ++++++++++++------ .../aggregate_function_percentile_approx.h | 20 ++- .../aggregate_function_product.h | 3 +- .../aggregate_function_quantile_state.h | 10 +- .../aggregate_function_reader_first_last.h | 25 ++-- .../aggregate_function_retention.h | 4 +- .../aggregate_function_sequence_match.h | 14 +- .../aggregate_function_stddev.h | 3 +- .../aggregate_function_sum.h | 3 +- .../aggregate_function_topn.h | 57 +++++--- .../aggregate_function_uniq.h | 7 +- .../aggregate_function_window.h | 6 +- .../aggregate_function_window_funnel.h | 11 +- be/src/vec/columns/column_array.cpp | 34 +++-- be/src/vec/columns/column_array.h | 4 +- be/src/vec/columns/column_complex.h | 4 +- be/src/vec/columns/column_const.h | 2 +- be/src/vec/columns/column_decimal.cpp | 2 +- be/src/vec/columns/column_decimal.h | 4 +- be/src/vec/columns/column_map.cpp | 2 +- be/src/vec/columns/column_map.h | 5 +- be/src/vec/columns/column_nullable.cpp | 10 +- be/src/vec/columns/column_nullable.h | 22 ++- be/src/vec/columns/column_object.cpp | 6 +- be/src/vec/columns/column_string.cpp | 4 +- be/src/vec/columns/column_struct.cpp | 10 +- be/src/vec/columns/column_vector.cpp | 3 +- be/src/vec/columns/column_vector.h | 9 +- be/src/vec/common/assert_cast.h | 35 +++-- .../vec/data_types/data_type_number_base.cpp | 29 ++-- .../serde/data_type_datetimev2_serde.cpp | 6 +- .../serde/data_type_struct_serde.cpp | 10 +- .../functions/array/function_array_element.h | 1 + .../functions/comparison_equal_for_null.cpp | 8 +- .../functions/function_binary_arithmetic.h | 24 +++- be/src/vec/functions/function_case.h | 8 +- be/src/vec/functions/function_cast.h | 17 ++- be/src/vec/functions/function_coalesce.cpp | 4 +- be/src/vec/functions/function_helpers.cpp | 2 +- be/src/vec/functions/function_helpers.h | 2 +- be/src/vec/functions/function_ip.h | 4 +- be/src/vec/functions/function_string.cpp | 1 + be/src/vec/functions/function_string.h | 17 ++- .../functions/function_variant_element.cpp | 4 +- 67 files changed, 632 insertions(+), 325 deletions(-) diff --git a/be/src/olap/base_tablet.cpp b/be/src/olap/base_tablet.cpp index 0fb12dd074f8b0..db1e0283854a39 100644 --- a/be/src/olap/base_tablet.cpp +++ b/be/src/olap/base_tablet.cpp @@ -36,6 +36,7 @@ #include "util/crc32c.h" #include "util/debug_points.h" #include "util/doris_metrics.h" +#include "vec/common/assert_cast.h" #include "vec/common/schema_util.h" #include "vec/data_types/data_type_factory.hpp" #include "vec/jsonb/serialize.h" @@ -1030,7 +1031,8 @@ Status BaseTablet::generate_new_block_for_partial_update( if (rs_column.has_default_value()) { mutable_column->insert_from(*mutable_default_value_columns[i].get(), 0); } else if (rs_column.is_nullable()) { - assert_cast(mutable_column.get()) + assert_cast( + mutable_column.get()) ->insert_null_elements(1); } else { mutable_column->insert_default(); diff --git a/be/src/olap/bloom_filter_predicate.h b/be/src/olap/bloom_filter_predicate.h index 9cc95d7152aa32..260c08fbbb77c3 100644 --- a/be/src/olap/bloom_filter_predicate.h +++ b/be/src/olap/bloom_filter_predicate.h @@ -25,6 +25,7 @@ #include "vec/columns/column_nullable.h" #include "vec/columns/column_vector.h" #include "vec/columns/predicate_column.h" +#include "vec/common/assert_cast.h" #include "vec/exprs/vruntimefilter_wrapper.h" namespace doris { diff --git a/be/src/vec/aggregate_functions/aggregate_function.h b/be/src/vec/aggregate_functions/aggregate_function.h index e9d7ff37dbc6e8..12d629b42c89f8 100644 --- a/be/src/vec/aggregate_functions/aggregate_function.h +++ b/be/src/vec/aggregate_functions/aggregate_function.h @@ -237,13 +237,16 @@ class IAggregateFunctionHelper : public IAggregateFunction { void destroy_vec(AggregateDataPtr __restrict place, const size_t num_rows) const noexcept override { const size_t size_of_data_ = size_of_data(); + const Derived* derived = assert_cast(this); for (size_t i = 0; i != num_rows; ++i) { - assert_cast(this)->destroy(place + size_of_data_ * i); + derived->destroy(place + size_of_data_ * i); } } void add_batch(size_t batch_size, AggregateDataPtr* places, size_t place_offset, const IColumn** columns, Arena* arena, bool agg_many) const override { + const Derived* derived = assert_cast(this); + if constexpr (std::is_same_v> || std::is_same_v> || std::is_same_v(this)->add_many(iter->first, columns, iter->second, - arena); + derived->add_many(iter->first, columns, iter->second, arena); iter++; } return; @@ -271,23 +273,25 @@ class IAggregateFunctionHelper : public IAggregateFunction { } for (size_t i = 0; i < batch_size; ++i) { - assert_cast(this)->add(places[i] + place_offset, columns, i, arena); + derived->add(places[i] + place_offset, columns, i, arena); } } void add_batch_selected(size_t batch_size, AggregateDataPtr* places, size_t place_offset, const IColumn** columns, Arena* arena) const override { + const Derived* derived = assert_cast(this); for (size_t i = 0; i < batch_size; ++i) { if (places[i]) { - assert_cast(this)->add(places[i] + place_offset, columns, i, arena); + derived->add(places[i] + place_offset, columns, i, arena); } } } void add_batch_single_place(size_t batch_size, AggregateDataPtr place, const IColumn** columns, Arena* arena) const override { + const Derived* derived = assert_cast(this); for (size_t i = 0; i < batch_size; ++i) { - assert_cast(this)->add(place, columns, i, arena); + derived->add(place, columns, i, arena); } } //now this is use for sum/count/avg/min/max win function, other win function should override this function in class @@ -295,31 +299,35 @@ class IAggregateFunctionHelper : public IAggregateFunction { void add_range_single_place(int64_t partition_start, int64_t partition_end, int64_t frame_start, int64_t frame_end, AggregateDataPtr place, const IColumn** columns, Arena* arena) const override { + const Derived* derived = assert_cast(this); frame_start = std::max(frame_start, partition_start); frame_end = std::min(frame_end, partition_end); for (int64_t i = frame_start; i < frame_end; ++i) { - assert_cast(this)->add(place, columns, i, arena); + derived->add(place, columns, i, arena); } } void add_batch_range(size_t batch_begin, size_t batch_end, AggregateDataPtr place, const IColumn** columns, Arena* arena, bool has_null) override { + const Derived* derived = assert_cast(this); for (size_t i = batch_begin; i <= batch_end; ++i) { - assert_cast(this)->add(place, columns, i, arena); + derived->add(place, columns, i, arena); } } void insert_result_into_vec(const std::vector& places, const size_t offset, IColumn& to, const size_t num_rows) const override { + const Derived* derived = assert_cast(this); for (size_t i = 0; i != num_rows; ++i) { - assert_cast(this)->insert_result_into(places[i] + offset, to); + derived->insert_result_into(places[i] + offset, to); } } void serialize_vec(const std::vector& places, size_t offset, BufferWritable& buf, const size_t num_rows) const override { + const Derived* derived = assert_cast(this); for (size_t i = 0; i != num_rows; ++i) { - assert_cast(this)->serialize(places[i] + offset, buf); + derived->serialize(places[i] + offset, buf); buf.commit(); } } @@ -333,11 +341,12 @@ class IAggregateFunctionHelper : public IAggregateFunction { void streaming_agg_serialize(const IColumn** columns, BufferWritable& buf, const size_t num_rows, Arena* arena) const override { std::vector place(size_of_data()); + const Derived* derived = assert_cast(this); for (size_t i = 0; i != num_rows; ++i) { - assert_cast(this)->create(place.data()); - DEFER({ assert_cast(this)->destroy(place.data()); }); - assert_cast(this)->add(place.data(), columns, i, arena); - assert_cast(this)->serialize(place.data(), buf); + derived->create(place.data()); + DEFER({ derived->destroy(place.data()); }); + derived->add(place.data(), columns, i, arena); + derived->serialize(place.data(), buf); buf.commit(); } } @@ -357,17 +366,18 @@ class IAggregateFunctionHelper : public IAggregateFunction { void deserialize_vec(AggregateDataPtr places, const ColumnString* column, Arena* arena, size_t num_rows) const override { - const auto size_of_data = assert_cast(this)->size_of_data(); + const Derived* derived = assert_cast(this); + const auto size_of_data = derived->size_of_data(); for (size_t i = 0; i != num_rows; ++i) { try { auto place = places + size_of_data * i; VectorBufferReader buffer_reader(column->get_data_at(i)); - assert_cast(this)->create(place); - assert_cast(this)->deserialize(place, buffer_reader, arena); + derived->create(place); + derived->deserialize(place, buffer_reader, arena); } catch (...) { for (int j = 0; j < i; ++j) { auto place = places + size_of_data * j; - assert_cast(this)->destroy(place); + derived->destroy(place); } throw; } @@ -377,49 +387,52 @@ class IAggregateFunctionHelper : public IAggregateFunction { void deserialize_and_merge_vec(const AggregateDataPtr* places, size_t offset, AggregateDataPtr rhs, const IColumn* column, Arena* arena, const size_t num_rows) const override { - const auto size_of_data = assert_cast(this)->size_of_data(); + const Derived* derived = assert_cast(this); + const auto size_of_data = derived->size_of_data(); const auto* column_string = assert_cast(column); + for (size_t i = 0; i != num_rows; ++i) { try { auto rhs_place = rhs + size_of_data * i; VectorBufferReader buffer_reader(column_string->get_data_at(i)); - assert_cast(this)->create(rhs_place); - assert_cast(this)->deserialize_and_merge( - places[i] + offset, rhs_place, buffer_reader, arena); + derived->create(rhs_place); + derived->deserialize_and_merge(places[i] + offset, rhs_place, buffer_reader, arena); } catch (...) { for (int j = 0; j < i; ++j) { auto place = rhs + size_of_data * j; - assert_cast(this)->destroy(place); + derived->destroy(place); } throw; } } - assert_cast(this)->destroy_vec(rhs, num_rows); + + derived->destroy_vec(rhs, num_rows); } void deserialize_and_merge_vec_selected(const AggregateDataPtr* places, size_t offset, AggregateDataPtr rhs, const IColumn* column, Arena* arena, const size_t num_rows) const override { - const auto size_of_data = assert_cast(this)->size_of_data(); + const auto* derived = assert_cast(this); + const auto size_of_data = derived->size_of_data(); const auto* column_string = assert_cast(column); for (size_t i = 0; i != num_rows; ++i) { try { auto rhs_place = rhs + size_of_data * i; VectorBufferReader buffer_reader(column_string->get_data_at(i)); - assert_cast(this)->create(rhs_place); + derived->create(rhs_place); if (places[i]) { - assert_cast(this)->deserialize_and_merge( - places[i] + offset, rhs_place, buffer_reader, arena); + derived->deserialize_and_merge(places[i] + offset, rhs_place, buffer_reader, + arena); } } catch (...) { for (int j = 0; j < i; ++j) { auto place = rhs + size_of_data * j; - assert_cast(this)->destroy(place); + derived->destroy(place); } throw; } } - assert_cast(this)->destroy_vec(rhs, num_rows); + derived->destroy_vec(rhs, num_rows); } void deserialize_from_column(AggregateDataPtr places, const IColumn& column, Arena* arena, @@ -429,21 +442,21 @@ class IAggregateFunctionHelper : public IAggregateFunction { void merge_vec(const AggregateDataPtr* places, size_t offset, ConstAggregateDataPtr rhs, Arena* arena, const size_t num_rows) const override { - const auto size_of_data = assert_cast(this)->size_of_data(); + const auto* derived = assert_cast(this); + const auto size_of_data = derived->size_of_data(); for (size_t i = 0; i != num_rows; ++i) { - assert_cast(this)->merge(places[i] + offset, rhs + size_of_data * i, - arena); + derived->merge(places[i] + offset, rhs + size_of_data * i, arena); } } void merge_vec_selected(const AggregateDataPtr* places, size_t offset, ConstAggregateDataPtr rhs, Arena* arena, const size_t num_rows) const override { - const auto size_of_data = assert_cast(this)->size_of_data(); + const auto* derived = assert_cast(this); + const auto size_of_data = derived->size_of_data(); for (size_t i = 0; i != num_rows; ++i) { if (places[i]) { - assert_cast(this)->merge(places[i] + offset, rhs + size_of_data * i, - arena); + derived->merge(places[i] + offset, rhs + size_of_data * i, arena); } } } @@ -455,13 +468,15 @@ class IAggregateFunctionHelper : public IAggregateFunction { << ", begin:" << begin << ", end:" << end << ", column.size():" << column.size(); std::vector deserialized_data(size_of_data()); auto* deserialized_place = (AggregateDataPtr)deserialized_data.data(); + const ColumnString& column_string = assert_cast(column); + const Derived* derived = assert_cast(this); for (size_t i = begin; i <= end; ++i) { - VectorBufferReader buffer_reader( - (assert_cast(column)).get_data_at(i)); - assert_cast(this)->create(deserialized_place); - DEFER({ assert_cast(this)->destroy(deserialized_place); }); - assert_cast(this)->deserialize_and_merge(place, deserialized_place, - buffer_reader, arena); + VectorBufferReader buffer_reader(column_string.get_data_at(i)); + derived->create(deserialized_place); + + DEFER({ derived->destroy(deserialized_place); }); + + derived->deserialize_and_merge(place, deserialized_place, buffer_reader, arena); } } @@ -475,8 +490,9 @@ class IAggregateFunctionHelper : public IAggregateFunction { void deserialize_and_merge(AggregateDataPtr __restrict place, AggregateDataPtr __restrict rhs, BufferReadable& buf, Arena* arena) const override { - assert_cast(this)->deserialize(rhs, buf, arena); - assert_cast(this)->merge(place, rhs, arena); + assert_cast(this)->deserialize(rhs, buf, + arena); + assert_cast(this)->merge(place, rhs, arena); } }; @@ -513,8 +529,9 @@ class IAggregateFunctionDataHelper : public IAggregateFunctionHelper { void deserialize_and_merge(AggregateDataPtr __restrict place, AggregateDataPtr __restrict rhs, BufferReadable& buf, Arena* arena) const override { - assert_cast(this)->deserialize(rhs, buf, arena); - assert_cast(this)->merge(place, rhs, arena); + assert_cast(this)->deserialize(rhs, buf, + arena); + assert_cast(this)->merge(place, rhs, arena); } }; diff --git a/be/src/vec/aggregate_functions/aggregate_function_approx_count_distinct.h b/be/src/vec/aggregate_functions/aggregate_function_approx_count_distinct.h index d0f5bce81a02be..d267499e059818 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_approx_count_distinct.h +++ b/be/src/vec/aggregate_functions/aggregate_function_approx_count_distinct.h @@ -31,6 +31,7 @@ #include "vec/aggregate_functions/aggregate_function.h" #include "vec/aggregate_functions/aggregate_function_simple_factory.h" #include "vec/columns/columns_number.h" +#include "vec/common/assert_cast.h" #include "vec/common/string_ref.h" #include "vec/core/types.h" #include "vec/data_types/data_type_number.h" @@ -98,12 +99,14 @@ class AggregateFunctionApproxCountDistinct final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { if constexpr (IsFixLenColumnType::value) { - auto column = assert_cast(columns[0]); + auto column = + assert_cast(columns[0]); auto value = column->get_element(row_num); this->data(place).add( HashUtil::murmur_hash64A((char*)&value, sizeof(value), HashUtil::MURMUR_SEED)); } else { - auto value = assert_cast(columns[0])->get_data_at(row_num); + auto value = assert_cast(columns[0]) + ->get_data_at(row_num); uint64_t hash_value = HashUtil::murmur_hash64A(value.data, value.size, HashUtil::MURMUR_SEED); this->data(place).add(hash_value); diff --git a/be/src/vec/aggregate_functions/aggregate_function_avg.h b/be/src/vec/aggregate_functions/aggregate_function_avg.h index 6827c6db373667..8a18a88839b4db 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_avg.h +++ b/be/src/vec/aggregate_functions/aggregate_function_avg.h @@ -145,7 +145,8 @@ class AggregateFunctionAvg final #ifdef __clang__ #pragma clang fp reassociate(on) #endif - const auto& column = assert_cast(*columns[0]); + const auto& column = + assert_cast(*columns[0]); if constexpr (IsDecimalNumber) { this->data(place).sum += column.get_data()[row_num].value; } else { diff --git a/be/src/vec/aggregate_functions/aggregate_function_avg_weighted.h b/be/src/vec/aggregate_functions/aggregate_function_avg_weighted.h index af3b2c98cd8b4c..b59a3dccf0cea8 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_avg_weighted.h +++ b/be/src/vec/aggregate_functions/aggregate_function_avg_weighted.h @@ -108,8 +108,10 @@ class AggregateFunctionAvgWeight final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& column = assert_cast(*columns[0]); - const auto& weight = assert_cast(*columns[1]); + const auto& column = + assert_cast(*columns[0]); + const auto& weight = + assert_cast(*columns[1]); this->data(place).add(column.get_data()[row_num], weight.get_element(row_num)); } diff --git a/be/src/vec/aggregate_functions/aggregate_function_bit.h b/be/src/vec/aggregate_functions/aggregate_function_bit.h index c0b2df85ba25d2..1ab01b03ceea38 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_bit.h +++ b/be/src/vec/aggregate_functions/aggregate_function_bit.h @@ -25,6 +25,7 @@ #include #include "vec/aggregate_functions/aggregate_function.h" +#include "vec/common/assert_cast.h" #include "vec/core/types.h" #include "vec/io/io_helper.h" @@ -114,7 +115,8 @@ class AggregateFunctionBitwise final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& column = assert_cast&>(*columns[0]); + const auto& column = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[0]); this->data(place).add(column.get_data()[row_num]); } diff --git a/be/src/vec/aggregate_functions/aggregate_function_bitmap.h b/be/src/vec/aggregate_functions/aggregate_function_bitmap.h index dd7af71de06ae0..6c504b91bf4abd 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_bitmap.h +++ b/be/src/vec/aggregate_functions/aggregate_function_bitmap.h @@ -166,9 +166,12 @@ class AggregateFunctionBitmapSerializationHelper col.resize(num_rows); auto* data = col.get_data().data(); for (size_t i = 0; i != num_rows; ++i) { - assert_cast(this)->create(place); - DEFER({ assert_cast(this)->destroy(place); }); - assert_cast(this)->add(place, columns, i, arena); + assert_cast(this)->create(place); + DEFER({ + assert_cast(this)->destroy(place); + }); + assert_cast(this)->add(place, columns, + i, arena); data[i] = std::move(this->data(place).value); } } else { @@ -304,7 +307,8 @@ class AggregateFunctionBitmapOp final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& column = assert_cast(*columns[0]); + const auto& column = + assert_cast(*columns[0]); this->data(place).add(column.get_data()[row_num]); } @@ -367,12 +371,13 @@ class AggregateFunctionBitmapCount final if constexpr (arg_is_nullable) { auto& nullable_column = assert_cast(*columns[0]); if (!nullable_column.is_null_at(row_num)) { - const auto& column = - assert_cast(nullable_column.get_nested_column()); + const auto& column = assert_cast( + nullable_column.get_nested_column()); this->data(place).add(column.get_data()[row_num]); } } else { - const auto& column = assert_cast(*columns[0]); + const auto& column = + assert_cast(*columns[0]); this->data(place).add(column.get_data()[row_num]); } } diff --git a/be/src/vec/aggregate_functions/aggregate_function_bitmap_agg.h b/be/src/vec/aggregate_functions/aggregate_function_bitmap_agg.h index ce80b38d0913ba..19352e022fa7a2 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_bitmap_agg.h +++ b/be/src/vec/aggregate_functions/aggregate_function_bitmap_agg.h @@ -27,6 +27,7 @@ #include "util/bitmap_value.h" #include "vec/aggregate_functions/aggregate_function.h" +#include "vec/common/assert_cast.h" #include "vec/data_types/data_type_bitmap.h" namespace doris { @@ -74,14 +75,16 @@ class AggregateFunctionBitmapAgg final Arena* arena) const override { DCHECK_LT(row_num, columns[0]->size()); if constexpr (arg_nullable) { - auto& nullable_col = assert_cast(*columns[0]); + auto& nullable_col = + assert_cast(*columns[0]); auto& nullable_map = nullable_col.get_null_map_data(); if (!nullable_map[row_num]) { - auto& col = assert_cast(nullable_col.get_nested_column()); + auto& col = assert_cast( + nullable_col.get_nested_column()); this->data(place).add(col.get_data()[row_num]); } } else { - auto& col = assert_cast(*columns[0]); + auto& col = assert_cast(*columns[0]); this->data(place).add(col.get_data()[row_num]); } } diff --git a/be/src/vec/aggregate_functions/aggregate_function_collect.h b/be/src/vec/aggregate_functions/aggregate_function_collect.h index 4da6e023eb3949..b99ecd959245e3 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_collect.h +++ b/be/src/vec/aggregate_functions/aggregate_function_collect.h @@ -69,7 +69,8 @@ struct AggregateFunctionCollectSetData { size_t size() const { return data_set.size(); } void add(const IColumn& column, size_t row_num) { - data_set.insert(assert_cast(column).get_data()[row_num]); + data_set.insert(assert_cast(column) + .get_data()[row_num]); } void merge(const SelfType& rhs) { @@ -191,7 +192,8 @@ struct AggregateFunctionCollectListData { size_t size() const { return data.size(); } void add(const IColumn& column, size_t row_num) { - const auto& vec = assert_cast(column).get_data(); + const auto& vec = + assert_cast(column).get_data(); data.push_back(vec[row_num]); } @@ -256,8 +258,10 @@ struct AggregateFunctionCollectListData { } max_size = rhs.max_size; - data->insert_range_from(*rhs.data, 0, - std::min(assert_cast(max_size - size()), rhs.size())); + data->insert_range_from( + *rhs.data, 0, + std::min(assert_cast(max_size - size()), + rhs.size())); } else { data->insert_range_from(*rhs.data, 0, rhs.size()); } @@ -326,8 +330,10 @@ struct AggregateFunctionArrayAggData { } void add(const IColumn& column, size_t row_num) { - const auto& col = assert_cast(column); - const auto& vec = assert_cast(col.get_nested_column()).get_data(); + const auto& col = assert_cast(column); + const auto& vec = + assert_cast(col.get_nested_column()) + .get_data(); null_map->push_back(col.get_null_map_data()[row_num]); nested_column->get_data().push_back(vec[row_num]); DCHECK(null_map->size() == nested_column->size()); @@ -426,8 +432,9 @@ struct AggregateFunctionArrayAggData { } void add(const IColumn& column, size_t row_num) { - const auto& col = assert_cast(column); - const auto& vec = assert_cast(col.get_nested_column()); + const auto& col = assert_cast(column); + const auto& vec = assert_cast( + col.get_nested_column()); null_map->push_back(col.get_null_map_data()[row_num]); nested_column->insert_from(vec, row_num); DCHECK(null_map->size() == nested_column->size()); @@ -561,7 +568,9 @@ class AggregateFunctionCollect if constexpr (HasLimit::value) { if (data.max_size == -1) { data.max_size = - (UInt64)assert_cast(columns[1])->get_element(row_num); + (UInt64)assert_cast( + columns[1]) + ->get_element(row_num); } if (data.size() >= data.max_size) { return; @@ -711,15 +720,20 @@ class AggregateFunctionCollect for (size_t i = 0; i < num_rows; ++i) { col_null->get_null_map_data().push_back(col_src.get_null_map_data()[i]); if constexpr (std::is_same_v) { - auto& vec = assert_cast(col_null->get_nested_column()); + auto& vec = assert_cast( + col_null->get_nested_column()); const auto& vec_src = - assert_cast(col_src.get_nested_column()); + assert_cast( + col_src.get_nested_column()); vec.insert_from(vec_src, i); } else { using ColVecType = ColumnVectorOrDecimal; - auto& vec = assert_cast(col_null->get_nested_column()).get_data(); - auto& vec_src = - assert_cast(col_src.get_nested_column()).get_data(); + auto& vec = assert_cast( + col_null->get_nested_column()) + .get_data(); + auto& vec_src = assert_cast( + col_src.get_nested_column()) + .get_data(); vec.push_back(vec_src[i]); } to_arr.get_offsets().push_back(to_nested_col.size()); diff --git a/be/src/vec/aggregate_functions/aggregate_function_count.h b/be/src/vec/aggregate_functions/aggregate_function_count.h index 7449c949cb9047..62aa869771c0a5 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_count.h +++ b/be/src/vec/aggregate_functions/aggregate_function_count.h @@ -196,7 +196,9 @@ class AggregateFunctionCountNotNullUnary final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - data(place).count += !assert_cast(*columns[0]).is_null_at(row_num); + data(place).count += + !assert_cast(*columns[0]) + .is_null_at(row_num); } void reset(AggregateDataPtr place) const override { data(place).count = 0; } diff --git a/be/src/vec/aggregate_functions/aggregate_function_covar.h b/be/src/vec/aggregate_functions/aggregate_function_covar.h index 9dc2d2d5b381c6..609b5f6d89c0cb 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_covar.h +++ b/be/src/vec/aggregate_functions/aggregate_function_covar.h @@ -107,9 +107,11 @@ struct BaseData { } void add(const IColumn* column_x, const IColumn* column_y, size_t row_num) { - const auto& sources_x = assert_cast&>(*column_x); + const auto& sources_x = + assert_cast&, TypeCheckOnRelease::DISABLE>(*column_x); double source_data_x = sources_x.get_data()[row_num]; - const auto& sources_y = assert_cast&>(*column_y); + const auto& sources_y = + assert_cast&, TypeCheckOnRelease::DISABLE>(*column_y); double source_data_y = sources_y.get_data()[row_num]; sum_x += source_data_x; @@ -186,7 +188,8 @@ struct BaseDatadecimal { } DecimalV2Value get_source_data(const IColumn* column, size_t row_num) { - const auto& sources = assert_cast&>(*column); + const auto& sources = + assert_cast&, TypeCheckOnRelease::DISABLE>(*column); Field field = sources[row_num]; auto decimal_field = field.template get>(); int128_t value; diff --git a/be/src/vec/aggregate_functions/aggregate_function_distinct.h b/be/src/vec/aggregate_functions/aggregate_function_distinct.h index 4f42e8509f2acc..6193b28a131e9f 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_distinct.h +++ b/be/src/vec/aggregate_functions/aggregate_function_distinct.h @@ -65,7 +65,9 @@ struct AggregateFunctionDistinctSingleNumericData { Container data; void add(const IColumn** columns, size_t /* columns_num */, size_t row_num, Arena*) { - const auto& vec = assert_cast&>(*columns[0]).get_data(); + const auto& vec = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[0]) + .get_data(); if constexpr (stable) { data.emplace(vec[row_num], data.size()); } else { diff --git a/be/src/vec/aggregate_functions/aggregate_function_foreach.h b/be/src/vec/aggregate_functions/aggregate_function_foreach.h index d5c1f7d09e47b5..4261ef24343b95 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_foreach.h +++ b/be/src/vec/aggregate_functions/aggregate_function_foreach.h @@ -228,10 +228,12 @@ class AggregateFunctionForEach : public IAggregateFunctionDataHelper nested(num_arguments); for (size_t i = 0; i < num_arguments; ++i) { - nested[i] = &assert_cast(*columns[i]).get_data(); + nested[i] = &assert_cast(*columns[i]) + .get_data(); } - const auto& first_array_column = assert_cast(*columns[0]); + const auto& first_array_column = + assert_cast(*columns[0]); const auto& offsets = first_array_column.get_offsets(); size_t begin = offsets[row_num - 1]; @@ -239,7 +241,8 @@ class AggregateFunctionForEach : public IAggregateFunctionDataHelper(*columns[i]); + const auto& ith_column = + assert_cast(*columns[i]); const auto& ith_offsets = ith_column.get_offsets(); if (ith_offsets[row_num] != end || diff --git a/be/src/vec/aggregate_functions/aggregate_function_group_array_intersect.h b/be/src/vec/aggregate_functions/aggregate_function_group_array_intersect.h index 5d627782f25e4d..d8cf91865f1ed2 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_group_array_intersect.h +++ b/be/src/vec/aggregate_functions/aggregate_function_group_array_intersect.h @@ -102,7 +102,8 @@ struct AggregateFunctionGroupArrayIntersectData { if (is_column_data_nullable) { auto* const_col_data = const_cast(&column_data); col_null = static_cast(const_col_data); - nested_column_data = &assert_cast(col_null->get_nested_column()); + nested_column_data = &assert_cast( + col_null->get_nested_column()); } else { nested_column_data = &static_cast(column_data); } @@ -172,10 +173,12 @@ class AggregateFunctionGroupArrayIntersect const bool col_is_nullable = (*columns[0]).is_nullable(); const ColumnArray& column = - col_is_nullable ? assert_cast( - assert_cast(*columns[0]) - .get_nested_column()) - : assert_cast(*columns[0]); + col_is_nullable + ? assert_cast( + assert_cast( + *columns[0]) + .get_nested_column()) + : assert_cast(*columns[0]); const auto& offsets = column.get_offsets(); const auto offset = offsets[row_num - 1]; @@ -364,10 +367,12 @@ class AggregateFunctionGroupArrayIntersectGeneric const bool col_is_nullable = (*columns[0]).is_nullable(); const ColumnArray& column = - col_is_nullable ? assert_cast( - assert_cast(*columns[0]) - .get_nested_column()) - : assert_cast(*columns[0]); + col_is_nullable + ? assert_cast( + assert_cast( + *columns[0]) + .get_nested_column()) + : assert_cast(*columns[0]); const auto nested_column_data = column.get_data_ptr(); const auto& offsets = column.get_offsets(); diff --git a/be/src/vec/aggregate_functions/aggregate_function_group_concat.h b/be/src/vec/aggregate_functions/aggregate_function_group_concat.h index 87ed907377ea36..a62ffb8da619f9 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_group_concat.h +++ b/be/src/vec/aggregate_functions/aggregate_function_group_concat.h @@ -25,6 +25,7 @@ #include "vec/aggregate_functions/aggregate_function.h" #include "vec/aggregate_functions/aggregate_function_simple_factory.h" #include "vec/columns/column_string.h" +#include "vec/common/assert_cast.h" #include "vec/common/string_ref.h" #include "vec/core/types.h" #include "vec/data_types/data_type_string.h" @@ -98,7 +99,8 @@ struct AggregateFunctionGroupConcatImplStr { static const std::string separator; static void add(AggregateFunctionGroupConcatData& __restrict place, const IColumn** columns, size_t row_num) { - place.add(assert_cast(*columns[0]).get_data_at(row_num), + place.add(assert_cast(*columns[0]) + .get_data_at(row_num), StringRef(separator.data(), separator.length())); } }; @@ -106,8 +108,10 @@ struct AggregateFunctionGroupConcatImplStr { struct AggregateFunctionGroupConcatImplStrStr { static void add(AggregateFunctionGroupConcatData& __restrict place, const IColumn** columns, size_t row_num) { - place.add(assert_cast(*columns[0]).get_data_at(row_num), - assert_cast(*columns[1]).get_data_at(row_num)); + place.add(assert_cast(*columns[0]) + .get_data_at(row_num), + assert_cast(*columns[1]) + .get_data_at(row_num)); } }; diff --git a/be/src/vec/aggregate_functions/aggregate_function_histogram.h b/be/src/vec/aggregate_functions/aggregate_function_histogram.h index 8fcd133b055bd3..25fc6957321586 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_histogram.h +++ b/be/src/vec/aggregate_functions/aggregate_function_histogram.h @@ -208,9 +208,12 @@ class AggregateFunctionHistogram final if constexpr (std::is_same_v) { this->data(place).add( - assert_cast(*columns[0]).get_data_at(row_num)); + assert_cast(*columns[0]) + .get_data_at(row_num)); } else { - this->data(place).add(assert_cast(*columns[0]).get_data()[row_num]); + this->data(place).add( + assert_cast(*columns[0]) + .get_data()[row_num]); } } diff --git a/be/src/vec/aggregate_functions/aggregate_function_hll_union_agg.h b/be/src/vec/aggregate_functions/aggregate_function_hll_union_agg.h index f976e959f8558d..1cf6dc7f2a29a9 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_hll_union_agg.h +++ b/be/src/vec/aggregate_functions/aggregate_function_hll_union_agg.h @@ -76,7 +76,7 @@ struct AggregateFunctionHLLData { void reset() { dst_hll.clear(); } void add(const IColumn* column, size_t row_num) { - const auto& sources = assert_cast(*column); + const auto& sources = assert_cast(*column); dst_hll.merge(sources.get_element(row_num)); } }; diff --git a/be/src/vec/aggregate_functions/aggregate_function_map.h b/be/src/vec/aggregate_functions/aggregate_function_map.h index 0f1a298aed10f3..ca962bd32076c9 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_map.h +++ b/be/src/vec/aggregate_functions/aggregate_function_map.h @@ -146,7 +146,9 @@ struct AggregateFunctionMapAggData { const size_t size = _key_column->size(); write_binary(size, buf); for (size_t i = 0; i < size; i++) { - write_binary(assert_cast(*_key_column).get_data_at(i), buf); + write_binary(assert_cast(*_key_column) + .get_data_at(i), + buf); } for (size_t i = 0; i < size; i++) { write_binary(_value_column->get_data_at(i), buf); @@ -163,7 +165,8 @@ struct AggregateFunctionMapAggData { continue; } key.data = _arena.insert(key.data, key.size); - assert_cast(*_key_column).insert_data(key.data, key.size); + assert_cast(*_key_column) + .insert_data(key.data, key.size); } StringRef val; for (size_t i = 0; i < size; i++) { @@ -205,22 +208,25 @@ class AggregateFunctionMapAgg final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena* arena) const override { if (columns[0]->is_nullable()) { - auto& nullable_col = assert_cast(*columns[0]); + auto& nullable_col = + assert_cast(*columns[0]); auto& nullable_map = nullable_col.get_null_map_data(); if (nullable_map[row_num]) { return; } Field value; columns[1]->get(row_num, value); - this->data(place).add( - assert_cast(nullable_col.get_nested_column()) - .get_data_at(row_num), - value); + this->data(place).add(assert_cast( + nullable_col.get_nested_column()) + .get_data_at(row_num), + value); } else { Field value; columns[1]->get(row_num, value); this->data(place).add( - assert_cast(*columns[0]).get_data_at(row_num), value); + assert_cast(*columns[0]) + .get_data_at(row_num), + value); } } diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max.h b/be/src/vec/aggregate_functions/aggregate_function_min_max.h index 7fe6e2923e1703..1281e7ca4c4841 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_min_max.h +++ b/be/src/vec/aggregate_functions/aggregate_function_min_max.h @@ -73,9 +73,13 @@ struct SingleValueDataFixed { void change_if(const IColumn& column, size_t row_num, bool less) { has_value = true; - value = less ? std::min(assert_cast&>(column).get_data()[row_num], + value = less ? std::min(assert_cast&, TypeCheckOnRelease::DISABLE>( + column) + .get_data()[row_num], value) - : std::max(assert_cast&>(column).get_data()[row_num], + : std::max(assert_cast&, TypeCheckOnRelease::DISABLE>( + column) + .get_data()[row_num], value); } @@ -109,7 +113,8 @@ struct SingleValueDataFixed { void change(const IColumn& column, size_t row_num, Arena*) { has_value = true; - value = assert_cast&>(column).get_data()[row_num]; + value = assert_cast&, TypeCheckOnRelease::DISABLE>(column) + .get_data()[row_num]; } /// Assuming to.has() @@ -119,7 +124,8 @@ struct SingleValueDataFixed { } bool change_if_less(const IColumn& column, size_t row_num, Arena* arena) { - if (!has() || assert_cast&>(column).get_data()[row_num] < value) { + if (!has() || assert_cast&, TypeCheckOnRelease::DISABLE>(column) + .get_data()[row_num] < value) { change(column, row_num, arena); return true; } else { @@ -137,7 +143,8 @@ struct SingleValueDataFixed { } bool change_if_greater(const IColumn& column, size_t row_num, Arena* arena) { - if (!has() || assert_cast&>(column).get_data()[row_num] > value) { + if (!has() || assert_cast&, TypeCheckOnRelease::DISABLE>(column) + .get_data()[row_num] > value) { change(column, row_num, arena); return true; } else { @@ -188,9 +195,13 @@ struct SingleValueDataDecimal { void change_if(const IColumn& column, size_t row_num, bool less) { has_value = true; - value = less ? std::min(assert_cast&>(column).get_data()[row_num], + value = less ? std::min(assert_cast&, TypeCheckOnRelease::DISABLE>( + column) + .get_data()[row_num], value) - : std::max(assert_cast&>(column).get_data()[row_num], + : std::max(assert_cast&, TypeCheckOnRelease::DISABLE>( + column) + .get_data()[row_num], value); } @@ -224,7 +235,8 @@ struct SingleValueDataDecimal { void change(const IColumn& column, size_t row_num, Arena*) { has_value = true; - value = assert_cast&>(column).get_data()[row_num]; + value = assert_cast&, TypeCheckOnRelease::DISABLE>(column) + .get_data()[row_num]; } /// Assuming to.has() @@ -234,7 +246,8 @@ struct SingleValueDataDecimal { } bool change_if_less(const IColumn& column, size_t row_num, Arena* arena) { - if (!has() || assert_cast&>(column).get_data()[row_num] < value) { + if (!has() || assert_cast&, TypeCheckOnRelease::DISABLE>(column) + .get_data()[row_num] < value) { change(column, row_num, arena); return true; } else { @@ -252,7 +265,8 @@ struct SingleValueDataDecimal { } bool change_if_greater(const IColumn& column, size_t row_num, Arena* arena) { - if (!has() || assert_cast&>(column).get_data()[row_num] > value) { + if (!has() || assert_cast&, TypeCheckOnRelease::DISABLE>(column) + .get_data()[row_num] > value) { change(column, row_num, arena); return true; } else { @@ -389,14 +403,18 @@ struct SingleValueDataString { } void change(const IColumn& column, size_t row_num, Arena* arena) { - change_impl(assert_cast(column).get_data_at(row_num), arena); + change_impl( + assert_cast(column).get_data_at( + row_num), + arena); } void change(const Self& to, Arena* arena) { change_impl(to.get_string_ref(), arena); } bool change_if_less(const IColumn& column, size_t row_num, Arena* arena) { if (!has() || - assert_cast(column).get_data_at(row_num) < get_string_ref()) { + assert_cast(column).get_data_at( + row_num) < get_string_ref()) { change(column, row_num, arena); return true; } else { @@ -406,7 +424,8 @@ struct SingleValueDataString { bool change_if_greater(const IColumn& column, size_t row_num, Arena* arena) { if (!has() || - assert_cast(column).get_data_at(row_num) > get_string_ref()) { + assert_cast(column).get_data_at( + row_num) > get_string_ref()) { change(column, row_num, arena); return true; } else { diff --git a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h index 634dc171f5960c..e46931151202c2 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h +++ b/be/src/vec/aggregate_functions/aggregate_function_min_max_by.h @@ -73,7 +73,8 @@ struct BitmapValueData { void change(const IColumn& column, size_t row_num, Arena*) { has_value = true; - value = assert_cast(column).get_data()[row_num]; + value = assert_cast(column) + .get_data()[row_num]; } void change(const Self& to, Arena*) { diff --git a/be/src/vec/aggregate_functions/aggregate_function_null.h b/be/src/vec/aggregate_functions/aggregate_function_null.h index d99d1aae3c39a3..382fb8f7a5310e 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_null.h +++ b/be/src/vec/aggregate_functions/aggregate_function_null.h @@ -200,7 +200,8 @@ class AggregateFunctionNullUnaryInline final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena* arena) const override { - const ColumnNullable* column = assert_cast(columns[0]); + const ColumnNullable* column = + assert_cast(columns[0]); if (!column->is_null_at(row_num)) { this->set_flag(place); const IColumn* nested_column = &column->get_nested_column(); @@ -308,7 +309,9 @@ class AggregateFunctionNullVariadicInline final for (size_t i = 0; i < number_of_arguments; ++i) { if (is_nullable[i]) { - const auto& nullable_col = assert_cast(*columns[i]); + const auto& nullable_col = + assert_cast( + *columns[i]); if (nullable_col.is_null_at(row_num)) { /// If at least one column has a null value in the current row, /// we don't process this row. diff --git a/be/src/vec/aggregate_functions/aggregate_function_orthogonal_bitmap.h b/be/src/vec/aggregate_functions/aggregate_function_orthogonal_bitmap.h index d7de66681ed110..deb53241abb92f 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_orthogonal_bitmap.h +++ b/be/src/vec/aggregate_functions/aggregate_function_orthogonal_bitmap.h @@ -53,8 +53,10 @@ struct AggOrthBitmapBaseData { using ColVecData = std::conditional_t, ColumnVector, ColumnString>; void add(const IColumn** columns, size_t row_num) { - const auto& bitmap_col = assert_cast(*columns[0]); - const auto& data_col = assert_cast(*columns[1]); + const auto& bitmap_col = + assert_cast(*columns[0]); + const auto& data_col = + assert_cast(*columns[1]); const auto& bitmap_value = bitmap_col.get_element(row_num); if constexpr (IsNumber) { @@ -71,7 +73,8 @@ struct AggOrthBitmapBaseData { if (first_init) { DCHECK(argument_size > 1); for (int idx = 2; idx < argument_size; ++idx) { - const auto& col = assert_cast(*columns[idx]); + const auto& col = + assert_cast(*columns[idx]); if constexpr (IsNumber) { bitmap.add_key(col.get_element(row_num)); } @@ -202,8 +205,10 @@ struct AggOrthBitmapExprCalBaseData { using ColVecData = std::conditional_t, ColumnVector, ColumnString>; void add(const IColumn** columns, size_t row_num) { - const auto& bitmap_col = assert_cast(*columns[0]); - const auto& data_col = assert_cast(*columns[1]); + const auto& bitmap_col = + assert_cast(*columns[0]); + const auto& data_col = + assert_cast(*columns[1]); const auto& bitmap_value = bitmap_col.get_element(row_num); std::string update_key = data_col.get_data_at(row_num).to_string(); bitmap_expr_cal.update(update_key, bitmap_value); @@ -212,7 +217,8 @@ struct AggOrthBitmapExprCalBaseData { void init_add_key(const IColumn** columns, size_t row_num, int argument_size) { if (first_init) { DCHECK(argument_size > 1); - const auto& col = assert_cast(*columns[2]); + const auto& col = + assert_cast(*columns[2]); std::string expr = col.get_data_at(row_num).to_string(); bitmap_expr_cal.bitmap_calculation_init(expr); first_init = false; @@ -306,7 +312,8 @@ struct OrthBitmapUnionCountData { void init_add_key(const IColumn** columns, size_t row_num, int argument_size) {} void add(const IColumn** columns, size_t row_num) { - const auto& column = assert_cast(*columns[0]); + const auto& column = + assert_cast(*columns[0]); value |= column.get_data()[row_num]; } void merge(const OrthBitmapUnionCountData& rhs) { result += rhs.result; } diff --git a/be/src/vec/aggregate_functions/aggregate_function_percentile.h b/be/src/vec/aggregate_functions/aggregate_function_percentile.h index 3f83744f13e468..fe3e18861877a6 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_percentile.h +++ b/be/src/vec/aggregate_functions/aggregate_function_percentile.h @@ -222,12 +222,15 @@ class AggregateFunctionPercentileApproxTwoParams_OLDER : public AggregateFunctio for (int i = 0; i < 2; ++i) { const auto* nullable_column = check_and_get_column(columns[i]); if (nullable_column == nullptr) { //Not Nullable column - const auto& column = assert_cast(*columns[i]); + const auto& column = + assert_cast( + *columns[i]); column_data[i] = column.get_element(row_num); } else if (!nullable_column->is_null_at( row_num)) { // Nullable column && Not null data const auto& column = - assert_cast(nullable_column->get_nested_column()); + assert_cast( + nullable_column->get_nested_column()); column_data[i] = column.get_element(row_num); } else { // Nullable column && null data if (i == 0) { @@ -240,8 +243,10 @@ class AggregateFunctionPercentileApproxTwoParams_OLDER : public AggregateFunctio this->data(place).add(column_data[0], column_data[1]); } else { - const auto& sources = assert_cast(*columns[0]); - const auto& quantile = assert_cast(*columns[1]); + const auto& sources = + assert_cast(*columns[0]); + const auto& quantile = + assert_cast(*columns[1]); this->data(place).init(); this->data(place).add(sources.get_element(row_num), quantile.get_element(row_num)); @@ -255,8 +260,10 @@ class AggregateFunctionPercentileApproxTwoParams : public AggregateFunctionPerce : AggregateFunctionPercentileApprox(argument_types_) {} void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& sources = assert_cast(*columns[0]); - const auto& quantile = assert_cast(*columns[1]); + const auto& sources = + assert_cast(*columns[0]); + const auto& quantile = + assert_cast(*columns[1]); this->data(place).init(); this->data(place).add(sources.get_element(row_num), quantile.get_element(row_num)); } @@ -276,12 +283,15 @@ class AggregateFunctionPercentileApproxThreeParams_OLDER for (int i = 0; i < 3; ++i) { const auto* nullable_column = check_and_get_column(columns[i]); if (nullable_column == nullptr) { //Not Nullable column - const auto& column = assert_cast(*columns[i]); + const auto& column = + assert_cast( + *columns[i]); column_data[i] = column.get_element(row_num); } else if (!nullable_column->is_null_at( row_num)) { // Nullable column && Not null data const auto& column = - assert_cast(nullable_column->get_nested_column()); + assert_cast( + nullable_column->get_nested_column()); column_data[i] = column.get_element(row_num); } else { // Nullable column && null data if (i == 0) { @@ -294,9 +304,12 @@ class AggregateFunctionPercentileApproxThreeParams_OLDER this->data(place).add(column_data[0], column_data[1]); } else { - const auto& sources = assert_cast(*columns[0]); - const auto& quantile = assert_cast(*columns[1]); - const auto& compression = assert_cast(*columns[2]); + const auto& sources = + assert_cast(*columns[0]); + const auto& quantile = + assert_cast(*columns[1]); + const auto& compression = + assert_cast(*columns[2]); this->data(place).init(compression.get_element(row_num)); this->data(place).add(sources.get_element(row_num), quantile.get_element(row_num)); @@ -310,9 +323,12 @@ class AggregateFunctionPercentileApproxThreeParams : public AggregateFunctionPer : AggregateFunctionPercentileApprox(argument_types_) {} void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& sources = assert_cast(*columns[0]); - const auto& quantile = assert_cast(*columns[1]); - const auto& compression = assert_cast(*columns[2]); + const auto& sources = + assert_cast(*columns[0]); + const auto& quantile = + assert_cast(*columns[1]); + const auto& compression = + assert_cast(*columns[2]); this->data(place).init(compression.get_element(row_num)); this->data(place).add(sources.get_element(row_num), quantile.get_element(row_num)); @@ -334,12 +350,15 @@ class AggregateFunctionPercentileApproxWeightedThreeParams_OLDER for (int i = 0; i < 3; ++i) { const auto* nullable_column = check_and_get_column(columns[i]); if (nullable_column == nullptr) { //Not Nullable column - const auto& column = assert_cast&>(*columns[i]); + const auto& column = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[i]); column_data[i] = column.get_element(row_num); } else if (!nullable_column->is_null_at( row_num)) { // Nullable column && Not null data - const auto& column = assert_cast&>( - nullable_column->get_nested_column()); + const auto& column = + assert_cast&, TypeCheckOnRelease::DISABLE>( + nullable_column->get_nested_column()); column_data[i] = column.get_element(row_num); } else { // Nullable column && null data if (i == 0) { @@ -351,9 +370,15 @@ class AggregateFunctionPercentileApproxWeightedThreeParams_OLDER this->data(place).add_with_weight(column_data[0], column_data[1], column_data[2]); } else { - const auto& sources = assert_cast&>(*columns[0]); - const auto& weight = assert_cast&>(*columns[1]); - const auto& quantile = assert_cast&>(*columns[2]); + const auto& sources = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[0]); + const auto& weight = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[1]); + const auto& quantile = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[2]); this->data(place).init(); this->data(place).add_with_weight(sources.get_element(row_num), @@ -371,9 +396,12 @@ class AggregateFunctionPercentileApproxWeightedThreeParams void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& sources = assert_cast&>(*columns[0]); - const auto& weight = assert_cast&>(*columns[1]); - const auto& quantile = assert_cast&>(*columns[2]); + const auto& sources = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[0]); + const auto& weight = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[1]); + const auto& quantile = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[2]); this->data(place).init(); this->data(place).add_with_weight(sources.get_element(row_num), weight.get_element(row_num), @@ -395,12 +423,15 @@ class AggregateFunctionPercentileApproxWeightedFourParams_OLDER for (int i = 0; i < 4; ++i) { const auto* nullable_column = check_and_get_column(columns[i]); if (nullable_column == nullptr) { //Not Nullable column - const auto& column = assert_cast&>(*columns[i]); + const auto& column = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[i]); column_data[i] = column.get_element(row_num); } else if (!nullable_column->is_null_at( row_num)) { // Nullable column && Not null data - const auto& column = assert_cast&>( - nullable_column->get_nested_column()); + const auto& column = + assert_cast&, TypeCheckOnRelease::DISABLE>( + nullable_column->get_nested_column()); column_data[i] = column.get_element(row_num); } else { // Nullable column && null data if (i == 0) { @@ -413,10 +444,18 @@ class AggregateFunctionPercentileApproxWeightedFourParams_OLDER this->data(place).add_with_weight(column_data[0], column_data[1], column_data[2]); } else { - const auto& sources = assert_cast&>(*columns[0]); - const auto& weight = assert_cast&>(*columns[1]); - const auto& quantile = assert_cast&>(*columns[2]); - const auto& compression = assert_cast&>(*columns[3]); + const auto& sources = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[0]); + const auto& weight = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[1]); + const auto& quantile = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[2]); + const auto& compression = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[3]); this->data(place).init(compression.get_element(row_num)); this->data(place).add_with_weight(sources.get_element(row_num), @@ -433,10 +472,14 @@ class AggregateFunctionPercentileApproxWeightedFourParams : AggregateFunctionPercentileApprox(argument_types_) {} void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& sources = assert_cast&>(*columns[0]); - const auto& weight = assert_cast&>(*columns[1]); - const auto& quantile = assert_cast&>(*columns[2]); - const auto& compression = assert_cast&>(*columns[3]); + const auto& sources = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[0]); + const auto& weight = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[1]); + const auto& quantile = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[2]); + const auto& compression = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[3]); this->data(place).init(compression.get_element(row_num)); this->data(place).add_with_weight(sources.get_element(row_num), weight.get_element(row_num), @@ -542,8 +585,10 @@ class AggregateFunctionPercentile final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& sources = assert_cast(*columns[0]); - const auto& quantile = assert_cast(*columns[1]); + const auto& sources = + assert_cast(*columns[0]); + const auto& quantile = + assert_cast(*columns[1]); AggregateFunctionPercentile::data(place).add(sources.get_data()[row_num], quantile.get_data(), 1); } @@ -590,12 +635,16 @@ class AggregateFunctionPercentileArray final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& sources = assert_cast(*columns[0]); - const auto& quantile_array = assert_cast(*columns[1]); + const auto& sources = + assert_cast(*columns[0]); + const auto& quantile_array = + assert_cast(*columns[1]); const auto& offset_column_data = quantile_array.get_offsets(); - const auto& nested_column = - assert_cast(quantile_array.get_data()).get_nested_column(); - const auto& nested_column_data = assert_cast(nested_column); + const auto& nested_column = assert_cast( + quantile_array.get_data()) + .get_nested_column(); + const auto& nested_column_data = + assert_cast(nested_column); AggregateFunctionPercentileArray::data(place).add( sources.get_int(row_num), nested_column_data.get_data(), diff --git a/be/src/vec/aggregate_functions/aggregate_function_percentile_approx.h b/be/src/vec/aggregate_functions/aggregate_function_percentile_approx.h index e73b71e9c9b4c5..8698355897d2cb 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_percentile_approx.h +++ b/be/src/vec/aggregate_functions/aggregate_function_percentile_approx.h @@ -156,8 +156,10 @@ class AggregateFunctionPercentileOld final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& sources = assert_cast&>(*columns[0]); - const auto& quantile = assert_cast(*columns[1]); + const auto& sources = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[0]); + const auto& quantile = + assert_cast(*columns[1]); AggregateFunctionPercentileOld::data(place).add(sources.get_int(row_num), quantile.get_data(), 1); } @@ -203,12 +205,16 @@ class AggregateFunctionPercentileArrayOld final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& sources = assert_cast&>(*columns[0]); - const auto& quantile_array = assert_cast(*columns[1]); + const auto& sources = + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[0]); + const auto& quantile_array = + assert_cast(*columns[1]); const auto& offset_column_data = quantile_array.get_offsets(); - const auto& nested_column = - assert_cast(quantile_array.get_data()).get_nested_column(); - const auto& nested_column_data = assert_cast(nested_column); + const auto& nested_column = assert_cast( + quantile_array.get_data()) + .get_nested_column(); + const auto& nested_column_data = + assert_cast(nested_column); AggregateFunctionPercentileArrayOld::data(place).add( sources.get_int(row_num), nested_column_data.get_data(), diff --git a/be/src/vec/aggregate_functions/aggregate_function_product.h b/be/src/vec/aggregate_functions/aggregate_function_product.h index 22a217263b2274..1ec9a2711cef72 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_product.h +++ b/be/src/vec/aggregate_functions/aggregate_function_product.h @@ -133,7 +133,8 @@ class AggregateFunctionProduct final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& column = assert_cast(*columns[0]); + const auto& column = + assert_cast(*columns[0]); this->data(place).add(TResult(column.get_data()[row_num]), multiplier); } diff --git a/be/src/vec/aggregate_functions/aggregate_function_quantile_state.h b/be/src/vec/aggregate_functions/aggregate_function_quantile_state.h index 14250087d2bd74..5954120553e17e 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_quantile_state.h +++ b/be/src/vec/aggregate_functions/aggregate_function_quantile_state.h @@ -114,14 +114,16 @@ class AggregateFunctionQuantileStateOp final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { if constexpr (arg_is_nullable) { - auto& nullable_column = assert_cast(*columns[0]); + auto& nullable_column = + assert_cast(*columns[0]); if (!nullable_column.is_null_at(row_num)) { - const auto& column = - assert_cast(nullable_column.get_nested_column()); + const auto& column = assert_cast( + nullable_column.get_nested_column()); this->data(place).add(column.get_data()[row_num]); } } else { - const auto& column = assert_cast(*columns[0]); + const auto& column = + assert_cast(*columns[0]); this->data(place).add(column.get_data()[row_num]); } } diff --git a/be/src/vec/aggregate_functions/aggregate_function_reader_first_last.h b/be/src/vec/aggregate_functions/aggregate_function_reader_first_last.h index f807f67a14b9a3..b9d2545e0c00dd 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_reader_first_last.h +++ b/be/src/vec/aggregate_functions/aggregate_function_reader_first_last.h @@ -43,17 +43,19 @@ struct Value { return true; } if constexpr (arg_is_nullable) { - return assert_cast(_ptr)->is_null_at(_offset); + return assert_cast(_ptr) + ->is_null_at(_offset); } return false; } void insert_into(IColumn& to) const { if constexpr (arg_is_nullable) { - auto* col = assert_cast(_ptr); - assert_cast(to).insert_from(col->get_nested_column(), _offset); + auto* col = assert_cast(_ptr); + assert_cast(to).insert_from( + col->get_nested_column(), _offset); } else { - assert_cast(to).insert_from(*_ptr, _offset); + assert_cast(to).insert_from(*_ptr, _offset); } } @@ -75,7 +77,9 @@ struct Value { template struct CopiedValue : public Value { public: - void insert_into(IColumn& to) const { assert_cast(to).insert(_copied_value); } + void insert_into(IColumn& to) const { + assert_cast(to).insert(_copied_value); + } bool is_null() const { return this->_ptr == nullptr; } @@ -85,12 +89,13 @@ struct CopiedValue : public Value { // because the address have meaningless, only need it to check is nullptr this->_ptr = (IColumn*)0x00000001; if constexpr (arg_is_nullable) { - auto* col = assert_cast(column); + auto* col = assert_cast(column); if (col->is_null_at(row)) { this->reset(); return; } else { - auto& nested_col = assert_cast(col->get_nested_column()); + auto& nested_col = assert_cast( + col->get_nested_column()); nested_col.get(row, _copied_value); } } else { @@ -162,7 +167,8 @@ struct ReaderFunctionFirstNonNullData : Data { return; } if constexpr (Data::nullable) { - const auto* nullable_column = assert_cast(columns[0]); + const auto* nullable_column = + assert_cast(columns[0]); if (nullable_column->is_null_at(row)) { return; } @@ -182,7 +188,8 @@ template struct ReaderFunctionLastNonNullData : Data { void add(int64_t row, const IColumn** columns) { if constexpr (Data::nullable) { - const auto* nullable_column = assert_cast(columns[0]); + const auto* nullable_column = + assert_cast(columns[0]); if (nullable_column->is_null_at(row)) { return; } diff --git a/be/src/vec/aggregate_functions/aggregate_function_retention.h b/be/src/vec/aggregate_functions/aggregate_function_retention.h index f38f1cf45a00d1..f6bf03282e5711 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_retention.h +++ b/be/src/vec/aggregate_functions/aggregate_function_retention.h @@ -127,7 +127,9 @@ class AggregateFunctionRetention void add(AggregateDataPtr __restrict place, const IColumn** columns, const ssize_t row_num, Arena*) const override { for (int i = 0; i < get_argument_types().size(); i++) { - auto event = assert_cast*>(columns[i])->get_data()[row_num]; + auto event = + assert_cast*, TypeCheckOnRelease::DISABLE>(columns[i]) + ->get_data()[row_num]; if (event) { this->data(place).set(i); } diff --git a/be/src/vec/aggregate_functions/aggregate_function_sequence_match.h b/be/src/vec/aggregate_functions/aggregate_function_sequence_match.h index 101c2c16fd00c8..586003043311c4 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_sequence_match.h +++ b/be/src/vec/aggregate_functions/aggregate_function_sequence_match.h @@ -201,7 +201,7 @@ struct AggregateFunctionSequenceMatchData final { using PatternActions = PODArrayWithStackMemory; - Derived& derived() { return assert_cast(*this); } + Derived& derived() { return assert_cast(*this); } void parse_pattern() { actions.clear(); @@ -602,16 +602,22 @@ class AggregateFunctionSequenceBase void add(AggregateDataPtr __restrict place, const IColumn** columns, const ssize_t row_num, Arena*) const override { std::string pattern = - assert_cast(columns[0])->get_data_at(0).to_string(); + assert_cast(columns[0]) + ->get_data_at(0) + .to_string(); this->data(place).init(pattern, arg_count); const auto& timestamp = - assert_cast&>(*columns[1]).get_data()[row_num]; + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[1]) + .get_data()[row_num]; typename AggregateFunctionSequenceMatchData::Events events; for (auto i = 2; i < arg_count; i++) { - const auto event = assert_cast(columns[i])->get_data()[row_num]; + const auto event = + assert_cast(columns[i]) + ->get_data()[row_num]; events.set(i - 2, event); } diff --git a/be/src/vec/aggregate_functions/aggregate_function_stddev.h b/be/src/vec/aggregate_functions/aggregate_function_stddev.h index 496212bc35c81b..2822334b6d7081 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_stddev.h +++ b/be/src/vec/aggregate_functions/aggregate_function_stddev.h @@ -105,7 +105,8 @@ struct BaseData { } void add(const IColumn* column, size_t row_num) { - const auto& sources = assert_cast&>(*column); + const auto& sources = + assert_cast&, TypeCheckOnRelease::DISABLE>(*column); double source_data = sources.get_data()[row_num]; double delta = source_data - mean; diff --git a/be/src/vec/aggregate_functions/aggregate_function_sum.h b/be/src/vec/aggregate_functions/aggregate_function_sum.h index 376b6ece4aafea..cc05435a95030b 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_sum.h +++ b/be/src/vec/aggregate_functions/aggregate_function_sum.h @@ -100,7 +100,8 @@ class AggregateFunctionSum final void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { - const auto& column = assert_cast(*columns[0]); + const auto& column = + assert_cast(*columns[0]); this->data(place).add(TResult(column.get_data()[row_num])); } diff --git a/be/src/vec/aggregate_functions/aggregate_function_topn.h b/be/src/vec/aggregate_functions/aggregate_function_topn.h index 6c7502c99a38fa..1c0fba5099fb17 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_topn.h +++ b/be/src/vec/aggregate_functions/aggregate_function_topn.h @@ -195,10 +195,11 @@ struct AggregateFunctionTopNData { for (int i = 0; i < std::min((int)counter_vector.size(), top_num); i++) { const auto& element = counter_vector[i]; if constexpr (std::is_same_v) { - assert_cast(to).insert_data(element.second.c_str(), - element.second.length()); + assert_cast(to).insert_data( + element.second.c_str(), element.second.length()); } else { - assert_cast(to).get_data().push_back(element.second); + assert_cast(to).get_data().push_back( + element.second); } } } @@ -213,16 +214,22 @@ struct AggregateFunctionTopNData { struct AggregateFunctionTopNImplInt { static void add(AggregateFunctionTopNData& __restrict place, const IColumn** columns, size_t row_num) { - place.set_paramenters(assert_cast(columns[1])->get_element(row_num)); - place.add(assert_cast(*columns[0]).get_data_at(row_num)); + place.set_paramenters( + assert_cast(columns[1]) + ->get_element(row_num)); + place.add(assert_cast(*columns[0]) + .get_data_at(row_num)); } }; struct AggregateFunctionTopNImplIntInt { static void add(AggregateFunctionTopNData& __restrict place, const IColumn** columns, size_t row_num) { - place.set_paramenters(assert_cast(columns[1])->get_element(row_num), - assert_cast(columns[2])->get_element(row_num)); + place.set_paramenters( + assert_cast(columns[1]) + ->get_element(row_num), + assert_cast(columns[2]) + ->get_element(row_num)); place.add(assert_cast(*columns[0]).get_data_at(row_num)); } }; @@ -235,17 +242,22 @@ struct AggregateFunctionTopNImplArray { size_t row_num) { if constexpr (has_default_param) { place.set_paramenters( - assert_cast(columns[1])->get_element(row_num), - assert_cast(columns[2])->get_element(row_num)); + assert_cast(columns[1]) + ->get_element(row_num), + assert_cast(columns[2]) + ->get_element(row_num)); } else { place.set_paramenters( - assert_cast(columns[1])->get_element(row_num)); + assert_cast(columns[1]) + ->get_element(row_num)); } if constexpr (std::is_same_v) { - place.add(assert_cast(*columns[0]).get_data_at(row_num)); + place.add(assert_cast(*columns[0]) + .get_data_at(row_num)); } else { - T val = assert_cast(*columns[0]).get_data()[row_num]; + T val = assert_cast(*columns[0]) + .get_data()[row_num]; place.add(val); } } @@ -259,19 +271,28 @@ struct AggregateFunctionTopNImplWeight { size_t row_num) { if constexpr (has_default_param) { place.set_paramenters( - assert_cast(columns[2])->get_element(row_num), - assert_cast(columns[3])->get_element(row_num)); + assert_cast(columns[2]) + ->get_element(row_num), + assert_cast(columns[3]) + ->get_element(row_num)); } else { place.set_paramenters( assert_cast(columns[2])->get_element(row_num)); } if constexpr (std::is_same_v) { - auto weight = assert_cast&>(*columns[1]).get_data()[row_num]; - place.add(assert_cast(*columns[0]).get_data_at(row_num), weight); + auto weight = assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[1]) + .get_data()[row_num]; + place.add(assert_cast(*columns[0]) + .get_data_at(row_num), + weight); } else { - T val = assert_cast(*columns[0]).get_data()[row_num]; - auto weight = assert_cast&>(*columns[1]).get_data()[row_num]; + T val = assert_cast(*columns[0]) + .get_data()[row_num]; + auto weight = assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[1]) + .get_data()[row_num]; place.add(val, weight); } } diff --git a/be/src/vec/aggregate_functions/aggregate_function_uniq.h b/be/src/vec/aggregate_functions/aggregate_function_uniq.h index 58abd3842c21b2..356e0ead2d3d56 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_uniq.h +++ b/be/src/vec/aggregate_functions/aggregate_function_uniq.h @@ -90,9 +90,12 @@ struct OneAdder { StringRef value = column.get_data_at(row_num); data.set.insert(Data::get_key(value)); } else if constexpr (IsDecimalNumber) { - data.set.insert(assert_cast&>(column).get_data()[row_num]); + data.set.insert( + assert_cast&, TypeCheckOnRelease::DISABLE>(column) + .get_data()[row_num]); } else { - data.set.insert(assert_cast&>(column).get_data()[row_num]); + data.set.insert(assert_cast&, TypeCheckOnRelease::DISABLE>(column) + .get_data()[row_num]); } } }; diff --git a/be/src/vec/aggregate_functions/aggregate_function_window.h b/be/src/vec/aggregate_functions/aggregate_function_window.h index 24ff2ad7ead165..ec1aab99e6a5fe 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_window.h +++ b/be/src/vec/aggregate_functions/aggregate_function_window.h @@ -387,7 +387,8 @@ struct LeadLagData { void set_value(const IColumn** columns, size_t pos) { if constexpr (arg_is_nullable) { - if (assert_cast(columns[0])->is_null_at(pos)) { + if (assert_cast(columns[0]) + ->is_null_at(pos)) { // ptr == nullptr means nullable _data_value.reset(); return; @@ -400,7 +401,8 @@ struct LeadLagData { void check_default(const IColumn* column) { if (!_is_inited) { if (is_column_nullable(*column)) { - const auto* nullable_column = assert_cast(column); + const auto* nullable_column = + assert_cast(column); if (nullable_column->is_null_at(0)) { _default_value.reset(); } else { diff --git a/be/src/vec/aggregate_functions/aggregate_function_window_funnel.h b/be/src/vec/aggregate_functions/aggregate_function_window_funnel.h index 3751078910badd..00ca7c58ed701a 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_window_funnel.h +++ b/be/src/vec/aggregate_functions/aggregate_function_window_funnel.h @@ -663,14 +663,19 @@ class AggregateFunctionWindowFunnelOld void add(AggregateDataPtr __restrict place, const IColumn** columns, ssize_t row_num, Arena*) const override { const auto& window = - assert_cast&>(*columns[0]).get_data()[row_num]; + assert_cast&, TypeCheckOnRelease::DISABLE>(*columns[0]) + .get_data()[row_num]; StringRef mode = columns[1]->get_data_at(row_num); const auto& timestamp = - assert_cast&>(*columns[2]).get_data()[row_num]; + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[2]) + .get_data()[row_num]; const int NON_EVENT_NUM = 3; for (int i = NON_EVENT_NUM; i < IAggregateFunction::get_argument_types().size(); i++) { const auto& is_set = - assert_cast&>(*columns[i]).get_data()[row_num]; + assert_cast&, TypeCheckOnRelease::DISABLE>( + *columns[i]) + .get_data()[row_num]; if (is_set) { this->data(place).add( binary_cast(timestamp), i - NON_EVENT_NUM, diff --git a/be/src/vec/columns/column_array.cpp b/be/src/vec/columns/column_array.cpp index 450ed7d5eb6891..2889e7ff381709 100644 --- a/be/src/vec/columns/column_array.cpp +++ b/be/src/vec/columns/column_array.cpp @@ -233,7 +233,7 @@ StringRef ColumnArray::serialize_value_into_arena(size_t n, Arena& arena, int ColumnArray::compare_at(size_t n, size_t m, const IColumn& rhs_, int nan_direction_hint) const { // since column type is complex, we can't use this function - const auto& rhs = assert_cast(rhs_); + const auto& rhs = assert_cast(rhs_); size_t lhs_size = size_at(n); size_t rhs_size = rhs.size_at(m); @@ -583,15 +583,17 @@ ColumnPtr ColumnArray::filter_number(const Filter& filt, ssize_t result_size_hin auto& res_elems = assert_cast&>(res->get_data()).get_data(); auto& res_offsets = res->get_offsets(); - filter_arrays_impl(assert_cast&>(*data).get_data(), - get_offsets(), res_elems, res_offsets, filt, result_size_hint); + filter_arrays_impl( + assert_cast&, TypeCheckOnRelease::DISABLE>(*data).get_data(), + get_offsets(), res_elems, res_offsets, filt, result_size_hint); return res; } template size_t ColumnArray::filter_number(const Filter& filter) { - return filter_arrays_impl(assert_cast&>(*data).get_data(), - get_offsets(), filter); + return filter_arrays_impl( + assert_cast&, TypeCheckOnRelease::DISABLE>(*data).get_data(), + get_offsets(), filter); } ColumnPtr ColumnArray::filter_string(const Filter& filt, ssize_t result_size_hint) const { @@ -794,7 +796,8 @@ size_t ColumnArray::filter_generic(const Filter& filter) { ColumnPtr ColumnArray::filter_nullable(const Filter& filt, ssize_t result_size_hint) const { if (get_offsets().empty()) return ColumnArray::create(data); - const ColumnNullable& nullable_elems = assert_cast(*data); + const ColumnNullable& nullable_elems = + assert_cast(*data); auto array_of_nested = ColumnArray::create(nullable_elems.get_nested_column_ptr(), offsets); auto filtered_array_of_nested_owner = array_of_nested->filter(filt, result_size_hint); @@ -817,7 +820,8 @@ size_t ColumnArray::filter_nullable(const Filter& filter) { return 0; } - ColumnNullable& nullable_elems = assert_cast(*data); + ColumnNullable& nullable_elems = + assert_cast(*data); const auto result_size = filter_arrays_impl_only_data(nullable_elems.get_null_map_data(), get_offsets(), filter); @@ -916,7 +920,7 @@ ColumnPtr ColumnArray::replicate_string(const IColumn::Offsets& replicate_offset if (0 == col_size) return res; - ColumnArray& res_arr = assert_cast(*res); + ColumnArray& res_arr = assert_cast(*res); const ColumnString& src_string = typeid_cast(*data); const ColumnString::Chars& src_chars = src_string.get_chars(); @@ -1019,7 +1023,7 @@ ColumnPtr ColumnArray::replicate_generic(const IColumn::Offsets& replicate_offse column_match_offsets_size(col_size, replicate_offsets.size()); MutableColumnPtr res = clone_empty(); - ColumnArray& res_concrete = assert_cast(*res); + ColumnArray& res_concrete = assert_cast(*res); if (0 == col_size) return res; @@ -1037,7 +1041,8 @@ ColumnPtr ColumnArray::replicate_generic(const IColumn::Offsets& replicate_offse } ColumnPtr ColumnArray::replicate_nullable(const IColumn::Offsets& replicate_offsets) const { - const ColumnNullable& nullable = assert_cast(*data); + const ColumnNullable& nullable = + assert_cast(*data); /// Make temporary arrays for each components of Nullable. Then replicate them independently and collect back to result. /// NOTE Offsets are calculated twice and it is redundant. @@ -1051,9 +1056,12 @@ ColumnPtr ColumnArray::replicate_nullable(const IColumn::Offsets& replicate_offs return ColumnArray::create( ColumnNullable::create( - assert_cast(*array_of_nested).get_data_ptr(), - assert_cast(*array_of_null_map).get_data_ptr()), - assert_cast(*array_of_nested).get_offsets_ptr()); + assert_cast(*array_of_nested) + .get_data_ptr(), + assert_cast(*array_of_null_map) + .get_data_ptr()), + assert_cast(*array_of_nested) + .get_offsets_ptr()); } ColumnPtr ColumnArray::permute(const Permutation& perm, size_t limit) const { diff --git a/be/src/vec/columns/column_array.h b/be/src/vec/columns/column_array.h index 7839503faa46ba..e2226ab01e1719 100644 --- a/be/src/vec/columns/column_array.h +++ b/be/src/vec/columns/column_array.h @@ -171,11 +171,11 @@ class ColumnArray final : public COWHelper { const IColumn& get_offsets_column() const { return *offsets; } Offsets64& ALWAYS_INLINE get_offsets() { - return assert_cast(*offsets).get_data(); + return assert_cast(*offsets).get_data(); } const Offsets64& ALWAYS_INLINE get_offsets() const { - return assert_cast(*offsets).get_data(); + return assert_cast(*offsets).get_data(); } bool has_equal_offsets(const ColumnArray& other) const; diff --git a/be/src/vec/columns/column_complex.h b/be/src/vec/columns/column_complex.h index c380ee1d0dd13a..feeb8f71b9d593 100644 --- a/be/src/vec/columns/column_complex.h +++ b/be/src/vec/columns/column_complex.h @@ -58,7 +58,7 @@ class ColumnComplexType final : public COWHelper> } void insert_from(const IColumn& src, size_t n) override { - data.push_back(assert_cast(src).get_data()[n]); + data.push_back(assert_cast(src).get_data()[n]); } void insert_data(const char* pos, size_t /*length*/) override { @@ -236,7 +236,7 @@ class ColumnComplexType final : public COWHelper> void replace_column_data(const IColumn& rhs, size_t row, size_t self_row = 0) override { DCHECK(size() > self_row); - data[self_row] = assert_cast(rhs).data[row]; + data[self_row] = assert_cast(rhs).data[row]; } private: diff --git a/be/src/vec/columns/column_const.h b/be/src/vec/columns/column_const.h index 2dad8cc6945783..0d1b16161eb2e3 100644 --- a/be/src/vec/columns/column_const.h +++ b/be/src/vec/columns/column_const.h @@ -228,7 +228,7 @@ class ColumnConst final : public COWHelper { size_t allocated_bytes() const override { return data->allocated_bytes() + sizeof(s); } int compare_at(size_t, size_t, const IColumn& rhs, int nan_direction_hint) const override { - auto rhs_const_column = assert_cast(rhs); + auto rhs_const_column = assert_cast(rhs); const auto* this_nullable = check_and_get_column(data.get()); const auto* rhs_nullable = diff --git a/be/src/vec/columns/column_decimal.cpp b/be/src/vec/columns/column_decimal.cpp index f11e183a54f1fc..65e8c9d79ac57f 100644 --- a/be/src/vec/columns/column_decimal.cpp +++ b/be/src/vec/columns/column_decimal.cpp @@ -46,7 +46,7 @@ namespace doris::vectorized { template int ColumnDecimal::compare_at(size_t n, size_t m, const IColumn& rhs_, int) const { - auto& other = assert_cast(rhs_); + auto& other = assert_cast(rhs_); const T& a = data[n]; const T& b = other.data[m]; diff --git a/be/src/vec/columns/column_decimal.h b/be/src/vec/columns/column_decimal.h index cc1661312a8dc2..0927cb88e15abc 100644 --- a/be/src/vec/columns/column_decimal.h +++ b/be/src/vec/columns/column_decimal.h @@ -116,7 +116,7 @@ class ColumnDecimal final : public COWHelper> { void resize(size_t n) override { data.resize(n); } void insert_from(const IColumn& src, size_t n) override { - data.push_back(assert_cast(src).get_data()[n]); + data.push_back(assert_cast(src).get_data()[n]); } void insert_indices_from(const IColumn& src, const uint32_t* indices_begin, @@ -241,7 +241,7 @@ class ColumnDecimal final : public COWHelper> { void replace_column_data(const IColumn& rhs, size_t row, size_t self_row = 0) override { DCHECK(size() > self_row); - data[self_row] = assert_cast(rhs).data[row]; + data[self_row] = assert_cast(rhs).data[row]; } void replace_column_null_data(const uint8_t* __restrict null_map) override; diff --git a/be/src/vec/columns/column_map.cpp b/be/src/vec/columns/column_map.cpp index a8fa5b2b51645d..b83ff6709dd16d 100644 --- a/be/src/vec/columns/column_map.cpp +++ b/be/src/vec/columns/column_map.cpp @@ -242,7 +242,7 @@ const char* ColumnMap::deserialize_and_insert_from_arena(const char* pos) { } int ColumnMap::compare_at(size_t n, size_t m, const IColumn& rhs_, int nan_direction_hint) const { - const auto& rhs = assert_cast(rhs_); + const auto& rhs = assert_cast(rhs_); size_t lhs_size = size_at(n); size_t rhs_size = rhs.size_at(m); diff --git a/be/src/vec/columns/column_map.h b/be/src/vec/columns/column_map.h index 9f2862da09ba4f..88705a514aeb66 100644 --- a/be/src/vec/columns/column_map.h +++ b/be/src/vec/columns/column_map.h @@ -141,10 +141,11 @@ class ColumnMap final : public COWHelper { } ColumnArray::Offsets64& ALWAYS_INLINE get_offsets() { - return assert_cast(*offsets_column).get_data(); + return assert_cast(*offsets_column).get_data(); } const ColumnArray::Offsets64& ALWAYS_INLINE get_offsets() const { - return assert_cast(*offsets_column).get_data(); + return assert_cast(*offsets_column) + .get_data(); } IColumn& get_offsets_column() { return *offsets_column; } const IColumn& get_offsets_column() const { return *offsets_column; } diff --git a/be/src/vec/columns/column_nullable.cpp b/be/src/vec/columns/column_nullable.cpp index 7424fa270e7a84..483ed5ca6cd59f 100644 --- a/be/src/vec/columns/column_nullable.cpp +++ b/be/src/vec/columns/column_nullable.cpp @@ -626,14 +626,18 @@ ColumnPtr make_nullable(const ColumnPtr& column, bool is_nullable) { ColumnPtr remove_nullable(const ColumnPtr& column) { if (is_column_nullable(*column)) { - return reinterpret_cast(column.get())->get_nested_column_ptr(); + return assert_cast(column.get()) + ->get_nested_column_ptr(); } if (is_column_const(*column)) { - const auto& column_nested = assert_cast(*column).get_data_column_ptr(); + const auto& column_nested = + assert_cast(*column) + .get_data_column_ptr(); if (is_column_nullable(*column_nested)) { return ColumnConst::create( - assert_cast(*column_nested).get_nested_column_ptr(), + assert_cast(*column_nested) + .get_nested_column_ptr(), column->size()); } } diff --git a/be/src/vec/columns/column_nullable.h b/be/src/vec/columns/column_nullable.h index 718d5e9e6cf161..5425242aad7142 100644 --- a/be/src/vec/columns/column_nullable.h +++ b/be/src/vec/columns/column_nullable.h @@ -88,9 +88,12 @@ class ColumnNullable final : public COWHelper { const char* get_family_name() const override { return "Nullable"; } std::string get_name() const override { return "Nullable(" + nested_column->get_name() + ")"; } MutableColumnPtr clone_resized(size_t size) const override; - size_t size() const override { return assert_cast(*null_map).size(); } + size_t size() const override { + return assert_cast(*null_map).size(); + } PURE bool is_null_at(size_t n) const override { - return assert_cast(*null_map).get_data()[n] != 0; + return assert_cast(*null_map) + .get_data()[n] != 0; } Field operator[](size_t n) const override; void get(size_t n, Field& res) const override; @@ -100,7 +103,9 @@ class ColumnNullable final : public COWHelper { // column must be nullable(uint8) bool get_bool_inline(size_t n) const { return is_null_at(n) ? false - : assert_cast(nested_column.get())->get_bool(n); + : assert_cast( + nested_column.get()) + ->get_bool(n); } StringRef get_data_at(size_t n) const override; @@ -306,10 +311,10 @@ class ColumnNullable final : public COWHelper { ColumnUInt8& get_null_map_column() { _need_update_has_null = true; - return assert_cast(*null_map); + return assert_cast(*null_map); } const ColumnUInt8& get_null_map_column() const { - return assert_cast(*null_map); + return assert_cast(*null_map); } void clear() override { @@ -345,7 +350,8 @@ class ColumnNullable final : public COWHelper { void replace_column_data(const IColumn& rhs, size_t row, size_t self_row = 0) override { DCHECK(size() > self_row); - const auto& nullable_rhs = assert_cast(rhs); + const auto& nullable_rhs = + assert_cast(rhs); null_map->replace_column_data(*nullable_rhs.null_map, row, self_row); if (!nullable_rhs.is_null_at(row)) { @@ -408,7 +414,9 @@ class ColumnNullable final : public COWHelper { private: // the two functions will not update `_need_update_has_null` - ColumnUInt8& _get_null_map_column() { return assert_cast(*null_map); } + ColumnUInt8& _get_null_map_column() { + return assert_cast(*null_map); + } NullMap& _get_null_map_data() { return _get_null_map_column().get_data(); } WrappedPtr nested_column; diff --git a/be/src/vec/columns/column_object.cpp b/be/src/vec/columns/column_object.cpp index a00d18f0ce147a..b5ec5e8cfd7a39 100644 --- a/be/src/vec/columns/column_object.cpp +++ b/be/src/vec/columns/column_object.cpp @@ -768,7 +768,8 @@ void ColumnObject::insert_from(const IColumn& src, size_t n) { if (src_v != nullptr && src_v->is_scalar_variant() && is_scalar_variant() && src_v->get_root_type()->equals(*get_root_type()) && src_v->is_finalized() && is_finalized()) { - assert_cast(*get_root()).insert_from(*src_v->get_root(), n); + assert_cast(*get_root()) + .insert_from(*src_v->get_root(), n); ++num_rows; return; } @@ -1332,7 +1333,8 @@ Status ColumnObject::merge_sparse_to_root_column() { Arena mem_pool; for (const auto& subcolumn : sparse_columns) { auto& column = subcolumn->data.get_finalized_column_ptr(); - if (assert_cast(*column).is_null_at(i)) { + if (assert_cast(*column).is_null_at( + i)) { ++null_count; continue; } diff --git a/be/src/vec/columns/column_string.cpp b/be/src/vec/columns/column_string.cpp index 952a1a97915046..c3cf6dadf0a5fa 100644 --- a/be/src/vec/columns/column_string.cpp +++ b/be/src/vec/columns/column_string.cpp @@ -571,7 +571,9 @@ void ColumnStr::compare_internal(size_t rhs_row_id, const IColumn& rhs, int n uint8* __restrict filter) const { auto sz = offsets.size(); DCHECK(cmp_res.size() == sz); - const auto& cmp_base = assert_cast&>(rhs).get_data_at(rhs_row_id); + const auto& cmp_base = + assert_cast&, TypeCheckOnRelease::DISABLE>(rhs).get_data_at( + rhs_row_id); size_t begin = simd::find_zero(cmp_res, 0); while (begin < sz) { size_t end = simd::find_one(cmp_res, begin + 1); diff --git a/be/src/vec/columns/column_struct.cpp b/be/src/vec/columns/column_struct.cpp index 78250bc952d075..c08d12560c9863 100644 --- a/be/src/vec/columns/column_struct.cpp +++ b/be/src/vec/columns/column_struct.cpp @@ -187,7 +187,7 @@ const char* ColumnStruct::deserialize_and_insert_from_arena(const char* pos) { int ColumnStruct::compare_at(size_t n, size_t m, const IColumn& rhs_, int nan_direction_hint) const { - const ColumnStruct& rhs = assert_cast(rhs_); + const ColumnStruct& rhs = assert_cast(rhs_); const size_t lhs_tuple_size = columns.size(); const size_t rhs_tuple_size = rhs.tuple_size(); @@ -246,8 +246,9 @@ void ColumnStruct::insert_indices_from(const IColumn& src, const uint32_t* indic void ColumnStruct::insert_range_from(const IColumn& src, size_t start, size_t length) { const size_t tuple_size = columns.size(); for (size_t i = 0; i < tuple_size; ++i) { - columns[i]->insert_range_from(*assert_cast(src).columns[i], start, - length); + columns[i]->insert_range_from( + *assert_cast(src).columns[i], + start, length); } } @@ -256,7 +257,8 @@ void ColumnStruct::insert_range_from_ignore_overflow(const IColumn& src, size_t const size_t tuple_size = columns.size(); for (size_t i = 0; i < tuple_size; ++i) { columns[i]->insert_range_from_ignore_overflow( - *assert_cast(src).columns[i], start, length); + *assert_cast(src).columns[i], + start, length); } } diff --git a/be/src/vec/columns/column_vector.cpp b/be/src/vec/columns/column_vector.cpp index f8d05c3d492a6f..590e2047cab7c6 100644 --- a/be/src/vec/columns/column_vector.cpp +++ b/be/src/vec/columns/column_vector.cpp @@ -162,7 +162,8 @@ void ColumnVector::compare_internal(size_t rhs_row_id, const IColumn& rhs, uint8* __restrict filter) const { const auto sz = data.size(); DCHECK(cmp_res.size() == sz); - const auto& cmp_base = assert_cast&>(rhs).get_data()[rhs_row_id]; + const auto& cmp_base = assert_cast&, TypeCheckOnRelease::DISABLE>(rhs) + .get_data()[rhs_row_id]; size_t begin = simd::find_zero(cmp_res, 0); while (begin < sz) { size_t end = simd::find_one(cmp_res, begin + 1); diff --git a/be/src/vec/columns/column_vector.h b/be/src/vec/columns/column_vector.h index d9e59b0fa86c3e..60b1845c4ee818 100644 --- a/be/src/vec/columns/column_vector.h +++ b/be/src/vec/columns/column_vector.h @@ -161,7 +161,7 @@ class ColumnVector final : public COWHelper> { } void insert_from(const IColumn& src, size_t n) override { - data.push_back(assert_cast(src).get_data()[n]); + data.push_back(assert_cast(src).get_data()[n]); } void insert_data(const char* pos, size_t /*length*/) override { @@ -324,8 +324,9 @@ class ColumnVector final : public COWHelper> { /// This method implemented in header because it could be possibly devirtualized. int compare_at(size_t n, size_t m, const IColumn& rhs_, int nan_direction_hint) const override { - return CompareHelper::compare(data[n], assert_cast(rhs_).data[m], - nan_direction_hint); + return CompareHelper::compare( + data[n], assert_cast(rhs_).data[m], + nan_direction_hint); } void get_permutation(bool reverse, size_t limit, int nan_direction_hint, @@ -401,7 +402,7 @@ class ColumnVector final : public COWHelper> { void replace_column_data(const IColumn& rhs, size_t row, size_t self_row = 0) override { DCHECK(size() > self_row); - data[self_row] = assert_cast(rhs).data[row]; + data[self_row] = assert_cast(rhs).data[row]; } void replace_column_null_data(const uint8_t* __restrict null_map) override; diff --git a/be/src/vec/common/assert_cast.h b/be/src/vec/common/assert_cast.h index 6d8765befa203f..02dce99e967bdb 100644 --- a/be/src/vec/common/assert_cast.h +++ b/be/src/vec/common/assert_cast.h @@ -26,14 +26,17 @@ #include "common/logging.h" #include "vec/common/demangle.h" -/** Perform static_cast in release build. - * Checks type by comparing typeid and throw an exception in debug build. +enum class TypeCheckOnRelease : bool { ENABLE = true, DISABLE = false }; + +/** Perform static_cast in release build when TypeCheckOnRelease is set to DISABLE. + * Checks type by comparing typeid and throw an exception in all the other situations. * The exact match of the type is checked. That is, cast to the ancestor will be unsuccessful. */ -template +template PURE To assert_cast(From&& from) { -#ifndef NDEBUG - try { + // https://godbolt.org/z/nrsx7nYhs + // perform_cast will not be compiled to asm in release build with TypeCheckOnRelease::DISABLE + auto perform_cast = [](auto&& from) -> To { if constexpr (std::is_pointer_v) { if (typeid(*from) == typeid(std::remove_pointer_t)) { return static_cast(from); @@ -51,14 +54,28 @@ PURE To assert_cast(From&& from) { return static_cast(from); } } + LOG(FATAL) << fmt::format("Bad cast from type:{} to {}", demangle(typeid(from).name()), + demangle(typeid(To).name())); + __builtin_unreachable(); + }; + +#ifndef NDEBUG + try { + return perform_cast(std::forward(from)); } catch (const std::exception& e) { LOG(FATAL) << "assert cast err:" << e.what(); } - - LOG(FATAL) << fmt::format("Bad cast from type:{} to {}", demangle(typeid(from).name()), - demangle(typeid(To).name())); __builtin_unreachable(); #else - return static_cast(from); + if constexpr (check == TypeCheckOnRelease::ENABLE) { + try { + return perform_cast(std::forward(from)); + } catch (const std::exception& e) { + LOG(FATAL) << "assert cast err:" << e.what(); + } + __builtin_unreachable(); + } else { + return static_cast(from); + } #endif } diff --git a/be/src/vec/data_types/data_type_number_base.cpp b/be/src/vec/data_types/data_type_number_base.cpp index 78d6e81fb5841c..c5441256cdf622 100644 --- a/be/src/vec/data_types/data_type_number_base.cpp +++ b/be/src/vec/data_types/data_type_number_base.cpp @@ -51,17 +51,22 @@ void DataTypeNumberBase::to_string(const IColumn& column, size_t row_num, row_num = result.second; if constexpr (std::is_same::value) { - std::string hex = - int128_to_string(assert_cast&>(*ptr).get_element(row_num)); + std::string hex = int128_to_string( + assert_cast&, TypeCheckOnRelease::DISABLE>(*ptr).get_element( + row_num)); ostr.write(hex.data(), hex.size()); } else if constexpr (std::is_same_v) { // fmt::format_to maybe get inaccurate results at float type, so we use gutil implement. char buf[MAX_FLOAT_STR_LENGTH + 2]; - int len = FloatToBuffer(assert_cast&>(*ptr).get_element(row_num), - MAX_FLOAT_STR_LENGTH + 2, buf); + int len = FloatToBuffer( + assert_cast&, TypeCheckOnRelease::DISABLE>(*ptr).get_element( + row_num), + MAX_FLOAT_STR_LENGTH + 2, buf); ostr.write(buf, len); } else if constexpr (std::is_integral::value || std::numeric_limits::is_iec559) { - ostr.write_number(assert_cast&>(*ptr).get_element(row_num)); + ostr.write_number( + assert_cast&, TypeCheckOnRelease::DISABLE>(*ptr).get_element( + row_num)); } } @@ -162,13 +167,19 @@ std::string DataTypeNumberBase::to_string(const IColumn& column, size_t row_n if constexpr (std::is_same::value || std::is_same::value || std::is_same::value) { - return int128_to_string(assert_cast&>(*ptr).get_element(row_num)); + return int128_to_string( + assert_cast&, TypeCheckOnRelease::DISABLE>(*ptr).get_element( + row_num)); } else if constexpr (std::is_integral::value) { - return std::to_string(assert_cast&>(*ptr).get_element(row_num)); + return std::to_string( + assert_cast&, TypeCheckOnRelease::DISABLE>(*ptr).get_element( + row_num)); } else if constexpr (std::numeric_limits::is_iec559) { fmt::memory_buffer buffer; // only use in size-predictable type. - fmt::format_to(buffer, "{}", - assert_cast&>(*ptr).get_element(row_num)); + fmt::format_to( + buffer, "{}", + assert_cast&, TypeCheckOnRelease::DISABLE>(*ptr).get_element( + row_num)); return std::string(buffer.data(), buffer.size()); } } diff --git a/be/src/vec/data_types/serde/data_type_datetimev2_serde.cpp b/be/src/vec/data_types/serde/data_type_datetimev2_serde.cpp index 02787f7deec823..e57af914d43e04 100644 --- a/be/src/vec/data_types/serde/data_type_datetimev2_serde.cpp +++ b/be/src/vec/data_types/serde/data_type_datetimev2_serde.cpp @@ -49,7 +49,9 @@ Status DataTypeDateTimeV2SerDe::serialize_one_cell_to_json(const IColumn& column ColumnPtr ptr = result.first; row_num = result.second; - UInt64 int_val = assert_cast(*ptr).get_element(row_num); + UInt64 int_val = + assert_cast(*ptr).get_element( + row_num); DateV2Value val = binary_cast>(int_val); @@ -76,7 +78,7 @@ Status DataTypeDateTimeV2SerDe::deserialize_column_from_json_vector( } Status DataTypeDateTimeV2SerDe::deserialize_one_cell_from_json(IColumn& column, Slice& slice, const FormatOptions& options) const { - auto& column_data = assert_cast(column); + auto& column_data = assert_cast(column); UInt64 val = 0; if (options.date_olap_format) { DateV2Value datetimev2_value; diff --git a/be/src/vec/data_types/serde/data_type_struct_serde.cpp b/be/src/vec/data_types/serde/data_type_struct_serde.cpp index 14d894e256d2ed..9b975be7ec92e2 100644 --- a/be/src/vec/data_types/serde/data_type_struct_serde.cpp +++ b/be/src/vec/data_types/serde/data_type_struct_serde.cpp @@ -53,7 +53,8 @@ Status DataTypeStructSerDe::serialize_one_cell_to_json(const IColumn& column, in ColumnPtr ptr = result.first; row_num = result.second; - const ColumnStruct& struct_column = assert_cast(*ptr); + const ColumnStruct& struct_column = + assert_cast(*ptr); bw.write('{'); for (int i = 0; i < struct_column.get_columns().size(); i++) { if (i != 0) { @@ -73,7 +74,7 @@ Status DataTypeStructSerDe::deserialize_one_cell_from_json(IColumn& column, Slic if (slice.empty()) { return Status::InvalidArgument("slice is empty!"); } - auto& struct_column = assert_cast(column); + auto& struct_column = assert_cast(column); if (slice[0] != '{') { std::stringstream ss; @@ -279,7 +280,8 @@ void DataTypeStructSerDe::serialize_one_cell_to_hive_text( ColumnPtr ptr = result.first; row_num = result.second; - const ColumnStruct& struct_column = assert_cast(*ptr); + const ColumnStruct& struct_column = + assert_cast(*ptr); char collection_delimiter = options.get_collection_delimiter(hive_text_complex_type_delimiter_level); @@ -335,7 +337,7 @@ Status DataTypeStructSerDe::_write_column_to_mysql(const IColumn& column, MysqlRowBuffer& result, int row_idx, bool col_const, const FormatOptions& options) const { - auto& col = assert_cast(column); + auto& col = assert_cast(column); const auto col_index = index_check_const(row_idx, col_const); result.open_dynamic_mode(); if (0 != result.push_string("{", 1)) { diff --git a/be/src/vec/functions/array/function_array_element.h b/be/src/vec/functions/array/function_array_element.h index 49fdc4176ce55a..4a9bffdbb3cc1d 100644 --- a/be/src/vec/functions/array/function_array_element.h +++ b/be/src/vec/functions/array/function_array_element.h @@ -38,6 +38,7 @@ #include "vec/columns/column_struct.h" #include "vec/columns/column_vector.h" #include "vec/columns/columns_number.h" +#include "vec/common/assert_cast.h" #include "vec/core/block.h" #include "vec/core/column_numbers.h" #include "vec/core/column_with_type_and_name.h" diff --git a/be/src/vec/functions/comparison_equal_for_null.cpp b/be/src/vec/functions/comparison_equal_for_null.cpp index cca941840e8565..49db471f8d1c9c 100644 --- a/be/src/vec/functions/comparison_equal_for_null.cpp +++ b/be/src/vec/functions/comparison_equal_for_null.cpp @@ -136,14 +136,18 @@ class FunctionEqForNull : public IFunction { if (left_const) { left_column = check_and_get_column( - assert_cast(col_left.column.get())->get_data_column_ptr()); + assert_cast( + col_left.column.get()) + ->get_data_column_ptr()); } else { left_column = check_and_get_column(col_left.column); } if (right_const) { right_column = check_and_get_column( - assert_cast(col_right.column.get())->get_data_column_ptr()); + assert_cast( + col_right.column.get()) + ->get_data_column_ptr()); } else { right_column = check_and_get_column(col_right.column); } diff --git a/be/src/vec/functions/function_binary_arithmetic.h b/be/src/vec/functions/function_binary_arithmetic.h index d69b00043a15ec..9f2af326f71901 100644 --- a/be/src/vec/functions/function_binary_arithmetic.h +++ b/be/src/vec/functions/function_binary_arithmetic.h @@ -413,9 +413,13 @@ struct DecimalBinaryOperation { const ResultType& max_result_number, const ResultType& scale_diff_multiplier, DataTypePtr res_data_type) { - auto type_result = assert_cast&>(*res_data_type); + auto type_result = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *res_data_type); auto column_result = ColumnDecimal::create( - 1, assert_cast&>(*res_data_type).get_scale()); + 1, assert_cast&, TypeCheckOnRelease::DISABLE>( + *res_data_type) + .get_scale()); if constexpr (check_overflow && !is_to_null_type && ((!OpTraits::is_multiply && !OpTraits::is_plus_minus))) { @@ -441,11 +445,15 @@ struct DecimalBinaryOperation { const ResultType& max_result_number, const ResultType& scale_diff_multiplier, DataTypePtr res_data_type) { - auto type_result = assert_cast&>(*res_data_type); + auto type_result = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *res_data_type); auto column_left_ptr = check_and_get_column(column_left); auto column_result = ColumnDecimal::create( column_left->size(), - assert_cast&>(*res_data_type).get_scale()); + assert_cast&, TypeCheckOnRelease::DISABLE>( + *res_data_type) + .get_scale()); DCHECK(column_left_ptr != nullptr); if constexpr (check_overflow && !is_to_null_type && @@ -472,11 +480,15 @@ struct DecimalBinaryOperation { const ResultType& max_result_number, const ResultType& scale_diff_multiplier, DataTypePtr res_data_type) { - auto type_result = assert_cast&>(*res_data_type); + auto type_result = + assert_cast&, TypeCheckOnRelease::DISABLE>( + *res_data_type); auto column_right_ptr = check_and_get_column(column_right); auto column_result = ColumnDecimal::create( column_right->size(), - assert_cast&>(*res_data_type).get_scale()); + assert_cast&, TypeCheckOnRelease::DISABLE>( + *res_data_type) + .get_scale()); DCHECK(column_right_ptr != nullptr); if constexpr (check_overflow && !is_to_null_type && diff --git a/be/src/vec/functions/function_case.h b/be/src/vec/functions/function_case.h index f320ab046c762e..f02b85aed456bf 100644 --- a/be/src/vec/functions/function_case.h +++ b/be/src/vec/functions/function_case.h @@ -302,11 +302,11 @@ class FunctionCase : public IFunction { } size_t target = is_consts[then_idx[row_idx]] ? 0 : row_idx; if constexpr (then_null) { - assert_cast(result_column_ptr.get()) + assert_cast(result_column_ptr.get()) ->insert_from_with_type(*raw_columns[then_idx[row_idx]], target); } else { - assert_cast(result_column_ptr.get()) + assert_cast(result_column_ptr.get()) ->insert_from(*raw_columns[then_idx[row_idx]], target); } } @@ -323,7 +323,9 @@ class FunctionCase : public IFunction { size_t rows_count = column_holder.rows_count; result_column_ptr->resize(rows_count); auto* __restrict result_raw_data = - assert_cast(result_column_ptr.get())->get_data().data(); + assert_cast(result_column_ptr.get()) + ->get_data() + .data(); // set default value for (int i = 0; i < rows_count; i++) { diff --git a/be/src/vec/functions/function_cast.h b/be/src/vec/functions/function_cast.h index f83cd63918d62c..17c7b4b76103cf 100644 --- a/be/src/vec/functions/function_cast.h +++ b/be/src/vec/functions/function_cast.h @@ -720,8 +720,8 @@ struct ConvertImplGenericFromJsonb { // add string to string column if (context->jsonb_string_as_string() && is_dst_string && value->isString()) { const auto* blob = static_cast(value); - assert_cast(*col_to).insert_data(blob->getBlob(), - blob->getBlobLen()); + assert_cast(*col_to).insert_data( + blob->getBlob(), blob->getBlobLen()); (*vec_null_map_to)[i] = 0; continue; } @@ -1525,7 +1525,15 @@ struct StringParsing { const ColumnString::Chars* chars = &col_from_string->get_chars(); const IColumn::Offsets* offsets = &col_from_string->get_offsets(); + [[maybe_unused]] UInt32 scale = 0; + if constexpr (IsDataTypeDateTimeV2) { + const auto* type = assert_cast( + block.get_by_position(result).type.get()); + scale = type->get_scale(); + } + size_t current_offset = 0; + for (size_t i = 0; i < row; ++i) { size_t next_offset = (*offsets)[i]; size_t string_size = next_offset - current_offset; @@ -1541,10 +1549,7 @@ struct StringParsing { res == StringParser::PARSE_OVERFLOW || res == StringParser::PARSE_UNDERFLOW); } else if constexpr (IsDataTypeDateTimeV2) { - const auto* type = assert_cast( - block.get_by_position(result).type.get()); - parsed = try_parse_impl(vec_to[i], read_buffer, context, - type->get_scale()); + parsed = try_parse_impl(vec_to[i], read_buffer, context, scale); } else { parsed = try_parse_impl(vec_to[i], read_buffer, context); diff --git a/be/src/vec/functions/function_coalesce.cpp b/be/src/vec/functions/function_coalesce.cpp index 63217c6d6bfd57..dbe75cf140845d 100644 --- a/be/src/vec/functions/function_coalesce.cpp +++ b/be/src/vec/functions/function_coalesce.cpp @@ -163,7 +163,9 @@ class FunctionCoalesce : public IFunction { auto res_column = (*temporary_block.get_by_position(1).column->convert_to_full_column_if_const()) .mutate(); - auto& res_map = assert_cast*>(res_column.get())->get_data(); + auto& res_map = + assert_cast*, TypeCheckOnRelease::DISABLE>(res_column.get()) + ->get_data(); auto* __restrict res = res_map.data(); // Here it's SIMD thought the compiler automatically diff --git a/be/src/vec/functions/function_helpers.cpp b/be/src/vec/functions/function_helpers.cpp index 22dbd9073d1797..ea3d98511b0624 100644 --- a/be/src/vec/functions/function_helpers.cpp +++ b/be/src/vec/functions/function_helpers.cpp @@ -148,7 +148,7 @@ void validate_argument_type(const IFunction& func, const DataTypes& arguments, const ColumnConst* check_and_get_column_const_string_or_fixedstring(const IColumn* column) { if (!is_column_const(*column)) return {}; - const ColumnConst* res = assert_cast(column); + const ColumnConst* res = assert_cast(column); if (check_column(&res->get_data_column())) return res; diff --git a/be/src/vec/functions/function_helpers.h b/be/src/vec/functions/function_helpers.h index f5d343f3678d81..28f79a8d0fb193 100644 --- a/be/src/vec/functions/function_helpers.h +++ b/be/src/vec/functions/function_helpers.h @@ -55,7 +55,7 @@ template const ColumnConst* check_and_get_column_const(const IColumn* column) { if (!column || !is_column_const(*column)) return {}; - const ColumnConst* res = assert_cast(column); + const ColumnConst* res = assert_cast(column); if (!check_column(&res->get_data_column())) return {}; diff --git a/be/src/vec/functions/function_ip.h b/be/src/vec/functions/function_ip.h index 3b02d779246a03..f019fa32797a7d 100644 --- a/be/src/vec/functions/function_ip.h +++ b/be/src/vec/functions/function_ip.h @@ -398,8 +398,10 @@ ColumnPtr convert_to_ipv6(const StringColumnType& string_column, std::string string_buffer; int offset_inc = 1; + ColumnString* column_string = nullptr; if constexpr (std::is_same_v) { offset_inc = IPV6_BINARY_LENGTH; + column_string = assert_cast(col_res.get()); } for (size_t out_offset = 0, i = 0; i < column_size; out_offset += offset_inc, ++i) { @@ -429,7 +431,7 @@ ColumnPtr convert_to_ipv6(const StringColumnType& string_column, (*vec_null_map_to)[i] = true; } if constexpr (std::is_same_v) { - auto* column_string = assert_cast(col_res.get()); + DCHECK(column_string != nullptr); column_string->get_offsets().push_back((i + 1) * IPV6_BINARY_LENGTH); } src_offset = src_next_offset; diff --git a/be/src/vec/functions/function_string.cpp b/be/src/vec/functions/function_string.cpp index 30384413d1d4cd..d0e12bb498430b 100644 --- a/be/src/vec/functions/function_string.cpp +++ b/be/src/vec/functions/function_string.cpp @@ -27,6 +27,7 @@ #include "common/status.h" #include "runtime/string_search.hpp" #include "util/url_coding.h" +#include "vec/columns/column.h" #include "vec/columns/column_string.h" #include "vec/common/pod_array_fwd.h" #include "vec/common/string_ref.h" diff --git a/be/src/vec/functions/function_string.h b/be/src/vec/functions/function_string.h index 1c843acb697248..bb4dbc67c5d5cd 100644 --- a/be/src/vec/functions/function_string.h +++ b/be/src/vec/functions/function_string.h @@ -3144,20 +3144,23 @@ class FunctionReplace : public IFunction { Status execute_impl(FunctionContext* context, Block& block, const ColumnNumbers& arguments, size_t result, size_t input_rows_count) const override { + // We need a local variable to hold a reference to the converted column. + // So that the converted column will not be released before we use it. auto col_origin = block.get_by_position(arguments[0]).column->convert_to_full_column_if_const(); + auto col_origin_str = assert_cast(col_origin.get()); auto col_old = block.get_by_position(arguments[1]).column->convert_to_full_column_if_const(); + auto col_old_str = assert_cast(col_old.get()); auto col_new = block.get_by_position(arguments[2]).column->convert_to_full_column_if_const(); + auto col_new_str = assert_cast(col_new.get()); ColumnString::MutablePtr col_res = ColumnString::create(); - for (int i = 0; i < input_rows_count; ++i) { - StringRef origin_str = - assert_cast(col_origin.get())->get_data_at(i); - StringRef old_str = assert_cast(col_old.get())->get_data_at(i); - StringRef new_str = assert_cast(col_new.get())->get_data_at(i); + StringRef origin_str = col_origin_str->get_data_at(i); + StringRef old_str = col_old_str->get_data_at(i); + StringRef new_str = col_new_str->get_data_at(i); std::string result = replace(origin_str.to_string(), old_str.to_string_view(), new_str.to_string_view()); @@ -3694,8 +3697,8 @@ class FunctionIntToChar : public IFunction { continue; } if (auto const_column = check_and_get_column(*str_columns[j])) { - auto str_column = - assert_cast(&(const_column->get_data_column())); + auto str_column = assert_cast( + &(const_column->get_data_column())); auto data_item = str_column->get_data_at(0); memcpy_small_allow_read_write_overflow15( &res_data[res_offset[i - 1]] + current_length, data_item.data, diff --git a/be/src/vec/functions/function_variant_element.cpp b/be/src/vec/functions/function_variant_element.cpp index 22bf45beb5ef97..76076a498d07c0 100644 --- a/be/src/vec/functions/function_variant_element.cpp +++ b/be/src/vec/functions/function_variant_element.cpp @@ -123,9 +123,9 @@ class FunctionVariantElement : public IFunction { field_name = "$." + field_name; } JsonFunctions::parse_json_paths(field_name, &parsed_paths); + ColumnString* col_str = assert_cast(result_column.get()); for (size_t i = 0; i < docs.size(); ++i) { - if (!extract_from_document(parser, docs.get_data_at(i), parsed_paths, - assert_cast(result_column.get()))) { + if (!extract_from_document(parser, docs.get_data_at(i), parsed_paths, col_str)) { VLOG_DEBUG << "failed to parse " << docs.get_data_at(i) << ", field " << field_name; result_column->insert_default();