This is an automated email from the ASF dual-hosted git repository.
dataroaring pushed a commit to branch branch-3.0
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/branch-3.0 by this push:
new e04a4aac216 [fix](serde)fix write to orc file (#52884)
e04a4aac216 is described below
commit e04a4aac216b94c7ef6fa0a274ad9e5fb8fcf77b
Author: amory <[email protected]>
AuthorDate: Wed Jul 9 09:52:08 2025 +0800
[fix](serde)fix write to orc file (#52884)
### What problem does this PR solve?
backport https://github.com/apache/doris/pull/52676
Issue Number: close #xxx
---
.../data_types/serde/data_type_bitmap_serde.cpp | 34 +++++++++++---
.../data_types/serde/data_type_date64_serde.cpp | 46 +++++++++++++-----
.../vec/data_types/serde/data_type_hll_serde.cpp | 34 +++++++++++---
.../vec/data_types/serde/data_type_ipv6_serde.cpp | 47 ++++++++++++++-----
.../vec/data_types/serde/data_type_jsonb_serde.cpp | 51 ++++++++++++++------
.../data_types/serde/data_type_number_serde.cpp | 37 ++++++++++++---
.../data_types/serde/data_type_object_serde.cpp | 54 +++++++++++++++-------
.../serde/data_type_quantilestate_serde.h | 34 +++++++++++---
be/src/vec/data_types/serde/data_type_serde.h | 25 ----------
9 files changed, 257 insertions(+), 105 deletions(-)
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 f60d054df31..9697a3b71bb 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
@@ -191,23 +191,43 @@ Status DataTypeBitMapSerDe::write_column_to_orc(const
std::string& timezone, con
std::vector<StringRef>&
buffer_list) const {
auto& col_data = assert_cast<const ColumnBitmap&>(column);
orc::StringVectorBatch* cur_batch =
dynamic_cast<orc::StringVectorBatch*>(orc_col_batch);
-
- INIT_MEMORY_FOR_ORC_WRITER()
-
+ // First pass: calculate total memory needed and collect serialized values
+ 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));
size_t len = bitmap_value.getSizeInBytes();
-
- REALLOC_MEMORY_FOR_ORC_WRITER()
-
+ total_size += len;
+ }
+ }
+ // Allocate continues memory based on calculated size
+ char* ptr = (char*)malloc(total_size);
+ if (!ptr) {
+ return Status::InternalError(
+ "malloc memory {} error when write variant column data to orc
file.", total_size);
+ }
+ StringRef bufferRef;
+ bufferRef.data = ptr;
+ bufferRef.size = total_size;
+ buffer_list.emplace_back(bufferRef);
+ // Second pass: copy data to allocated memory
+ 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));
+ size_t len = bitmap_value.getSizeInBytes();
+ if (offset + len > total_size) {
+ return Status::InternalError(
+ "Buffer overflow when writing column data to ORC file.
offset {} with len "
+ "{} exceed total_size {} . ",
+ offset, len, total_size);
+ }
bitmap_value.write_to(const_cast<char*>(bufferRef.data) + offset);
cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) +
offset;
cur_batch->length[row_id] = len;
offset += len;
}
}
-
cur_batch->numElements = end - start;
return Status::OK();
}
diff --git a/be/src/vec/data_types/serde/data_type_date64_serde.cpp
b/be/src/vec/data_types/serde/data_type_date64_serde.cpp
index 1ce0ff54ac8..0aa81907180 100644
--- a/be/src/vec/data_types/serde/data_type_date64_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_date64_serde.cpp
@@ -324,23 +324,47 @@ Status DataTypeDate64SerDe::write_column_to_orc(const
std::string& timezone, con
auto& col_data = static_cast<const
ColumnVector<Int64>&>(column).get_data();
orc::StringVectorBatch* cur_batch =
dynamic_cast<orc::StringVectorBatch*>(orc_col_batch);
- INIT_MEMORY_FOR_ORC_WRITER()
-
+ // First pass: calculate total memory needed and collect serialized values
+ std::vector<std::string> serialized_values;
+ std::vector<size_t> valid_row_indices;
+ size_t total_size = 0;
for (size_t row_id = start; row_id < end; row_id++) {
- if (cur_batch->notNull[row_id] == 0) {
- continue;
+ if (cur_batch->notNull[row_id] == 1) {
+ char buf[64];
+ size_t len = binary_cast<Int64,
VecDateTimeValue>(col_data[row_id]).to_buffer(buf);
+ total_size += len;
+ // avoid copy
+ serialized_values.emplace_back(buf, len);
+ valid_row_indices.push_back(row_id);
}
-
- int len = binary_cast<Int64, VecDateTimeValue>(col_data[row_id])
- .to_buffer(const_cast<char*>(bufferRef.data) +
offset);
-
- REALLOC_MEMORY_FOR_ORC_WRITER()
-
+ }
+ // Allocate continues memory based on calculated size
+ char* ptr = (char*)malloc(total_size);
+ if (!ptr) {
+ return Status::InternalError(
+ "malloc memory {} error when write variant column data to orc
file.", total_size);
+ }
+ StringRef bufferRef;
+ bufferRef.data = ptr;
+ bufferRef.size = total_size;
+ buffer_list.emplace_back(bufferRef);
+ // Second pass: copy data to allocated memory
+ size_t offset = 0;
+ for (size_t i = 0; i < serialized_values.size(); i++) {
+ const auto& serialized_value = serialized_values[i];
+ size_t row_id = valid_row_indices[i];
+ size_t len = serialized_value.length();
+ if (offset + len > total_size) {
+ return Status::InternalError(
+ "Buffer overflow when writing column data to ORC file.
offset {} with len {} "
+ "exceed total_size {} . ",
+ offset, len, total_size);
+ }
+ memcpy(const_cast<char*>(bufferRef.data) + offset,
serialized_value.data(), len);
cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) + offset;
cur_batch->length[row_id] = len;
offset += len;
}
-
cur_batch->numElements = end - start;
return Status::OK();
}
diff --git a/be/src/vec/data_types/serde/data_type_hll_serde.cpp
b/be/src/vec/data_types/serde/data_type_hll_serde.cpp
index aba3a9d0619..156e1dce7b6 100644
--- a/be/src/vec/data_types/serde/data_type_hll_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_hll_serde.cpp
@@ -184,23 +184,43 @@ Status DataTypeHLLSerDe::write_column_to_orc(const
std::string& timezone, const
int end, std::vector<StringRef>&
buffer_list) const {
auto& col_data = assert_cast<const ColumnHLL&>(column);
orc::StringVectorBatch* cur_batch =
dynamic_cast<orc::StringVectorBatch*>(orc_col_batch);
-
- INIT_MEMORY_FOR_ORC_WRITER()
-
+ // First pass: calculate total memory needed and collect serialized values
+ size_t total_size = 0;
for (size_t row_id = start; row_id < end; row_id++) {
if (cur_batch->notNull[row_id] == 1) {
auto hll_value =
const_cast<HyperLogLog&>(col_data.get_element(row_id));
size_t len = hll_value.max_serialized_size();
-
- REALLOC_MEMORY_FOR_ORC_WRITER()
-
+ total_size += len;
+ }
+ }
+ // Allocate continues memory based on calculated size
+ char* ptr = (char*)malloc(total_size);
+ if (!ptr) {
+ return Status::InternalError(
+ "malloc memory {} error when write variant column data to orc
file.", total_size);
+ }
+ StringRef bufferRef;
+ bufferRef.data = ptr;
+ bufferRef.size = total_size;
+ buffer_list.emplace_back(bufferRef);
+ // Second pass: copy data to allocated memory
+ size_t offset = 0;
+ for (size_t row_id = start; row_id < end; row_id++) {
+ if (cur_batch->notNull[row_id] == 1) {
+ auto hll_value =
const_cast<HyperLogLog&>(col_data.get_element(row_id));
+ size_t len = hll_value.max_serialized_size();
+ if (offset + len > total_size) {
+ return Status::InternalError(
+ "Buffer overflow when writing column data to ORC file.
offset {} with len "
+ "{} exceed total_size {} ",
+ offset, len, total_size);
+ }
hll_value.serialize((uint8_t*)(bufferRef.data) + offset);
cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) +
offset;
cur_batch->length[row_id] = len;
offset += len;
}
}
-
cur_batch->numElements = end - start;
return Status::OK();
}
diff --git a/be/src/vec/data_types/serde/data_type_ipv6_serde.cpp
b/be/src/vec/data_types/serde/data_type_ipv6_serde.cpp
index 83acbf9cda1..a25628f62b5 100644
--- a/be/src/vec/data_types/serde/data_type_ipv6_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_ipv6_serde.cpp
@@ -198,20 +198,45 @@ Status DataTypeIPv6SerDe::write_column_to_orc(const
std::string& timezone, const
const auto& col_data = assert_cast<const ColumnIPv6&>(column).get_data();
orc::StringVectorBatch* cur_batch =
assert_cast<orc::StringVectorBatch*>(orc_col_batch);
- INIT_MEMORY_FOR_ORC_WRITER()
-
+ // First pass: calculate total memory needed and collect serialized values
+ std::vector<std::string> serialized_values;
+ std::vector<size_t> valid_row_indices;
+ size_t total_size = 0;
for (size_t row_id = start; row_id < end; row_id++) {
if (cur_batch->notNull[row_id] == 1) {
- std::string ipv6_str = IPv6Value::to_string(col_data[row_id]);
- size_t len = ipv6_str.size();
-
- REALLOC_MEMORY_FOR_ORC_WRITER()
-
- strcpy(const_cast<char*>(bufferRef.data) + offset,
ipv6_str.c_str());
- cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) +
offset;
- cur_batch->length[row_id] = len;
- offset += len;
+ auto serialized_value = IPv6Value::to_string(col_data[row_id]);
+ serialized_values.push_back(std::move(serialized_value));
+ size_t len = serialized_values.back().length();
+ total_size += len;
+ valid_row_indices.push_back(row_id);
+ }
+ }
+ // Allocate continues memory based on calculated size
+ char* ptr = (char*)malloc(total_size);
+ if (!ptr) {
+ return Status::InternalError(
+ "malloc memory {} error when write variant column data to orc
file.", total_size);
+ }
+ StringRef bufferRef;
+ bufferRef.data = ptr;
+ bufferRef.size = total_size;
+ buffer_list.emplace_back(bufferRef);
+ // Second pass: copy data to allocated memory
+ size_t offset = 0;
+ for (size_t i = 0; i < serialized_values.size(); i++) {
+ const auto& serialized_value = serialized_values[i];
+ size_t row_id = valid_row_indices[i];
+ size_t len = serialized_value.length();
+ if (offset + len > total_size) {
+ return Status::InternalError(
+ "Buffer overflow when writing column data to ORC file.
offset {} with len {} "
+ "exceed total_size {} . ",
+ offset, len, total_size);
}
+ memcpy(const_cast<char*>(bufferRef.data) + offset,
serialized_value.data(), len);
+ cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) + offset;
+ cur_batch->length[row_id] = len;
+ offset += len;
}
cur_batch->numElements = end - start;
diff --git a/be/src/vec/data_types/serde/data_type_jsonb_serde.cpp
b/be/src/vec/data_types/serde/data_type_jsonb_serde.cpp
index eb6c783cf28..181669555d6 100644
--- a/be/src/vec/data_types/serde/data_type_jsonb_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_jsonb_serde.cpp
@@ -142,25 +142,48 @@ Status DataTypeJsonbSerDe::write_column_to_orc(const
std::string& timezone, cons
int end,
std::vector<StringRef>& buffer_list) const {
auto* cur_batch = dynamic_cast<orc::StringVectorBatch*>(orc_col_batch);
const auto& string_column = assert_cast<const ColumnString&>(column);
-
- INIT_MEMORY_FOR_ORC_WRITER()
-
+ // First pass: calculate total memory needed and collect serialized values
+ std::vector<std::string> serialized_values;
+ std::vector<size_t> valid_row_indices;
+ size_t total_size = 0;
for (size_t row_id = start; row_id < end; row_id++) {
if (cur_batch->notNull[row_id] == 1) {
std::string_view string_ref =
string_column.get_data_at(row_id).to_string_view();
- auto serialized_value = std::make_unique<std::string>(
- JsonbToJson::jsonb_to_json_string(string_ref.data(),
string_ref.size()));
- auto len = serialized_value->size();
-
- REALLOC_MEMORY_FOR_ORC_WRITER()
-
- memcpy(const_cast<char*>(bufferRef.data) + offset,
serialized_value->data(), len);
- cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) +
offset;
- cur_batch->length[row_id] = len;
- offset += len;
+ auto serialized_value =
+ JsonbToJson::jsonb_to_json_string(string_ref.data(),
string_ref.size());
+ serialized_values.push_back(std::move(serialized_value));
+ size_t len = serialized_values.back().length();
+ total_size += len;
+ valid_row_indices.push_back(row_id);
}
}
-
+ // Allocate continues memory based on calculated size
+ char* ptr = (char*)malloc(total_size);
+ if (!ptr) {
+ return Status::InternalError(
+ "malloc memory {} error when write variant column data to orc
file.", total_size);
+ }
+ StringRef bufferRef;
+ bufferRef.data = ptr;
+ bufferRef.size = total_size;
+ buffer_list.emplace_back(bufferRef);
+ // Second pass: copy data to allocated memory
+ size_t offset = 0;
+ for (size_t i = 0; i < serialized_values.size(); i++) {
+ const auto& serialized_value = serialized_values[i];
+ size_t row_id = valid_row_indices[i];
+ size_t len = serialized_value.length();
+ if (offset + len > total_size) {
+ return Status::InternalError(
+ "Buffer overflow when writing column data to ORC file.
offset {} with len {} "
+ "exceed total_size {} . ",
+ offset, len, total_size);
+ }
+ memcpy(const_cast<char*>(bufferRef.data) + offset,
serialized_value.data(), len);
+ cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) + offset;
+ cur_batch->length[row_id] = len;
+ offset += len;
+ }
cur_batch->numElements = end - start;
return Status::OK();
}
diff --git a/be/src/vec/data_types/serde/data_type_number_serde.cpp
b/be/src/vec/data_types/serde/data_type_number_serde.cpp
index 20ce78bf9c2..c691c55d8d2 100644
--- a/be/src/vec/data_types/serde/data_type_number_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_number_serde.cpp
@@ -351,17 +351,40 @@ Status DataTypeNumberSerDe<T>::write_column_to_orc(const
std::string& timezone,
if constexpr (std::is_same_v<T, Int128>) { // largeint
orc::StringVectorBatch* cur_batch =
dynamic_cast<orc::StringVectorBatch*>(orc_col_batch);
-
- INIT_MEMORY_FOR_ORC_WRITER()
-
+ // First pass: calculate total memory needed and collect serialized
values
+ size_t total_size = 0;
for (size_t row_id = start; row_id < end; row_id++) {
if (cur_batch->notNull[row_id] == 1) {
std::string value_str = fmt::format("{}", col_data[row_id]);
size_t len = value_str.size();
-
- REALLOC_MEMORY_FOR_ORC_WRITER()
-
- strcpy(const_cast<char*>(bufferRef.data) + offset,
value_str.c_str());
+ total_size += len;
+ }
+ }
+ // Allocate continues memory based on calculated size
+ char* ptr = (char*)malloc(total_size);
+ if (!ptr) {
+ return Status::InternalError(
+ "malloc memory {} error when write variant column data to
orc file.",
+ total_size);
+ }
+ StringRef bufferRef;
+ bufferRef.data = ptr;
+ bufferRef.size = total_size;
+ buffer_list.emplace_back(bufferRef);
+ // Second pass: fill the data and update the batch
+ size_t offset = 0;
+ for (size_t row_id = start; row_id < end; row_id++) {
+ if (cur_batch->notNull[row_id] == 1) {
+ std::string value_str = fmt::format("{}", col_data[row_id]);
+ size_t len = value_str.size();
+ if (offset + len > total_size) {
+ return Status::InternalError(
+ "Buffer overflow when writing column data to ORC
file. offset {} with "
+ "len {} exceed total_size {} . ",
+ offset, len, total_size);
+ }
+ // do not use strcpy here, because this buffer is not
null-terminated
+ memcpy(const_cast<char*>(bufferRef.data) + offset,
value_str.c_str(), len);
cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) +
offset;
cur_batch->length[row_id] = len;
offset += len;
diff --git a/be/src/vec/data_types/serde/data_type_object_serde.cpp
b/be/src/vec/data_types/serde/data_type_object_serde.cpp
index 31d91444823..3a944904e54 100644
--- a/be/src/vec/data_types/serde/data_type_object_serde.cpp
+++ b/be/src/vec/data_types/serde/data_type_object_serde.cpp
@@ -208,27 +208,47 @@ Status DataTypeObjectSerDe::write_column_to_orc(const
std::string& timezone, con
std::vector<StringRef>&
buffer_list) const {
const auto* var = check_and_get_column<ColumnObject>(column);
orc::StringVectorBatch* cur_batch =
dynamic_cast<orc::StringVectorBatch*>(orc_col_batch);
-
- INIT_MEMORY_FOR_ORC_WRITER()
-
+ // First pass: calculate total memory needed and collect serialized values
+ std::vector<std::string> serialized_values;
+ std::vector<size_t> valid_row_indices;
+ size_t total_size = 0;
for (size_t row_id = start; row_id < end; row_id++) {
if (cur_batch->notNull[row_id] == 1) {
- auto serialized_value = std::make_unique<std::string>();
- if (!var->serialize_one_row_to_string(row_id,
serialized_value.get())) {
- throw doris::Exception(ErrorCode::INTERNAL_ERROR, "Failed to
serialize variant {}",
- var->dump_structure());
- }
- auto len = serialized_value->length();
-
- REALLOC_MEMORY_FOR_ORC_WRITER()
-
- memcpy(const_cast<char*>(bufferRef.data) + offset,
serialized_value->data(), len);
- cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) +
offset;
- cur_batch->length[row_id] = len;
- offset += len;
+ // avoid move the string data, use emplace_back to construct in
place
+ serialized_values.emplace_back();
+ RETURN_IF_ERROR(var->serialize_one_row_to_string(row_id,
&serialized_values.back()));
+ size_t len = serialized_values.back().length();
+ total_size += len;
+ valid_row_indices.push_back(row_id);
}
}
-
+ // Allocate continues memory based on calculated size
+ char* ptr = (char*)malloc(total_size);
+ if (!ptr) {
+ return Status::InternalError(
+ "malloc memory {} error when write variant column data to orc
file.", total_size);
+ }
+ StringRef bufferRef;
+ bufferRef.data = ptr;
+ bufferRef.size = total_size;
+ buffer_list.emplace_back(bufferRef);
+ // Second pass: copy data to allocated memory
+ size_t offset = 0;
+ for (size_t i = 0; i < serialized_values.size(); i++) {
+ const auto& serialized_value = serialized_values[i];
+ size_t row_id = valid_row_indices[i];
+ size_t len = serialized_value.length();
+ if (offset + len > total_size) {
+ return Status::InternalError(
+ "Buffer overflow when writing column data to ORC file.
offset {} with len {} "
+ "exceed total_size {} . ",
+ offset, len, total_size);
+ }
+ memcpy(const_cast<char*>(bufferRef.data) + offset,
serialized_value.data(), len);
+ cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) + offset;
+ cur_batch->length[row_id] = len;
+ offset += len;
+ }
cur_batch->numElements = end - start;
return Status::OK();
}
diff --git a/be/src/vec/data_types/serde/data_type_quantilestate_serde.h
b/be/src/vec/data_types/serde/data_type_quantilestate_serde.h
index e24a3a29543..67530000810 100644
--- a/be/src/vec/data_types/serde/data_type_quantilestate_serde.h
+++ b/be/src/vec/data_types/serde/data_type_quantilestate_serde.h
@@ -154,16 +154,38 @@ public:
std::vector<StringRef>& buffer_list) const
override {
auto& col_data = assert_cast<const ColumnQuantileState&>(column);
orc::StringVectorBatch* cur_batch =
dynamic_cast<orc::StringVectorBatch*>(orc_col_batch);
-
- INIT_MEMORY_FOR_ORC_WRITER()
-
+ // First pass: calculate total memory needed and collect serialized
values
+ size_t total_size = 0;
for (size_t row_id = start; row_id < end; row_id++) {
if (cur_batch->notNull[row_id] == 1) {
auto quantilestate_value =
const_cast<QuantileState&>(col_data.get_element(row_id));
size_t len = quantilestate_value.get_serialized_size();
-
- REALLOC_MEMORY_FOR_ORC_WRITER()
-
+ total_size += len;
+ }
+ }
+ // Allocate continues memory based on calculated size
+ char* ptr = (char*)malloc(total_size);
+ if (!ptr) {
+ return Status::InternalError(
+ "malloc memory {} error when write variant column data to
orc file.",
+ total_size);
+ }
+ StringRef bufferRef;
+ bufferRef.data = ptr;
+ bufferRef.size = total_size;
+ buffer_list.push_back(bufferRef);
+ // Second pass: copy data to allocated memory
+ size_t offset = 0;
+ for (size_t row_id = start; row_id < end; row_id++) {
+ if (cur_batch->notNull[row_id] == 1) {
+ auto quantilestate_value =
const_cast<QuantileState&>(col_data.get_element(row_id));
+ size_t len = quantilestate_value.get_serialized_size();
+ if (offset + len > total_size) {
+ return Status::InternalError(
+ "Buffer overflow when writing column data to ORC
file. offset {} with "
+ "len {} exceed total_size {} . ",
+ offset, len, total_size);
+ }
quantilestate_value.serialize((uint8_t*)(bufferRef.data) +
offset);
cur_batch->data[row_id] = const_cast<char*>(bufferRef.data) +
offset;
cur_batch->length[row_id] = len;
diff --git a/be/src/vec/data_types/serde/data_type_serde.h
b/be/src/vec/data_types/serde/data_type_serde.h
index f7446d5c52a..d9da4dd872c 100644
--- a/be/src/vec/data_types/serde/data_type_serde.h
+++ b/be/src/vec/data_types/serde/data_type_serde.h
@@ -75,31 +75,6 @@ struct ColumnVectorBatch;
++*num_deserialized;
\
}
-#define INIT_MEMORY_FOR_ORC_WRITER()
\
- char* ptr = (char*)malloc(BUFFER_UNIT_SIZE);
\
- if (!ptr) {
\
- return Status::InternalError(
\
- "malloc memory error when write largeint column data to orc
file."); \
- }
\
- StringRef bufferRef;
\
- bufferRef.data = ptr;
\
- bufferRef.size = BUFFER_UNIT_SIZE;
\
- size_t offset = 0;
\
- buffer_list.emplace_back(bufferRef);
-
-#define REALLOC_MEMORY_FOR_ORC_WRITER()
\
- while (bufferRef.size - BUFFER_RESERVED_SIZE < offset + len) {
\
- char* new_ptr = (char*)malloc(bufferRef.size + BUFFER_UNIT_SIZE);
\
- if (!new_ptr) {
\
- return Status::InternalError(
\
- "malloc memory error when write largeint column data to
orc file."); \
- }
\
- memcpy(new_ptr, bufferRef.data, bufferRef.size);
\
- free(const_cast<char*>(bufferRef.data));
\
- bufferRef.data = new_ptr;
\
- bufferRef.size = bufferRef.size + BUFFER_UNIT_SIZE;
\
- }
-
namespace doris {
class PValues;
class JsonbValue;
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
