This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch branch-4.0
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/branch-4.0 by this push:
new 91a7b0ae145 branch-4.0: [fix] remove useless const_cast and explain
const_cast for vec (3) #56600 (#56783)
91a7b0ae145 is described below
commit 91a7b0ae1451bb964614db008ef6a1295f365ffe
Author: github-actions[bot]
<41898282+github-actions[bot]@users.noreply.github.com>
AuthorDate: Sat Oct 11 18:18:12 2025 +0800
branch-4.0: [fix] remove useless const_cast and explain const_cast for vec
(3) #56600 (#56783)
Cherry-picked from #56600
Co-authored-by: admiring_xm <[email protected]>
---
be/src/exprs/math_functions.cpp | 2 +
be/src/olap/like_column_predicate.cpp | 12 ++---
be/src/olap/like_column_predicate.h | 3 +-
be/src/util/bitmap_value.h | 36 +++++++++------
be/src/util/simd/vstring_function.h | 8 ++--
be/src/vec/data_types/data_type_bitmap.cpp | 17 ++++---
.../data_types/serde/data_type_bitmap_serde.cpp | 16 +++----
be/src/vec/functions/ai/ai_functions.h | 7 ++-
be/src/vec/functions/function_bitmap.cpp | 32 ++++++-------
be/src/vec/functions/function_hll.cpp | 4 +-
be/src/vec/functions/function_jsonb.cpp | 5 +-
be/src/vec/functions/function_string.h | 6 ++-
be/src/vec/functions/like.cpp | 54 ++++++++++++----------
be/src/vec/functions/like.h | 42 ++++++++---------
be/src/vec/olap/olap_data_convertor.cpp | 25 +++++-----
be/src/vec/olap/olap_data_convertor.h | 2 +-
16 files changed, 139 insertions(+), 132 deletions(-)
diff --git a/be/src/exprs/math_functions.cpp b/be/src/exprs/math_functions.cpp
index 93e28efb733..6b1d060e06b 100644
--- a/be/src/exprs/math_functions.cpp
+++ b/be/src/exprs/math_functions.cpp
@@ -125,6 +125,8 @@ StringRef MathFunctions::decimal_to_base(FunctionContext*
ctx, int64_t src_num,
buf[buf_index] = '-';
++result_len;
}
+
+ // Modify a string passed via stringref
StringRef result = ctx->create_temp_string_val(result_len);
memcpy(const_cast<char*>(result.data), buf + max_digits - result_len,
result_len);
return result;
diff --git a/be/src/olap/like_column_predicate.cpp
b/be/src/olap/like_column_predicate.cpp
index e8fedc1f87f..a2bc50735ef 100644
--- a/be/src/olap/like_column_predicate.cpp
+++ b/be/src/olap/like_column_predicate.cpp
@@ -91,8 +91,7 @@ uint16_t LikeColumnPredicate<T>::_evaluate_inner(const
vectorized::IColumn& colu
sel[new_size] = idx;
unsigned char flag = 0;
THROW_IF_ERROR((_state->scalar_function)(
-
const_cast<vectorized::LikeSearchState*>(&_like_state),
- str_col->get_data_at(idx), pattern, &flag));
+ &_like_state, str_col->get_data_at(idx), pattern,
&flag));
new_size += _opposite ^ flag;
}
} else {
@@ -107,8 +106,8 @@ uint16_t LikeColumnPredicate<T>::_evaluate_inner(const
vectorized::IColumn& colu
StringRef cell_value = str_col->get_data_at(idx);
unsigned char flag = 0;
THROW_IF_ERROR((_state->scalar_function)(
-
const_cast<vectorized::LikeSearchState*>(&_like_state),
- StringRef(cell_value.data, cell_value.size),
pattern, &flag));
+ &_like_state, StringRef(cell_value.data,
cell_value.size), pattern,
+ &flag));
new_size += _opposite ^ flag;
}
}
@@ -134,9 +133,8 @@ uint16_t LikeColumnPredicate<T>::_evaluate_inner(const
vectorized::IColumn& colu
uint16_t idx = sel[i];
sel[new_size] = idx;
unsigned char flag = 0;
- THROW_IF_ERROR((_state->scalar_function)(
- const_cast<vectorized::LikeSearchState*>(&_like_state),
- str_col->get_data_at(idx), pattern, &flag));
+ THROW_IF_ERROR((_state->scalar_function)(&_like_state,
str_col->get_data_at(idx),
+ pattern, &flag));
new_size += _opposite ^ flag;
}
}
diff --git a/be/src/olap/like_column_predicate.h
b/be/src/olap/like_column_predicate.h
index 37af7a14298..0cf717cac6d 100644
--- a/be/src/olap/like_column_predicate.h
+++ b/be/src/olap/like_column_predicate.h
@@ -154,8 +154,7 @@ private:
StringRef cell_value = column.get_shrink_value(i);
unsigned char flag = 0;
THROW_IF_ERROR((_state->scalar_function)(
- const_cast<vectorized::LikeSearchState*>(&_like_state),
- StringRef(cell_value.data, cell_value.size), pattern,
&flag));
+ &_like_state, StringRef(cell_value.data, cell_value.size),
pattern, &flag));
tmp_res[i] = flag;
}
// Sometimes the dict is not initialized when run comparison predicate
here, for example,
diff --git a/be/src/util/bitmap_value.h b/be/src/util/bitmap_value.h
index a2a6323f287..06a18f8bb4f 100644
--- a/be/src/util/bitmap_value.h
+++ b/be/src/util/bitmap_value.h
@@ -889,6 +889,7 @@ public:
DCHECK(res);
}
+ // !FIXME: We should rethink the logic here
BitmapValue(const BitmapValue& other) {
_type = other._type;
switch (other._type) {
@@ -909,10 +910,11 @@ public:
_is_shared = true;
// should also set other's state to shared, so that other bitmap
value will
// create a new bitmap when it wants to modify it.
- const_cast<BitmapValue&>(other)._is_shared = true;
+ other._is_shared = true;
}
}
+ // !FIXME: We should rethink the logic here
BitmapValue(BitmapValue&& other) noexcept {
_type = other._type;
switch (other._type) {
@@ -934,6 +936,7 @@ public:
other._is_shared = false;
}
+ // !FIXME: We should rethink the logic here
BitmapValue& operator=(const BitmapValue& other) {
if (this == &other) {
return *this;
@@ -958,7 +961,7 @@ public:
_is_shared = true;
// should also set other's state to shared, so that other bitmap
value will
// create a new bitmap when it wants to modify it.
- const_cast<BitmapValue&>(other)._is_shared = true;
+ other._is_shared = true;
}
return *this;
}
@@ -1219,6 +1222,7 @@ public:
// EMPTY -> SINGLE
// EMPTY -> BITMAP
// SINGLE -> BITMAP
+ // !FIXME: We should rethink the logic here
BitmapValue& operator|=(const BitmapValue& rhs) {
switch (rhs._type) {
case EMPTY:
@@ -1230,13 +1234,13 @@ public:
switch (_type) {
case EMPTY:
_bitmap = rhs._bitmap;
- const_cast<BitmapValue&>(rhs)._is_shared = true;
+ rhs._is_shared = true;
_is_shared = true;
_type = BITMAP;
break;
case SINGLE:
_bitmap = rhs._bitmap;
- const_cast<BitmapValue&>(rhs)._is_shared = true;
+ rhs._is_shared = true;
_is_shared = true;
_prepare_bitmap_for_write();
_bitmap->add(_sv);
@@ -1529,6 +1533,7 @@ public:
// SINGLE -> EMPTY
// BITMAP -> EMPTY
// BITMAP -> SINGLE
+ // !FIXME: We should rethink the logic here
BitmapValue& operator^=(const BitmapValue& rhs) {
switch (rhs._type) {
case EMPTY:
@@ -1566,13 +1571,13 @@ public:
switch (_type) {
case EMPTY:
_bitmap = rhs._bitmap;
- const_cast<BitmapValue&>(rhs)._is_shared = true;
+ rhs._is_shared = true;
_is_shared = true;
_type = BITMAP;
break;
case SINGLE:
_bitmap = rhs._bitmap;
- const_cast<BitmapValue&>(rhs)._is_shared = true;
+ rhs._is_shared = true;
_is_shared = true;
_type = BITMAP;
_prepare_bitmap_for_write();
@@ -1870,7 +1875,8 @@ public:
// Return how many bytes are required to serialize this bitmap.
// See BitmapTypeCode for the serialized format.
- size_t getSizeInBytes() {
+ // !FIXME: We should rethink the logic here
+ size_t getSizeInBytes() const {
size_t res = 0;
switch (_type) {
case EMPTY:
@@ -2129,7 +2135,7 @@ public:
* Return new set with specified range (not include the range_end)
*/
int64_t sub_range(const int64_t& range_start, const int64_t& range_end,
- BitmapValue* ret_bitmap) {
+ BitmapValue* ret_bitmap) const {
switch (_type) {
case EMPTY:
return 0;
@@ -2181,7 +2187,7 @@ public:
* @return the real count for subset, maybe less than cardinality_limit
*/
int64_t sub_limit(const int64_t& range_start, const int64_t&
cardinality_limit,
- BitmapValue* ret_bitmap) {
+ BitmapValue* ret_bitmap) const {
switch (_type) {
case EMPTY:
return 0;
@@ -2236,7 +2242,8 @@ public:
* The number of returned elements is limited by the cardinality_limit
parameter.
* Analog of the substring string function, but for bitmap.
*/
- int64_t offset_limit(const int64_t& offset, const int64_t& limit,
BitmapValue* ret_bitmap) {
+ int64_t offset_limit(const int64_t& offset, const int64_t& limit,
+ BitmapValue* ret_bitmap) const {
switch (_type) {
case EMPTY:
return 0;
@@ -2393,7 +2400,7 @@ private:
return result;
}
- void _prepare_bitmap_for_write() {
+ void _prepare_bitmap_for_write() const {
if (!_bitmap) {
_bitmap = std::make_shared<detail::Roaring64Map>();
_is_shared = false;
@@ -2431,12 +2438,13 @@ private:
BITMAP = 2, // more than one elements
SET = 3 // elements count less or equal than 32
};
- uint64_t _sv = 0; // store the single value
when _type == SINGLE
- std::shared_ptr<detail::Roaring64Map> _bitmap; // used when _type == BITMAP
+ uint64_t _sv = 0; // store the single value when _type == SINGLE
+ // !FIXME: We should rethink the logic about _bitmap and _is_shared
+ mutable std::shared_ptr<detail::Roaring64Map> _bitmap; // used when _type
== BITMAP
SetContainer<uint64_t> _set;
BitmapDataType _type {EMPTY};
// Indicate whether the state is shared among multi BitmapValue object
- bool _is_shared = true;
+ mutable bool _is_shared = true;
static constexpr uint64_t SET_TYPE_THRESHOLD = 32;
};
diff --git a/be/src/util/simd/vstring_function.h
b/be/src/util/simd/vstring_function.h
index 4f9808ccf8e..09cf7835dbb 100644
--- a/be/src/util/simd/vstring_function.h
+++ b/be/src/util/simd/vstring_function.h
@@ -211,20 +211,20 @@ public:
return validate_ascii_fast(str.data, str.size);
}
- static void reverse(const StringRef& str, StringRef dst) {
+ static void reverse(const StringRef& str, std::string* dst) {
if (is_ascii(str)) {
int64_t begin = 0;
int64_t end = str.size;
- int64_t result_end = dst.size - 1;
+ int64_t result_end = dst->size() - 1;
// auto SIMD here
- auto* __restrict l = const_cast<char*>(dst.data);
+ auto* __restrict l = dst->data();
auto* __restrict r = str.data;
for (; begin < end; ++begin, --result_end) {
l[result_end] = r[begin];
}
} else {
- char* dst_data = const_cast<char*>(dst.data);
+ char* dst_data = dst->data();
for (size_t i = 0, char_size = 0; i < str.size; i += char_size) {
char_size = UTF8_BYTE_LENGTH[(unsigned char)(str.data)[i]];
// there exists occasion where the last character is an
illegal UTF-8 one which returns
diff --git a/be/src/vec/data_types/data_type_bitmap.cpp
b/be/src/vec/data_types/data_type_bitmap.cpp
index 1e493756bf0..496f8bedd99 100644
--- a/be/src/vec/data_types/data_type_bitmap.cpp
+++ b/be/src/vec/data_types/data_type_bitmap.cpp
@@ -50,7 +50,7 @@ int64_t
DataTypeBitMap::get_uncompressed_serialized_bytes(const IColumn& column,
auto allocate_len_size = sizeof(size_t) * real_need_copy_num;
size_t allocate_content_size = 0;
for (size_t i = 0; i < real_need_copy_num; ++i) {
- auto& bitmap =
const_cast<BitmapValue&>(data_column.get_element(i));
+ auto& bitmap = data_column.get_element(i);
allocate_content_size += bitmap.getSizeInBytes();
}
return size + allocate_len_size + allocate_content_size;
@@ -61,7 +61,7 @@ int64_t
DataTypeBitMap::get_uncompressed_serialized_bytes(const IColumn& column,
auto allocate_len_size = sizeof(size_t) * (column.size() + 1);
size_t allocate_content_size = 0;
for (size_t i = 0; i < column.size(); ++i) {
- auto& bitmap =
const_cast<BitmapValue&>(data_column.get_element(i));
+ auto& bitmap = data_column.get_element(i);
allocate_content_size += bitmap.getSizeInBytes();
}
@@ -79,14 +79,14 @@ char* DataTypeBitMap::serialize(const IColumn& column,
char* buf, int be_exec_ve
// serialize the bitmap size array
auto* meta_ptr = reinterpret_cast<size_t*>(buf);
for (size_t i = 0; i < real_need_copy_num; ++i) {
- auto& bitmap =
const_cast<BitmapValue&>(data_column.get_element(i));
+ auto& bitmap = data_column.get_element(i);
unaligned_store<size_t>(&meta_ptr[i], bitmap.getSizeInBytes());
}
// serialize each bitmap
char* data_ptr = buf + sizeof(size_t) * real_need_copy_num;
for (size_t i = 0; i < real_need_copy_num; ++i) {
- auto& bitmap =
const_cast<BitmapValue&>(data_column.get_element(i));
+ auto& bitmap = data_column.get_element(i);
bitmap.write_to(data_ptr);
data_ptr += unaligned_load<size_t>(&meta_ptr[i]);
}
@@ -99,14 +99,14 @@ char* DataTypeBitMap::serialize(const IColumn& column,
char* buf, int be_exec_ve
auto* meta_ptr = reinterpret_cast<size_t*>(buf);
meta_ptr[0] = column.size();
for (size_t i = 0; i < meta_ptr[0]; ++i) {
- auto& bitmap =
const_cast<BitmapValue&>(data_column.get_element(i));
+ auto& bitmap = data_column.get_element(i);
unaligned_store<size_t>(&meta_ptr[i + 1], bitmap.getSizeInBytes());
}
// serialize each bitmap
char* data_ptr = buf + sizeof(size_t) * (meta_ptr[0] + 1);
for (size_t i = 0; i < meta_ptr[0]; ++i) {
- auto& bitmap =
const_cast<BitmapValue&>(data_column.get_element(i));
+ auto& bitmap = data_column.get_element(i);
bitmap.write_to(data_ptr);
data_ptr += unaligned_load<size_t>(&meta_ptr[i + 1]);
}
@@ -161,11 +161,10 @@ Status DataTypeBitMap::check_column(const IColumn&
column) const {
}
void DataTypeBitMap::serialize_as_stream(const BitmapValue& cvalue,
BufferWritable& buf) {
- auto& value = const_cast<BitmapValue&>(cvalue);
std::string memory_buffer;
- size_t bytesize = value.getSizeInBytes();
+ size_t bytesize = cvalue.getSizeInBytes();
memory_buffer.resize(bytesize);
- value.write_to(const_cast<char*>(memory_buffer.data()));
+ cvalue.write_to(memory_buffer.data());
buf.write_binary(memory_buffer);
}
diff --git a/be/src/vec/data_types/serde/data_type_bitmap_serde.cpp
b/be/src/vec/data_types/serde/data_type_bitmap_serde.cpp
index 86317699271..4f0166615f2 100644
--- a/be/src/vec/data_types/serde/data_type_bitmap_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_bitmap_serde.cpp
@@ -87,11 +87,11 @@ Status DataTypeBitMapSerDe::write_column_to_pb(const
IColumn& column, PValues& r
auto row_count = cast_set<int>(end - start);
result.mutable_bytes_value()->Reserve(row_count);
for (auto row = start; row < end; ++row) {
- auto& value = const_cast<BitmapValue&>(data_column.get_element(row));
+ auto& value = data_column.get_element(row);
std::string memory_buffer;
auto bytesize = value.getSizeInBytes();
memory_buffer.resize(bytesize);
- value.write_to(const_cast<char*>(memory_buffer.data()));
+ value.write_to(memory_buffer.data());
result.add_bytes_value(memory_buffer);
}
return Status::OK();
@@ -111,12 +111,12 @@ void DataTypeBitMapSerDe::write_one_cell_to_jsonb(const
IColumn& column, JsonbWr
int64_t row_num) const {
const auto& data_column = assert_cast<const ColumnBitmap&>(column);
result.writeKey(cast_set<JsonbKeyValue::keyid_type>(col_id));
- auto bitmap_value =
const_cast<BitmapValue&>(data_column.get_element(row_num));
+ auto bitmap_value = data_column.get_element(row_num);
// serialize the content of string
auto size = bitmap_value.getSizeInBytes();
// serialize the content of string
- auto* ptr = arena.alloc(size);
- bitmap_value.write_to(const_cast<char*>(ptr));
+ char* ptr = arena.alloc(size);
+ bitmap_value.write_to(ptr);
result.writeStartBinary();
result.writeBinary(reinterpret_cast<const char*>(ptr), size);
result.writeEndBinary();
@@ -132,7 +132,7 @@ Status DataTypeBitMapSerDe::write_column_to_arrow(const
IColumn& column, const N
RETURN_IF_ERROR(checkArrowStatus(builder.AppendNull(),
column.get_name(),
array_builder->type()->name()));
} else {
- auto& bitmap_value =
const_cast<BitmapValue&>(col.get_element(string_i));
+ auto& bitmap_value = col.get_element(string_i);
std::string memory_buffer(bitmap_value.getSizeInBytes(), '0');
bitmap_value.write_to(memory_buffer.data());
RETURN_IF_ERROR(checkArrowStatus(
@@ -198,7 +198,7 @@ Status DataTypeBitMapSerDe::write_column_to_orc(const
std::string& timezone, con
size_t total_size = 0;
for (size_t row_id = start; row_id < end; row_id++) {
if (cur_batch->notNull[row_id] == 1) {
- auto bitmap_value =
const_cast<BitmapValue&>(col_data.get_element(row_id));
+ auto bitmap_value = col_data.get_element(row_id);
size_t len = bitmap_value.getSizeInBytes();
total_size += len;
}
@@ -213,7 +213,7 @@ Status DataTypeBitMapSerDe::write_column_to_orc(const
std::string& timezone, con
size_t offset = 0;
for (size_t row_id = start; row_id < end; row_id++) {
if (cur_batch->notNull[row_id] == 1) {
- auto bitmap_value =
const_cast<BitmapValue&>(col_data.get_element(row_id));
+ auto bitmap_value = col_data.get_element(row_id);
size_t len = bitmap_value.getSizeInBytes();
if (offset + len > total_size) {
return Status::InternalError(
diff --git a/be/src/vec/functions/ai/ai_functions.h
b/be/src/vec/functions/ai/ai_functions.h
index 0443829efef..7075ed4b420 100644
--- a/be/src/vec/functions/ai/ai_functions.h
+++ b/be/src/vec/functions/ai/ai_functions.h
@@ -77,9 +77,8 @@ public:
TAIResource config;
std::shared_ptr<AIAdapter> adapter;
- if (Status status =
- const_cast<Derived*>(assert_cast<const Derived*>(this))
- ->_init_from_resource(context, block, arguments,
config, adapter);
+ if (Status status = assert_cast<const
Derived*>(this)->_init_from_resource(
+ context, block, arguments, config, adapter);
!status.ok()) {
return status;
}
@@ -151,7 +150,7 @@ private:
// The ai resource must be literal
Status _init_from_resource(FunctionContext* context, const Block& block,
const ColumnNumbers& arguments, TAIResource&
config,
- std::shared_ptr<AIAdapter>& adapter) {
+ std::shared_ptr<AIAdapter>& adapter) const {
// 1. Initialize config
const ColumnWithTypeAndName& resource_column =
block.get_by_position(arguments[0]);
StringRef resource_name_ref = resource_column.column->get_data_at(0);
diff --git a/be/src/vec/functions/function_bitmap.cpp
b/be/src/vec/functions/function_bitmap.cpp
index eb5ba2d128c..d91abe10087 100644
--- a/be/src/vec/functions/function_bitmap.cpp
+++ b/be/src/vec/functions/function_bitmap.cpp
@@ -905,7 +905,7 @@ struct BitmapHasAny {
static void vector_vector(const TData& lvec, const TData& rvec, ResTData&
res) {
size_t size = lvec.size();
for (size_t i = 0; i < size; ++i) {
- auto bitmap = const_cast<BitmapValue&>(lvec[i]);
+ auto bitmap = lvec[i];
bitmap &= rvec[i];
res[i] = bitmap.cardinality() != 0;
}
@@ -913,7 +913,7 @@ struct BitmapHasAny {
static void vector_scalar(const TData& lvec, const BitmapValue& rval,
ResTData& res) {
size_t size = lvec.size();
for (size_t i = 0; i < size; ++i) {
- auto bitmap = const_cast<BitmapValue&>(lvec[i]);
+ auto bitmap = lvec[i];
bitmap &= rval;
res[i] = bitmap.cardinality() != 0;
}
@@ -921,7 +921,7 @@ struct BitmapHasAny {
static void scalar_vector(const BitmapValue& lval, const TData& rvec,
ResTData& res) {
size_t size = rvec.size();
for (size_t i = 0; i < size; ++i) {
- auto bitmap = const_cast<BitmapValue&>(lval);
+ auto bitmap = lval;
bitmap &= rvec[i];
res[i] = bitmap.cardinality() != 0;
}
@@ -944,7 +944,7 @@ struct BitmapHasAll {
size_t size = lvec.size();
for (size_t i = 0; i < size; ++i) {
uint64_t lhs_cardinality = lvec[i].cardinality();
- auto bitmap = const_cast<BitmapValue&>(lvec[i]);
+ auto bitmap = lvec[i];
bitmap |= rvec[i];
res[i] = bitmap.cardinality() == lhs_cardinality;
}
@@ -953,16 +953,16 @@ struct BitmapHasAll {
size_t size = lvec.size();
for (size_t i = 0; i < size; ++i) {
uint64_t lhs_cardinality = lvec[i].cardinality();
- auto bitmap = const_cast<BitmapValue&>(lvec[i]);
+ auto bitmap = lvec[i];
bitmap |= rval;
res[i] = bitmap.cardinality() == lhs_cardinality;
}
}
static void scalar_vector(const BitmapValue& lval, const TData& rvec,
ResTData& res) {
size_t size = rvec.size();
+ uint64_t lhs_cardinality = lval.cardinality();
for (size_t i = 0; i < size; ++i) {
- uint64_t lhs_cardinality = lval.cardinality();
- auto bitmap = const_cast<BitmapValue&>(lval);
+ auto bitmap = lval;
bitmap |= rvec[i];
res[i] = bitmap.cardinality() == lhs_cardinality;
}
@@ -1010,7 +1010,7 @@ struct BitmapToBase64 {
offsets.resize(size);
size_t output_char_size = 0;
for (size_t i = 0; i < size; ++i) {
- BitmapValue& bitmap_val = const_cast<BitmapValue&>(data[i]);
+ const BitmapValue& bitmap_val = data[i];
auto ser_size = bitmap_val.getSizeInBytes();
output_char_size += (int)(4.0 * ceil((double)ser_size / 3.0));
}
@@ -1023,7 +1023,7 @@ struct BitmapToBase64 {
std::string ser_buff;
size_t encoded_offset = 0;
for (size_t i = 0; i < size; ++i) {
- BitmapValue& bitmap_val = const_cast<BitmapValue&>(data[i]);
+ const BitmapValue& bitmap_val = data[i];
cur_ser_size = bitmap_val.getSizeInBytes();
if (cur_ser_size > last_ser_size) {
last_ser_size = cur_ser_size;
@@ -1058,8 +1058,7 @@ struct SubBitmap {
null_map[i] = 1;
continue;
}
- if
(const_cast<TData1&>(bitmap_data)[i].offset_limit(offset_data[i], limit_data[i],
- &res[i]) ==
0) {
+ if (bitmap_data[i].offset_limit(offset_data[i], limit_data[i],
&res[i]) == 0) {
null_map[i] = 1;
}
}
@@ -1075,8 +1074,7 @@ struct SubBitmap {
null_map[i] = 1;
continue;
}
- if (const_cast<TData1&>(bitmap_data)[i].offset_limit(offset_data,
limit_data,
- &res[i]) ==
0) {
+ if (bitmap_data[i].offset_limit(offset_data, limit_data, &res[i])
== 0) {
null_map[i] = 1;
}
}
@@ -1099,7 +1097,7 @@ struct BitmapSubsetLimit {
null_map[i] = 1;
continue;
}
- const_cast<TData1&>(bitmap_data)[i].sub_limit(offset_data[i],
limit_data[i], &res[i]);
+ bitmap_data[i].sub_limit(offset_data[i], limit_data[i], &res[i]);
}
}
static void vector_scalars(const TData1& bitmap_data, const Int64&
offset_data,
@@ -1113,7 +1111,7 @@ struct BitmapSubsetLimit {
null_map[i] = 1;
continue;
}
- const_cast<TData1&>(bitmap_data)[i].sub_limit(offset_data,
limit_data, &res[i]);
+ bitmap_data[i].sub_limit(offset_data, limit_data, &res[i]);
}
}
};
@@ -1134,7 +1132,7 @@ struct BitmapSubsetInRange {
null_map[i] = 1;
continue;
}
- const_cast<TData1&>(bitmap_data)[i].sub_range(range_start[i],
range_end[i], &res[i]);
+ bitmap_data[i].sub_range(range_start[i], range_end[i], &res[i]);
}
}
static void vector_scalars(const TData1& bitmap_data, const Int64&
range_start,
@@ -1148,7 +1146,7 @@ struct BitmapSubsetInRange {
null_map[i] = 1;
continue;
}
- const_cast<TData1&>(bitmap_data)[i].sub_range(range_start,
range_end, &res[i]);
+ bitmap_data[i].sub_range(range_start, range_end, &res[i]);
}
}
};
diff --git a/be/src/vec/functions/function_hll.cpp
b/be/src/vec/functions/function_hll.cpp
index ea0124c132c..a8b827c7475 100644
--- a/be/src/vec/functions/function_hll.cpp
+++ b/be/src/vec/functions/function_hll.cpp
@@ -275,7 +275,7 @@ struct HllToBase64 {
offsets.resize(size);
size_t output_char_size = 0;
for (size_t i = 0; i < size; ++i) {
- auto& hll_val = const_cast<HyperLogLog&>(data[i]);
+ auto& hll_val = data[i];
auto ser_size = hll_val.max_serialized_size();
output_char_size += (int)(4.0 * ceil((double)ser_size / 3.0));
}
@@ -288,7 +288,7 @@ struct HllToBase64 {
std::string ser_buff;
size_t encoded_offset = 0;
for (size_t i = 0; i < size; ++i) {
- auto& hll_val = const_cast<HyperLogLog&>(data[i]);
+ auto& hll_val = data[i];
cur_ser_size = hll_val.max_serialized_size();
if (cur_ser_size > last_ser_size) {
diff --git a/be/src/vec/functions/function_jsonb.cpp
b/be/src/vec/functions/function_jsonb.cpp
index de2b52480a9..aaf6a2f2295 100644
--- a/be/src/vec/functions/function_jsonb.cpp
+++ b/be/src/vec/functions/function_jsonb.cpp
@@ -2396,11 +2396,10 @@ private:
const auto* object = element->unpack<ObjectVal>();
bool find = false;
for (const auto& item : *object) {
- const std::string_view key(item.getKeyStr(), item.klen());
+ Slice key(item.getKeyStr(), item.klen());
const auto* child_element = item.value();
// construct an object member path leg.
- auto leg =
std::make_unique<leg_info>(const_cast<char*>(key.data()), key.size(), 0,
- MEMBER_CODE);
+ auto leg = std::make_unique<leg_info>(key.data, key.size, 0,
MEMBER_CODE);
cur_path->add_leg_to_leg_vector(std::move(leg));
find |= find_matches(child_element, one_match, state,
cur_path, matches);
cur_path->pop_leg_from_leg_vector();
diff --git a/be/src/vec/functions/function_string.h
b/be/src/vec/functions/function_string.h
index 16e788843be..06e806a75a4 100644
--- a/be/src/vec/functions/function_string.h
+++ b/be/src/vec/functions/function_string.h
@@ -2952,6 +2952,7 @@ StringRef do_money_format(FunctionContext* context,
UInt32 scale, T int_value, T
(append_sign_manually ? 1 : 0) + integer_str_len + 1 +
frac_str_len;
StringRef result = context->create_temp_string_val(whole_decimal_str_len);
+ // Modify a string passed via stringref
char* result_data = const_cast<char*>(result.data);
if (append_sign_manually) {
@@ -2970,6 +2971,7 @@ static StringRef do_money_format(FunctionContext*
context, const std::string& va
bool is_positive = (value[0] != '-');
int32_t result_len = value.size() + (value.size() - (is_positive ? 4 : 5))
/ 3;
StringRef result = context->create_temp_string_val(result_len);
+ // Modify a string passed via stringref
char* result_data = const_cast<char*>(result.data);
if (!is_positive) {
*result_data = '-';
@@ -3079,6 +3081,7 @@ StringRef do_format_round(FunctionContext* context,
UInt32 scale, T int_value, T
(decimal_places > 0 ? 1 : 0) +
frac_str_len;
StringRef result = context->create_temp_string_val(whole_decimal_str_len);
+ // Modify a string passed via stringref
char* result_data = const_cast<char*>(result.data);
if (append_sign_manually) {
@@ -3749,8 +3752,7 @@ struct ReverseImpl {
int64_t src_len = offsets[i] - offsets[i - 1];
std::string dst;
dst.resize(src_len);
- simd::VStringFunctions::reverse(StringRef((uint8_t*)src_str,
src_len),
- StringRef((uint8_t*)dst.data(),
src_len));
+ simd::VStringFunctions::reverse(StringRef((uint8_t*)src_str,
src_len), &dst);
StringOP::push_value_string(std::string_view(dst.data(), src_len),
i, res_data,
res_offsets);
}
diff --git a/be/src/vec/functions/like.cpp b/be/src/vec/functions/like.cpp
index 6eaaee311da..95703197990 100644
--- a/be/src/vec/functions/like.cpp
+++ b/be/src/vec/functions/like.cpp
@@ -212,15 +212,15 @@ Status LikeSearchState::clone(LikeSearchState& cloned) {
return Status::OK();
}
-Status FunctionLikeBase::constant_allpass_fn(LikeSearchState* state, const
ColumnString& vals,
+Status FunctionLikeBase::constant_allpass_fn(const LikeSearchState* state,
const ColumnString& vals,
const StringRef& pattern,
ColumnUInt8::Container& result) {
memset(result.data(), 1, vals.size());
return Status::OK();
}
-Status FunctionLikeBase::constant_allpass_fn_scalar(LikeSearchState* state,
const StringRef& val,
- const StringRef& pattern,
+Status FunctionLikeBase::constant_allpass_fn_scalar(const LikeSearchState*
state,
+ const StringRef& val,
const StringRef& pattern,
unsigned char* result) {
*result = 1;
return Status::OK();
@@ -235,8 +235,8 @@ Status FunctionLikeBase::vector_allpass_fn(const
ColumnString& vals,
return Status::OK();
}
-Status FunctionLikeBase::constant_starts_with_fn(LikeSearchState* state, const
ColumnString& val,
- const StringRef& pattern,
+Status FunctionLikeBase::constant_starts_with_fn(const LikeSearchState* state,
+ const ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container&
result) {
auto sz = val.size();
for (size_t i = 0; i < sz; i++) {
@@ -247,7 +247,7 @@ Status
FunctionLikeBase::constant_starts_with_fn(LikeSearchState* state, const C
return Status::OK();
}
-Status FunctionLikeBase::constant_starts_with_fn_scalar(LikeSearchState* state,
+Status FunctionLikeBase::constant_starts_with_fn_scalar(const LikeSearchState*
state,
const StringRef& val,
const StringRef&
pattern,
unsigned char* result)
{
@@ -270,8 +270,8 @@ Status FunctionLikeBase::vector_starts_with_fn(const
ColumnString& vals,
return Status::OK();
}
-Status FunctionLikeBase::constant_ends_with_fn(LikeSearchState* state, const
ColumnString& val,
- const StringRef& pattern,
+Status FunctionLikeBase::constant_ends_with_fn(const LikeSearchState* state,
+ const ColumnString& val, const
StringRef& pattern,
ColumnUInt8::Container& result)
{
auto sz = val.size();
for (size_t i = 0; i < sz; i++) {
@@ -282,7 +282,8 @@ Status
FunctionLikeBase::constant_ends_with_fn(LikeSearchState* state, const Col
return Status::OK();
}
-Status FunctionLikeBase::constant_ends_with_fn_scalar(LikeSearchState* state,
const StringRef& val,
+Status FunctionLikeBase::constant_ends_with_fn_scalar(const LikeSearchState*
state,
+ const StringRef& val,
const StringRef& pattern,
unsigned char* result) {
*result = (val.size >= state->search_string_sv.size) &&
@@ -305,7 +306,7 @@ Status FunctionLikeBase::vector_ends_with_fn(const
ColumnString& vals,
return Status::OK();
}
-Status FunctionLikeBase::constant_equals_fn(LikeSearchState* state, const
ColumnString& val,
+Status FunctionLikeBase::constant_equals_fn(const LikeSearchState* state,
const ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container& result) {
auto sz = val.size();
@@ -315,8 +316,8 @@ Status
FunctionLikeBase::constant_equals_fn(LikeSearchState* state, const Column
return Status::OK();
}
-Status FunctionLikeBase::constant_equals_fn_scalar(LikeSearchState* state,
const StringRef& val,
- const StringRef& pattern,
+Status FunctionLikeBase::constant_equals_fn_scalar(const LikeSearchState*
state,
+ const StringRef& val, const
StringRef& pattern,
unsigned char* result) {
*result = (val == state->search_string_sv);
return Status::OK();
@@ -336,8 +337,8 @@ Status FunctionLikeBase::vector_equals_fn(const
ColumnString& vals,
return Status::OK();
}
-Status FunctionLikeBase::constant_substring_fn(LikeSearchState* state, const
ColumnString& val,
- const StringRef& pattern,
+Status FunctionLikeBase::constant_substring_fn(const LikeSearchState* state,
+ const ColumnString& val, const
StringRef& pattern,
ColumnUInt8::Container& result)
{
auto sz = val.size();
for (size_t i = 0; i < sz; i++) {
@@ -350,7 +351,8 @@ Status
FunctionLikeBase::constant_substring_fn(LikeSearchState* state, const Col
return Status::OK();
}
-Status FunctionLikeBase::constant_substring_fn_scalar(LikeSearchState* state,
const StringRef& val,
+Status FunctionLikeBase::constant_substring_fn_scalar(const LikeSearchState*
state,
+ const StringRef& val,
const StringRef& pattern,
unsigned char* result) {
if (state->search_string_sv.size == 0) {
@@ -380,8 +382,9 @@ Status FunctionLikeBase::vector_substring_fn(const
ColumnString& vals,
return Status::OK();
}
-Status FunctionLikeBase::constant_regex_fn_scalar(LikeSearchState* state,
const StringRef& val,
- const StringRef& pattern,
unsigned char* result) {
+Status FunctionLikeBase::constant_regex_fn_scalar(const LikeSearchState* state,
+ const StringRef& val, const
StringRef& pattern,
+ unsigned char* result) {
if (state->hs_database) { // use hyperscan
auto ret = hs_scan(state->hs_database.get(), val.data, (int)val.size,
0,
state->hs_scratch.get(),
@@ -396,7 +399,7 @@ Status
FunctionLikeBase::constant_regex_fn_scalar(LikeSearchState* state, const
return Status::OK();
}
-Status FunctionLikeBase::regexp_fn_scalar(LikeSearchState* state, const
StringRef& val,
+Status FunctionLikeBase::regexp_fn_scalar(const LikeSearchState* state, const
StringRef& val,
const StringRef& pattern, unsigned
char* result) {
RE2::Options opts;
opts.set_never_nl(false);
@@ -411,7 +414,7 @@ Status FunctionLikeBase::regexp_fn_scalar(LikeSearchState*
state, const StringRe
return Status::OK();
}
-Status FunctionLikeBase::constant_regex_fn(LikeSearchState* state, const
ColumnString& val,
+Status FunctionLikeBase::constant_regex_fn(const LikeSearchState* state, const
ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container& result) {
auto sz = val.size();
@@ -437,7 +440,7 @@ Status FunctionLikeBase::constant_regex_fn(LikeSearchState*
state, const ColumnS
return Status::OK();
}
-Status FunctionLikeBase::regexp_fn(LikeSearchState* state, const ColumnString&
val,
+Status FunctionLikeBase::regexp_fn(const LikeSearchState* state, const
ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container& result) {
std::string re_pattern(pattern.data, pattern.size);
@@ -523,8 +526,9 @@ Status FunctionLikeBase::execute_impl(FunctionContext*
context, Block& block,
context->get_function_state(FunctionContext::THREAD_LOCAL));
// for constant_substring_fn, use long run length search for performance
if (constant_substring_fn ==
- *(state->function.target<doris::Status (*)(LikeSearchState* state,
const ColumnString&,
- const StringRef&,
ColumnUInt8::Container&)>())) {
+ *(state->function
+ .target<doris::Status (*)(const LikeSearchState* state,
const ColumnString&,
+ const StringRef&,
ColumnUInt8::Container&)>())) {
RETURN_IF_ERROR(execute_substring(values->get_chars(),
values->get_offsets(), vec_res,
&state->search_state));
} else {
@@ -699,14 +703,14 @@ Status FunctionLikeBase::vector_non_const(const
ColumnString& values, const Colu
return (vector_search_state->_vector_function)(values, *search_strings,
result);
}
-Status FunctionLike::like_fn(LikeSearchState* state, const ColumnString& val,
+Status FunctionLike::like_fn(const LikeSearchState* state, const ColumnString&
val,
const StringRef& pattern, ColumnUInt8::Container&
result) {
std::string re_pattern;
convert_like_pattern(state, std::string(pattern.data, pattern.size),
&re_pattern);
return regexp_fn(state, val, {re_pattern.c_str(), re_pattern.size()},
result);
}
-Status FunctionLike::like_fn_scalar(LikeSearchState* state, const StringRef&
val,
+Status FunctionLike::like_fn_scalar(const LikeSearchState* state, const
StringRef& val,
const StringRef& pattern, unsigned char*
result) {
std::string re_pattern;
convert_like_pattern(state, std::string(pattern.data, pattern.size),
&re_pattern);
@@ -715,7 +719,7 @@ Status FunctionLike::like_fn_scalar(LikeSearchState* state,
const StringRef& val
{re_pattern.c_str(), re_pattern.size()}, result);
}
-void FunctionLike::convert_like_pattern(LikeSearchState* state, const
std::string& pattern,
+void FunctionLike::convert_like_pattern(const LikeSearchState* state, const
std::string& pattern,
std::string* re_pattern) {
re_pattern->clear();
diff --git a/be/src/vec/functions/like.h b/be/src/vec/functions/like.h
index 30665ade359..1128e4f3f69 100644
--- a/be/src/vec/functions/like.h
+++ b/be/src/vec/functions/like.h
@@ -136,10 +136,10 @@ struct LikeSearchState {
}
};
-using LikeFn = std::function<doris::Status(LikeSearchState*, const
ColumnString&, const StringRef&,
- ColumnUInt8::Container&)>;
+using LikeFn = std::function<doris::Status(const LikeSearchState*, const
ColumnString&,
+ const StringRef&,
ColumnUInt8::Container&)>;
-using ScalarLikeFn = std::function<doris::Status(LikeSearchState*, const
StringRef&,
+using ScalarLikeFn = std::function<doris::Status(const LikeSearchState*, const
StringRef&,
const StringRef&, unsigned
char*)>;
using VectorLikeFn = std::function<doris::Status(const ColumnString&, const
ColumnString&,
@@ -208,62 +208,62 @@ protected:
template <bool LIKE_PATTERN>
static VPatternSearchStateSPtr pattern_type_recognition(const
ColumnString& patterns);
- static Status constant_allpass_fn(LikeSearchState* state, const
ColumnString& val,
+ static Status constant_allpass_fn(const LikeSearchState* state, const
ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container& result);
- static Status constant_allpass_fn_scalar(LikeSearchState* state, const
StringRef& val,
+ static Status constant_allpass_fn_scalar(const LikeSearchState* state,
const StringRef& val,
const StringRef& pattern,
unsigned char* result);
static Status vector_allpass_fn(const ColumnString& vals, const
ColumnString& search_strings,
ColumnUInt8::Container& result);
- static Status constant_starts_with_fn(LikeSearchState* state, const
ColumnString& val,
+ static Status constant_starts_with_fn(const LikeSearchState* state, const
ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container& result);
- static Status constant_starts_with_fn_scalar(LikeSearchState* state, const
StringRef& val,
+ static Status constant_starts_with_fn_scalar(const LikeSearchState* state,
const StringRef& val,
const StringRef& pattern,
unsigned char* result);
static Status vector_starts_with_fn(const ColumnString& vals,
const ColumnString& search_strings,
ColumnUInt8::Container& result);
- static Status constant_ends_with_fn(LikeSearchState* state, const
ColumnString& val,
+ static Status constant_ends_with_fn(const LikeSearchState* state, const
ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container& result);
- static Status constant_ends_with_fn_scalar(LikeSearchState* state, const
StringRef& val,
+ static Status constant_ends_with_fn_scalar(const LikeSearchState* state,
const StringRef& val,
const StringRef& pattern,
unsigned char* result);
static Status vector_ends_with_fn(const ColumnString& vals, const
ColumnString& search_strings,
ColumnUInt8::Container& result);
- static Status constant_equals_fn(LikeSearchState* state, const
ColumnString& val,
+ static Status constant_equals_fn(const LikeSearchState* state, const
ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container& result);
- static Status constant_equals_fn_scalar(LikeSearchState* state, const
StringRef& val,
+ static Status constant_equals_fn_scalar(const LikeSearchState* state,
const StringRef& val,
const StringRef& pattern, unsigned
char* result);
static Status vector_equals_fn(const ColumnString& vals, const
ColumnString& search_strings,
ColumnUInt8::Container& result);
- static Status constant_substring_fn(LikeSearchState* state, const
ColumnString& val,
+ static Status constant_substring_fn(const LikeSearchState* state, const
ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container& result);
- static Status constant_substring_fn_scalar(LikeSearchState* state, const
StringRef& val,
+ static Status constant_substring_fn_scalar(const LikeSearchState* state,
const StringRef& val,
const StringRef& pattern,
unsigned char* result);
static Status vector_substring_fn(const ColumnString& vals, const
ColumnString& search_strings,
ColumnUInt8::Container& result);
- static Status constant_regex_fn(LikeSearchState* state, const
ColumnString& val,
+ static Status constant_regex_fn(const LikeSearchState* state, const
ColumnString& val,
const StringRef& pattern,
ColumnUInt8::Container& result);
- static Status constant_regex_fn_scalar(LikeSearchState* state, const
StringRef& val,
+ static Status constant_regex_fn_scalar(const LikeSearchState* state, const
StringRef& val,
const StringRef& pattern, unsigned
char* result);
- static Status regexp_fn(LikeSearchState* state, const ColumnString& val,
+ static Status regexp_fn(const LikeSearchState* state, const ColumnString&
val,
const StringRef& pattern, ColumnUInt8::Container&
result);
- static Status regexp_fn_scalar(LikeSearchState* state, const StringRef&
val,
+ static Status regexp_fn_scalar(const LikeSearchState* state, const
StringRef& val,
const StringRef& pattern, unsigned char*
result);
// hyperscan compile expression to database and allocate scratch space
@@ -293,13 +293,13 @@ public:
friend struct VectorEndsWithSearchState;
private:
- static Status like_fn(LikeSearchState* state, const ColumnString& val,
const StringRef& pattern,
- ColumnUInt8::Container& result);
+ static Status like_fn(const LikeSearchState* state, const ColumnString&
val,
+ const StringRef& pattern, ColumnUInt8::Container&
result);
- static Status like_fn_scalar(LikeSearchState* state, const StringRef& val,
+ static Status like_fn_scalar(const LikeSearchState* state, const
StringRef& val,
const StringRef& pattern, unsigned char*
result);
- static void convert_like_pattern(LikeSearchState* state, const
std::string& pattern,
+ static void convert_like_pattern(const LikeSearchState* state, const
std::string& pattern,
std::string* re_pattern);
static void remove_escape_character(std::string* search_string);
diff --git a/be/src/vec/olap/olap_data_convertor.cpp
b/be/src/vec/olap/olap_data_convertor.cpp
index 5ccae6f0a0f..5bcfae7ea43 100644
--- a/be/src/vec/olap/olap_data_convertor.cpp
+++ b/be/src/vec/olap/olap_data_convertor.cpp
@@ -354,9 +354,9 @@ Status
OlapBlockDataConvertor::OlapColumnDataConvertorBitMap::convert_to_olap()
}
assert(column_bitmap);
- auto* bitmap_value =
const_cast<BitmapValue*>(column_bitmap->get_data().data() + _row_pos);
- BitmapValue* bitmap_value_cur = bitmap_value;
- BitmapValue* bitmap_value_end = bitmap_value_cur + _num_rows;
+ const BitmapValue* bitmap_value = column_bitmap->get_data().data() +
_row_pos;
+ const BitmapValue* bitmap_value_cur = bitmap_value;
+ const BitmapValue* bitmap_value_end = bitmap_value_cur + _num_rows;
size_t total_size = 0;
if (_nullmap) {
@@ -428,10 +428,9 @@ Status
OlapBlockDataConvertor::OlapColumnDataConvertorQuantileState::convert_to_
assert_cast<const
vectorized::ColumnQuantileState*>(_typed_column.column.get());
assert(column_quantile_state);
- auto* quantile_state =
-
const_cast<QuantileState*>(column_quantile_state->get_data().data() + _row_pos);
- QuantileState* quantile_state_cur = quantile_state;
- QuantileState* quantile_state_end = quantile_state_cur + _num_rows;
+ const QuantileState* quantile_state =
column_quantile_state->get_data().data() + _row_pos;
+ const QuantileState* quantile_state_cur = quantile_state;
+ const QuantileState* quantile_state_end = quantile_state_cur + _num_rows;
size_t total_size = 0;
while (quantile_state_cur != quantile_state_end) {
@@ -470,9 +469,9 @@ Status
OlapBlockDataConvertor::OlapColumnDataConvertorHLL::convert_to_olap() {
column_hll = assert_cast<const
vectorized::ColumnHLL*>(_typed_column.column.get());
assert(column_hll);
- auto* hll_value = const_cast<HyperLogLog*>(column_hll->get_data().data() +
_row_pos);
- HyperLogLog* hll_value_cur = hll_value;
- HyperLogLog* hll_value_end = hll_value_cur + _num_rows;
+ const HyperLogLog* hll_value = column_hll->get_data().data() + _row_pos;
+ const HyperLogLog* hll_value_cur = hll_value;
+ const HyperLogLog* hll_value_end = hll_value_cur + _num_rows;
size_t total_size = 0;
while (hll_value_cur != hll_value_end) {
@@ -588,13 +587,13 @@ Status
OlapBlockDataConvertor::OlapColumnDataConvertorVarChar::convert_to_olap(
const ColumnString::Offset* offset_cur =
column_string->get_offsets().data() + _row_pos;
const ColumnString::Offset* offset_end = offset_cur + _num_rows;
- Slice* slice = _slice.data();
+ StringRef* slice = _slice.data();
size_t string_offset = *(offset_cur - 1);
if (null_map) {
const UInt8* nullmap_cur = null_map + _row_pos;
while (offset_cur != offset_end) {
if (!*nullmap_cur) {
- slice->data = const_cast<char*>(char_data + string_offset);
+ slice->data = char_data + string_offset;
slice->size = *offset_cur - string_offset;
if (UNLIKELY(slice->size >
config::string_type_length_soft_limit_bytes &&
_check_length)) {
@@ -621,7 +620,7 @@ Status
OlapBlockDataConvertor::OlapColumnDataConvertorVarChar::convert_to_olap(
assert(nullmap_cur == null_map + _row_pos + _num_rows && slice ==
_slice.get_end_ptr());
} else {
while (offset_cur != offset_end) {
- slice->data = const_cast<char*>(char_data + string_offset);
+ slice->data = char_data + string_offset;
slice->size = *offset_cur - string_offset;
if (UNLIKELY(slice->size >
config::string_type_length_soft_limit_bytes &&
_check_length)) {
diff --git a/be/src/vec/olap/olap_data_convertor.h
b/be/src/vec/olap/olap_data_convertor.h
index 5b46554d269..7768dbcf0bd 100644
--- a/be/src/vec/olap/olap_data_convertor.h
+++ b/be/src/vec/olap/olap_data_convertor.h
@@ -228,7 +228,7 @@ private:
bool _check_length;
bool _is_jsonb =
false; // Make sure that the json binary data written in is
the correct jsonb value.
- PaddedPODArray<Slice> _slice;
+ PaddedPODArray<StringRef> _slice;
};
class OlapColumnDataConvertorAggState : public OlapColumnDataConvertorBase
{
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
