imay closed pull request #380: Unify Slice code path
URL: https://github.com/apache/incubator-doris/pull/380
This is a PR merged from a forked repository.
As GitHub hides the original diff on merge, it is displayed below for
the sake of provenance:
As this is a foreign pull request (from a fork), the diff is supplied
below (as it won't show otherwise due to GitHub magic):
diff --git a/be/src/exec/broker_scanner.cpp b/be/src/exec/broker_scanner.cpp
index 49f335e2..c60e3566 100644
--- a/be/src/exec/broker_scanner.cpp
+++ b/be/src/exec/broker_scanner.cpp
@@ -37,38 +37,6 @@
namespace doris {
-class Slice {
-public:
- Slice(const uint8_t* data, int size) : _data(data), _size(size) { }
- Slice(const std::string& str) : _data((const uint8_t*)str.data()),
_size(str.size()) { }
-
- ~Slice() {
- // No need to delete _begin, because it only record the index in a
std::string.
- // The c-string will be released along with the std::string object.
- }
-
- int size() const {
- return _size;
- }
-
- const uint8_t* data() const {
- return _data;
- }
-
- const uint8_t* end() const {
- return _data + _size;
- }
-private:
- friend std::ostream& operator<<(std::ostream& os, const Slice& slice);
- const uint8_t* _data;
- int _size;
-};
-
-std::ostream& operator<<(std::ostream& os, const Slice& slice) {
- os << std::string((const char*)slice._data, slice._size);
- return os;
-}
-
BrokerScanner::BrokerScanner(RuntimeState* state,
RuntimeProfile* profile,
const TBrokerScanRangeParams& params,
@@ -81,8 +49,8 @@ BrokerScanner::BrokerScanner(RuntimeState* state,
_ranges(ranges),
_broker_addresses(broker_addresses),
// _splittable(params.splittable),
- _value_separator(params.column_separator),
- _line_delimiter(params.line_delimiter),
+ _value_separator(static_cast<char>(params.column_separator)),
+ _line_delimiter(static_cast<char>(params.line_delimiter)),
_cur_file_reader(nullptr),
_cur_line_reader(nullptr),
_cur_decompressor(nullptr),
@@ -397,9 +365,9 @@ void BrokerScanner::close() {
void BrokerScanner::split_line(
const Slice& line, std::vector<Slice>* values) {
// line-begin char and line-end char are considered to be 'delimeter'
- const uint8_t* value = line.data();
- const uint8_t* ptr = line.data();
- for (size_t i = 0; i < line.size(); ++i, ++ptr) {
+ const char* value = line.data;
+ const char* ptr = line.data;
+ for (size_t i = 0; i < line.size; ++i, ++ptr) {
if (*ptr == _value_separator) {
values->emplace_back(value, ptr - value);
value = ptr + 1;
@@ -411,12 +379,12 @@ void BrokerScanner::split_line(
void BrokerScanner::fill_fix_length_string(
const Slice& value, MemPool* pool,
char** new_value_p, const int new_value_length) {
- if (new_value_length != 0 && value.size() < new_value_length) {
+ if (new_value_length != 0 && value.size < new_value_length) {
*new_value_p =
reinterpret_cast<char*>(pool->allocate(new_value_length));
// 'value' is guaranteed not to be nullptr
- memcpy(*new_value_p, value.data(), value.size());
- for (int i = value.size(); i < new_value_length; ++i) {
+ memcpy(*new_value_p, value.data, value.size);
+ for (int i = value.size; i < new_value_length; ++i) {
(*new_value_p)[i] = '\0';
}
}
@@ -430,13 +398,13 @@ bool BrokerScanner::check_decimal_input(
const Slice& slice,
int precision, int scale,
std::stringstream* error_msg) {
- const uint8_t* value = slice.data();
- int value_length = slice.size();
+ const char* value = slice.data;
+ size_t value_length = slice.size;
if (value_length > (precision + 2)) {
(*error_msg) << "the length of decimal value is overflow. "
<< "precision in schema: (" << precision << ", " << scale <<
"); "
- << "value: [" << slice << "]; "
+ << "value: [" << slice.to_string() << "]; "
<< "str actual length: " << value_length << ";";
return false;
}
@@ -479,21 +447,21 @@ bool BrokerScanner::check_decimal_input(
if (value_int_len > (precision - scale)) {
(*error_msg) << "the int part length longer than schema precision ["
<< precision << "]. "
- << "value [" << slice << "]. ";
+ << "value [" << slice.to_string() << "]. ";
return false;
} else if (value_frac_len > scale) {
(*error_msg) << "the frac part length longer than schema scale ["
<< scale << "]. "
- << "value [" << slice << "]. ";
+ << "value [" << slice.to_string() << "]. ";
return false;
}
return true;
}
bool is_null(const Slice& slice) {
- return slice.size() == 2 &&
- slice.data()[0] == '\\' &&
- slice.data()[1] == 'N';
+ return slice.size == 2 &&
+ slice.data[0] == '\\' &&
+ slice.data[1] == 'N';
}
// Writes a slot in _tuple from an value containing text data.
@@ -503,29 +471,29 @@ bool BrokerScanner::write_slot(
Tuple* tuple, MemPool* tuple_pool,
std::stringstream* error_msg) {
- if (value.size() == 0 && !slot->type().is_string_type()) {
+ if (value.size == 0 && !slot->type().is_string_type()) {
(*error_msg) << "the length of input should not be 0. "
<< "column_name: " << column_name << "; "
<< "type: " << slot->type();
return false;
}
- char* value_to_convert = (char*)value.data();
- int value_to_convert_length = value.size();
+ char* value_to_convert = value.data;
+ size_t value_to_convert_length = value.size;
// Fill all the spaces if it is 'TYPE_CHAR' type
if (slot->type().is_string_type()) {
int char_len = column_type.len;
- if (value.size() > char_len) {
+ if (value.size > char_len) {
(*error_msg) << "the length of input is too long than schema. "
<< "column_name: " << column_name << "; "
- << "input_str: [" << value << "] "
+ << "input_str: [" << value.to_string() << "] "
<< "type: " << slot->type() << "; "
<< "schema length: " << char_len << "; "
- << "actual length: " << value.size() << "; ";
+ << "actual length: " << value.size << "; ";
return false;
}
- if (slot->type().type == TYPE_CHAR && value.size() < char_len) {
+ if (slot->type().type == TYPE_CHAR && value.size < char_len) {
if (!is_null(value)) {
fill_fix_length_string(
value, tuple_pool,
@@ -547,7 +515,7 @@ bool BrokerScanner::write_slot(
(*error_msg) << "convert csv string to "
<< slot->type() << " failed. "
<< "column_name: " << column_name << "; "
- << "input_str: [" << value << "]; ";
+ << "input_str: [" << value.to_string() << "]; ";
return false;
}
@@ -576,7 +544,7 @@ bool BrokerScanner::line_to_src_tuple(const Slice& line) {
error_msg << "actual column number is less than schema column number. "
<< "actual number: " << values.size() << " sep: " <<
_value_separator << ", "
<< "schema number: " << _src_slot_descs.size() << "; ";
- _state->append_error_msg_to_file(std::string((const char*)line.data(),
line.size()),
+ _state->append_error_msg_to_file(std::string(line.data, line.size),
error_msg.str());
_counter->num_rows_filtered++;
return false;
@@ -585,7 +553,7 @@ bool BrokerScanner::line_to_src_tuple(const Slice& line) {
error_msg << "actual column number is more than schema column number. "
<< "actual number: " << values.size() << " sep: " <<
_value_separator << ", "
<< "schema number: " << _src_slot_descs.size() << "; ";
- _state->append_error_msg_to_file(std::string((const char*)line.data(),
line.size()),
+ _state->append_error_msg_to_file(std::string(line.data, line.size),
error_msg.str());
_counter->num_rows_filtered++;
return false;
@@ -601,8 +569,8 @@ bool BrokerScanner::line_to_src_tuple(const Slice& line) {
_src_tuple->set_not_null(slot_desc->null_indicator_offset());
void* slot = _src_tuple->get_slot(slot_desc->tuple_offset());
StringValue* str_slot = reinterpret_cast<StringValue*>(slot);
- str_slot->ptr = (char*)value.data();
- str_slot->len = value.size();
+ str_slot->ptr = value.data;
+ str_slot->len = value.size;
}
return true;
@@ -624,7 +592,7 @@ bool BrokerScanner::fill_dest_tuple(const Slice& line,
Tuple* dest_tuple, MemPoo
std::stringstream error_msg;
error_msg << "column(" << slot_desc->col_name() << ") value is
null";
_state->append_error_msg_to_file(
- std::string((const char*)line.data(), line.size()),
error_msg.str());
+ std::string(line.data, line.size), error_msg.str());
_counter->num_rows_filtered++;
return false;
}
diff --git a/be/src/exec/broker_scanner.h b/be/src/exec/broker_scanner.h
index 0f14c58e..26a84c7c 100644
--- a/be/src/exec/broker_scanner.h
+++ b/be/src/exec/broker_scanner.h
@@ -27,6 +27,7 @@
#include "gen_cpp/PlanNodes_types.h"
#include "gen_cpp/Types_types.h"
#include "runtime/mem_pool.h"
+#include "util/slice.h"
#include "util/runtime_profile.h"
namespace doris {
@@ -121,8 +122,8 @@ class BrokerScanner {
std::unique_ptr<TextConverter> _text_converter;
- uint8_t _value_separator;
- uint8_t _line_delimiter;
+ char _value_separator;
+ char _line_delimiter;
// Reader
FileReader* _cur_file_reader;
diff --git a/be/src/exec/olap_scanner.cpp b/be/src/exec/olap_scanner.cpp
index 31b92f9b..e3576b0d 100644
--- a/be/src/exec/olap_scanner.cpp
+++ b/be/src/exec/olap_scanner.cpp
@@ -361,7 +361,7 @@ void OlapScanner::_convert_row_to_tuple(Tuple* tuple) {
size_t len = field->size();
switch (slot_desc->type().type) {
case TYPE_CHAR: {
- StringSlice* slice = reinterpret_cast<StringSlice*>(ptr);
+ Slice* slice = reinterpret_cast<Slice*>(ptr);
StringValue *slot =
tuple->get_string_slot(slot_desc->tuple_offset());
slot->ptr = slice->data;
slot->len = strnlen(slot->ptr, slice->size);
@@ -369,7 +369,7 @@ void OlapScanner::_convert_row_to_tuple(Tuple* tuple) {
}
case TYPE_VARCHAR:
case TYPE_HLL: {
- StringSlice* slice = reinterpret_cast<StringSlice*>(ptr);
+ Slice* slice = reinterpret_cast<Slice*>(ptr);
StringValue *slot =
tuple->get_string_slot(slot_desc->tuple_offset());
slot->ptr = slice->data;
slot->len = slice->size;
diff --git a/be/src/olap/aggregate_func.h b/be/src/olap/aggregate_func.h
index 0d1f6e24..2c627952 100644
--- a/be/src/olap/aggregate_func.h
+++ b/be/src/olap/aggregate_func.h
@@ -198,8 +198,8 @@ struct AggregateFuncTraits<OLAP_FIELD_AGGREGATION_REPLACE,
OLAP_FIELD_TYPE_CHAR>
bool r_null = *reinterpret_cast<const bool*>(right);
*reinterpret_cast<bool*>(left) = r_null;
if (!r_null) {
- StringSlice* l_slice = reinterpret_cast<StringSlice*>(left + 1);
- const StringSlice* r_slice = reinterpret_cast<const
StringSlice*>(right + 1);
+ Slice* l_slice = reinterpret_cast<Slice*>(left + 1);
+ const Slice* r_slice = reinterpret_cast<const Slice*>(right + 1);
if (arena == nullptr || l_slice->size >= r_slice->size) {
memory_copy(l_slice->data, r_slice->data, r_slice->size);
l_slice->size = r_slice->size;
@@ -224,13 +224,13 @@ struct
AggregateFuncTraits<OLAP_FIELD_AGGREGATION_REPLACE, OLAP_FIELD_TYPE_VARCH
template <>
struct AggregateFuncTraits<OLAP_FIELD_AGGREGATION_HLL_UNION,
OLAP_FIELD_TYPE_HLL> {
static void aggregate(char* left, const char* right, Arena* arena) {
- StringSlice* l_slice = reinterpret_cast<StringSlice*>(left + 1);
+ Slice* l_slice = reinterpret_cast<Slice*>(left + 1);
size_t hll_ptr = *(size_t*)(l_slice->data - sizeof(HllContext*));
HllContext* context = (reinterpret_cast<HllContext*>(hll_ptr));
HllSetHelper::fill_set(right + 1, context);
}
static void finalize(char* data) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(data);
+ Slice* slice = reinterpret_cast<Slice*>(data);
size_t hll_ptr = *(size_t*)(slice->data - sizeof(HllContext*));
HllContext* context = (reinterpret_cast<HllContext*>(hll_ptr));
std::map<int, uint8_t> index_to_value;
diff --git a/be/src/olap/column_reader.cpp b/be/src/olap/column_reader.cpp
index d5dd6070..38e9cd35 100644
--- a/be/src/olap/column_reader.cpp
+++ b/be/src/olap/column_reader.cpp
@@ -106,7 +106,7 @@ OLAPStatus StringColumnDirectReader::init(
return OLAP_ERR_COLUMN_STREAM_NOT_EXIST;
}
- _values = reinterpret_cast<StringSlice*>(mem_pool->allocate(size *
sizeof(StringSlice)));
+ _values = reinterpret_cast<Slice*>(mem_pool->allocate(size *
sizeof(Slice)));
ReadOnlyFileStream* length_stream = extract_stream(_column_unique_id,
StreamInfoMessage::LENGTH,
@@ -436,7 +436,7 @@ OLAPStatus StringColumnDictionaryReader::init(
}
*/
- _values = reinterpret_cast<StringSlice*>(mem_pool->allocate(size *
sizeof(StringSlice)));
+ _values = reinterpret_cast<Slice*>(mem_pool->allocate(size *
sizeof(Slice)));
int64_t read_buffer_size = 1024;
char* _read_buffer = new(std::nothrow) char[read_buffer_size];
diff --git a/be/src/olap/column_reader.h b/be/src/olap/column_reader.h
index 3deb8900..566dde1d 100644
--- a/be/src/olap/column_reader.h
+++ b/be/src/olap/column_reader.h
@@ -123,7 +123,7 @@ class StringColumnDirectReader {
private:
bool _eof;
uint32_t _column_unique_id;
- StringSlice* _values;
+ Slice* _values;
ReadOnlyFileStream* _data_stream;
RunLengthIntegerReader* _length_reader;
};
@@ -158,7 +158,7 @@ class StringColumnDictionaryReader {
bool _eof;
uint32_t _dictionary_size;
uint32_t _column_unique_id;
- StringSlice* _values;
+ Slice* _values;
char* _read_buffer;
//uint64_t _dictionary_size;
//uint64_t* _offset_dictionary; // 用来查找响应数据的数字对应的offset
@@ -335,27 +335,27 @@ class DefaultValueReader : public ColumnReader {
}
case OLAP_FIELD_TYPE_CHAR: {
_values =
- reinterpret_cast<void*>(mem_pool->allocate(size *
sizeof(StringSlice)));
+ reinterpret_cast<void*>(mem_pool->allocate(size *
sizeof(Slice)));
int32_t length = _length;
char* string_buffer =
reinterpret_cast<char*>(mem_pool->allocate(size * length));
memset(string_buffer, 0, size * length);
for (int i = 0; i < size; ++i) {
memory_copy(string_buffer, _default_value.c_str(),
_default_value.length());
- ((StringSlice*)_values)[i].size = length;
- ((StringSlice*)_values)[i].data = string_buffer;
+ ((Slice*)_values)[i].size = length;
+ ((Slice*)_values)[i].data = string_buffer;
string_buffer += length;
}
break;
}
case OLAP_FIELD_TYPE_VARCHAR: {
_values =
- reinterpret_cast<void*>(mem_pool->allocate(size *
sizeof(StringSlice)));
+ reinterpret_cast<void*>(mem_pool->allocate(size *
sizeof(Slice)));
int32_t length = _default_value.length();
char* string_buffer =
reinterpret_cast<char*>(mem_pool->allocate(size * length));
for (int i = 0; i < size; ++i) {
memory_copy(string_buffer, _default_value.c_str(), length);
- ((StringSlice*)_values)[i].size = length;
- ((StringSlice*)_values)[i].data = string_buffer;
+ ((Slice*)_values)[i].size = length;
+ ((Slice*)_values)[i].data = string_buffer;
string_buffer += length;
}
break;
diff --git a/be/src/olap/column_writer.cpp b/be/src/olap/column_writer.cpp
index a95f5390..91ed9291 100755
--- a/be/src/olap/column_writer.cpp
+++ b/be/src/olap/column_writer.cpp
@@ -266,7 +266,7 @@ OLAPStatus ColumnWriter::write(RowCursor* row_cursor) {
_field_info.type == OLAP_FIELD_TYPE_VARCHAR ||
_field_info.type == OLAP_FIELD_TYPE_HLL)
{
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
_bf->add_bytes(slice->data, slice->size);
} else {
_bf->add_bytes(buf, field->size());
diff --git a/be/src/olap/column_writer.h b/be/src/olap/column_writer.h
index 82b36412..4ec0e538 100644
--- a/be/src/olap/column_writer.h
+++ b/be/src/olap/column_writer.h
@@ -438,7 +438,7 @@ class VarStringColumnWriter : public ColumnWriter {
bool is_null = field->is_null(cursor->get_buf());
if (!is_null) {
char* buf = field->get_ptr(cursor->get_buf());
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
res = write(slice->data, slice->size);
if (res != OLAP_SUCCESS) {
LOG(WARNING) << "fail to write varchar, res=" << res;
@@ -521,7 +521,7 @@ class FixLengthStringColumnWriter : public
VarStringColumnWriter {
if (!is_null) {
//const char* str = reinterpret_cast<const char*>(buf);
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
res = VarStringColumnWriter::write(slice->data, slice->size);
if (res != OLAP_SUCCESS) {
LOG(WARNING) << "fail to write fix-length string, res=" <<
res;
diff --git a/be/src/olap/field.cpp b/be/src/olap/field.cpp
index a18cd665..42562e71 100644
--- a/be/src/olap/field.cpp
+++ b/be/src/olap/field.cpp
@@ -58,7 +58,7 @@ Field::Field(const FieldInfo& field_info)
_type_info = get_type_info(field_info.type);
if (_type == OLAP_FIELD_TYPE_CHAR || _type == OLAP_FIELD_TYPE_VARCHAR
|| _type == OLAP_FIELD_TYPE_HLL) {
- _size = sizeof(StringSlice);
+ _size = sizeof(Slice);
} else {
/*
* the field_info.size and field_info.index_length is equal to zero,
diff --git a/be/src/olap/field.h b/be/src/olap/field.h
index dddd4312..1688a328 100644
--- a/be/src/olap/field.h
+++ b/be/src/olap/field.h
@@ -24,12 +24,12 @@
#include "olap/field_info.h"
#include "olap/olap_common.h"
#include "olap/olap_define.h"
-#include "olap/string_slice.h"
#include "olap/types.h"
#include "olap/utils.h"
#include "runtime/mem_pool.h"
#include "util/hash_util.hpp"
#include "util/mem_util.hpp"
+#include "util/slice.h"
namespace doris {
@@ -151,8 +151,8 @@ inline int Field::index_cmp(char* left, char* right) const {
int32_t res = 0;
if (_type == OLAP_FIELD_TYPE_VARCHAR) {
- StringSlice* l_slice = reinterpret_cast<StringSlice*>(left + 1);
- StringSlice* r_slice = reinterpret_cast<StringSlice*>(right + 1);
+ Slice* l_slice = reinterpret_cast<Slice*>(left + 1);
+ Slice* r_slice = reinterpret_cast<Slice*>(right + 1);
if (r_slice->size + OLAP_STRING_MAX_BYTES > _index_size) {
// 如果field的实际长度比short key长，则仅比较前缀，确保相同short key的所有block都被扫描，
@@ -225,7 +225,7 @@ inline void Field::agg_init(char* dest, const char* src) {
} else {
bool is_null = *reinterpret_cast<const bool*>(src);
*reinterpret_cast<bool*>(dest) = is_null;
- StringSlice* slice = reinterpret_cast<StringSlice*>(dest + 1);
+ Slice* slice = reinterpret_cast<Slice*>(dest + 1);
size_t hll_ptr = *(size_t*)(slice->data - sizeof(HllContext*));
HllContext* context = (reinterpret_cast<HllContext*>(hll_ptr));
HllSetHelper::init_context(context);
@@ -244,7 +244,7 @@ inline void Field::to_index(char* dest, const char* src) {
if (_type == OLAP_FIELD_TYPE_VARCHAR) {
// 先清零，再拷贝
memset(dest + 1, 0, _index_size);
- const StringSlice* slice = reinterpret_cast<const StringSlice*>(src +
1);
+ const Slice* slice = reinterpret_cast<const Slice*>(src + 1);
size_t copy_size = slice->size < _index_size - OLAP_STRING_MAX_BYTES ?
slice->size : _index_size - OLAP_STRING_MAX_BYTES;
*reinterpret_cast<StringLengthType*>(dest + 1) = copy_size;
@@ -252,7 +252,7 @@ inline void Field::to_index(char* dest, const char* src) {
} else if (_type == OLAP_FIELD_TYPE_CHAR) {
// 先清零，再拷贝
memset(dest + 1, 0, _index_size);
- const StringSlice* slice = reinterpret_cast<const StringSlice*>(src +
1);
+ const Slice* slice = reinterpret_cast<const Slice*>(src + 1);
memory_copy(dest + 1, slice->data, _index_size);
} else {
memory_copy(dest + 1, src + 1, size());
diff --git a/be/src/olap/hll.cpp b/be/src/olap/hll.cpp
index c26f0ac1..39e53418 100644
--- a/be/src/olap/hll.cpp
+++ b/be/src/olap/hll.cpp
@@ -22,7 +22,7 @@
#include <sstream>
#include <string>
-#include "olap/string_slice.h"
+#include "util/slice.h"
using std::map;
using std::nothrow;
@@ -209,7 +209,7 @@ void HllSetHelper::set_max_register(char* registers, int
registers_len,
void HllSetHelper::fill_set(const char* data, HllContext* context) {
HllSetResolver resolver;
- const StringSlice* slice = reinterpret_cast<const StringSlice*>(data);
+ const Slice* slice = reinterpret_cast<const Slice*>(data);
resolver.init(slice->data, slice->size);
resolver.parse();
if (resolver.get_hll_data_type() == HLL_DATA_EXPLICIT) {
diff --git a/be/src/olap/memtable.cpp b/be/src/olap/memtable.cpp
index 0f62e05e..f145ef02 100644
--- a/be/src/olap/memtable.cpp
+++ b/be/src/olap/memtable.cpp
@@ -71,7 +71,7 @@ void MemTable::insert(Tuple* tuple) {
switch (type.type) {
case TYPE_CHAR: {
const StringValue* src =
tuple->get_string_slot(slot->tuple_offset());
- StringSlice* dest = (StringSlice*)(_tuple_buf + offset);
+ Slice* dest = (Slice*)(_tuple_buf + offset);
dest->size = (*_field_infos)[i].length;
dest->data = _arena.Allocate(dest->size);
memcpy(dest->data, src->ptr, src->len);
@@ -80,7 +80,7 @@ void MemTable::insert(Tuple* tuple) {
}
case TYPE_VARCHAR: {
const StringValue* src =
tuple->get_string_slot(slot->tuple_offset());
- StringSlice* dest = (StringSlice*)(_tuple_buf + offset);
+ Slice* dest = (Slice*)(_tuple_buf + offset);
dest->size = src->len;
dest->data = _arena.Allocate(dest->size);
memcpy(dest->data, src->ptr, dest->size);
@@ -88,7 +88,7 @@ void MemTable::insert(Tuple* tuple) {
}
case TYPE_HLL: {
const StringValue* src =
tuple->get_string_slot(slot->tuple_offset());
- StringSlice* dest = (StringSlice*)(_tuple_buf + offset);
+ Slice* dest = (Slice*)(_tuple_buf + offset);
dest->size = src->len;
bool exist = _skip_list->Contains(_tuple_buf);
if (exist) {
diff --git a/be/src/olap/new_status.cpp b/be/src/olap/new_status.cpp
index ef9e79da..3fcb1954 100644
--- a/be/src/olap/new_status.cpp
+++ b/be/src/olap/new_status.cpp
@@ -39,7 +39,7 @@ NewStatus IOError(const std::string& context, int err) {
return NewStatus::IOError(context, ErrnoToString(err), err);
}
-NewStatus::NewStatus(Code code, const StringSlice& msg, const StringSlice&
msg2, int32_t posix_code)
+NewStatus::NewStatus(Code code, const Slice& msg, const Slice& msg2, int32_t
posix_code)
: _code(code), _posix_code(posix_code) {
DCHECK(code != kOk);
const uint32_t len1 = msg.size;
diff --git a/be/src/olap/new_status.h b/be/src/olap/new_status.h
index 8d694815..73e1cad6 100644
--- a/be/src/olap/new_status.h
+++ b/be/src/olap/new_status.h
@@ -6,7 +6,7 @@
#define DORIS_BE_SRC_OLAP_STATUS_H
#include <string>
-#include "olap/string_slice.h"
+#include "util/slice.h"
namespace doris {
@@ -30,51 +30,51 @@ class NewStatus {
static NewStatus OK() { return NewStatus(); }
// Return error status of an appropriate type.
- static NewStatus NotFound(const StringSlice& msg, const StringSlice& msg2
= StringSlice(),
+ static NewStatus NotFound(const Slice& msg, const Slice& msg2 = Slice(),
int32_t posix_code = -1) {
return NewStatus(kNotFound, msg, msg2, posix_code);
}
- static NewStatus Corruption(const StringSlice& msg, const StringSlice&
msg2 = StringSlice(),
+ static NewStatus Corruption(const Slice& msg, const Slice& msg2 = Slice(),
int32_t posix_code = -1) {
return NewStatus(kCorruption, msg, msg2, posix_code);
}
- static NewStatus NotSupported(const StringSlice& msg, const StringSlice&
msg2 = StringSlice(),
+ static NewStatus NotSupported(const Slice& msg, const Slice& msg2 =
Slice(),
int32_t posix_code = -1) {
return NewStatus(kNotSupported, msg, msg2, posix_code);
}
- static NewStatus InvalidArgument(const StringSlice& msg, const
StringSlice& msg2 = StringSlice(),
+ static NewStatus InvalidArgument(const Slice& msg, const Slice& msg2 =
Slice(),
int32_t posix_code = -1) {
return NewStatus(kInvalidArgument, msg, msg2, posix_code);
}
- static NewStatus AlreadyExist(const StringSlice& msg, const StringSlice&
msg2 = StringSlice(),
+ static NewStatus AlreadyExist(const Slice& msg, const Slice& msg2 =
Slice(),
int32_t posix_code = -1) {
return NewStatus(kAlreadyExist, msg, msg2, posix_code);
}
- static NewStatus NoSpace(const StringSlice& msg, const StringSlice& msg2 =
StringSlice(),
+ static NewStatus NoSpace(const Slice& msg, const Slice& msg2 = Slice(),
int32_t posix_code = -1) {
return NewStatus(kNoSpace, msg, msg2, posix_code);
}
- static NewStatus EndOfFile(const StringSlice& msg, const StringSlice& msg2
= StringSlice(),
+ static NewStatus EndOfFile(const Slice& msg, const Slice& msg2 = Slice(),
int32_t posix_code = -1) {
return NewStatus(kEndOfFile, msg, msg2, posix_code);
}
- static NewStatus DiskFailure(const StringSlice& msg, const StringSlice&
msg2 = StringSlice(),
+ static NewStatus DiskFailure(const Slice& msg, const Slice& msg2 = Slice(),
int32_t posix_code = -1) {
return NewStatus(kDiskFailure, msg, msg2, posix_code);
}
- static NewStatus IOError(const StringSlice& msg, const StringSlice& msg2 =
StringSlice(),
+ static NewStatus IOError(const Slice& msg, const Slice& msg2 = Slice(),
int32_t posix_code = -1) {
return NewStatus(kIOError, msg, msg2, posix_code);
}
- static NewStatus TimedOut(const StringSlice& msg, const StringSlice& msg2
= StringSlice(),
+ static NewStatus TimedOut(const Slice& msg, const Slice& msg2 = Slice(),
int32_t posix_code = -1) {
return NewStatus(kTimedOut, msg, msg2, posix_code);
}
- static NewStatus MemoryLimitExceeded(const StringSlice& msg, const
StringSlice& msg2 = StringSlice(),
+ static NewStatus MemoryLimitExceeded(const Slice& msg, const Slice& msg2 =
Slice(),
int32_t posix_code = -1) {
return NewStatus(kMemoryLimitExceeded, msg, msg2, posix_code);
}
- static NewStatus DeadLock(const StringSlice& msg, const StringSlice& msg2
= StringSlice(),
+ static NewStatus DeadLock(const Slice& msg, const Slice& msg2 = Slice(),
int32_t posix_code = -1) {
return NewStatus(kDeadLock, msg, msg2, posix_code);
}
@@ -159,7 +159,7 @@ class NewStatus {
// _state[4..] == message
const char* _state;
- NewStatus(Code code, const StringSlice& msg, const StringSlice& msg2,
int32_t posix_code);
+ NewStatus(Code code, const Slice& msg, const Slice& msg2, int32_t
posix_code);
static const char* CopyState(const char* s);
};
diff --git a/be/src/olap/olap_cond.cpp b/be/src/olap/olap_cond.cpp
index b11e4c1c..0b94a0a6 100644
--- a/be/src/olap/olap_cond.cpp
+++ b/be/src/olap/olap_cond.cpp
@@ -431,7 +431,7 @@ bool Cond::eval(const BloomFilter& bf) const {
case OP_EQ: {
bool existed = false;
if (operand_field->is_string_type()) {
- StringSlice* slice = (StringSlice*)(operand_field->ptr());
+ Slice* slice = (Slice*)(operand_field->ptr());
existed = bf.test_bytes(slice->data, slice->size);
} else {
existed = bf.test_bytes(operand_field->ptr(),
operand_field->size());
@@ -443,7 +443,7 @@ bool Cond::eval(const BloomFilter& bf) const {
for (; it != operand_set.end(); ++it) {
bool existed = false;
if ((*it)->is_string_type()) {
- StringSlice* slice = (StringSlice*)((*it)->ptr());
+ Slice* slice = (Slice*)((*it)->ptr());
existed = bf.test_bytes(slice->data, slice->size);
} else {
existed = bf.test_bytes((*it)->ptr(), (*it)->size());
diff --git a/be/src/olap/olap_index.cpp b/be/src/olap/olap_index.cpp
index bbc55e63..5fbc81cf 100644
--- a/be/src/olap/olap_index.cpp
+++ b/be/src/olap/olap_index.cpp
@@ -191,7 +191,7 @@ OLAPStatus MemIndex::load_segment(const char* file, size_t
*current_num_rows_per
storage_field_offset += (*_fields)[i].index_length + null_byte;
mem_ptr = mem_buf + mem_field_offset;
if ((*_fields)[i].type == OLAP_FIELD_TYPE_VARCHAR) {
- mem_field_offset += sizeof(StringSlice) + 1;
+ mem_field_offset += sizeof(Slice) + 1;
for (size_t j = 0; j < num_entries; ++j) {
/*
* Varchar is null_byte|length|content in OlapIndex storage
@@ -207,7 +207,7 @@ OLAPStatus MemIndex::load_segment(const char* file, size_t
*current_num_rows_per
// 2. copy length and content
size_t storage_field_bytes =
*reinterpret_cast<StringLengthType*>(storage_ptr +
null_byte);
- StringSlice* slice = reinterpret_cast<StringSlice*>(mem_ptr +
1);
+ Slice* slice = reinterpret_cast<Slice*>(mem_ptr + 1);
char* data =
reinterpret_cast<char*>(_mem_pool->allocate(storage_field_bytes));
memory_copy(data, storage_ptr + sizeof(StringLengthType) +
null_byte, storage_field_bytes);
slice->data = data;
@@ -217,7 +217,7 @@ OLAPStatus MemIndex::load_segment(const char* file, size_t
*current_num_rows_per
storage_ptr += storage_row_bytes;
}
} else if ((*_fields)[i].type == OLAP_FIELD_TYPE_CHAR) {
- mem_field_offset += sizeof(StringSlice) + 1;
+ mem_field_offset += sizeof(Slice) + 1;
size_t storage_field_bytes = (*_fields)[i].index_length;
for (size_t j = 0; j < num_entries; ++j) {
/*
@@ -232,7 +232,7 @@ OLAPStatus MemIndex::load_segment(const char* file, size_t
*current_num_rows_per
memory_copy(mem_ptr, storage_ptr, null_byte);
// 2. copy length and content
- StringSlice* slice = reinterpret_cast<StringSlice*>(mem_ptr +
1);
+ Slice* slice = reinterpret_cast<Slice*>(mem_ptr + 1);
char* data =
reinterpret_cast<char*>(_mem_pool->allocate(storage_field_bytes));
memory_copy(data, storage_ptr + null_byte,
storage_field_bytes);
slice->data = data;
diff --git a/be/src/olap/push_handler.cpp b/be/src/olap/push_handler.cpp
index ce89abc4..a51c7950 100644
--- a/be/src/olap/push_handler.cpp
+++ b/be/src/olap/push_handler.cpp
@@ -1060,7 +1060,7 @@ OLAPStatus BinaryReader::next(RowCursor* row, MemPool*
mem_pool) {
if (schema[i].type == OLAP_FIELD_TYPE_CHAR
|| schema[i].type == OLAP_FIELD_TYPE_VARCHAR
|| schema[i].type == OLAP_FIELD_TYPE_HLL) {
- StringSlice slice(_row_buf + offset, field_size);
+ Slice slice(_row_buf + offset, field_size);
row->set_field_content(i, reinterpret_cast<char*>(&slice),
mem_pool);
} else {
row->set_field_content(i, _row_buf + offset, mem_pool);
@@ -1183,7 +1183,7 @@ OLAPStatus LzoBinaryReader::next(RowCursor* row, MemPool*
mem_pool) {
if (schema[i].type == OLAP_FIELD_TYPE_CHAR
|| schema[i].type == OLAP_FIELD_TYPE_VARCHAR
|| schema[i].type == OLAP_FIELD_TYPE_HLL) {
- StringSlice slice(_row_buf + _next_row_start + offset, field_size);
+ Slice slice(_row_buf + _next_row_start + offset, field_size);
row->set_field_content(i, reinterpret_cast<char*>(&slice),
mem_pool);
} else {
row->set_field_content(i, _row_buf + _next_row_start + offset,
mem_pool);
diff --git a/be/src/olap/row_block.cpp b/be/src/olap/row_block.cpp
index 614041b6..eddef5e1 100644
--- a/be/src/olap/row_block.cpp
+++ b/be/src/olap/row_block.cpp
@@ -141,7 +141,7 @@ void RowBlock::_convert_storage_to_memory() {
size_t storage_field_bytes =
*(StringLengthType*)(value_ptr + null_byte);
value_ptr += sizeof(StringLengthType);
- StringSlice* slice = reinterpret_cast<StringSlice*>(memory_ptr
+ 1);
+ Slice* slice = reinterpret_cast<Slice*>(memory_ptr + 1);
slice->data = value_ptr + null_byte;
slice->size = storage_field_bytes;
@@ -163,7 +163,7 @@ void RowBlock::_convert_storage_to_memory() {
memory_copy(memory_ptr, storage_ptr, null_byte);
// 2. copy length and content
- StringSlice* slice = reinterpret_cast<StringSlice*>(memory_ptr
+ 1);
+ Slice* slice = reinterpret_cast<Slice*>(memory_ptr + 1);
slice->data = storage_ptr + null_byte;
slice->size = storage_field_bytes;
@@ -215,7 +215,7 @@ void RowBlock::_convert_memory_to_storage(uint32_t
num_rows) {
storage_variable_ptr += null_byte;
// 3. copy length and content
- StringSlice* slice = reinterpret_cast<StringSlice*>(memory_ptr
+ 1);
+ Slice* slice = reinterpret_cast<Slice*>(memory_ptr + 1);
*reinterpret_cast<StringLengthType*>(storage_variable_ptr) =
slice->size;
storage_variable_ptr += sizeof(StringLengthType);
memory_copy(storage_variable_ptr, slice->data, slice->size);
@@ -238,7 +238,7 @@ void RowBlock::_convert_memory_to_storage(uint32_t
num_rows) {
memory_copy(storage_ptr, memory_ptr, null_byte);
// 2. copy content
- StringSlice* slice = reinterpret_cast<StringSlice*>(memory_ptr
+ 1);
+ Slice* slice = reinterpret_cast<Slice*>(memory_ptr + 1);
memory_copy(storage_ptr + null_byte, slice->data, slice->size);
memory_ptr += _mem_row_bytes;
storage_ptr += storage_field_bytes + null_byte;
@@ -328,14 +328,14 @@ void RowBlock::_compute_layout() {
if (has_nullbyte()) {
storage_variable_bytes += sizeof(char);
}
- memory_size += sizeof(StringSlice) + sizeof(char);
+ memory_size += sizeof(Slice) + sizeof(char);
} else {
storage_fixed_bytes += field.length;
if (has_nullbyte()) {
storage_fixed_bytes += sizeof(char);
}
if (field.type == OLAP_FIELD_TYPE_CHAR) {
- memory_size += sizeof(StringSlice) + sizeof(char);
+ memory_size += sizeof(Slice) + sizeof(char);
} else {
memory_size += field.length + sizeof(char);
}
diff --git a/be/src/olap/row_cursor.cpp b/be/src/olap/row_cursor.cpp
index 5d395fb0..71d7c5c8 100644
--- a/be/src/olap/row_cursor.cpp
+++ b/be/src/olap/row_cursor.cpp
@@ -60,7 +60,7 @@ OLAPStatus RowCursor::_init(const std::vector<FieldInfo>&
tablet_schema,
if (type == OLAP_FIELD_TYPE_CHAR ||
type == OLAP_FIELD_TYPE_VARCHAR ||
type == OLAP_FIELD_TYPE_HLL) {
- field_buf_lens.push_back(sizeof(StringSlice));
+ field_buf_lens.push_back(sizeof(Slice));
} else {
field_buf_lens.push_back(tablet_schema[i].length);
}
@@ -185,12 +185,12 @@ OLAPStatus RowCursor::init_scan_key(const
std::vector<FieldInfo>& tablet_schema,
fixed_ptr = _fixed_buf + _field_array[cid]->get_offset();
FieldType type = tablet_schema[cid].type;
if (type == OLAP_FIELD_TYPE_VARCHAR) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(fixed_ptr + 1);
+ Slice* slice = reinterpret_cast<Slice*>(fixed_ptr + 1);
slice->data = variable_ptr;
slice->size = scan_keys[cid].length();
variable_ptr += scan_keys[cid].length();
} else if (type == OLAP_FIELD_TYPE_CHAR) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(fixed_ptr + 1);
+ Slice* slice = reinterpret_cast<Slice*>(fixed_ptr + 1);
slice->data = variable_ptr;
slice->size = std::max(scan_keys[cid].length(),
(size_t)(tablet_schema[cid].length));
variable_ptr += slice->size;
@@ -228,17 +228,17 @@ OLAPStatus RowCursor::allocate_memory_for_string_type(
fixed_ptr = _fixed_buf + _field_array[cid]->get_offset();
FieldType type = tablet_schema[cid].type;
if (type == OLAP_FIELD_TYPE_VARCHAR) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(fixed_ptr + 1);
+ Slice* slice = reinterpret_cast<Slice*>(fixed_ptr + 1);
slice->data = variable_ptr;
slice->size = tablet_schema[cid].length - OLAP_STRING_MAX_BYTES;
variable_ptr += slice->size;
} else if (type == OLAP_FIELD_TYPE_CHAR) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(fixed_ptr + 1);
+ Slice* slice = reinterpret_cast<Slice*>(fixed_ptr + 1);
slice->data = variable_ptr;
slice->size = tablet_schema[cid].length;
variable_ptr += slice->size;
} else if (type == OLAP_FIELD_TYPE_HLL) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(fixed_ptr + 1);
+ Slice* slice = reinterpret_cast<Slice*>(fixed_ptr + 1);
HllContext* context = nullptr;
if (mem_pool != nullptr) {
char* mem =
reinterpret_cast<char*>(mem_pool->allocate(sizeof(HllContext)));
diff --git a/be/src/olap/schema_change.cpp b/be/src/olap/schema_change.cpp
index 45c8744c..89ebc6e4 100644
--- a/be/src/olap/schema_change.cpp
+++ b/be/src/olap/schema_change.cpp
@@ -289,7 +289,7 @@ bool RowBlockChanger::change_row_block(
write_helper.set_not_null(i);
int p = ref_block.tablet_schema()[ref_column].length -
1;
- StringSlice* slice =
reinterpret_cast<StringSlice*>(field_to_read->get_ptr(read_helper.get_buf()));
+ Slice* slice =
reinterpret_cast<Slice*>(field_to_read->get_ptr(read_helper.get_buf()));
char* buf = slice->data;
while (p >= 0 && buf[p] == '\0') {
p--;
diff --git a/be/src/olap/segment_group.cpp b/be/src/olap/segment_group.cpp
index 07ec48d7..a5c24c0f 100644
--- a/be/src/olap/segment_group.cpp
+++ b/be/src/olap/segment_group.cpp
@@ -87,7 +87,7 @@ SegmentGroup::SegmentGroup(OLAPTable* table, Version version,
VersionHash versio
_short_key_length += tablet_schema[i].index_length + 1;// 1 for null
byte
if (tablet_schema[i].type == OLAP_FIELD_TYPE_CHAR ||
tablet_schema[i].type == OLAP_FIELD_TYPE_VARCHAR) {
- _new_short_key_length += sizeof(StringSlice) + 1;
+ _new_short_key_length += sizeof(Slice) + 1;
} else {
_new_short_key_length += tablet_schema[i].index_length + 1;
}
@@ -121,7 +121,7 @@ SegmentGroup::SegmentGroup(OLAPTable* table, bool
delete_flag,
_short_key_length += tablet_schema[i].index_length + 1;// 1 for null
byte
if (tablet_schema[i].type == OLAP_FIELD_TYPE_CHAR ||
tablet_schema[i].type == OLAP_FIELD_TYPE_VARCHAR) {
- _new_short_key_length += sizeof(StringSlice) + 1;
+ _new_short_key_length += sizeof(Slice) + 1;
} else {
_new_short_key_length += tablet_schema[i].index_length + 1;
}
diff --git a/be/src/olap/types.h b/be/src/olap/types.h
index 66231a8d..fe234d93 100644
--- a/be/src/olap/types.h
+++ b/be/src/olap/types.h
@@ -28,10 +28,10 @@
#include "olap/olap_common.h"
#include "olap/olap_define.h"
#include "olap/field_info.h"
-#include "olap/string_slice.h"
#include "runtime/mem_pool.h"
#include "util/hash_util.hpp"
#include "util/mem_util.hpp"
+#include "util/slice.h"
#include "util/types.h"
namespace doris {
@@ -708,18 +708,18 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DATETIME> {
template<>
struct FieldTypeTraits<OLAP_FIELD_TYPE_CHAR> {
- typedef StringSlice CppType;
+ typedef Slice CppType;
static const char* name() {
return "char";
}
static int equal(const void* left, const void* right) {
- const StringSlice* l_slice = reinterpret_cast<const
StringSlice*>(left);
- const StringSlice* r_slice = reinterpret_cast<const
StringSlice*>(right);
+ const Slice* l_slice = reinterpret_cast<const Slice*>(left);
+ const Slice* r_slice = reinterpret_cast<const Slice*>(right);
return *l_slice == *r_slice;
}
static int cmp(const void* left, const void* right) {
- const StringSlice* l_slice = reinterpret_cast<const
StringSlice*>(left);
- const StringSlice* r_slice = reinterpret_cast<const
StringSlice*>(right);
+ const Slice* l_slice = reinterpret_cast<const Slice*>(left);
+ const Slice* r_slice = reinterpret_cast<const Slice*>(right);
return l_slice->compare(*r_slice);
}
static OLAPStatus from_string(char* buf, const std::string& scan_key) {
@@ -730,7 +730,7 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_CHAR> {
return OLAP_ERR_INPUT_PARAMETER_ERROR;
}
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
memory_copy(slice->data, scan_key.c_str(), value_len);
if (slice->size < value_len) {
/*
@@ -743,34 +743,34 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_CHAR> {
return OLAP_SUCCESS;
}
static std::string to_string(char* src) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(src);
+ Slice* slice = reinterpret_cast<Slice*>(src);
return slice->to_string();
}
static void copy_with_pool(char* dest, const char* src, MemPool* mem_pool)
{
- StringSlice* l_slice = reinterpret_cast<StringSlice*>(dest);
- const StringSlice* r_slice = reinterpret_cast<const StringSlice*>(src);
+ Slice* l_slice = reinterpret_cast<Slice*>(dest);
+ const Slice* r_slice = reinterpret_cast<const Slice*>(src);
l_slice->data =
reinterpret_cast<char*>(mem_pool->allocate(r_slice->size));
memory_copy(l_slice->data, r_slice->data, r_slice->size);
l_slice->size = r_slice->size;
}
static void copy_without_pool(char* dest, const char* src) {
- StringSlice* l_slice = reinterpret_cast<StringSlice*>(dest);
- const StringSlice* r_slice = reinterpret_cast<const StringSlice*>(src);
+ Slice* l_slice = reinterpret_cast<Slice*>(dest);
+ const Slice* r_slice = reinterpret_cast<const Slice*>(src);
memory_copy(l_slice->data, r_slice->data, r_slice->size);
l_slice->size = r_slice->size;
}
static void set_to_max(char* buf) {
// this function is used by scan key,
// the size may be greater than length in schema.
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
memset(slice->data, 0xff, slice->size);
}
static void set_to_min(char* buf) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
memset(slice->data, 0, slice->size);
}
static bool is_min(char* buf) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
size_t i = 0;
while (i < slice->size) {
if (slice->data[i] != '\0') {
@@ -781,25 +781,25 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_CHAR> {
return true;
}
static uint32_t hash_code(char* data, uint32_t seed) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(data);
+ Slice* slice = reinterpret_cast<Slice*>(data);
return HashUtil::hash(slice->data, slice->size, seed);
}
};
template<>
struct FieldTypeTraits<OLAP_FIELD_TYPE_VARCHAR> {
- typedef StringSlice CppType;
+ typedef Slice CppType;
static const char* name() {
return "varchar";
}
static int equal(const void* left, const void* right) {
- const StringSlice* l_slice = reinterpret_cast<const
StringSlice*>(left);
- const StringSlice* r_slice = reinterpret_cast<const
StringSlice*>(right);
+ const Slice* l_slice = reinterpret_cast<const Slice*>(left);
+ const Slice* r_slice = reinterpret_cast<const Slice*>(right);
return *l_slice == *r_slice;
}
static int cmp(const void* left, const void* right) {
- const StringSlice* l_slice = reinterpret_cast<const
StringSlice*>(left);
- const StringSlice* r_slice = reinterpret_cast<const
StringSlice*>(right);
+ const Slice* l_slice = reinterpret_cast<const Slice*>(left);
+ const Slice* r_slice = reinterpret_cast<const Slice*>(right);
return l_slice->compare(*r_slice);
}
static OLAPStatus from_string(char* buf, const std::string& scan_key) {
@@ -810,44 +810,44 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_VARCHAR> {
return OLAP_ERR_INPUT_PARAMETER_ERROR;
}
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
memory_copy(slice->data, scan_key.c_str(), value_len);
slice->size = value_len;
return OLAP_SUCCESS;
}
static std::string to_string(char* src) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(src);
+ Slice* slice = reinterpret_cast<Slice*>(src);
return slice->to_string();
}
static void copy_with_pool(char* dest, const char* src, MemPool* mem_pool)
{
- StringSlice* l_slice = reinterpret_cast<StringSlice*>(dest);
- const StringSlice* r_slice = reinterpret_cast<const StringSlice*>(src);
+ Slice* l_slice = reinterpret_cast<Slice*>(dest);
+ const Slice* r_slice = reinterpret_cast<const Slice*>(src);
l_slice->data =
reinterpret_cast<char*>(mem_pool->allocate(r_slice->size));
memory_copy(l_slice->data, r_slice->data, r_slice->size);
l_slice->size = r_slice->size;
}
static void copy_without_pool(char* dest, const char* src) {
- StringSlice* l_slice = reinterpret_cast<StringSlice*>(dest);
- const StringSlice* r_slice = reinterpret_cast<const StringSlice*>(src);
+ Slice* l_slice = reinterpret_cast<Slice*>(dest);
+ const Slice* r_slice = reinterpret_cast<const Slice*>(src);
memory_copy(l_slice->data, r_slice->data, r_slice->size);
l_slice->size = r_slice->size;
}
static void set_to_max(char* buf) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
slice->size = 1;
memset(slice->data, 0xFF, 1);
}
static void set_to_min(char* buf) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
slice->size = 0;
}
static bool is_min(char* buf) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(buf);
+ Slice* slice = reinterpret_cast<Slice*>(buf);
return (slice->size == 0);
}
static uint32_t hash_code(char* data, uint32_t seed) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(data);
+ Slice* slice = reinterpret_cast<Slice*>(data);
return HashUtil::hash(slice->data, slice->size, seed);
}
};
diff --git a/be/src/olap/wrapper_field.cpp b/be/src/olap/wrapper_field.cpp
index 559dd6d3..02ab4363 100644
--- a/be/src/olap/wrapper_field.cpp
+++ b/be/src/olap/wrapper_field.cpp
@@ -68,7 +68,7 @@ WrapperField::WrapperField(Field* rep, size_t variable_len,
bool is_string_type)
_buf = _field_buf + 1;
if (_is_string_type) {
- StringSlice* slice = reinterpret_cast<StringSlice*>(_buf);
+ Slice* slice = reinterpret_cast<Slice*>(_buf);
slice->size = variable_len;
slice->data = _buf + fixed_len;
}
diff --git a/be/src/runtime/vectorized_row_batch.cpp
b/be/src/runtime/vectorized_row_batch.cpp
index f38009d3..2631795c 100644
--- a/be/src/runtime/vectorized_row_batch.cpp
+++ b/be/src/runtime/vectorized_row_batch.cpp
@@ -54,7 +54,7 @@ void VectorizedRowBatch::dump_to_row_block(RowBlock*
row_block) {
if (field_info.type == OLAP_FIELD_TYPE_CHAR ||
field_info.type == OLAP_FIELD_TYPE_VARCHAR ||
field_info.type == OLAP_FIELD_TYPE_HLL) {
- field_size = sizeof(StringSlice);
+ field_size = sizeof(Slice);
} else {
field_size = field_info.length;
}
@@ -98,7 +98,7 @@ void VectorizedRowBatch::dump_to_row_block(RowBlock*
row_block) {
if (field_info.type == OLAP_FIELD_TYPE_CHAR ||
field_info.type == OLAP_FIELD_TYPE_VARCHAR ||
field_info.type == OLAP_FIELD_TYPE_HLL) {
- field_size = sizeof(StringSlice);
+ field_size = sizeof(Slice);
} else {
field_size = field_info.length;
}
diff --git a/be/src/olap/string_slice.h b/be/src/util/slice.h
similarity index 76%
rename from be/src/olap/string_slice.h
rename to be/src/util/slice.h
index 2907fcf5..85176f62 100644
--- a/be/src/olap/string_slice.h
+++ b/be/src/util/slice.h
@@ -31,35 +31,44 @@ namespace doris {
/// @brief A wrapper around externally allocated data.
///
-/// StringSlice is a simple structure containing a pointer into some external
-/// storage and a size. The user of a StringSlice must ensure that the slice
+/// Slice is a simple structure containing a pointer into some external
+/// storage and a size. The user of a Slice must ensure that the slice
/// is not used after the corresponding external storage has been
/// deallocated.
///
-/// Multiple threads can invoke const methods on a StringSlice without
+/// Multiple threads can invoke const methods on a Slice without
/// external synchronization, but if any of the threads may call a
-/// non-const method, all threads accessing the same StringSlice must use
+/// non-const method, all threads accessing the same Slice must use
/// external synchronization.
-struct StringSlice {
+struct Slice {
public:
char* data;
size_t size;
// Intentionally copyable
/// Create an empty slice.
- StringSlice() : data(const_cast<char*>("")), size(0) { }
+ Slice() : data(const_cast<char*>("")), size(0) { }
/// Create a slice that refers to a @c char byte array.
- StringSlice(const char* d, size_t n) :
+ Slice(const char* d, size_t n) :
data(const_cast<char*>(d)), size(n) { }
+
+ // Create a slice that refers to a @c uint8_t byte array.
+ //
+ // @param [in] d
+ // The input array.
+ // @param [in] n
+ // Number of bytes in the array.
+ Slice(const uint8_t* s, size_t n) :
+ data(const_cast<char*>(reinterpret_cast<const char*>(s))), size(n) { }
/// Create a slice that refers to the contents of the given string.
- StringSlice(const std::string& s) : // NOLINT(runtime/explicit)
+ Slice(const std::string& s) : // NOLINT(runtime/explicit)
data(const_cast<char*>(s.data())), size(s.size()) { }
/// Create a slice that refers to a C-string s[0,strlen(s)-1].
- StringSlice(const char* s) : // NOLINT(runtime/explicit)
+ Slice(const char* s) : // NOLINT(runtime/explicit)
data(const_cast<char*>(s)), size(strlen(s)) { }
/*
@@ -121,24 +130,24 @@ struct StringSlice {
std::string to_string() const { return std::string(data, size); }
/// Do a three-way comparison of the slice's data.
- int compare(const StringSlice& b) const;
+ int compare(const Slice& b) const;
/// Check whether the slice starts with the given prefix.
- bool starts_with(const StringSlice& x) const {
+ bool starts_with(const Slice& x) const {
return ((size >= x.size) &&
(mem_equal(data, x.data, x.size)));
}
/// @brief Comparator struct, useful for ordered collections (like STL
maps).
struct Comparator {
- /// Compare two slices using StringSlice::compare()
+ /// Compare two slices using Slice::compare()
///
/// @param [in] a
- /// The slice to call StringSlice::compare() at.
+ /// The slice to call Slice::compare() at.
/// @param [in] b
- /// The slice to use as a parameter for StringSlice::compare().
- /// @return @c true iff @c a is less than @c b by
StringSlice::compare().
- bool operator()(const StringSlice& a, const StringSlice& b) const {
+ /// The slice to use as a parameter for Slice::compare().
+ /// @return @c true iff @c a is less than @c b by Slice::compare().
+ bool operator()(const Slice& a, const Slice& b) const {
return a.compare(b) < 0;
}
};
@@ -156,7 +165,7 @@ struct StringSlice {
}
}
- friend bool operator==(const StringSlice& x, const StringSlice& y);
+ friend bool operator==(const Slice& x, const Slice& y);
static bool mem_equal(const void* a, const void* b, size_t n) {
return memcmp(a, b, n) == 0;
@@ -169,17 +178,17 @@ struct StringSlice {
};
/// Check whether two slices are identical.
-inline bool operator==(const StringSlice& x, const StringSlice& y) {
+inline bool operator==(const Slice& x, const Slice& y) {
return ((x.size == y.size) &&
- (StringSlice::mem_equal(x.data, y.data, x.size)));
+ (Slice::mem_equal(x.data, y.data, x.size)));
}
/// Check whether two slices are not identical.
-inline bool operator!=(const StringSlice& x, const StringSlice& y) {
+inline bool operator!=(const Slice& x, const Slice& y) {
return !(x == y);
}
-inline int StringSlice::compare(const StringSlice& b) const {
+inline int Slice::compare(const Slice& b) const {
const int min_len = (size < b.size) ? size : b.size;
int r = mem_compare(data, b.data, min_len);
if (r == 0) {
@@ -189,11 +198,11 @@ inline int StringSlice::compare(const StringSlice& b)
const {
return r;
}
-/// @brief STL map whose keys are StringSlices.
+/// @brief STL map whose keys are Slices.
///
/// An example of usage:
/// @code
-/// typedef StringSliceMap<int>::type MySliceMap;
+/// typedef SliceMap<int>::type MySliceMap;
///
/// MySliceMap my_map;
/// my_map.insert(MySliceMap::value_type(a, 1));
@@ -205,9 +214,9 @@ inline int StringSlice::compare(const StringSlice& b) const
{
/// }
/// @endcode
template <typename T>
-struct StringSliceMap {
+struct SliceMap {
/// A handy typedef for the slice map with appropriate comparison operator.
- typedef std::map<StringSlice, T, StringSlice::Comparator> type;
+ typedef std::map<Slice, T, Slice::Comparator> type;
};
} // namespace doris
diff --git a/be/test/olap/column_reader_test.cpp
b/be/test/olap/column_reader_test.cpp
index 88fa0b08..fb99929c 100644
--- a/be/test/olap/column_reader_test.cpp
+++ b/be/test/olap/column_reader_test.cpp
@@ -2479,7 +2479,7 @@ TEST_F(TestColumn,
VectorizedDirectVarcharColumnWithoutPresent) {
ASSERT_EQ(_column_reader->next_vector(
_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS);
- StringSlice* value =
reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ Slice* value = reinterpret_cast<Slice*>(_col_vector->col_data());
ASSERT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0);
for (uint32_t i = 0; i < 2; i++) {
value++;
@@ -2548,7 +2548,7 @@ TEST_F(TestColumn,
VectorizedDirectVarcharColumnWithPresent) {
ASSERT_EQ(is_null[0], true);
ASSERT_EQ(is_null[1], false);
- StringSlice* value =
reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ Slice* value = reinterpret_cast<Slice*>(_col_vector->col_data());
value++;
ASSERT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0);
}
@@ -2609,7 +2609,7 @@ TEST_F(TestColumn, SkipDirectVarcharColumnWithPresent) {
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(
_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
- StringSlice* value =
reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ Slice* value = reinterpret_cast<Slice*>(_col_vector->col_data());
ASSERT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0);
}
@@ -2684,14 +2684,14 @@ TEST_F(TestColumn,
SeekDirectVarcharColumnWithoutPresent) {
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(
_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
- StringSlice* value =
reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ Slice* value = reinterpret_cast<Slice*>(_col_vector->col_data());
ASSERT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(
_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
- value = reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ value = reinterpret_cast<Slice*>(_col_vector->col_data());
ASSERT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0);
}
@@ -2766,14 +2766,14 @@ TEST_F(TestColumn, SeekDirectVarcharColumnWithPresent) {
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(
_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
- StringSlice* value =
reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ Slice* value = reinterpret_cast<Slice*>(_col_vector->col_data());
ASSERT_TRUE(strncmp(value->data, "YWJjZGU=", value->size) == 0);
ASSERT_EQ(_column_reader->seek(&position1), OLAP_SUCCESS);
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(
_col_vector.get(), 1, _mem_pool.get()), OLAP_SUCCESS);
- value = reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ value = reinterpret_cast<Slice*>(_col_vector->col_data());
ASSERT_TRUE(strncmp(value->data, "YWFhYWE=", value->size) == 0);
}
@@ -2836,7 +2836,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithoutPresent) {
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(
_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS);
- StringSlice* value =
reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ Slice* value = reinterpret_cast<Slice*>(_col_vector->col_data());
ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0);
for (uint32_t i = 0; i < 2; i++) {
@@ -2904,7 +2904,7 @@ TEST_F(TestColumn, VectorizedStringColumnWithPresent) {
ASSERT_EQ(is_null[0], true);
ASSERT_EQ(is_null[1], false);
- StringSlice* value =
reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ Slice* value = reinterpret_cast<Slice*>(_col_vector->col_data());
value++;
ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0);
}
@@ -2986,7 +2986,7 @@ TEST_F(TestColumn,
VectorizedStringColumnWithoutoutPresent2) {
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(
_col_vector.get(), 5, _mem_pool.get()), OLAP_SUCCESS);
- StringSlice* value =
reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ Slice* value = reinterpret_cast<Slice*>(_col_vector->col_data());
ASSERT_TRUE(strncmp(value->data, "abcde", value->size) == 0);
@@ -3058,7 +3058,7 @@ TEST_F(TestColumn,
VectorizedDirectVarcharColumnWith65533) {
_col_vector.reset(new ColumnVector());
ASSERT_EQ(_column_reader->next_vector(
_col_vector.get(), 3, _mem_pool.get()), OLAP_SUCCESS);
- StringSlice* value =
reinterpret_cast<StringSlice*>(_col_vector->col_data());
+ Slice* value = reinterpret_cast<Slice*>(_col_vector->col_data());
for (uint32_t i = 0; i < 65533; i++) {
ASSERT_TRUE(strncmp(value->data + i, "a", 1) == 0);
diff --git a/be/test/olap/row_block_test.cpp b/be/test/olap/row_block_test.cpp
index 04961dbc..15d3316e 100644
--- a/be/test/olap/row_block_test.cpp
+++ b/be/test/olap/row_block_test.cpp
@@ -163,7 +163,7 @@ TEST_F(TestRowBlock, write_and_read) {
{
char buf[10];
memset(buf, 'a' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_not_null(1);
row.set_field_content(1, (const char*)&val, block.mem_pool());
}
@@ -171,7 +171,7 @@ TEST_F(TestRowBlock, write_and_read) {
{
char buf[10];
memset(buf, '0' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_not_null(2);
row.set_field_content(2, (const char*)&val, block.mem_pool());
}
@@ -203,7 +203,7 @@ TEST_F(TestRowBlock, write_and_read) {
}
{
ASSERT_FALSE(row.is_null(1));
- StringSlice* slice =
(StringSlice*)row.get_field_content_ptr(1);
+ Slice* slice = (Slice*)row.get_field_content_ptr(1);
char buf[10];
memset(buf, 'a' + i, 10);
ASSERT_EQ(10, slice->size);
@@ -211,7 +211,7 @@ TEST_F(TestRowBlock, write_and_read) {
}
{
ASSERT_FALSE(row.is_null(2));
- StringSlice* slice =
(StringSlice*)row.get_field_content_ptr(2);
+ Slice* slice = (Slice*)row.get_field_content_ptr(2);
char buf[20];
memset(buf, '0' + i, 10);
ASSERT_EQ(10, slice->size);
@@ -279,7 +279,7 @@ TEST_F(TestRowBlock, write_and_read_without_nullbyte) {
{
char buf[10];
memset(buf, 'a' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_not_null(1);
row.set_field_content(1, (const char*)&val, block.mem_pool());
}
@@ -287,7 +287,7 @@ TEST_F(TestRowBlock, write_and_read_without_nullbyte) {
{
char buf[10];
memset(buf, '0' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_not_null(2);
row.set_field_content(2, (const char*)&val, block.mem_pool());
}
@@ -319,7 +319,7 @@ TEST_F(TestRowBlock, write_and_read_without_nullbyte) {
}
{
ASSERT_FALSE(row.is_null(1));
- StringSlice* slice =
(StringSlice*)row.get_field_content_ptr(1);
+ Slice* slice = (Slice*)row.get_field_content_ptr(1);
char buf[10];
memset(buf, 'a' + i, 10);
ASSERT_EQ(10, slice->size);
@@ -327,7 +327,7 @@ TEST_F(TestRowBlock, write_and_read_without_nullbyte) {
}
{
ASSERT_FALSE(row.is_null(2));
- StringSlice* slice =
(StringSlice*)row.get_field_content_ptr(2);
+ Slice* slice = (Slice*)row.get_field_content_ptr(2);
char buf[20];
memset(buf, '0' + i, 10);
ASSERT_EQ(10, slice->size);
@@ -394,14 +394,14 @@ TEST_F(TestRowBlock, compress_failed) {
{
char buf[10];
memset(buf, 'a' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_field_content(1, (const char*)&val, block.mem_pool());
}
// varchar
{
char buf[10];
memset(buf, '0' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_field_content(2, (const char*)&val, block.mem_pool());
}
}
@@ -471,14 +471,14 @@ TEST_F(TestRowBlock, decompress_failed) {
{
char buf[10];
memset(buf, 'a' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_field_content(1, (const char*)&val, block.mem_pool());
}
// varchar
{
char buf[10];
memset(buf, '0' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_field_content(2, (const char*)&val, block.mem_pool());
}
}
@@ -572,7 +572,7 @@ TEST_F(TestRowBlock, find_row) {
{
char buf[10];
memset(buf, 'a' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_not_null(1);
row.set_field_content(1, (const char*)&val, block.mem_pool());
}
@@ -580,7 +580,7 @@ TEST_F(TestRowBlock, find_row) {
{
char buf[10];
memset(buf, '0' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
row.set_not_null(2);
row.set_field_content(2, (const char*)&val, block.mem_pool());
}
@@ -602,7 +602,7 @@ TEST_F(TestRowBlock, find_row) {
{
char buf[10];
memset(buf, 'a' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
find_row.set_not_null(1);
find_row.set_field_content(1, (const char*)&val,
block.mem_pool());
}
@@ -610,7 +610,7 @@ TEST_F(TestRowBlock, find_row) {
{
char buf[10];
memset(buf, '0' + i, 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
find_row.set_not_null(2);
find_row.set_field_content(2, (const char*)&val,
block.mem_pool());
}
@@ -633,14 +633,14 @@ TEST_F(TestRowBlock, find_row) {
{
char buf[10];
memset(buf, 'c', 9);
- StringSlice val(buf, 9);
+ Slice val(buf, 9);
find_row.set_field_content(1, (const char*)&val,
block.mem_pool());
}
// varchar
{
char buf[10];
memset(buf, '0', 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
find_row.set_field_content(2, (const char*)&val,
block.mem_pool());
}
uint32_t row_index;
@@ -658,14 +658,14 @@ TEST_F(TestRowBlock, find_row) {
{
char buf[10];
memset(buf, 'c', 9);
- StringSlice val(buf, 9);
+ Slice val(buf, 9);
find_row.set_field_content(1, (const char*)&val,
block.mem_pool());
}
// varchar
{
char buf[10];
memset(buf, '0', 10);
- StringSlice val(buf, 10);
+ Slice val(buf, 10);
find_row.set_field_content(2, (const char*)&val,
block.mem_pool());
}
uint32_t row_index;
diff --git a/be/test/olap/row_cursor_test.cpp b/be/test/olap/row_cursor_test.cpp
index 62e0bb94..604126d0 100644
--- a/be/test/olap/row_cursor_test.cpp
+++ b/be/test/olap/row_cursor_test.cpp
@@ -341,7 +341,7 @@ TEST_F(TestRowCursor, EqualAndCompare) {
ASSERT_EQ(left.get_fixed_len(), 78);
ASSERT_EQ(left.get_variable_len(), 20);
- StringSlice l_char("well");
+ Slice l_char("well");
int32_t l_int = 10;
left.set_field_content(0, reinterpret_cast<char*>(&l_char),
_mem_pool.get());
left.set_field_content(1, reinterpret_cast<char*>(&l_int),
_mem_pool.get());
@@ -382,14 +382,14 @@ TEST_F(TestRowCursor, IndexCmp) {
ASSERT_EQ(left.get_fixed_len(), 78);
ASSERT_EQ(left.get_variable_len(), 20);
- StringSlice l_char("well");
+ Slice l_char("well");
int32_t l_int = 10;
left.set_field_content(0, reinterpret_cast<char*>(&l_char),
_mem_pool.get());
left.set_field_content(1, reinterpret_cast<char*>(&l_int),
_mem_pool.get());
RowCursor right_eq;
res = right_eq.init(tablet_schema);
- StringSlice r_char_eq("well");
+ Slice r_char_eq("well");
int32_t r_int_eq = 10;
right_eq.set_field_content(0, reinterpret_cast<char*>(&r_char_eq),
_mem_pool.get());
right_eq.set_field_content(1, reinterpret_cast<char*>(&r_int_eq),
_mem_pool.get());
@@ -398,7 +398,7 @@ TEST_F(TestRowCursor, IndexCmp) {
RowCursor right_lt;
res = right_lt.init(tablet_schema);
- StringSlice r_char_lt("well");
+ Slice r_char_lt("well");
int32_t r_int_lt = 11;
right_lt.set_field_content(0, reinterpret_cast<char*>(&r_char_lt),
_mem_pool.get());
right_lt.set_field_content(1, reinterpret_cast<char*>(&r_int_lt),
_mem_pool.get());
@@ -406,7 +406,7 @@ TEST_F(TestRowCursor, IndexCmp) {
RowCursor right_gt;
res = right_gt.init(tablet_schema);
- StringSlice r_char_gt("good");
+ Slice r_char_gt("good");
int32_t r_int_gt = 10;
right_gt.set_field_content(0, reinterpret_cast<char*>(&r_char_gt),
_mem_pool.get());
right_gt.set_field_content(1, reinterpret_cast<char*>(&r_int_gt),
_mem_pool.get());
@@ -423,14 +423,14 @@ TEST_F(TestRowCursor, FullKeyCmp) {
ASSERT_EQ(left.get_fixed_len(), 78);
ASSERT_EQ(left.get_variable_len(), 20);
- StringSlice l_char("well");
+ Slice l_char("well");
int32_t l_int = 10;
left.set_field_content(0, reinterpret_cast<char*>(&l_char),
_mem_pool.get());
left.set_field_content(1, reinterpret_cast<char*>(&l_int),
_mem_pool.get());
RowCursor right_eq;
res = right_eq.init(tablet_schema);
- StringSlice r_char_eq("well");
+ Slice r_char_eq("well");
int32_t r_int_eq = 10;
right_eq.set_field_content(0, reinterpret_cast<char*>(&r_char_eq),
_mem_pool.get());
right_eq.set_field_content(1, reinterpret_cast<char*>(&r_int_eq),
_mem_pool.get());
@@ -438,7 +438,7 @@ TEST_F(TestRowCursor, FullKeyCmp) {
RowCursor right_lt;
res = right_lt.init(tablet_schema);
- StringSlice r_char_lt("well");
+ Slice r_char_lt("well");
int32_t r_int_lt = 11;
right_lt.set_field_content(0, reinterpret_cast<char*>(&r_char_lt),
_mem_pool.get());
right_lt.set_field_content(1, reinterpret_cast<char*>(&r_int_lt),
_mem_pool.get());
@@ -446,7 +446,7 @@ TEST_F(TestRowCursor, FullKeyCmp) {
RowCursor right_gt;
res = right_gt.init(tablet_schema);
- StringSlice r_char_gt("good");
+ Slice r_char_gt("good");
int32_t r_int_gt = 10;
right_gt.set_field_content(0, reinterpret_cast<char*>(&r_char_gt),
_mem_pool.get());
right_gt.set_field_content(1, reinterpret_cast<char*>(&r_int_gt),
_mem_pool.get());
@@ -467,12 +467,12 @@ TEST_F(TestRowCursor, AggregateWithoutNull) {
RowCursor left;
res = left.init(tablet_schema);
- StringSlice l_char("well");
+ Slice l_char("well");
int32_t l_int = 10;
int128_t l_largeint = (int128_t)(1) << 100;
double l_double = 8.8;
decimal12_t l_decimal(11, 22);
- StringSlice l_varchar("beijing");
+ Slice l_varchar("beijing");
left.set_field_content(0, reinterpret_cast<char*>(&l_char),
_mem_pool.get());
left.set_field_content(1, reinterpret_cast<char*>(&l_int),
_mem_pool.get());
left.set_field_content(2, reinterpret_cast<char*>(&l_largeint),
_mem_pool.get());
@@ -485,12 +485,12 @@ TEST_F(TestRowCursor, AggregateWithoutNull) {
RowCursor right;
res = right.init(tablet_schema);
- StringSlice r_char("well");
+ Slice r_char("well");
int32_t r_int = 10;
int128_t r_largeint = (int128_t)(1) << 100;
double r_double = 5.5;
decimal12_t r_decimal(22, 22);
- StringSlice r_varchar("shenzhen");
+ Slice r_varchar("shenzhen");
right.set_field_content(0, reinterpret_cast<char*>(&r_char),
_mem_pool.get());
right.set_field_content(1, reinterpret_cast<char*>(&r_int),
_mem_pool.get());
right.set_field_content(2, reinterpret_cast<char*>(&r_largeint),
_mem_pool.get());
@@ -509,7 +509,7 @@ TEST_F(TestRowCursor, AggregateWithoutNull) {
decimal12_t agg_decimal =
*reinterpret_cast<decimal12_t*>(row.get_field_content_ptr(4));
ASSERT_TRUE(agg_decimal == r_decimal);
- StringSlice* agg_varchar =
reinterpret_cast<StringSlice*>(row.get_field_content_ptr(5));
+ Slice* agg_varchar =
reinterpret_cast<Slice*>(row.get_field_content_ptr(5));
ASSERT_EQ(agg_varchar->compare(r_varchar), 0);
}
@@ -527,10 +527,10 @@ TEST_F(TestRowCursor, AggregateWithNull) {
RowCursor left;
res = left.init(tablet_schema);
- StringSlice l_char("well");
+ Slice l_char("well");
int32_t l_int = 10;
int128_t l_largeint = (int128_t)(1) << 100;
- StringSlice l_varchar("beijing");
+ Slice l_varchar("beijing");
left.set_field_content(0, reinterpret_cast<char*>(&l_char),
_mem_pool.get());
left.set_field_content(1, reinterpret_cast<char*>(&l_int),
_mem_pool.get());
left.set_field_content(2, reinterpret_cast<char*>(&l_largeint),
_mem_pool.get());
@@ -543,7 +543,7 @@ TEST_F(TestRowCursor, AggregateWithNull) {
RowCursor right;
res = right.init(tablet_schema);
- StringSlice r_char("well");
+ Slice r_char("well");
int32_t r_int = 10;
int128_t r_largeint = (int128_t)(1) << 100;
double r_double = 5.5;
----------------------------------------------------------------
This is an automated message from the Apache Git Service.
To respond to the message, please log on GitHub and use the
URL above to go to the specific comment.
For queries about this service, please contact Infrastructure at:
[email protected]
With regards,
Apache Git Services
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
