You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@doris.apache.org by yi...@apache.org on 2023/04/10 00:53:56 UTC
[doris] branch master updated: [Chore](storage) change FieldType to enum class #18500
This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new c9b4eaea76 [Chore](storage) change FieldType to enum class #18500
c9b4eaea76 is described below
commit c9b4eaea763ac9dcf3d30a58da6ac199ee34e645
Author: Pxl <px...@qq.com>
AuthorDate: Mon Apr 10 08:53:44 2023 +0800
[Chore](storage) change FieldType to enum class #18500
---
be/src/exprs/create_predicate_function.h | 6 +-
be/src/olap/delete_handler.cpp | 47 +++---
be/src/olap/field.h | 48 +++---
be/src/olap/key_coder.cpp | 38 ++---
be/src/olap/key_coder.h | 41 +++--
be/src/olap/match_predicate.cpp | 4 +-
be/src/olap/olap_common.h | 37 +++--
be/src/olap/predicate_creator.h | 38 ++---
be/src/olap/primary_key_index.cpp | 2 +-
be/src/olap/row_cursor.cpp | 17 +-
be/src/olap/rowset/segment_v2/binary_dict_page.cpp | 20 ++-
be/src/olap/rowset/segment_v2/binary_dict_page.h | 6 +-
be/src/olap/rowset/segment_v2/binary_plain_page.h | 6 +-
.../olap/rowset/segment_v2/bitmap_index_reader.h | 2 +-
.../olap/rowset/segment_v2/bitmap_index_writer.cpp | 78 ++++-----
be/src/olap/rowset/segment_v2/bitshuffle_page.h | 3 +-
.../rowset/segment_v2/bloom_filter_index_reader.h | 2 +-
.../segment_v2/bloom_filter_index_writer.cpp | 56 ++++---
be/src/olap/rowset/segment_v2/column_reader.cpp | 63 +++----
be/src/olap/rowset/segment_v2/column_writer.cpp | 27 +--
be/src/olap/rowset/segment_v2/encoding_info.cpp | 166 +++++++++----------
.../rowset/segment_v2/indexed_column_reader.cpp | 3 +-
.../rowset/segment_v2/indexed_column_writer.cpp | 6 +-
.../rowset/segment_v2/inverted_index_writer.cpp | 92 ++++++-----
.../olap/rowset/segment_v2/ordinal_page_index.cpp | 8 +-
be/src/olap/rowset/segment_v2/rle_page.h | 4 +-
be/src/olap/rowset/segment_v2/segment_iterator.cpp | 17 +-
be/src/olap/rowset/segment_v2/segment_iterator.h | 10 +-
be/src/olap/rowset/segment_v2/segment_writer.cpp | 2 +-
be/src/olap/rowset/segment_v2/zone_map_index.cpp | 12 +-
be/src/olap/schema.cpp | 46 +++---
be/src/olap/tablet_schema.cpp | 134 +++++++--------
be/src/olap/tablet_schema.h | 13 +-
be/src/olap/types.cpp | 152 ++++++++---------
be/src/olap/types.h | 146 +++++++++--------
be/src/olap/utils.h | 35 ++--
be/src/olap/wrapper_field.cpp | 28 ++--
be/src/vec/columns/column_dictionary.h | 4 +-
be/src/vec/common/schema_util.cpp | 23 +--
be/src/vec/data_types/data_type_factory.cpp | 58 +++----
be/src/vec/jsonb/serialize.cpp | 53 +++---
be/src/vec/olap/olap_data_convertor.cpp | 2 +-
be/src/vec/olap/vgeneric_iterators.cpp | 10 +-
be/test/olap/key_coder_test.cpp | 26 +--
be/test/olap/memtable_flush_executor_test.cpp | 7 +-
.../rowset/segment_v2/binary_dict_page_test.cpp | 17 +-
.../rowset/segment_v2/binary_plain_page_test.cpp | 13 +-
.../rowset/segment_v2/binary_prefix_page_test.cpp | 6 +-
.../olap/rowset/segment_v2/bitmap_index_test.cpp | 24 +--
.../rowset/segment_v2/bitshuffle_page_test.cpp | 103 ++++++------
.../bloom_filter_index_reader_writer_test.cpp | 30 ++--
.../segment_v2/column_reader_writer_test.cpp | 182 +++++++++++----------
.../olap/rowset/segment_v2/encoding_info_test.cpp | 4 +-
.../segment_v2/frame_of_reference_page_test.cpp | 83 ++++++----
be/test/olap/rowset/segment_v2/plain_page_test.cpp | 105 ++++++------
be/test/olap/rowset/segment_v2/rle_page_test.cpp | 36 ++--
be/test/olap/storage_types_test.cpp | 84 ++++++----
be/test/olap/tablet_schema_helper.cpp | 22 +--
be/test/testutil/test_util.cpp | 6 +-
be/test/vec/exec/vgeneric_iterators_test.cpp | 17 +-
be/test/vec/jsonb/serialize_test.cpp | 18 +-
61 files changed, 1234 insertions(+), 1114 deletions(-)
diff --git a/be/src/exprs/create_predicate_function.h b/be/src/exprs/create_predicate_function.h
index 5a6d66d1f6..f52e9d756b 100644
--- a/be/src/exprs/create_predicate_function.h
+++ b/be/src/exprs/create_predicate_function.h
@@ -273,16 +273,16 @@ ColumnPredicate* create_column_predicate(uint32_t column_id, const std::shared_p
const TabletColumn* column = nullptr) {
switch (type) {
#define M(NAME) \
- case OLAP_FIELD_##NAME: { \
+ case FieldType::OLAP_FIELD_##NAME: { \
return create_olap_column_predicate<NAME>(column_id, filter, be_exec_version, column); \
}
APPLY_FOR_PRIMTYPE(M)
#undef M
- case OLAP_FIELD_TYPE_DECIMAL: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL: {
return create_olap_column_predicate<TYPE_DECIMALV2>(column_id, filter, be_exec_version,
column);
}
- case OLAP_FIELD_TYPE_BOOL: {
+ case FieldType::OLAP_FIELD_TYPE_BOOL: {
return create_olap_column_predicate<TYPE_BOOLEAN>(column_id, filter, be_exec_version,
column);
}
diff --git a/be/src/olap/delete_handler.cpp b/be/src/olap/delete_handler.cpp
index 8932991178..655670e9a8 100644
--- a/be/src/olap/delete_handler.cpp
+++ b/be/src/olap/delete_handler.cpp
@@ -120,46 +120,46 @@ bool DeleteHandler::is_condition_value_valid(const TabletColumn& column,
FieldType field_type = column.type();
switch (field_type) {
- case OLAP_FIELD_TYPE_TINYINT:
+ case FieldType::OLAP_FIELD_TYPE_TINYINT:
return valid_signed_number<int8_t>(value_str);
- case OLAP_FIELD_TYPE_SMALLINT:
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT:
return valid_signed_number<int16_t>(value_str);
- case OLAP_FIELD_TYPE_INT:
+ case FieldType::OLAP_FIELD_TYPE_INT:
return valid_signed_number<int32_t>(value_str);
- case OLAP_FIELD_TYPE_BIGINT:
+ case FieldType::OLAP_FIELD_TYPE_BIGINT:
return valid_signed_number<int64_t>(value_str);
- case OLAP_FIELD_TYPE_LARGEINT:
+ case FieldType::OLAP_FIELD_TYPE_LARGEINT:
return valid_signed_number<int128_t>(value_str);
- case OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
return valid_unsigned_number<uint8_t>(value_str);
- case OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
return valid_unsigned_number<uint16_t>(value_str);
- case OLAP_FIELD_TYPE_UNSIGNED_INT:
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT:
return valid_unsigned_number<uint32_t>(value_str);
- case OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
return valid_unsigned_number<uint64_t>(value_str);
- case OLAP_FIELD_TYPE_DECIMAL:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL:
return valid_decimal(value_str, column.precision(), column.frac());
- case OLAP_FIELD_TYPE_DECIMAL32:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
return valid_decimal(value_str, column.precision(), column.frac());
- case OLAP_FIELD_TYPE_DECIMAL64:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
return valid_decimal(value_str, column.precision(), column.frac());
- case OLAP_FIELD_TYPE_DECIMAL128I:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
return valid_decimal(value_str, column.precision(), column.frac());
- case OLAP_FIELD_TYPE_CHAR:
- case OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
return value_str.size() <= column.length();
- case OLAP_FIELD_TYPE_STRING:
+ case FieldType::OLAP_FIELD_TYPE_STRING:
return value_str.size() <= config::string_type_length_soft_limit_bytes;
- case OLAP_FIELD_TYPE_DATE:
- case OLAP_FIELD_TYPE_DATETIME:
- case OLAP_FIELD_TYPE_DATEV2:
- case OLAP_FIELD_TYPE_DATETIMEV2:
+ case FieldType::OLAP_FIELD_TYPE_DATE:
+ case FieldType::OLAP_FIELD_TYPE_DATETIME:
+ case FieldType::OLAP_FIELD_TYPE_DATEV2:
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2:
return valid_datetime(value_str, column.frac());
- case OLAP_FIELD_TYPE_BOOL:
+ case FieldType::OLAP_FIELD_TYPE_BOOL:
return valid_bool(value_str);
default:
- LOG(WARNING) << "unknown field type. [type=" << field_type << "]";
+ LOG(WARNING) << "unknown field type. [type=" << int(field_type) << "]";
}
return false;
}
@@ -177,7 +177,8 @@ Status DeleteHandler::check_condition_valid(const TabletSchema& schema, const TC
const TabletColumn& column = schema.column(field_index);
if ((!column.is_key() && schema.keys_type() != KeysType::DUP_KEYS) ||
- column.type() == OLAP_FIELD_TYPE_DOUBLE || column.type() == OLAP_FIELD_TYPE_FLOAT) {
+ column.type() == FieldType::OLAP_FIELD_TYPE_DOUBLE ||
+ column.type() == FieldType::OLAP_FIELD_TYPE_FLOAT) {
LOG(WARNING) << "field is not key column, or storage model is not duplicate, or data type "
"is float or double.";
return Status::Error<DELETE_INVALID_CONDITION>();
diff --git a/be/src/olap/field.h b/be/src/olap/field.h
index c516203f92..c88dcbdfed 100644
--- a/be/src/olap/field.h
+++ b/be/src/olap/field.h
@@ -125,7 +125,7 @@ public:
if (is_null) {
return;
}
- if (type() == OLAP_FIELD_TYPE_STRING) {
+ if (type() == FieldType::OLAP_FIELD_TYPE_STRING) {
auto dst_slice = reinterpret_cast<Slice*>(dst->mutable_cell_ptr());
auto src_slice = reinterpret_cast<const Slice*>(src.cell_ptr());
if (dst_slice->size < src_slice->size) {
@@ -154,7 +154,7 @@ public:
// value_string should end with '\0'
Status from_string(char* buf, const std::string& value_string, const int precision = 0,
const int scale = 0) const {
- if (type() == OLAP_FIELD_TYPE_STRING && !value_string.empty()) {
+ if (type() == FieldType::OLAP_FIELD_TYPE_STRING && !value_string.empty()) {
auto slice = reinterpret_cast<Slice*>(buf);
if (slice->size < value_string.size()) {
*_long_text_buf = static_cast<char*>(realloc(*_long_text_buf, value_string.size()));
@@ -538,13 +538,13 @@ public:
// for key column
if (column.is_key()) {
switch (column.type()) {
- case OLAP_FIELD_TYPE_CHAR:
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
return new CharField(column);
- case OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
return new VarcharField(column);
- case OLAP_FIELD_TYPE_STRING:
+ case FieldType::OLAP_FIELD_TYPE_STRING:
return new StringField(column);
- case OLAP_FIELD_TYPE_STRUCT: {
+ case FieldType::OLAP_FIELD_TYPE_STRUCT: {
auto* local = new StructField(column);
for (uint32_t i = 0; i < column.get_subtype_count(); i++) {
std::unique_ptr<Field> sub_field(
@@ -553,13 +553,13 @@ public:
}
return local;
}
- case OLAP_FIELD_TYPE_ARRAY: {
+ case FieldType::OLAP_FIELD_TYPE_ARRAY: {
std::unique_ptr<Field> item_field(FieldFactory::create(column.get_sub_column(0)));
auto* local = new ArrayField(column);
local->add_sub_field(std::move(item_field));
return local;
}
- case OLAP_FIELD_TYPE_MAP: {
+ case FieldType::OLAP_FIELD_TYPE_MAP: {
std::unique_ptr<Field> key_field(FieldFactory::create(column.get_sub_column(0)));
std::unique_ptr<Field> val_field(FieldFactory::create(column.get_sub_column(1)));
auto* local = new MapField(column);
@@ -567,15 +567,15 @@ public:
local->add_sub_field(std::move(val_field));
return local;
}
- case OLAP_FIELD_TYPE_DECIMAL:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL:
[[fallthrough]];
- case OLAP_FIELD_TYPE_DECIMAL32:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
[[fallthrough]];
- case OLAP_FIELD_TYPE_DECIMAL64:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
[[fallthrough]];
- case OLAP_FIELD_TYPE_DECIMAL128I:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
[[fallthrough]];
- case OLAP_FIELD_TYPE_DATETIMEV2: {
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: {
Field* field = new Field(column);
field->set_precision(column.precision());
field->set_scale(column.frac());
@@ -595,13 +595,13 @@ public:
case OLAP_FIELD_AGGREGATION_REPLACE:
case OLAP_FIELD_AGGREGATION_REPLACE_IF_NOT_NULL:
switch (column.type()) {
- case OLAP_FIELD_TYPE_CHAR:
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
return new CharField(column);
- case OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
return new VarcharField(column);
- case OLAP_FIELD_TYPE_STRING:
+ case FieldType::OLAP_FIELD_TYPE_STRING:
return new StringField(column);
- case OLAP_FIELD_TYPE_STRUCT: {
+ case FieldType::OLAP_FIELD_TYPE_STRUCT: {
auto* local = new StructField(column);
for (uint32_t i = 0; i < column.get_subtype_count(); i++) {
std::unique_ptr<Field> sub_field(
@@ -610,13 +610,13 @@ public:
}
return local;
}
- case OLAP_FIELD_TYPE_ARRAY: {
+ case FieldType::OLAP_FIELD_TYPE_ARRAY: {
std::unique_ptr<Field> item_field(FieldFactory::create(column.get_sub_column(0)));
auto* local = new ArrayField(column);
local->add_sub_field(std::move(item_field));
return local;
}
- case OLAP_FIELD_TYPE_MAP: {
+ case FieldType::OLAP_FIELD_TYPE_MAP: {
DCHECK(column.get_subtype_count() == 2);
auto* local = new MapField(column);
std::unique_ptr<Field> key_field(FieldFactory::create(column.get_sub_column(0)));
@@ -625,15 +625,15 @@ public:
local->add_sub_field(std::move(value_field));
return local;
}
- case OLAP_FIELD_TYPE_DECIMAL:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL:
[[fallthrough]];
- case OLAP_FIELD_TYPE_DECIMAL32:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
[[fallthrough]];
- case OLAP_FIELD_TYPE_DECIMAL64:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
[[fallthrough]];
- case OLAP_FIELD_TYPE_DECIMAL128I:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
[[fallthrough]];
- case OLAP_FIELD_TYPE_DATETIMEV2: {
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: {
Field* field = new Field(column);
field->set_precision(column.precision());
field->set_scale(column.frac());
diff --git a/be/src/olap/key_coder.cpp b/be/src/olap/key_coder.cpp
index 9f1c2a2788..450c805a8d 100644
--- a/be/src/olap/key_coder.cpp
+++ b/be/src/olap/key_coder.cpp
@@ -58,26 +58,26 @@ public:
private:
KeyCoderResolver() {
- add_mapping<OLAP_FIELD_TYPE_TINYINT>();
- add_mapping<OLAP_FIELD_TYPE_SMALLINT>();
- add_mapping<OLAP_FIELD_TYPE_INT>();
- add_mapping<OLAP_FIELD_TYPE_UNSIGNED_INT>();
- add_mapping<OLAP_FIELD_TYPE_BIGINT>();
- add_mapping<OLAP_FIELD_TYPE_UNSIGNED_BIGINT>();
- add_mapping<OLAP_FIELD_TYPE_LARGEINT>();
- add_mapping<OLAP_FIELD_TYPE_DATETIME>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_TINYINT>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_SMALLINT>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_INT>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_BIGINT>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_LARGEINT>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_DATETIME>();
- add_mapping<OLAP_FIELD_TYPE_DATE>();
- add_mapping<OLAP_FIELD_TYPE_DECIMAL>();
- add_mapping<OLAP_FIELD_TYPE_CHAR>();
- add_mapping<OLAP_FIELD_TYPE_VARCHAR>();
- add_mapping<OLAP_FIELD_TYPE_STRING>();
- add_mapping<OLAP_FIELD_TYPE_BOOL>();
- add_mapping<OLAP_FIELD_TYPE_DATEV2>();
- add_mapping<OLAP_FIELD_TYPE_DATETIMEV2>();
- add_mapping<OLAP_FIELD_TYPE_DECIMAL32>();
- add_mapping<OLAP_FIELD_TYPE_DECIMAL64>();
- add_mapping<OLAP_FIELD_TYPE_DECIMAL128I>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_DATE>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_DECIMAL>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_CHAR>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_VARCHAR>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_STRING>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_BOOL>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_DATEV2>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_DECIMAL32>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_DECIMAL64>();
+ add_mapping<FieldType::OLAP_FIELD_TYPE_DECIMAL128I>();
}
template <FieldType field_type>
diff --git a/be/src/olap/key_coder.h b/be/src/olap/key_coder.h
index c6541f12ad..411517bd05 100644
--- a/be/src/olap/key_coder.h
+++ b/be/src/olap/key_coder.h
@@ -91,7 +91,7 @@ private:
case 16:
return BigEndian::FromHost128(val);
default:
- LOG(FATAL) << "Invalid type to big endian, type=" << field_type
+ LOG(FATAL) << "Invalid type to big endian, type=" << int(field_type)
<< ", size=" << sizeof(UnsignedCppType);
}
}
@@ -136,10 +136,11 @@ public:
};
template <>
-class KeyCoderTraits<OLAP_FIELD_TYPE_DATE> {
+class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_DATE> {
public:
- using CppType = typename CppTypeTraits<OLAP_FIELD_TYPE_DATE>::CppType;
- using UnsignedCppType = typename CppTypeTraits<OLAP_FIELD_TYPE_DATE>::UnsignedCppType;
+ using CppType = typename CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATE>::CppType;
+ using UnsignedCppType =
+ typename CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATE>::UnsignedCppType;
public:
static void full_encode_ascending(const void* value, std::string* buf) {
@@ -169,10 +170,11 @@ public:
};
template <>
-class KeyCoderTraits<OLAP_FIELD_TYPE_DATEV2> {
+class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_DATEV2> {
public:
- using CppType = typename CppTypeTraits<OLAP_FIELD_TYPE_DATEV2>::CppType;
- using UnsignedCppType = typename CppTypeTraits<OLAP_FIELD_TYPE_DATEV2>::UnsignedCppType;
+ using CppType = typename CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATEV2>::CppType;
+ using UnsignedCppType =
+ typename CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATEV2>::UnsignedCppType;
public:
static void full_encode_ascending(const void* value, std::string* buf) {
@@ -202,10 +204,11 @@ public:
};
template <>
-class KeyCoderTraits<OLAP_FIELD_TYPE_DATETIMEV2> {
+class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_DATETIMEV2> {
public:
- using CppType = typename CppTypeTraits<OLAP_FIELD_TYPE_DATETIMEV2>::CppType;
- using UnsignedCppType = typename CppTypeTraits<OLAP_FIELD_TYPE_DATETIMEV2>::UnsignedCppType;
+ using CppType = typename CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>::CppType;
+ using UnsignedCppType =
+ typename CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>::UnsignedCppType;
public:
static void full_encode_ascending(const void* value, std::string* buf) {
@@ -235,13 +238,15 @@ public:
};
template <>
-class KeyCoderTraits<OLAP_FIELD_TYPE_DECIMAL> {
+class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL> {
public:
static void full_encode_ascending(const void* value, std::string* buf) {
decimal12_t decimal_val;
memcpy(&decimal_val, value, sizeof(decimal12_t));
- KeyCoderTraits<OLAP_FIELD_TYPE_BIGINT>::full_encode_ascending(&decimal_val.integer, buf);
- KeyCoderTraits<OLAP_FIELD_TYPE_INT>::full_encode_ascending(&decimal_val.fraction, buf);
+ KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_BIGINT>::full_encode_ascending(
+ &decimal_val.integer, buf);
+ KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_INT>::full_encode_ascending(&decimal_val.fraction,
+ buf);
} // namespace doris
static void encode_ascending(const void* value, size_t index_size, std::string* buf) {
@@ -250,9 +255,9 @@ public:
static Status decode_ascending(Slice* encoded_key, size_t index_size, uint8_t* cell_ptr) {
decimal12_t decimal_val = {0, 0};
- RETURN_IF_ERROR(KeyCoderTraits<OLAP_FIELD_TYPE_BIGINT>::decode_ascending(
+ RETURN_IF_ERROR(KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_BIGINT>::decode_ascending(
encoded_key, sizeof(decimal_val.integer), (uint8_t*)&decimal_val.integer));
- RETURN_IF_ERROR(KeyCoderTraits<OLAP_FIELD_TYPE_INT>::decode_ascending(
+ RETURN_IF_ERROR(KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_INT>::decode_ascending(
encoded_key, sizeof(decimal_val.fraction), (uint8_t*)&decimal_val.fraction));
memcpy(cell_ptr, &decimal_val, sizeof(decimal12_t));
return Status::OK();
@@ -260,7 +265,7 @@ public:
};
template <>
-class KeyCoderTraits<OLAP_FIELD_TYPE_CHAR> {
+class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_CHAR> {
public:
static void full_encode_ascending(const void* value, std::string* buf) {
auto slice = reinterpret_cast<const Slice*>(value);
@@ -282,7 +287,7 @@ public:
};
template <>
-class KeyCoderTraits<OLAP_FIELD_TYPE_VARCHAR> {
+class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_VARCHAR> {
public:
static void full_encode_ascending(const void* value, std::string* buf) {
auto slice = reinterpret_cast<const Slice*>(value);
@@ -302,7 +307,7 @@ public:
};
template <>
-class KeyCoderTraits<OLAP_FIELD_TYPE_STRING> {
+class KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_STRING> {
public:
static void full_encode_ascending(const void* value, std::string* buf) {
auto slice = reinterpret_cast<const Slice*>(value);
diff --git a/be/src/olap/match_predicate.cpp b/be/src/olap/match_predicate.cpp
index e78f52e2f8..e9b68e3b3e 100644
--- a/be/src/olap/match_predicate.cpp
+++ b/be/src/olap/match_predicate.cpp
@@ -47,7 +47,7 @@ Status MatchPredicate::evaluate(const Schema& schema, InvertedIndexIterator* ite
auto inverted_index_query_type = _to_inverted_index_query_type(_match_type);
if (is_string_type(column_desc->type()) ||
- (column_desc->type() == OLAP_FIELD_TYPE_ARRAY &&
+ (column_desc->type() == FieldType::OLAP_FIELD_TYPE_ARRAY &&
is_string_type(column_desc->get_sub_field(0)->type_info()->type()))) {
StringRef match_value;
int32_t length = _value.length();
@@ -55,7 +55,7 @@ Status MatchPredicate::evaluate(const Schema& schema, InvertedIndexIterator* ite
match_value.replace(buffer, length); //is it safe?
s = iterator->read_from_inverted_index(column_desc->name(), &match_value,
inverted_index_query_type, num_rows, &roaring);
- } else if (column_desc->type() == OLAP_FIELD_TYPE_ARRAY &&
+ } else if (column_desc->type() == FieldType::OLAP_FIELD_TYPE_ARRAY &&
is_numeric_type(column_desc->get_sub_field(0)->type_info()->type())) {
char buf[column_desc->get_sub_field(0)->type_info()->size()];
column_desc->get_sub_field(0)->from_string(buf, _value);
diff --git a/be/src/olap/olap_common.h b/be/src/olap/olap_common.h
index 4e7ad41a48..afb2bdcf22 100644
--- a/be/src/olap/olap_common.h
+++ b/be/src/olap/olap_common.h
@@ -105,7 +105,7 @@ struct TabletSize {
// Define all data types supported by Field.
// If new filed_type is defined, not only new TypeInfo may need be defined,
// but also some functions like get_type_info in types.cpp need to be changed.
-enum FieldType {
+enum class FieldType {
OLAP_FIELD_TYPE_TINYINT = 1, // MYSQL_TYPE_TINY
OLAP_FIELD_TYPE_UNSIGNED_TINYINT = 2,
OLAP_FIELD_TYPE_SMALLINT = 3, // MYSQL_TYPE_SHORT
@@ -170,22 +170,31 @@ enum PushType {
};
constexpr bool field_is_slice_type(const FieldType& field_type) {
- return field_type == OLAP_FIELD_TYPE_VARCHAR || field_type == OLAP_FIELD_TYPE_CHAR ||
- field_type == OLAP_FIELD_TYPE_STRING;
+ return field_type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ field_type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ field_type == FieldType::OLAP_FIELD_TYPE_STRING;
}
constexpr bool field_is_numeric_type(const FieldType& field_type) {
- return field_type == OLAP_FIELD_TYPE_INT || field_type == OLAP_FIELD_TYPE_UNSIGNED_INT ||
- field_type == OLAP_FIELD_TYPE_BIGINT || field_type == OLAP_FIELD_TYPE_SMALLINT ||
- field_type == OLAP_FIELD_TYPE_UNSIGNED_TINYINT ||
- field_type == OLAP_FIELD_TYPE_UNSIGNED_SMALLINT ||
- field_type == OLAP_FIELD_TYPE_TINYINT || field_type == OLAP_FIELD_TYPE_DOUBLE ||
- field_type == OLAP_FIELD_TYPE_FLOAT || field_type == OLAP_FIELD_TYPE_DATE ||
- field_type == OLAP_FIELD_TYPE_DATEV2 || field_type == OLAP_FIELD_TYPE_DATETIME ||
- field_type == OLAP_FIELD_TYPE_DATETIMEV2 || field_type == OLAP_FIELD_TYPE_LARGEINT ||
- field_type == OLAP_FIELD_TYPE_DECIMAL || field_type == OLAP_FIELD_TYPE_DECIMAL32 ||
- field_type == OLAP_FIELD_TYPE_DECIMAL64 || field_type == OLAP_FIELD_TYPE_DECIMAL128I ||
- field_type == OLAP_FIELD_TYPE_BOOL;
+ return field_type == FieldType::OLAP_FIELD_TYPE_INT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_BIGINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_SMALLINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_TINYINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DOUBLE ||
+ field_type == FieldType::OLAP_FIELD_TYPE_FLOAT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DATE ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DATEV2 ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DATETIME ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DATETIMEV2 ||
+ field_type == FieldType::OLAP_FIELD_TYPE_LARGEINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DECIMAL ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DECIMAL32 ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DECIMAL64 ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DECIMAL128I ||
+ field_type == FieldType::OLAP_FIELD_TYPE_BOOL;
}
// <start_version_id, end_version_id>, such as <100, 110>
diff --git a/be/src/olap/predicate_creator.h b/be/src/olap/predicate_creator.h
index fb83eebf25..bd30d32d43 100644
--- a/be/src/olap/predicate_creator.h
+++ b/be/src/olap/predicate_creator.h
@@ -157,28 +157,28 @@ private:
template <PredicateType PT, typename ConditionType>
std::unique_ptr<PredicateCreator<ConditionType>> get_creator(const FieldType& type) {
switch (type) {
- case OLAP_FIELD_TYPE_TINYINT: {
+ case FieldType::OLAP_FIELD_TYPE_TINYINT: {
return std::make_unique<IntegerPredicateCreator<TYPE_TINYINT, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_SMALLINT: {
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT: {
return std::make_unique<IntegerPredicateCreator<TYPE_SMALLINT, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_INT: {
+ case FieldType::OLAP_FIELD_TYPE_INT: {
return std::make_unique<IntegerPredicateCreator<TYPE_INT, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_BIGINT: {
+ case FieldType::OLAP_FIELD_TYPE_BIGINT: {
return std::make_unique<IntegerPredicateCreator<TYPE_BIGINT, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_LARGEINT: {
+ case FieldType::OLAP_FIELD_TYPE_LARGEINT: {
return std::make_unique<IntegerPredicateCreator<TYPE_LARGEINT, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_FLOAT: {
+ case FieldType::OLAP_FIELD_TYPE_FLOAT: {
return std::make_unique<IntegerPredicateCreator<TYPE_FLOAT, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_DOUBLE: {
+ case FieldType::OLAP_FIELD_TYPE_DOUBLE: {
return std::make_unique<IntegerPredicateCreator<TYPE_DOUBLE, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_DECIMAL: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL: {
return std::make_unique<CustomPredicateCreator<TYPE_DECIMALV2, PT, ConditionType>>(
[](const std::string& condition) {
decimal12_t value = {0, 0};
@@ -186,39 +186,39 @@ std::unique_ptr<PredicateCreator<ConditionType>> get_creator(const FieldType& ty
return value;
});
}
- case OLAP_FIELD_TYPE_DECIMAL32: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32: {
return std::make_unique<DecimalPredicateCreator<TYPE_DECIMAL32, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_DECIMAL64: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64: {
return std::make_unique<DecimalPredicateCreator<TYPE_DECIMAL64, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_DECIMAL128I: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I: {
return std::make_unique<DecimalPredicateCreator<TYPE_DECIMAL128I, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_CHAR: {
+ case FieldType::OLAP_FIELD_TYPE_CHAR: {
return std::make_unique<StringPredicateCreator<TYPE_CHAR, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_VARCHAR:
- case OLAP_FIELD_TYPE_STRING: {
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_STRING: {
return std::make_unique<StringPredicateCreator<TYPE_STRING, PT, ConditionType>>();
}
- case OLAP_FIELD_TYPE_DATE: {
+ case FieldType::OLAP_FIELD_TYPE_DATE: {
return std::make_unique<CustomPredicateCreator<TYPE_DATE, PT, ConditionType>>(
timestamp_from_date);
}
- case OLAP_FIELD_TYPE_DATEV2: {
+ case FieldType::OLAP_FIELD_TYPE_DATEV2: {
return std::make_unique<CustomPredicateCreator<TYPE_DATEV2, PT, ConditionType>>(
timestamp_from_date_v2);
}
- case OLAP_FIELD_TYPE_DATETIME: {
+ case FieldType::OLAP_FIELD_TYPE_DATETIME: {
return std::make_unique<CustomPredicateCreator<TYPE_DATETIME, PT, ConditionType>>(
timestamp_from_datetime);
}
- case OLAP_FIELD_TYPE_DATETIMEV2: {
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: {
return std::make_unique<CustomPredicateCreator<TYPE_DATETIMEV2, PT, ConditionType>>(
timestamp_from_datetime_v2);
}
- case OLAP_FIELD_TYPE_BOOL: {
+ case FieldType::OLAP_FIELD_TYPE_BOOL: {
return std::make_unique<CustomPredicateCreator<TYPE_BOOLEAN, PT, ConditionType>>(
[](const std::string& condition) {
int32_t ivalue = 0;
diff --git a/be/src/olap/primary_key_index.cpp b/be/src/olap/primary_key_index.cpp
index 7c2c5fe16a..f9656ee897 100644
--- a/be/src/olap/primary_key_index.cpp
+++ b/be/src/olap/primary_key_index.cpp
@@ -25,7 +25,7 @@ namespace doris {
Status PrimaryKeyIndexBuilder::init() {
// TODO(liaoxin) using the column type directly if there's only one column in unique key columns
- const auto* type_info = get_scalar_type_info<OLAP_FIELD_TYPE_VARCHAR>();
+ const auto* type_info = get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_VARCHAR>();
segment_v2::IndexedColumnWriterOptions options;
options.write_ordinal_index = true;
options.write_value_index = true;
diff --git a/be/src/olap/row_cursor.cpp b/be/src/olap/row_cursor.cpp
index e9fe2e9396..ec0fd094ff 100644
--- a/be/src/olap/row_cursor.cpp
+++ b/be/src/olap/row_cursor.cpp
@@ -51,7 +51,7 @@ Status RowCursor::_init(const std::vector<uint32_t>& columns) {
return Status::Error<INIT_FAILED>();
}
_variable_len += column_schema(cid)->get_variable_len();
- if (_schema->column(cid)->type() == OLAP_FIELD_TYPE_STRING) {
+ if (_schema->column(cid)->type() == FieldType::OLAP_FIELD_TYPE_STRING) {
++_string_field_count;
}
}
@@ -87,11 +87,12 @@ Status RowCursor::_init_scan_key(TabletSchemaSPtr schema,
for (auto cid : _schema->column_ids()) {
const TabletColumn& column = schema->column(cid);
FieldType type = column.type();
- if (type == OLAP_FIELD_TYPE_VARCHAR) {
+ if (type == FieldType::OLAP_FIELD_TYPE_VARCHAR) {
_variable_len += scan_keys[cid].length();
- } else if (type == OLAP_FIELD_TYPE_CHAR || type == OLAP_FIELD_TYPE_ARRAY) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ type == FieldType::OLAP_FIELD_TYPE_ARRAY) {
_variable_len += std::max(scan_keys[cid].length(), column.length());
- } else if (type == OLAP_FIELD_TYPE_STRING) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_STRING) {
++_string_field_count;
}
}
@@ -105,17 +106,17 @@ Status RowCursor::_init_scan_key(TabletSchemaSPtr schema,
const TabletColumn& column = schema->column(cid);
fixed_ptr = _fixed_buf + _schema->column_offset(cid);
FieldType type = column.type();
- if (type == OLAP_FIELD_TYPE_VARCHAR) {
+ if (type == FieldType::OLAP_FIELD_TYPE_VARCHAR) {
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) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_CHAR) {
Slice* slice = reinterpret_cast<Slice*>(fixed_ptr + 1);
slice->data = variable_ptr;
slice->size = std::max(scan_keys[cid].length(), column.length());
variable_ptr += slice->size;
- } else if (type == OLAP_FIELD_TYPE_STRING) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_STRING) {
_schema->mutable_column(cid)->set_long_text_buf(long_text_ptr);
Slice* slice = reinterpret_cast<Slice*>(fixed_ptr + 1);
slice->data = *(long_text_ptr);
@@ -221,7 +222,7 @@ Status RowCursor::allocate_memory_for_string_type(TabletSchemaSPtr schema) {
char** long_text_ptr = _long_text_buf;
for (auto cid : _schema->column_ids()) {
fixed_ptr = _fixed_buf + _schema->column_offset(cid);
- if (_schema->column(cid)->type() == OLAP_FIELD_TYPE_STRING) {
+ if (_schema->column(cid)->type() == FieldType::OLAP_FIELD_TYPE_STRING) {
Slice* slice = reinterpret_cast<Slice*>(fixed_ptr + 1);
_schema->mutable_column(cid)->set_long_text_buf(long_text_ptr);
slice->data = *(long_text_ptr);
diff --git a/be/src/olap/rowset/segment_v2/binary_dict_page.cpp b/be/src/olap/rowset/segment_v2/binary_dict_page.cpp
index 85e1d4db2d..4ac002400e 100644
--- a/be/src/olap/rowset/segment_v2/binary_dict_page.cpp
+++ b/be/src/olap/rowset/segment_v2/binary_dict_page.cpp
@@ -34,12 +34,13 @@ BinaryDictPageBuilder::BinaryDictPageBuilder(const PageBuilderOptions& options)
_encoding_type(DICT_ENCODING) {
// initially use DICT_ENCODING
// TODO: the data page builder type can be created by Factory according to user config
- _data_page_builder.reset(new BitshufflePageBuilder<OLAP_FIELD_TYPE_INT>(options));
+ _data_page_builder.reset(new BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>(options));
PageBuilderOptions dict_builder_options;
dict_builder_options.data_page_size =
std::min(_options.data_page_size, _options.dict_page_size);
dict_builder_options.is_dict_page = true;
- _dict_builder.reset(new BinaryPlainPageBuilder<OLAP_FIELD_TYPE_VARCHAR>(dict_builder_options));
+ _dict_builder.reset(
+ new BinaryPlainPageBuilder<FieldType::OLAP_FIELD_TYPE_VARCHAR>(dict_builder_options));
reset();
}
@@ -60,8 +61,8 @@ Status BinaryDictPageBuilder::add(const uint8_t* vals, size_t* count) {
const Slice* src = reinterpret_cast<const Slice*>(vals);
size_t num_added = 0;
uint32_t value_code = -1;
- auto* actual_builder =
- down_cast<BitshufflePageBuilder<OLAP_FIELD_TYPE_INT>*>(_data_page_builder.get());
+ auto* actual_builder = down_cast<BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>*>(
+ _data_page_builder.get());
if (_data_page_builder->count() == 0) {
_first_value.assign_copy(reinterpret_cast<const uint8_t*>(src->get_data()),
@@ -139,7 +140,8 @@ void BinaryDictPageBuilder::reset() {
_buffer.resize(BINARY_DICT_PAGE_HEADER_SIZE);
if (_encoding_type == DICT_ENCODING && _dict_builder->is_page_full()) {
- _data_page_builder.reset(new BinaryPlainPageBuilder<OLAP_FIELD_TYPE_VARCHAR>(_options));
+ _data_page_builder.reset(
+ new BinaryPlainPageBuilder<FieldType::OLAP_FIELD_TYPE_VARCHAR>(_options));
_encoding_type = PLAIN_ENCODING;
} else {
_data_page_builder->reset();
@@ -203,10 +205,12 @@ Status BinaryDictPageDecoder::init() {
_data.remove_prefix(BINARY_DICT_PAGE_HEADER_SIZE);
if (_encoding_type == DICT_ENCODING) {
_data_page_decoder.reset(
- _bit_shuffle_ptr = new BitShufflePageDecoder<OLAP_FIELD_TYPE_INT>(_data, _options));
+ _bit_shuffle_ptr =
+ new BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>(_data, _options));
} else if (_encoding_type == PLAIN_ENCODING) {
DCHECK_EQ(_encoding_type, PLAIN_ENCODING);
- _data_page_decoder.reset(new BinaryPlainPageDecoder<OLAP_FIELD_TYPE_INT>(_data, _options));
+ _data_page_decoder.reset(
+ new BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_INT>(_data, _options));
} else {
LOG(WARNING) << "invalid encoding type:" << _encoding_type;
return Status::Corruption("invalid encoding type:{}", _encoding_type);
@@ -228,7 +232,7 @@ bool BinaryDictPageDecoder::is_dict_encoding() const {
}
void BinaryDictPageDecoder::set_dict_decoder(PageDecoder* dict_decoder, StringRef* dict_word_info) {
- _dict_decoder = (BinaryPlainPageDecoder<OLAP_FIELD_TYPE_VARCHAR>*)dict_decoder;
+ _dict_decoder = (BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_VARCHAR>*)dict_decoder;
_dict_word_info = dict_word_info;
};
diff --git a/be/src/olap/rowset/segment_v2/binary_dict_page.h b/be/src/olap/rowset/segment_v2/binary_dict_page.h
index 3e3b80a4fc..26bf127a1f 100644
--- a/be/src/olap/rowset/segment_v2/binary_dict_page.h
+++ b/be/src/olap/rowset/segment_v2/binary_dict_page.h
@@ -75,7 +75,7 @@ private:
std::unique_ptr<PageBuilder> _data_page_builder;
- std::unique_ptr<BinaryPlainPageBuilder<OLAP_FIELD_TYPE_VARCHAR>> _dict_builder;
+ std::unique_ptr<BinaryPlainPageBuilder<FieldType::OLAP_FIELD_TYPE_VARCHAR>> _dict_builder;
EncodingTypePB _encoding_type;
struct HashOfSlice {
@@ -123,8 +123,8 @@ private:
Slice _data;
PageDecoderOptions _options;
std::unique_ptr<PageDecoder> _data_page_decoder;
- BinaryPlainPageDecoder<OLAP_FIELD_TYPE_VARCHAR>* _dict_decoder = nullptr;
- BitShufflePageDecoder<OLAP_FIELD_TYPE_INT>* _bit_shuffle_ptr = nullptr;
+ BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_VARCHAR>* _dict_decoder = nullptr;
+ BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>* _bit_shuffle_ptr = nullptr;
bool _parsed;
EncodingTypePB _encoding_type;
diff --git a/be/src/olap/rowset/segment_v2/binary_plain_page.h b/be/src/olap/rowset/segment_v2/binary_plain_page.h
index f2fc869508..0c60c9582c 100644
--- a/be/src/olap/rowset/segment_v2/binary_plain_page.h
+++ b/be/src/olap/rowset/segment_v2/binary_plain_page.h
@@ -70,7 +70,7 @@ public:
// If the page is full, should stop adding more items.
while (!is_page_full() && i < *count) {
auto src = reinterpret_cast<const Slice*>(vals);
- if constexpr (Type == OLAP_FIELD_TYPE_OBJECT) {
+ if constexpr (Type == FieldType::OLAP_FIELD_TYPE_OBJECT) {
if (_options.need_check_bitmap) {
RETURN_IF_ERROR(BitmapTypeCode::validate(*(src->data)));
}
@@ -220,7 +220,7 @@ public:
const uint32_t start_offset = last_offset;
last_offset = guarded_offset(_cur_idx + 1);
offsets[i + 1] = last_offset;
- if constexpr (Type == OLAP_FIELD_TYPE_OBJECT) {
+ if constexpr (Type == FieldType::OLAP_FIELD_TYPE_OBJECT) {
if (_options.need_check_bitmap) {
RETURN_IF_ERROR(BitmapTypeCode::validate(*(_data.data + start_offset)));
}
@@ -228,7 +228,7 @@ public:
}
_cur_idx++;
offsets[max_fetch] = offset(_cur_idx);
- if constexpr (Type == OLAP_FIELD_TYPE_OBJECT) {
+ if constexpr (Type == FieldType::OLAP_FIELD_TYPE_OBJECT) {
if (_options.need_check_bitmap) {
RETURN_IF_ERROR(BitmapTypeCode::validate(*(_data.data + last_offset)));
}
diff --git a/be/src/olap/rowset/segment_v2/bitmap_index_reader.h b/be/src/olap/rowset/segment_v2/bitmap_index_reader.h
index c515e6452b..e5fc28adcd 100644
--- a/be/src/olap/rowset/segment_v2/bitmap_index_reader.h
+++ b/be/src/olap/rowset/segment_v2/bitmap_index_reader.h
@@ -40,7 +40,7 @@ public:
explicit BitmapIndexReader(io::FileReaderSPtr file_reader,
const BitmapIndexPB* bitmap_index_meta)
: _file_reader(std::move(file_reader)),
- _type_info(get_scalar_type_info<OLAP_FIELD_TYPE_VARCHAR>()),
+ _type_info(get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_VARCHAR>()),
_bitmap_index_meta(bitmap_index_meta) {}
Status load(bool use_page_cache, bool kept_in_memory);
diff --git a/be/src/olap/rowset/segment_v2/bitmap_index_writer.cpp b/be/src/olap/rowset/segment_v2/bitmap_index_writer.cpp
index 57b6b3b30a..957da3dc3d 100644
--- a/be/src/olap/rowset/segment_v2/bitmap_index_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/bitmap_index_writer.cpp
@@ -139,7 +139,8 @@ public:
bitmap_sizes.push_back(bitmap_size);
}
- const auto* bitmap_type_info = get_scalar_type_info<OLAP_FIELD_TYPE_OBJECT>();
+ const auto* bitmap_type_info =
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_OBJECT>();
IndexedColumnWriterOptions options;
options.write_ordinal_index = true;
options.write_value_index = false;
@@ -189,62 +190,63 @@ Status BitmapIndexWriter::create(const TypeInfo* type_info,
std::unique_ptr<BitmapIndexWriter>* res) {
FieldType type = type_info->type();
switch (type) {
- case OLAP_FIELD_TYPE_TINYINT:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_TINYINT>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_TINYINT:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_TINYINT>(type_info));
break;
- case OLAP_FIELD_TYPE_SMALLINT:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_SMALLINT>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_SMALLINT>(type_info));
break;
- case OLAP_FIELD_TYPE_INT:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_INT>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_INT:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_INT>(type_info));
break;
- case OLAP_FIELD_TYPE_UNSIGNED_INT:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_UNSIGNED_INT>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT>(type_info));
break;
- case OLAP_FIELD_TYPE_BIGINT:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_BIGINT>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_BIGINT:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_BIGINT>(type_info));
break;
- case OLAP_FIELD_TYPE_CHAR:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_CHAR>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_CHAR>(type_info));
break;
- case OLAP_FIELD_TYPE_VARCHAR:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_VARCHAR>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_VARCHAR>(type_info));
break;
- case OLAP_FIELD_TYPE_STRING:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_STRING>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_STRING:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_STRING>(type_info));
break;
- case OLAP_FIELD_TYPE_DATE:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_DATE>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_DATE:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_DATE>(type_info));
break;
- case OLAP_FIELD_TYPE_DATETIME:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_DATETIME>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_DATETIME:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_DATETIME>(type_info));
break;
- case OLAP_FIELD_TYPE_DATEV2:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_DATEV2>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_DATEV2:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_DATEV2>(type_info));
break;
- case OLAP_FIELD_TYPE_DATETIMEV2:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_DATETIMEV2>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(type_info));
break;
- case OLAP_FIELD_TYPE_LARGEINT:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_LARGEINT>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_LARGEINT:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_LARGEINT>(type_info));
break;
- case OLAP_FIELD_TYPE_DECIMAL:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_DECIMAL>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_DECIMAL>(type_info));
break;
- case OLAP_FIELD_TYPE_DECIMAL32:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_DECIMAL32>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_DECIMAL32>(type_info));
break;
- case OLAP_FIELD_TYPE_DECIMAL64:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_DECIMAL64>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_DECIMAL64>(type_info));
break;
- case OLAP_FIELD_TYPE_DECIMAL128I:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_DECIMAL128I>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_DECIMAL128I>(type_info));
break;
- case OLAP_FIELD_TYPE_BOOL:
- res->reset(new BitmapIndexWriterImpl<OLAP_FIELD_TYPE_BOOL>(type_info));
+ case FieldType::OLAP_FIELD_TYPE_BOOL:
+ res->reset(new BitmapIndexWriterImpl<FieldType::OLAP_FIELD_TYPE_BOOL>(type_info));
break;
default:
- return Status::NotSupported("unsupported type for bitmap index: {}", std::to_string(type));
+ return Status::NotSupported("unsupported type for bitmap index: {}",
+ std::to_string(int(type)));
}
return Status::OK();
}
diff --git a/be/src/olap/rowset/segment_v2/bitshuffle_page.h b/be/src/olap/rowset/segment_v2/bitshuffle_page.h
index c5c2d235ed..767ff35cfe 100644
--- a/be/src/olap/rowset/segment_v2/bitshuffle_page.h
+++ b/be/src/olap/rowset/segment_v2/bitshuffle_page.h
@@ -300,7 +300,8 @@ public:
}
// Currently, only the UINT32 block encoder supports expanding size:
- if (UNLIKELY(Type != OLAP_FIELD_TYPE_UNSIGNED_INT && _size_of_element != SIZE_OF_TYPE)) {
+ if (UNLIKELY(Type != FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT &&
+ _size_of_element != SIZE_OF_TYPE)) {
return Status::InternalError(
"invalid size info. size of element:{}, SIZE_OF_TYPE:{}, type:{}",
_size_of_element, SIZE_OF_TYPE, Type);
diff --git a/be/src/olap/rowset/segment_v2/bloom_filter_index_reader.h b/be/src/olap/rowset/segment_v2/bloom_filter_index_reader.h
index 66217ae7b7..bb9a02c244 100644
--- a/be/src/olap/rowset/segment_v2/bloom_filter_index_reader.h
+++ b/be/src/olap/rowset/segment_v2/bloom_filter_index_reader.h
@@ -43,7 +43,7 @@ public:
explicit BloomFilterIndexReader(io::FileReaderSPtr file_reader,
const BloomFilterIndexPB* bloom_filter_index_meta)
: _file_reader(std::move(file_reader)),
- _type_info(get_scalar_type_info<OLAP_FIELD_TYPE_VARCHAR>()),
+ _type_info(get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_VARCHAR>()),
_bloom_filter_index_meta(bloom_filter_index_meta) {}
Status load(bool use_page_cache, bool kept_in_memory);
diff --git a/be/src/olap/rowset/segment_v2/bloom_filter_index_writer.cpp b/be/src/olap/rowset/segment_v2/bloom_filter_index_writer.cpp
index 7d9455dcdf..588f2eb997 100644
--- a/be/src/olap/rowset/segment_v2/bloom_filter_index_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/bloom_filter_index_writer.cpp
@@ -125,7 +125,7 @@ public:
meta->set_algorithm(BLOCK_BLOOM_FILTER);
// write bloom filters
- const auto* bf_type_info = get_scalar_type_info<OLAP_FIELD_TYPE_VARCHAR>();
+ const auto* bf_type_info = get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_VARCHAR>();
IndexedColumnWriterOptions options;
options.write_ordinal_index = true;
options.write_value_index = false;
@@ -147,13 +147,14 @@ public:
}
private:
- // supported slice types are: OLAP_FIELD_TYPE_CHAR|OLAP_FIELD_TYPE_VARCHAR
+ // supported slice types are: FieldType::OLAP_FIELD_TYPE_CHAR|FieldType::OLAP_FIELD_TYPE_VARCHAR
static constexpr bool _is_slice_type() {
- return field_type == OLAP_FIELD_TYPE_VARCHAR || field_type == OLAP_FIELD_TYPE_CHAR ||
- field_type == OLAP_FIELD_TYPE_STRING;
+ return field_type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ field_type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ field_type == FieldType::OLAP_FIELD_TYPE_STRING;
}
- static constexpr bool _is_int128() { return field_type == OLAP_FIELD_TYPE_LARGEINT; }
+ static constexpr bool _is_int128() { return field_type == FieldType::OLAP_FIELD_TYPE_LARGEINT; }
private:
BloomFilterOptions _bf_options;
@@ -204,7 +205,7 @@ Status NGramBloomFilterIndexWriterImpl::finish(io::FileWriter* file_writer,
meta->set_algorithm(NGRAM_BLOOM_FILTER);
// write bloom filters
- const TypeInfo* bf_typeinfo = get_scalar_type_info(OLAP_FIELD_TYPE_VARCHAR);
+ const TypeInfo* bf_typeinfo = get_scalar_type_info(FieldType::OLAP_FIELD_TYPE_VARCHAR);
IndexedColumnWriterOptions options;
options.write_ordinal_index = true;
options.write_value_index = false;
@@ -235,25 +236,26 @@ Status BloomFilterIndexWriter::create(const BloomFilterOptions& bf_options,
case TYPE: \
res->reset(new BloomFilterIndexWriterImpl<TYPE>(bf_options, type_info)); \
break;
- M(OLAP_FIELD_TYPE_SMALLINT)
- M(OLAP_FIELD_TYPE_INT)
- M(OLAP_FIELD_TYPE_UNSIGNED_INT)
- M(OLAP_FIELD_TYPE_BIGINT)
- M(OLAP_FIELD_TYPE_LARGEINT)
- M(OLAP_FIELD_TYPE_CHAR)
- M(OLAP_FIELD_TYPE_VARCHAR)
- M(OLAP_FIELD_TYPE_STRING)
- M(OLAP_FIELD_TYPE_DATE)
- M(OLAP_FIELD_TYPE_DATETIME)
- M(OLAP_FIELD_TYPE_DECIMAL)
- M(OLAP_FIELD_TYPE_DATEV2)
- M(OLAP_FIELD_TYPE_DATETIMEV2)
- M(OLAP_FIELD_TYPE_DECIMAL32)
- M(OLAP_FIELD_TYPE_DECIMAL64)
- M(OLAP_FIELD_TYPE_DECIMAL128I)
+ M(FieldType::OLAP_FIELD_TYPE_SMALLINT)
+ M(FieldType::OLAP_FIELD_TYPE_INT)
+ M(FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT)
+ M(FieldType::OLAP_FIELD_TYPE_BIGINT)
+ M(FieldType::OLAP_FIELD_TYPE_LARGEINT)
+ M(FieldType::OLAP_FIELD_TYPE_CHAR)
+ M(FieldType::OLAP_FIELD_TYPE_VARCHAR)
+ M(FieldType::OLAP_FIELD_TYPE_STRING)
+ M(FieldType::OLAP_FIELD_TYPE_DATE)
+ M(FieldType::OLAP_FIELD_TYPE_DATETIME)
+ M(FieldType::OLAP_FIELD_TYPE_DECIMAL)
+ M(FieldType::OLAP_FIELD_TYPE_DATEV2)
+ M(FieldType::OLAP_FIELD_TYPE_DATETIMEV2)
+ M(FieldType::OLAP_FIELD_TYPE_DECIMAL32)
+ M(FieldType::OLAP_FIELD_TYPE_DECIMAL64)
+ M(FieldType::OLAP_FIELD_TYPE_DECIMAL128I)
#undef M
default:
- return Status::NotSupported("unsupported type for bitmap index: {}", std::to_string(type));
+ return Status::NotSupported("unsupported type for bitmap index: {}",
+ std::to_string(int(type)));
}
return Status::OK();
}
@@ -264,14 +266,14 @@ Status NGramBloomFilterIndexWriterImpl::create(const BloomFilterOptions& bf_opti
std::unique_ptr<BloomFilterIndexWriter>* res) {
FieldType type = typeinfo->type();
switch (type) {
- case OLAP_FIELD_TYPE_CHAR:
- case OLAP_FIELD_TYPE_VARCHAR:
- case OLAP_FIELD_TYPE_STRING:
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_STRING:
res->reset(new NGramBloomFilterIndexWriterImpl(bf_options, gram_size, gram_bf_size));
break;
default:
return Status::NotSupported("unsupported type for ngram bloom filter index:{}",
- std::to_string(type));
+ std::to_string(int(type)));
}
return Status::OK();
}
diff --git a/be/src/olap/rowset/segment_v2/column_reader.cpp b/be/src/olap/rowset/segment_v2/column_reader.cpp
index 5ddf1d5ec9..a4a437c353 100644
--- a/be/src/olap/rowset/segment_v2/column_reader.cpp
+++ b/be/src/olap/rowset/segment_v2/column_reader.cpp
@@ -136,7 +136,7 @@ Status ColumnReader::create(const ColumnReaderOptions& opts, const ColumnMetaPB&
}
default:
return Status::NotSupported("unsupported type for ColumnReader: {}",
- std::to_string(type));
+ std::to_string(int(type)));
}
}
}
@@ -342,7 +342,7 @@ Status ColumnReader::_get_filtered_pages(const AndBlockColumnPredicate* col_pred
for (auto del_pred : *delete_predicates) {
// TODO: Both `min_value` and `max_value` should be 0 or neither should be 0.
// So nullable only need to judge once.
- if (min_value.get() != nullptr && max_value.get() != nullptr &&
+ if (min_value != nullptr && max_value != nullptr &&
del_pred->evaluate_del({min_value.get(), max_value.get()})) {
should_read = false;
break;
@@ -553,7 +553,7 @@ Status ColumnReader::new_iterator(ColumnIterator** iterator) {
}
default:
return Status::NotSupported("unsupported type to create iterator: {}",
- std::to_string(type));
+ std::to_string(int(type)));
}
}
}
@@ -1112,12 +1112,12 @@ Status FileColumnIterator::_read_data_page(const OrdinalPageIndexIterator& iter)
_compress_codec));
// ignore dict_footer.dict_page_footer().encoding() due to only
// PLAIN_ENCODING is supported for dict page right now
- _dict_decoder = std::make_unique<BinaryPlainPageDecoder<OLAP_FIELD_TYPE_VARCHAR>>(
- dict_data);
+ _dict_decoder = std::make_unique<
+ BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_VARCHAR>>(dict_data);
RETURN_IF_ERROR(_dict_decoder->init());
- auto* pd_decoder =
- (BinaryPlainPageDecoder<OLAP_FIELD_TYPE_VARCHAR>*)_dict_decoder.get();
+ auto* pd_decoder = (BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_VARCHAR>*)
+ _dict_decoder.get();
_dict_word_info.reset(new StringRef[pd_decoder->_num_elems]);
pd_decoder->get_dict_word_info(_dict_word_info.get());
}
@@ -1161,23 +1161,23 @@ Status DefaultValueColumnIterator::init(const ColumnIteratorOptions& opts) {
Status s = Status::OK();
// If char length is 10, but default value is 'a' , it's length is 1
// not fill 0 to the ending, because segment iterator will shrink the tail 0 char
- if (_type_info->type() == OLAP_FIELD_TYPE_VARCHAR ||
- _type_info->type() == OLAP_FIELD_TYPE_HLL ||
- _type_info->type() == OLAP_FIELD_TYPE_OBJECT ||
- _type_info->type() == OLAP_FIELD_TYPE_STRING ||
- _type_info->type() == OLAP_FIELD_TYPE_CHAR) {
+ if (_type_info->type() == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ _type_info->type() == FieldType::OLAP_FIELD_TYPE_HLL ||
+ _type_info->type() == FieldType::OLAP_FIELD_TYPE_OBJECT ||
+ _type_info->type() == FieldType::OLAP_FIELD_TYPE_STRING ||
+ _type_info->type() == FieldType::OLAP_FIELD_TYPE_CHAR) {
((Slice*)_mem_value.data())->size = _default_value.length();
((Slice*)_mem_value.data())->data = _default_value.data();
- } else if (_type_info->type() == OLAP_FIELD_TYPE_ARRAY) {
+ } else if (_type_info->type() == FieldType::OLAP_FIELD_TYPE_ARRAY) {
if (_default_value != "[]") {
return Status::NotSupported("Array default {} is unsupported", _default_value);
} else {
((Slice*)_mem_value.data())->size = _default_value.length();
((Slice*)_mem_value.data())->data = _default_value.data();
}
- } else if (_type_info->type() == OLAP_FIELD_TYPE_STRUCT) {
+ } else if (_type_info->type() == FieldType::OLAP_FIELD_TYPE_STRUCT) {
return Status::NotSupported("STRUCT default type is unsupported");
- } else if (_type_info->type() == OLAP_FIELD_TYPE_MAP) {
+ } else if (_type_info->type() == FieldType::OLAP_FIELD_TYPE_MAP) {
return Status::NotSupported("MAP default type is unsupported");
} else {
s = _type_info->from_string(_mem_value.data(), _default_value, _precision, _scale);
@@ -1202,18 +1202,19 @@ void DefaultValueColumnIterator::insert_default_data(const TypeInfo* type_info,
dst = dst->convert_to_predicate_column_if_dictionary();
switch (type_info->type()) {
- case OLAP_FIELD_TYPE_OBJECT:
- case OLAP_FIELD_TYPE_HLL: {
+ case FieldType::OLAP_FIELD_TYPE_OBJECT:
+ case FieldType::OLAP_FIELD_TYPE_HLL: {
dst->insert_many_defaults(n);
break;
}
- case OLAP_FIELD_TYPE_DATE: {
+ case FieldType::OLAP_FIELD_TYPE_DATE: {
vectorized::Int64 int64;
char* data_ptr = (char*)&int64;
size_t data_len = sizeof(int64);
- assert(type_size == sizeof(FieldTypeTraits<OLAP_FIELD_TYPE_DATE>::CppType)); //uint24_t
- std::string str = FieldTypeTraits<OLAP_FIELD_TYPE_DATE>::to_string(mem_value);
+ assert(type_size ==
+ sizeof(FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DATE>::CppType)); //uint24_t
+ std::string str = FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DATE>::to_string(mem_value);
vectorized::VecDateTimeValue value;
value.from_date_str(str.c_str(), str.length());
@@ -1223,13 +1224,15 @@ void DefaultValueColumnIterator::insert_default_data(const TypeInfo* type_info,
dst->insert_many_data(data_ptr, data_len, n);
break;
}
- case OLAP_FIELD_TYPE_DATETIME: {
+ case FieldType::OLAP_FIELD_TYPE_DATETIME: {
vectorized::Int64 int64;
char* data_ptr = (char*)&int64;
size_t data_len = sizeof(int64);
- assert(type_size == sizeof(FieldTypeTraits<OLAP_FIELD_TYPE_DATETIME>::CppType)); //int64_t
- std::string str = FieldTypeTraits<OLAP_FIELD_TYPE_DATETIME>::to_string(mem_value);
+ assert(type_size ==
+ sizeof(FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIME>::CppType)); //int64_t
+ std::string str =
+ FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIME>::to_string(mem_value);
vectorized::VecDateTimeValue value;
value.from_date_str(str.c_str(), str.length());
@@ -1239,28 +1242,28 @@ void DefaultValueColumnIterator::insert_default_data(const TypeInfo* type_info,
dst->insert_many_data(data_ptr, data_len, n);
break;
}
- case OLAP_FIELD_TYPE_DECIMAL: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL: {
vectorized::Int128 int128;
char* data_ptr = (char*)&int128;
size_t data_len = sizeof(int128);
assert(type_size ==
- sizeof(FieldTypeTraits<OLAP_FIELD_TYPE_DECIMAL>::CppType)); //decimal12_t
+ sizeof(FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL>::CppType)); //decimal12_t
decimal12_t* d = (decimal12_t*)mem_value;
int128 = DecimalV2Value(d->integer, d->fraction).value();
dst->insert_many_data(data_ptr, data_len, n);
break;
}
- case OLAP_FIELD_TYPE_STRING:
- case OLAP_FIELD_TYPE_VARCHAR:
- case OLAP_FIELD_TYPE_CHAR:
- case OLAP_FIELD_TYPE_JSONB: {
+ case FieldType::OLAP_FIELD_TYPE_STRING:
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
+ case FieldType::OLAP_FIELD_TYPE_JSONB: {
char* data_ptr = ((Slice*)mem_value)->data;
size_t data_len = ((Slice*)mem_value)->size;
dst->insert_many_data(data_ptr, data_len, n);
break;
}
- case OLAP_FIELD_TYPE_ARRAY: {
+ case FieldType::OLAP_FIELD_TYPE_ARRAY: {
if (dst->is_nullable()) {
static_cast<vectorized::ColumnNullable&>(*dst).insert_not_null_elements(n);
} else {
diff --git a/be/src/olap/rowset/segment_v2/column_writer.cpp b/be/src/olap/rowset/segment_v2/column_writer.cpp
index 2ffd3ee6b0..ab542a49dd 100644
--- a/be/src/olap/rowset/segment_v2/column_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/column_writer.cpp
@@ -133,10 +133,10 @@ Status ColumnWriter::create(const ColumnWriterOptions& opts, const TabletColumn*
null_options.meta = opts.meta->add_children_columns();
null_options.meta->set_column_id(column->get_subtype_count() + 1);
null_options.meta->set_unique_id(column->get_subtype_count() + 1);
- null_options.meta->set_type(null_type);
+ null_options.meta->set_type(int(null_type));
null_options.meta->set_is_nullable(false);
null_options.meta->set_length(
- get_scalar_type_info<OLAP_FIELD_TYPE_TINYINT>()->size());
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_TINYINT>()->size());
null_options.meta->set_encoding(DEFAULT_ENCODING);
null_options.meta->set_compression(opts.meta->compression());
@@ -190,10 +190,10 @@ Status ColumnWriter::create(const ColumnWriterOptions& opts, const TabletColumn*
length_options.meta = opts.meta->add_children_columns();
length_options.meta->set_column_id(2);
length_options.meta->set_unique_id(2);
- length_options.meta->set_type(length_type);
+ length_options.meta->set_type(int(length_type));
length_options.meta->set_is_nullable(false);
length_options.meta->set_length(
- get_scalar_type_info<OLAP_FIELD_TYPE_UNSIGNED_BIGINT>()->size());
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT>()->size());
length_options.meta->set_encoding(DEFAULT_ENCODING);
length_options.meta->set_compression(opts.meta->compression());
@@ -218,10 +218,10 @@ Status ColumnWriter::create(const ColumnWriterOptions& opts, const TabletColumn*
null_options.meta = opts.meta->add_children_columns();
null_options.meta->set_column_id(3);
null_options.meta->set_unique_id(3);
- null_options.meta->set_type(null_type);
+ null_options.meta->set_type(int(null_type));
null_options.meta->set_is_nullable(false);
null_options.meta->set_length(
- get_scalar_type_info<OLAP_FIELD_TYPE_TINYINT>()->size());
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_TINYINT>()->size());
null_options.meta->set_encoding(DEFAULT_ENCODING);
null_options.meta->set_compression(opts.meta->compression());
@@ -281,10 +281,10 @@ Status ColumnWriter::create(const ColumnWriterOptions& opts, const TabletColumn*
length_options.meta = opts.meta->add_children_columns();
length_options.meta->set_column_id(column->get_subtype_count() + 1);
length_options.meta->set_unique_id(column->get_subtype_count() + 1);
- length_options.meta->set_type(length_type);
+ length_options.meta->set_type(int(length_type));
length_options.meta->set_is_nullable(false);
length_options.meta->set_length(
- get_scalar_type_info<OLAP_FIELD_TYPE_UNSIGNED_BIGINT>()->size());
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT>()->size());
length_options.meta->set_encoding(DEFAULT_ENCODING);
length_options.meta->set_compression(opts.meta->compression());
@@ -308,10 +308,10 @@ Status ColumnWriter::create(const ColumnWriterOptions& opts, const TabletColumn*
null_options.meta = opts.meta->add_children_columns();
null_options.meta->set_column_id(column->get_subtype_count() + 2);
null_options.meta->set_unique_id(column->get_subtype_count() + 2);
- null_options.meta->set_type(null_type);
+ null_options.meta->set_type(int(null_type));
null_options.meta->set_is_nullable(false);
null_options.meta->set_length(
- get_scalar_type_info<OLAP_FIELD_TYPE_TINYINT>()->size());
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_TINYINT>()->size());
null_options.meta->set_encoding(DEFAULT_ENCODING);
null_options.meta->set_compression(opts.meta->compression());
@@ -340,7 +340,7 @@ Status ColumnWriter::create(const ColumnWriterOptions& opts, const TabletColumn*
}
default:
return Status::NotSupported("unsupported type for ColumnWriter: {}",
- std::to_string(field->type()));
+ std::to_string(int(field->type())));
}
}
}
@@ -367,10 +367,11 @@ Status ColumnWriter::append_nullable(const uint8_t* null_map, const uint8_t** pt
auto next_run_step = [&]() {
size_t step = 1;
for (auto i = offset + 1; i < num_rows; ++i) {
- if (null_map[offset] == null_map[i])
+ if (null_map[offset] == null_map[i]) {
step++;
- else
+ } else {
break;
+ }
}
return step;
};
diff --git a/be/src/olap/rowset/segment_v2/encoding_info.cpp b/be/src/olap/rowset/segment_v2/encoding_info.cpp
index 7ba80492ee..0949e9c1b9 100644
--- a/be/src/olap/rowset/segment_v2/encoding_info.cpp
+++ b/be/src/olap/rowset/segment_v2/encoding_info.cpp
@@ -34,8 +34,9 @@ namespace doris {
namespace segment_v2 {
struct EncodingMapHash {
+ size_t operator()(const FieldType& type) const { return int(type); }
size_t operator()(const std::pair<FieldType, EncodingTypePB>& pair) const {
- return (pair.first << 5) ^ pair.second;
+ return (int(pair.first) << 6) ^ pair.second;
}
};
@@ -83,14 +84,14 @@ struct TypeEncodingTraits<type, BIT_SHUFFLE, CppType,
};
template <>
-struct TypeEncodingTraits<OLAP_FIELD_TYPE_BOOL, RLE, bool> {
+struct TypeEncodingTraits<FieldType::OLAP_FIELD_TYPE_BOOL, RLE, bool> {
static Status create_page_builder(const PageBuilderOptions& opts, PageBuilder** builder) {
- *builder = new RlePageBuilder<OLAP_FIELD_TYPE_BOOL>(opts);
+ *builder = new RlePageBuilder<FieldType::OLAP_FIELD_TYPE_BOOL>(opts);
return Status::OK();
}
static Status create_page_decoder(const Slice& data, const PageDecoderOptions& opts,
PageDecoder** decoder) {
- *decoder = new RlePageDecoder<OLAP_FIELD_TYPE_BOOL>(data, opts);
+ *decoder = new RlePageDecoder<FieldType::OLAP_FIELD_TYPE_BOOL>(data, opts);
return Status::OK();
}
};
@@ -109,43 +110,44 @@ struct TypeEncodingTraits<type, DICT_ENCODING, Slice> {
};
template <>
-struct TypeEncodingTraits<OLAP_FIELD_TYPE_DATE, FOR_ENCODING,
- typename CppTypeTraits<OLAP_FIELD_TYPE_DATE>::CppType> {
+struct TypeEncodingTraits<FieldType::OLAP_FIELD_TYPE_DATE, FOR_ENCODING,
+ typename CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATE>::CppType> {
static Status create_page_builder(const PageBuilderOptions& opts, PageBuilder** builder) {
- *builder = new FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_DATE>(opts);
+ *builder = new FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_DATE>(opts);
return Status::OK();
}
static Status create_page_decoder(const Slice& data, const PageDecoderOptions& opts,
PageDecoder** decoder) {
- *decoder = new FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_DATE>(data, opts);
+ *decoder = new FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_DATE>(data, opts);
return Status::OK();
}
};
template <>
-struct TypeEncodingTraits<OLAP_FIELD_TYPE_DATEV2, FOR_ENCODING,
- typename CppTypeTraits<OLAP_FIELD_TYPE_DATEV2>::CppType> {
+struct TypeEncodingTraits<FieldType::OLAP_FIELD_TYPE_DATEV2, FOR_ENCODING,
+ typename CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATEV2>::CppType> {
static Status create_page_builder(const PageBuilderOptions& opts, PageBuilder** builder) {
- *builder = new FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_DATEV2>(opts);
+ *builder = new FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_DATEV2>(opts);
return Status::OK();
}
static Status create_page_decoder(const Slice& data, const PageDecoderOptions& opts,
PageDecoder** decoder) {
- *decoder = new FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_DATEV2>(data, opts);
+ *decoder = new FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_DATEV2>(data, opts);
return Status::OK();
}
};
template <>
-struct TypeEncodingTraits<OLAP_FIELD_TYPE_DATETIMEV2, FOR_ENCODING,
- typename CppTypeTraits<OLAP_FIELD_TYPE_DATETIMEV2>::CppType> {
+struct TypeEncodingTraits<FieldType::OLAP_FIELD_TYPE_DATETIMEV2, FOR_ENCODING,
+ typename CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>::CppType> {
static Status create_page_builder(const PageBuilderOptions& opts, PageBuilder** builder) {
- *builder = new FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_DATETIMEV2>(opts);
+ *builder = new FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(opts);
return Status::OK();
}
static Status create_page_decoder(const Slice& data, const PageDecoderOptions& opts,
PageDecoder** decoder) {
- *decoder = new FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_DATETIMEV2>(data, opts);
+ *decoder =
+ new FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(data, opts);
return Status::OK();
}
};
@@ -222,103 +224,103 @@ private:
_encoding_map.emplace(key, encoding.release());
}
- std::unordered_map<FieldType, EncodingTypePB, std::hash<int>> _default_encoding_type_map;
+ std::unordered_map<FieldType, EncodingTypePB, EncodingMapHash> _default_encoding_type_map;
// default encoding for each type which optimizes value seek
- std::unordered_map<FieldType, EncodingTypePB, std::hash<int>> _value_seek_encoding_map;
+ std::unordered_map<FieldType, EncodingTypePB, EncodingMapHash> _value_seek_encoding_map;
std::unordered_map<std::pair<FieldType, EncodingTypePB>, EncodingInfo*, EncodingMapHash>
_encoding_map;
};
EncodingInfoResolver::EncodingInfoResolver() {
- _add_map<OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_TINYINT, FOR_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_TINYINT, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_TINYINT, FOR_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_TINYINT, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_SMALLINT, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_SMALLINT, FOR_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_SMALLINT, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_SMALLINT, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_SMALLINT, FOR_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_SMALLINT, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_INT, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_INT, FOR_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_INT, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_INT, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_INT, FOR_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_INT, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_BIGINT, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_BIGINT, FOR_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_BIGINT, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_BIGINT, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_BIGINT, FOR_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_BIGINT, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_UNSIGNED_BIGINT, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_UNSIGNED_INT, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_LARGEINT, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_LARGEINT, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_LARGEINT, FOR_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_LARGEINT, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_LARGEINT, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_LARGEINT, FOR_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_FLOAT, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_FLOAT, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_FLOAT, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_FLOAT, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_DOUBLE, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_DOUBLE, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DOUBLE, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DOUBLE, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_CHAR, DICT_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_CHAR, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_CHAR, PREFIX_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_CHAR, DICT_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_CHAR, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_CHAR, PREFIX_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_VARCHAR, DICT_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_VARCHAR, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_VARCHAR, PREFIX_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_VARCHAR, DICT_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_VARCHAR, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_VARCHAR, PREFIX_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_STRING, DICT_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_STRING, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_STRING, PREFIX_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_STRING, DICT_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_STRING, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_STRING, PREFIX_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_JSONB, DICT_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_JSONB, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_JSONB, PREFIX_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_JSONB, DICT_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_JSONB, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_JSONB, PREFIX_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_BOOL, RLE>();
- _add_map<OLAP_FIELD_TYPE_BOOL, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_BOOL, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_BOOL, PLAIN_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_BOOL, RLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_BOOL, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_BOOL, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_BOOL, PLAIN_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_DATE, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_DATE, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_DATE, FOR_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATE, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATE, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATE, FOR_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_DATEV2, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_DATEV2, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_DATEV2, FOR_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATEV2, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATEV2, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATEV2, FOR_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_DATETIMEV2, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_DATETIMEV2, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_DATETIMEV2, FOR_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATETIMEV2, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATETIMEV2, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATETIMEV2, FOR_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_DATETIME, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_DATETIME, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_DATETIME, FOR_ENCODING, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATETIME, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATETIME, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DATETIME, FOR_ENCODING, true>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL, BIT_SHUFFLE, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL, BIT_SHUFFLE, true>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL32, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL32, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL32, BIT_SHUFFLE, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL32, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL32, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL32, BIT_SHUFFLE, true>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL64, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL64, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL64, BIT_SHUFFLE, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL64, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL64, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL64, BIT_SHUFFLE, true>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL128I, BIT_SHUFFLE>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL128I, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_DECIMAL128I, BIT_SHUFFLE, true>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL128I, BIT_SHUFFLE>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL128I, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_DECIMAL128I, BIT_SHUFFLE, true>();
- _add_map<OLAP_FIELD_TYPE_HLL, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_HLL, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_OBJECT, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_OBJECT, PLAIN_ENCODING>();
- _add_map<OLAP_FIELD_TYPE_QUANTILE_STATE, PLAIN_ENCODING>();
+ _add_map<FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE, PLAIN_ENCODING>();
}
EncodingInfoResolver::~EncodingInfoResolver() {
diff --git a/be/src/olap/rowset/segment_v2/indexed_column_reader.cpp b/be/src/olap/rowset/segment_v2/indexed_column_reader.cpp
index bc6dd603bc..0dc0bffca6 100644
--- a/be/src/olap/rowset/segment_v2/indexed_column_reader.cpp
+++ b/be/src/olap/rowset/segment_v2/indexed_column_reader.cpp
@@ -140,7 +140,8 @@ Status IndexedColumnIterator::seek_to_ordinal(ordinal_t idx) {
// need to read the data page containing row at idx
if (_reader->_has_index_page) {
std::string key;
- KeyCoderTraits<OLAP_FIELD_TYPE_UNSIGNED_BIGINT>::full_encode_ascending(&idx, &key);
+ KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT>::full_encode_ascending(&idx,
+ &key);
RETURN_IF_ERROR(_ordinal_iter.seek_at_or_before(key));
RETURN_IF_ERROR(_read_data_page(_ordinal_iter.current_page_pointer()));
_current_iter = &_ordinal_iter;
diff --git a/be/src/olap/rowset/segment_v2/indexed_column_writer.cpp b/be/src/olap/rowset/segment_v2/indexed_column_writer.cpp
index f91e061ffe..bd912c6eb8 100644
--- a/be/src/olap/rowset/segment_v2/indexed_column_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/indexed_column_writer.cpp
@@ -118,8 +118,8 @@ Status IndexedColumnWriter::_finish_current_data_page(size_t& num_val) {
if (_options.write_ordinal_index) {
std::string key;
- KeyCoderTraits<OLAP_FIELD_TYPE_UNSIGNED_BIGINT>::full_encode_ascending(&first_ordinal,
- &key);
+ KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT>::full_encode_ascending(
+ &first_ordinal, &key);
_ordinal_index_builder->add(key, _last_data_page);
}
@@ -143,7 +143,7 @@ Status IndexedColumnWriter::finish(IndexedColumnMetaPB* meta) {
if (_options.write_value_index) {
RETURN_IF_ERROR(_flush_index(_value_index_builder.get(), meta->mutable_value_index_meta()));
}
- meta->set_data_type(_type_info->type());
+ meta->set_data_type(int(_type_info->type()));
meta->set_encoding(_options.encoding);
meta->set_num_values(_num_values);
meta->set_compression(_options.compression);
diff --git a/be/src/olap/rowset/segment_v2/inverted_index_writer.cpp b/be/src/olap/rowset/segment_v2/inverted_index_writer.cpp
index aa8dc52f3c..466dd5867a 100644
--- a/be/src/olap/rowset/segment_v2/inverted_index_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/inverted_index_writer.cpp
@@ -340,7 +340,7 @@ public:
InvertedIndexDescriptor::get_temporary_bkd_index_file_name().c_str());
if (data_out != nullptr && meta_out != nullptr && index_out != nullptr) {
_bkd_writer->meta_finish(meta_out, _bkd_writer->finish(data_out, index_out),
- field_type);
+ int(field_type));
}
FINALIZE_OUTPUT(meta_out)
FINALIZE_OUTPUT(data_out)
@@ -392,115 +392,121 @@ Status InvertedIndexColumnWriter::create(const Field* field,
auto typeinfo = field->type_info();
FieldType type = typeinfo->type();
std::string field_name = field->name();
- if (type == OLAP_FIELD_TYPE_ARRAY) {
+ if (type == FieldType::OLAP_FIELD_TYPE_ARRAY) {
const auto array_typeinfo = dynamic_cast<const ArrayTypeInfo*>(typeinfo);
typeinfo = array_typeinfo->item_type_info();
type = typeinfo->type();
}
switch (type) {
- case OLAP_FIELD_TYPE_CHAR: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_CHAR>>(
+ case FieldType::OLAP_FIELD_TYPE_CHAR: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_CHAR>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_VARCHAR: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_VARCHAR>>(
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_VARCHAR>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_STRING: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_STRING>>(
+ case FieldType::OLAP_FIELD_TYPE_STRING: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_STRING>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_DATETIME: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_DATETIME>>(
+ case FieldType::OLAP_FIELD_TYPE_DATETIME: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_DATETIME>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_DATE: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_DATE>>(
+ case FieldType::OLAP_FIELD_TYPE_DATE: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_DATE>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_DATETIMEV2: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_DATETIMEV2>>(
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: {
+ *res = std::make_unique<
+ InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_DATEV2: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_DATEV2>>(
+ case FieldType::OLAP_FIELD_TYPE_DATEV2: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_DATEV2>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_TINYINT: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_TINYINT>>(
+ case FieldType::OLAP_FIELD_TYPE_TINYINT: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_TINYINT>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_SMALLINT: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_SMALLINT>>(
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_SMALLINT>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_UNSIGNED_INT: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_UNSIGNED_INT>>(
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT: {
+ *res = std::make_unique<
+ InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_INT: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_INT>>(
+ case FieldType::OLAP_FIELD_TYPE_INT: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_INT>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_LARGEINT: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_LARGEINT>>(
+ case FieldType::OLAP_FIELD_TYPE_LARGEINT: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_LARGEINT>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_DECIMAL: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_DECIMAL>>(
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_DECIMAL>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_DECIMAL32: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_DECIMAL32>>(
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32: {
+ *res = std::make_unique<
+ InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_DECIMAL32>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_DECIMAL64: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_DECIMAL64>>(
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64: {
+ *res = std::make_unique<
+ InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_DECIMAL64>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_DECIMAL128I: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_DECIMAL128I>>(
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I: {
+ *res = std::make_unique<
+ InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_DECIMAL128I>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_BOOL: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_BOOL>>(
+ case FieldType::OLAP_FIELD_TYPE_BOOL: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_BOOL>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_DOUBLE: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_DOUBLE>>(
+ case FieldType::OLAP_FIELD_TYPE_DOUBLE: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_DOUBLE>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_FLOAT: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_FLOAT>>(
+ case FieldType::OLAP_FIELD_TYPE_FLOAT: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_FLOAT>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
- case OLAP_FIELD_TYPE_BIGINT: {
- *res = std::make_unique<InvertedIndexColumnWriterImpl<OLAP_FIELD_TYPE_BIGINT>>(
+ case FieldType::OLAP_FIELD_TYPE_BIGINT: {
+ *res = std::make_unique<InvertedIndexColumnWriterImpl<FieldType::OLAP_FIELD_TYPE_BIGINT>>(
field_name, segment_file_name, dir, fs, index_meta);
break;
}
default:
- return Status::NotSupported("unsupported type for inverted index: " + std::to_string(type));
+ return Status::NotSupported("unsupported type for inverted index: " +
+ std::to_string(int(type)));
}
if (*res != nullptr) {
RETURN_IF_ERROR((*res)->init());
diff --git a/be/src/olap/rowset/segment_v2/ordinal_page_index.cpp b/be/src/olap/rowset/segment_v2/ordinal_page_index.cpp
index 7e4914ccb8..5a077ae80a 100644
--- a/be/src/olap/rowset/segment_v2/ordinal_page_index.cpp
+++ b/be/src/olap/rowset/segment_v2/ordinal_page_index.cpp
@@ -29,7 +29,8 @@ namespace segment_v2 {
void OrdinalIndexWriter::append_entry(ordinal_t ordinal, const PagePointer& data_pp) {
std::string key;
- KeyCoderTraits<OLAP_FIELD_TYPE_UNSIGNED_BIGINT>::full_encode_ascending(&ordinal, &key);
+ KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT>::full_encode_ascending(&ordinal,
+ &key);
_page_builder->add(key, data_pp);
_last_pp = data_pp;
}
@@ -95,8 +96,9 @@ Status OrdinalIndexReader::load(bool use_page_cache, bool kept_in_memory) {
for (int i = 0; i < _num_pages; i++) {
Slice key = reader.get_key(i);
ordinal_t ordinal = 0;
- RETURN_IF_ERROR(KeyCoderTraits<OLAP_FIELD_TYPE_UNSIGNED_BIGINT>::decode_ascending(
- &key, sizeof(ordinal_t), (uint8_t*)&ordinal));
+ RETURN_IF_ERROR(
+ KeyCoderTraits<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT>::decode_ascending(
+ &key, sizeof(ordinal_t), (uint8_t*)&ordinal));
_ordinals[i] = ordinal;
_pages[i] = reader.get_value(i);
diff --git a/be/src/olap/rowset/segment_v2/rle_page.h b/be/src/olap/rowset/segment_v2/rle_page.h
index 991a18aee0..bae694dbfc 100644
--- a/be/src/olap/rowset/segment_v2/rle_page.h
+++ b/be/src/olap/rowset/segment_v2/rle_page.h
@@ -56,7 +56,7 @@ public:
RlePageBuilder(const PageBuilderOptions& options)
: _options(options), _count(0), _finished(false), _bit_width(0), _rle_encoder(nullptr) {
switch (Type) {
- case OLAP_FIELD_TYPE_BOOL: {
+ case FieldType::OLAP_FIELD_TYPE_BOOL: {
_bit_width = 1;
break;
}
@@ -167,7 +167,7 @@ public:
_parsed = true;
switch (Type) {
- case OLAP_FIELD_TYPE_BOOL: {
+ case FieldType::OLAP_FIELD_TYPE_BOOL: {
_bit_width = 1;
break;
}
diff --git a/be/src/olap/rowset/segment_v2/segment_iterator.cpp b/be/src/olap/rowset/segment_v2/segment_iterator.cpp
index a73bc5c808..874908c416 100644
--- a/be/src/olap/rowset/segment_v2/segment_iterator.cpp
+++ b/be/src/olap/rowset/segment_v2/segment_iterator.cpp
@@ -1322,12 +1322,13 @@ bool SegmentIterator::_can_evaluated_by_vectorized(ColumnPredicate* predicate) {
case PredicateType::LT:
case PredicateType::GE:
case PredicateType::GT: {
- if (field_type == OLAP_FIELD_TYPE_VARCHAR || field_type == OLAP_FIELD_TYPE_CHAR ||
- field_type == OLAP_FIELD_TYPE_STRING) {
+ if (field_type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ field_type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ field_type == FieldType::OLAP_FIELD_TYPE_STRING) {
return config::enable_low_cardinality_optimize &&
_opts.io_ctx.reader_type == ReaderType::READER_QUERY &&
_column_iterators[_schema.unique_id(cid)]->is_all_dict_encoding();
- } else if (field_type == OLAP_FIELD_TYPE_DECIMAL) {
+ } else if (field_type == FieldType::OLAP_FIELD_TYPE_DECIMAL) {
return false;
}
return true;
@@ -1343,13 +1344,13 @@ void SegmentIterator::_vec_init_char_column_id() {
auto column_desc = _schema.column(cid);
do {
- if (column_desc->type() == OLAP_FIELD_TYPE_CHAR) {
+ if (column_desc->type() == FieldType::OLAP_FIELD_TYPE_CHAR) {
_char_type_idx.emplace_back(i);
if (i != 0) {
_char_type_idx_no_0.emplace_back(i);
}
break;
- } else if (column_desc->type() != OLAP_FIELD_TYPE_ARRAY) {
+ } else if (column_desc->type() != FieldType::OLAP_FIELD_TYPE_ARRAY) {
break;
}
// for Array<Char> or Array<Array<Char>>
@@ -1409,11 +1410,11 @@ void SegmentIterator::_init_current_block(
} else { // non-predicate column
current_columns[cid] = std::move(*block->get_by_position(i).column).mutate();
- if (column_desc->type() == OLAP_FIELD_TYPE_DATE) {
+ if (column_desc->type() == FieldType::OLAP_FIELD_TYPE_DATE) {
current_columns[cid]->set_date_type();
- } else if (column_desc->type() == OLAP_FIELD_TYPE_DATETIME) {
+ } else if (column_desc->type() == FieldType::OLAP_FIELD_TYPE_DATETIME) {
current_columns[cid]->set_datetime_type();
- } else if (column_desc->type() == OLAP_FIELD_TYPE_DECIMAL) {
+ } else if (column_desc->type() == FieldType::OLAP_FIELD_TYPE_DECIMAL) {
current_columns[cid]->set_decimalv2_type();
}
current_columns[cid]->reserve(_opts.block_row_max);
diff --git a/be/src/olap/rowset/segment_v2/segment_iterator.h b/be/src/olap/rowset/segment_v2/segment_iterator.h
index 80b2ea5981..9650ad9e27 100644
--- a/be/src/olap/rowset/segment_v2/segment_iterator.h
+++ b/be/src/olap/rowset/segment_v2/segment_iterator.h
@@ -257,9 +257,9 @@ private:
auto* field = key.schema()->column(cid);
_short_key[cid] = Schema::get_column_by_field(*field);
- if (field->type() == OLAP_FIELD_TYPE_DATE) {
+ if (field->type() == FieldType::OLAP_FIELD_TYPE_DATE) {
_short_key[cid]->set_date_type();
- } else if (field->type() == OLAP_FIELD_TYPE_DATETIME) {
+ } else if (field->type() == FieldType::OLAP_FIELD_TYPE_DATETIME) {
_short_key[cid]->set_datetime_type();
}
}
@@ -278,9 +278,9 @@ private:
if (cell.is_null()) {
_short_key[cid]->insert_default();
} else {
- if (field->type() == OLAP_FIELD_TYPE_VARCHAR ||
- field->type() == OLAP_FIELD_TYPE_CHAR ||
- field->type() == OLAP_FIELD_TYPE_STRING) {
+ if (field->type() == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ field->type() == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ field->type() == FieldType::OLAP_FIELD_TYPE_STRING) {
const Slice* slice = reinterpret_cast<const Slice*>(cell.cell_ptr());
_short_key[cid]->insert_data(slice->data, slice->size);
} else {
diff --git a/be/src/olap/rowset/segment_v2/segment_writer.cpp b/be/src/olap/rowset/segment_v2/segment_writer.cpp
index 0789777cf3..32787a29f4 100644
--- a/be/src/olap/rowset/segment_v2/segment_writer.cpp
+++ b/be/src/olap/rowset/segment_v2/segment_writer.cpp
@@ -78,7 +78,7 @@ void SegmentWriter::init_column_meta(ColumnMetaPB* meta, uint32_t column_id,
const TabletColumn& column, TabletSchemaSPtr tablet_schema) {
meta->set_column_id(column_id);
meta->set_unique_id(column.unique_id());
- meta->set_type(column.type());
+ meta->set_type(int(column.type()));
meta->set_length(column.length());
meta->set_encoding(DEFAULT_ENCODING);
meta->set_compression(tablet_schema->compression_type());
diff --git a/be/src/olap/rowset/segment_v2/zone_map_index.cpp b/be/src/olap/rowset/segment_v2/zone_map_index.cpp
index eedb91887c..5b63bcda03 100644
--- a/be/src/olap/rowset/segment_v2/zone_map_index.cpp
+++ b/be/src/olap/rowset/segment_v2/zone_map_index.cpp
@@ -113,7 +113,7 @@ Status TypedZoneMapIndexWriter<Type>::finish(io::FileWriter* file_writer,
_segment_zone_map.to_proto(meta->mutable_segment_zone_map(), _field);
// write out zone map for each data pages
- const auto* type_info = get_scalar_type_info<OLAP_FIELD_TYPE_OBJECT>();
+ const auto* type_info = get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_OBJECT>();
IndexedColumnWriterOptions options;
options.write_ordinal_index = true;
options.write_value_index = false;
@@ -140,8 +140,8 @@ Status ZoneMapIndexReader::load(bool use_page_cache, bool kept_in_memory) {
// read and cache all page zone maps
for (int i = 0; i < reader.num_values(); ++i) {
size_t num_to_read = 1;
- // The type of reader is OLAP_FIELD_TYPE_OBJECT.
- // ColumnBitmap will be created when using OLAP_FIELD_TYPE_OBJECT.
+ // The type of reader is FieldType::OLAP_FIELD_TYPE_OBJECT.
+ // ColumnBitmap will be created when using FieldType::OLAP_FIELD_TYPE_OBJECT.
// But what we need actually is ColumnString.
vectorized::MutableColumnPtr column = vectorized::ColumnString::create();
@@ -180,17 +180,17 @@ Status ZoneMapIndexReader::load(bool use_page_cache, bool kept_in_memory) {
Status ZoneMapIndexWriter::create(Field* field, std::unique_ptr<ZoneMapIndexWriter>& res) {
switch (field->type()) {
#define M(NAME) \
- case OLAP_FIELD_##NAME: { \
+ case FieldType::OLAP_FIELD_##NAME: { \
res.reset(new TypedZoneMapIndexWriter<NAME>(field)); \
return Status::OK(); \
}
APPLY_FOR_PRIMITITYPE(M)
#undef M
- case OLAP_FIELD_TYPE_DECIMAL: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL: {
res.reset(new TypedZoneMapIndexWriter<TYPE_DECIMALV2>(field));
return Status::OK();
}
- case OLAP_FIELD_TYPE_BOOL: {
+ case FieldType::OLAP_FIELD_TYPE_BOOL: {
res.reset(new TypedZoneMapIndexWriter<TYPE_BOOLEAN>(field));
return Status::OK();
}
diff --git a/be/src/olap/schema.cpp b/be/src/olap/schema.cpp
index aa3f07e232..ab75f1f93a 100644
--- a/be/src/olap/schema.cpp
+++ b/be/src/olap/schema.cpp
@@ -121,45 +121,45 @@ vectorized::IColumn::MutablePtr Schema::get_predicate_column_ptr(const Field& fi
const ReaderType reader_type) {
vectorized::IColumn::MutablePtr ptr = nullptr;
switch (field.type()) {
- case OLAP_FIELD_TYPE_BOOL:
+ case FieldType::OLAP_FIELD_TYPE_BOOL:
ptr = doris::vectorized::PredicateColumnType<TYPE_BOOLEAN>::create();
break;
- case OLAP_FIELD_TYPE_TINYINT:
+ case FieldType::OLAP_FIELD_TYPE_TINYINT:
ptr = doris::vectorized::PredicateColumnType<TYPE_TINYINT>::create();
break;
- case OLAP_FIELD_TYPE_SMALLINT:
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT:
ptr = doris::vectorized::PredicateColumnType<TYPE_SMALLINT>::create();
break;
- case OLAP_FIELD_TYPE_INT:
+ case FieldType::OLAP_FIELD_TYPE_INT:
ptr = doris::vectorized::PredicateColumnType<TYPE_INT>::create();
break;
- case OLAP_FIELD_TYPE_FLOAT:
+ case FieldType::OLAP_FIELD_TYPE_FLOAT:
ptr = doris::vectorized::PredicateColumnType<TYPE_FLOAT>::create();
break;
- case OLAP_FIELD_TYPE_DOUBLE:
+ case FieldType::OLAP_FIELD_TYPE_DOUBLE:
ptr = doris::vectorized::PredicateColumnType<TYPE_DOUBLE>::create();
break;
- case OLAP_FIELD_TYPE_BIGINT:
+ case FieldType::OLAP_FIELD_TYPE_BIGINT:
ptr = doris::vectorized::PredicateColumnType<TYPE_BIGINT>::create();
break;
- case OLAP_FIELD_TYPE_LARGEINT:
+ case FieldType::OLAP_FIELD_TYPE_LARGEINT:
ptr = doris::vectorized::PredicateColumnType<TYPE_LARGEINT>::create();
break;
- case OLAP_FIELD_TYPE_DATE:
+ case FieldType::OLAP_FIELD_TYPE_DATE:
ptr = doris::vectorized::PredicateColumnType<TYPE_DATE>::create();
break;
- case OLAP_FIELD_TYPE_DATEV2:
+ case FieldType::OLAP_FIELD_TYPE_DATEV2:
ptr = doris::vectorized::PredicateColumnType<TYPE_DATEV2>::create();
break;
- case OLAP_FIELD_TYPE_DATETIMEV2:
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2:
ptr = doris::vectorized::PredicateColumnType<TYPE_DATETIMEV2>::create();
break;
- case OLAP_FIELD_TYPE_DATETIME:
+ case FieldType::OLAP_FIELD_TYPE_DATETIME:
ptr = doris::vectorized::PredicateColumnType<TYPE_DATETIME>::create();
break;
- case OLAP_FIELD_TYPE_CHAR:
- case OLAP_FIELD_TYPE_VARCHAR:
- case OLAP_FIELD_TYPE_STRING:
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_STRING:
if (config::enable_low_cardinality_optimize && reader_type == ReaderType::READER_QUERY) {
ptr = doris::vectorized::ColumnDictionary<doris::vectorized::Int32>::create(
field.type());
@@ -167,24 +167,24 @@ vectorized::IColumn::MutablePtr Schema::get_predicate_column_ptr(const Field& fi
ptr = doris::vectorized::PredicateColumnType<TYPE_STRING>::create();
}
break;
- case OLAP_FIELD_TYPE_DECIMAL:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL:
ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMALV2>::create();
break;
- case OLAP_FIELD_TYPE_DECIMAL32:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL32>::create();
break;
- case OLAP_FIELD_TYPE_DECIMAL64:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL64>::create();
break;
- case OLAP_FIELD_TYPE_DECIMAL128I:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
ptr = doris::vectorized::PredicateColumnType<TYPE_DECIMAL128I>::create();
break;
- case OLAP_FIELD_TYPE_ARRAY:
+ case FieldType::OLAP_FIELD_TYPE_ARRAY:
ptr = doris::vectorized::ColumnArray::create(
get_predicate_column_ptr(*field.get_sub_field(0), reader_type),
doris::vectorized::ColumnArray::ColumnOffsets::create());
break;
- case OLAP_FIELD_TYPE_STRUCT: {
+ case FieldType::OLAP_FIELD_TYPE_STRUCT: {
size_t field_size = field.get_sub_field_count();
doris::vectorized::MutableColumns columns(field_size);
for (size_t i = 0; i < field_size; i++) {
@@ -193,14 +193,14 @@ vectorized::IColumn::MutablePtr Schema::get_predicate_column_ptr(const Field& fi
ptr = doris::vectorized::ColumnStruct::create(std::move(columns));
break;
}
- case OLAP_FIELD_TYPE_MAP:
+ case FieldType::OLAP_FIELD_TYPE_MAP:
ptr = doris::vectorized::ColumnMap::create(
get_predicate_column_ptr(*field.get_sub_field(0), reader_type),
get_predicate_column_ptr(*field.get_sub_field(1), reader_type),
doris::vectorized::ColumnArray::ColumnOffsets::create());
break;
default:
- LOG(FATAL) << "Unexpected type when choosing predicate column, type=" << field.type();
+ LOG(FATAL) << "Unexpected type when choosing predicate column, type=" << int(field.type());
}
if (field.is_nullable()) {
diff --git a/be/src/olap/tablet_schema.cpp b/be/src/olap/tablet_schema.cpp
index b08bc10f99..2f6a54529d 100644
--- a/be/src/olap/tablet_schema.cpp
+++ b/be/src/olap/tablet_schema.cpp
@@ -39,72 +39,72 @@ FieldType TabletColumn::get_field_type_by_string(const std::string& type_str) {
FieldType type;
if (0 == upper_type_str.compare("TINYINT")) {
- type = OLAP_FIELD_TYPE_TINYINT;
+ type = FieldType::OLAP_FIELD_TYPE_TINYINT;
} else if (0 == upper_type_str.compare("SMALLINT")) {
- type = OLAP_FIELD_TYPE_SMALLINT;
+ type = FieldType::OLAP_FIELD_TYPE_SMALLINT;
} else if (0 == upper_type_str.compare("INT")) {
- type = OLAP_FIELD_TYPE_INT;
+ type = FieldType::OLAP_FIELD_TYPE_INT;
} else if (0 == upper_type_str.compare("BIGINT")) {
- type = OLAP_FIELD_TYPE_BIGINT;
+ type = FieldType::OLAP_FIELD_TYPE_BIGINT;
} else if (0 == upper_type_str.compare("LARGEINT")) {
- type = OLAP_FIELD_TYPE_LARGEINT;
+ type = FieldType::OLAP_FIELD_TYPE_LARGEINT;
} else if (0 == upper_type_str.compare("UNSIGNED_TINYINT")) {
- type = OLAP_FIELD_TYPE_UNSIGNED_TINYINT;
+ type = FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT;
} else if (0 == upper_type_str.compare("UNSIGNED_SMALLINT")) {
- type = OLAP_FIELD_TYPE_UNSIGNED_SMALLINT;
+ type = FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT;
} else if (0 == upper_type_str.compare("UNSIGNED_INT")) {
- type = OLAP_FIELD_TYPE_UNSIGNED_INT;
+ type = FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT;
} else if (0 == upper_type_str.compare("UNSIGNED_BIGINT")) {
- type = OLAP_FIELD_TYPE_UNSIGNED_BIGINT;
+ type = FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT;
} else if (0 == upper_type_str.compare("FLOAT")) {
- type = OLAP_FIELD_TYPE_FLOAT;
+ type = FieldType::OLAP_FIELD_TYPE_FLOAT;
} else if (0 == upper_type_str.compare("DISCRETE_DOUBLE")) {
- type = OLAP_FIELD_TYPE_DISCRETE_DOUBLE;
+ type = FieldType::OLAP_FIELD_TYPE_DISCRETE_DOUBLE;
} else if (0 == upper_type_str.compare("DOUBLE")) {
- type = OLAP_FIELD_TYPE_DOUBLE;
+ type = FieldType::OLAP_FIELD_TYPE_DOUBLE;
} else if (0 == upper_type_str.compare("CHAR")) {
- type = OLAP_FIELD_TYPE_CHAR;
+ type = FieldType::OLAP_FIELD_TYPE_CHAR;
} else if (0 == upper_type_str.compare("DATE")) {
- type = OLAP_FIELD_TYPE_DATE;
+ type = FieldType::OLAP_FIELD_TYPE_DATE;
} else if (0 == upper_type_str.compare("DATEV2")) {
- type = OLAP_FIELD_TYPE_DATEV2;
+ type = FieldType::OLAP_FIELD_TYPE_DATEV2;
} else if (0 == upper_type_str.compare("DATETIMEV2")) {
- type = OLAP_FIELD_TYPE_DATETIMEV2;
+ type = FieldType::OLAP_FIELD_TYPE_DATETIMEV2;
} else if (0 == upper_type_str.compare("DATETIME")) {
- type = OLAP_FIELD_TYPE_DATETIME;
+ type = FieldType::OLAP_FIELD_TYPE_DATETIME;
} else if (0 == upper_type_str.compare("DECIMAL32")) {
- type = OLAP_FIELD_TYPE_DECIMAL32;
+ type = FieldType::OLAP_FIELD_TYPE_DECIMAL32;
} else if (0 == upper_type_str.compare("DECIMAL64")) {
- type = OLAP_FIELD_TYPE_DECIMAL64;
+ type = FieldType::OLAP_FIELD_TYPE_DECIMAL64;
} else if (0 == upper_type_str.compare("DECIMAL128I")) {
- type = OLAP_FIELD_TYPE_DECIMAL128I;
+ type = FieldType::OLAP_FIELD_TYPE_DECIMAL128I;
} else if (0 == upper_type_str.compare(0, 7, "DECIMAL")) {
- type = OLAP_FIELD_TYPE_DECIMAL;
+ type = FieldType::OLAP_FIELD_TYPE_DECIMAL;
} else if (0 == upper_type_str.compare(0, 7, "VARCHAR")) {
- type = OLAP_FIELD_TYPE_VARCHAR;
+ type = FieldType::OLAP_FIELD_TYPE_VARCHAR;
} else if (0 == upper_type_str.compare("STRING")) {
- type = OLAP_FIELD_TYPE_STRING;
+ type = FieldType::OLAP_FIELD_TYPE_STRING;
} else if (0 == upper_type_str.compare("JSONB")) {
- type = OLAP_FIELD_TYPE_JSONB;
+ type = FieldType::OLAP_FIELD_TYPE_JSONB;
} else if (0 == upper_type_str.compare("BOOLEAN")) {
- type = OLAP_FIELD_TYPE_BOOL;
+ type = FieldType::OLAP_FIELD_TYPE_BOOL;
} else if (0 == upper_type_str.compare(0, 3, "HLL")) {
- type = OLAP_FIELD_TYPE_HLL;
+ type = FieldType::OLAP_FIELD_TYPE_HLL;
} else if (0 == upper_type_str.compare("STRUCT")) {
- type = OLAP_FIELD_TYPE_STRUCT;
+ type = FieldType::OLAP_FIELD_TYPE_STRUCT;
} else if (0 == upper_type_str.compare("LIST")) {
- type = OLAP_FIELD_TYPE_ARRAY;
+ type = FieldType::OLAP_FIELD_TYPE_ARRAY;
} else if (0 == upper_type_str.compare("MAP")) {
- type = OLAP_FIELD_TYPE_MAP;
+ type = FieldType::OLAP_FIELD_TYPE_MAP;
} else if (0 == upper_type_str.compare("OBJECT")) {
- type = OLAP_FIELD_TYPE_OBJECT;
+ type = FieldType::OLAP_FIELD_TYPE_OBJECT;
} else if (0 == upper_type_str.compare("ARRAY")) {
- type = OLAP_FIELD_TYPE_ARRAY;
+ type = FieldType::OLAP_FIELD_TYPE_ARRAY;
} else if (0 == upper_type_str.compare("QUANTILE_STATE")) {
- type = OLAP_FIELD_TYPE_QUANTILE_STATE;
+ type = FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE;
} else {
LOG(WARNING) << "invalid type string. [type='" << type_str << "']";
- type = OLAP_FIELD_TYPE_UNKNOWN;
+ type = FieldType::OLAP_FIELD_TYPE_UNKNOWN;
}
return type;
@@ -144,96 +144,96 @@ FieldAggregationMethod TabletColumn::get_aggregation_type_by_string(const std::s
std::string TabletColumn::get_string_by_field_type(FieldType type) {
switch (type) {
- case OLAP_FIELD_TYPE_TINYINT:
+ case FieldType::OLAP_FIELD_TYPE_TINYINT:
return "TINYINT";
- case OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
return "UNSIGNED_TINYINT";
- case OLAP_FIELD_TYPE_SMALLINT:
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT:
return "SMALLINT";
- case OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
return "UNSIGNED_SMALLINT";
- case OLAP_FIELD_TYPE_INT:
+ case FieldType::OLAP_FIELD_TYPE_INT:
return "INT";
- case OLAP_FIELD_TYPE_UNSIGNED_INT:
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT:
return "UNSIGNED_INT";
- case OLAP_FIELD_TYPE_BIGINT:
+ case FieldType::OLAP_FIELD_TYPE_BIGINT:
return "BIGINT";
- case OLAP_FIELD_TYPE_LARGEINT:
+ case FieldType::OLAP_FIELD_TYPE_LARGEINT:
return "LARGEINT";
- case OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
return "UNSIGNED_BIGINT";
- case OLAP_FIELD_TYPE_FLOAT:
+ case FieldType::OLAP_FIELD_TYPE_FLOAT:
return "FLOAT";
- case OLAP_FIELD_TYPE_DOUBLE:
+ case FieldType::OLAP_FIELD_TYPE_DOUBLE:
return "DOUBLE";
- case OLAP_FIELD_TYPE_DISCRETE_DOUBLE:
+ case FieldType::OLAP_FIELD_TYPE_DISCRETE_DOUBLE:
return "DISCRETE_DOUBLE";
- case OLAP_FIELD_TYPE_CHAR:
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
return "CHAR";
- case OLAP_FIELD_TYPE_DATE:
+ case FieldType::OLAP_FIELD_TYPE_DATE:
return "DATE";
- case OLAP_FIELD_TYPE_DATEV2:
+ case FieldType::OLAP_FIELD_TYPE_DATEV2:
return "DATEV2";
- case OLAP_FIELD_TYPE_DATETIME:
+ case FieldType::OLAP_FIELD_TYPE_DATETIME:
return "DATETIME";
- case OLAP_FIELD_TYPE_DATETIMEV2:
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2:
return "DATETIMEV2";
- case OLAP_FIELD_TYPE_DECIMAL:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL:
return "DECIMAL";
- case OLAP_FIELD_TYPE_DECIMAL32:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
return "DECIMAL32";
- case OLAP_FIELD_TYPE_DECIMAL64:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
return "DECIMAL64";
- case OLAP_FIELD_TYPE_DECIMAL128I:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
return "DECIMAL128I";
- case OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
return "VARCHAR";
- case OLAP_FIELD_TYPE_JSONB:
+ case FieldType::OLAP_FIELD_TYPE_JSONB:
return "JSONB";
- case OLAP_FIELD_TYPE_STRING:
+ case FieldType::OLAP_FIELD_TYPE_STRING:
return "STRING";
- case OLAP_FIELD_TYPE_BOOL:
+ case FieldType::OLAP_FIELD_TYPE_BOOL:
return "BOOLEAN";
- case OLAP_FIELD_TYPE_HLL:
+ case FieldType::OLAP_FIELD_TYPE_HLL:
return "HLL";
- case OLAP_FIELD_TYPE_STRUCT:
+ case FieldType::OLAP_FIELD_TYPE_STRUCT:
return "STRUCT";
- case OLAP_FIELD_TYPE_ARRAY:
+ case FieldType::OLAP_FIELD_TYPE_ARRAY:
return "ARRAY";
- case OLAP_FIELD_TYPE_MAP:
+ case FieldType::OLAP_FIELD_TYPE_MAP:
return "MAP";
- case OLAP_FIELD_TYPE_OBJECT:
+ case FieldType::OLAP_FIELD_TYPE_OBJECT:
return "OBJECT";
- case OLAP_FIELD_TYPE_QUANTILE_STATE:
+ case FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE:
return "QUANTILE_STATE";
default:
@@ -457,17 +457,17 @@ void TabletColumn::to_schema_pb(ColumnPB* column) const {
}
column->set_visible(_visible);
- if (_type == OLAP_FIELD_TYPE_STRUCT) {
+ if (_type == FieldType::OLAP_FIELD_TYPE_STRUCT) {
for (size_t i = 0; i < _sub_columns.size(); i++) {
ColumnPB* child = column->add_children_columns();
_sub_columns[i].to_schema_pb(child);
}
- } else if (_type == OLAP_FIELD_TYPE_ARRAY) {
+ } else if (_type == FieldType::OLAP_FIELD_TYPE_ARRAY) {
DCHECK(_sub_columns.size() == 1) << "ARRAY type has more than 1 children types.";
ColumnPB* child = column->add_children_columns();
_sub_columns[0].to_schema_pb(child);
}
- if (_type == OLAP_FIELD_TYPE_MAP) {
+ if (_type == FieldType::OLAP_FIELD_TYPE_MAP) {
DCHECK(_sub_columns.size() == 2) << "MAP type has more than 2 children types.";
ColumnPB* child_key = column->add_children_columns();
_sub_columns[0].to_schema_pb(child_key);
diff --git a/be/src/olap/tablet_schema.h b/be/src/olap/tablet_schema.h
index 08654a4f09..74d8073031 100644
--- a/be/src/olap/tablet_schema.h
+++ b/be/src/olap/tablet_schema.h
@@ -54,14 +54,17 @@ public:
void set_type(FieldType type) { _type = type; }
bool is_key() const { return _is_key; }
bool is_nullable() const { return _is_nullable; }
- bool is_variant_type() const { return _type == OLAP_FIELD_TYPE_VARIANT; }
+ bool is_variant_type() const { return _type == FieldType::OLAP_FIELD_TYPE_VARIANT; }
bool is_bf_column() const { return _is_bf_column; }
bool has_bitmap_index() const { return _has_bitmap_index; }
- bool is_array_type() const { return _type == OLAP_FIELD_TYPE_ARRAY; }
+ bool is_array_type() const { return _type == FieldType::OLAP_FIELD_TYPE_ARRAY; }
bool is_length_variable_type() const {
- return _type == OLAP_FIELD_TYPE_CHAR || _type == OLAP_FIELD_TYPE_VARCHAR ||
- _type == OLAP_FIELD_TYPE_STRING || _type == OLAP_FIELD_TYPE_HLL ||
- _type == OLAP_FIELD_TYPE_OBJECT || _type == OLAP_FIELD_TYPE_QUANTILE_STATE;
+ return _type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ _type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ _type == FieldType::OLAP_FIELD_TYPE_STRING ||
+ _type == FieldType::OLAP_FIELD_TYPE_HLL ||
+ _type == FieldType::OLAP_FIELD_TYPE_OBJECT ||
+ _type == FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE;
}
bool has_default_value() const { return _has_default_value; }
std::string default_value() const { return _default_value; }
diff --git a/be/src/olap/types.cpp b/be/src/olap/types.cpp
index 7d83e4ec30..da3fd4a255 100644
--- a/be/src/olap/types.cpp
+++ b/be/src/olap/types.cpp
@@ -24,16 +24,16 @@
namespace doris {
-void (*FieldTypeTraits<OLAP_FIELD_TYPE_CHAR>::set_to_max)(void*) = nullptr;
+void (*FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_CHAR>::set_to_max)(void*) = nullptr;
static TypeInfoPtr create_type_info_ptr(const TypeInfo* type_info, bool should_reclaim_memory);
bool is_scalar_type(FieldType field_type) {
switch (field_type) {
- case OLAP_FIELD_TYPE_STRUCT:
- case OLAP_FIELD_TYPE_ARRAY:
- case OLAP_FIELD_TYPE_MAP:
- case OLAP_FIELD_TYPE_VARIANT:
+ case FieldType::OLAP_FIELD_TYPE_STRUCT:
+ case FieldType::OLAP_FIELD_TYPE_ARRAY:
+ case FieldType::OLAP_FIELD_TYPE_MAP:
+ case FieldType::OLAP_FIELD_TYPE_VARIANT:
return false;
default:
return true;
@@ -42,12 +42,12 @@ bool is_scalar_type(FieldType field_type) {
bool is_olap_string_type(FieldType field_type) {
switch (field_type) {
- case OLAP_FIELD_TYPE_CHAR:
- case OLAP_FIELD_TYPE_VARCHAR:
- case OLAP_FIELD_TYPE_HLL:
- case OLAP_FIELD_TYPE_OBJECT:
- case OLAP_FIELD_TYPE_STRING:
- case OLAP_FIELD_TYPE_JSONB:
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_HLL:
+ case FieldType::OLAP_FIELD_TYPE_OBJECT:
+ case FieldType::OLAP_FIELD_TYPE_STRING:
+ case FieldType::OLAP_FIELD_TYPE_JSONB:
return true;
default:
return false;
@@ -58,42 +58,42 @@ const TypeInfo* get_scalar_type_info(FieldType field_type) {
// nullptr means that there is no TypeInfo implementation for the corresponding field_type
static const TypeInfo* field_type_array[] = {
nullptr,
- get_scalar_type_info<OLAP_FIELD_TYPE_TINYINT>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_TINYINT>(),
nullptr,
- get_scalar_type_info<OLAP_FIELD_TYPE_SMALLINT>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_SMALLINT>(),
nullptr,
- get_scalar_type_info<OLAP_FIELD_TYPE_INT>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_UNSIGNED_INT>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_BIGINT>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_UNSIGNED_BIGINT>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_LARGEINT>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_FLOAT>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_DOUBLE>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_INT>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_BIGINT>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_LARGEINT>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_FLOAT>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_DOUBLE>(),
nullptr,
- get_scalar_type_info<OLAP_FIELD_TYPE_CHAR>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_DATE>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_DATETIME>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_DECIMAL>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_VARCHAR>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_CHAR>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_DATE>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_DATETIME>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_DECIMAL>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_VARCHAR>(),
nullptr,
nullptr,
nullptr,
nullptr,
nullptr,
- get_scalar_type_info<OLAP_FIELD_TYPE_HLL>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_BOOL>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_OBJECT>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_STRING>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_QUANTILE_STATE>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_DATEV2>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_DATETIMEV2>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_TIMEV2>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_DECIMAL32>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_DECIMAL64>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_DECIMAL128I>(),
- get_scalar_type_info<OLAP_FIELD_TYPE_JSONB>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_HLL>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_BOOL>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_OBJECT>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_STRING>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_DATEV2>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_TIMEV2>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_DECIMAL32>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_DECIMAL64>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_DECIMAL128I>(),
+ get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_JSONB>(),
};
- return field_type_array[field_type];
+ return field_type_array[int(field_type)];
}
#define INIT_ARRAY_TYPE_INFO_LIST(type) \
@@ -129,42 +129,42 @@ const TypeInfo* get_array_type_info(FieldType leaf_type, int32_t iterations) {
static constexpr int32_t depth = 9;
static const ArrayTypeInfo* array_type_Info_arr[][depth] = {
{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_TINYINT),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_TINYINT),
{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_SMALLINT),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_SMALLINT),
{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_INT),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_UNSIGNED_INT),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_BIGINT),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_UNSIGNED_BIGINT),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_LARGEINT),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_FLOAT),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_DOUBLE),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_INT),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_BIGINT),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_LARGEINT),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_FLOAT),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_DOUBLE),
{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_CHAR),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_DATE),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_DATETIME),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_DECIMAL),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_VARCHAR),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_CHAR),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_DATE),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_DATETIME),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_DECIMAL),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_VARCHAR),
{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
{nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr},
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_HLL),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_BOOL),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_OBJECT),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_STRING),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_QUANTILE_STATE),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_DATEV2),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_DATETIMEV2),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_TIMEV2),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_DECIMAL32),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_DECIMAL64),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_DECIMAL128I),
- INIT_ARRAY_TYPE_INFO_LIST(OLAP_FIELD_TYPE_JSONB),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_HLL),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_BOOL),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_OBJECT),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_STRING),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_DATEV2),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_DATETIMEV2),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_TIMEV2),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_DECIMAL32),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_DECIMAL64),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_DECIMAL128I),
+ INIT_ARRAY_TYPE_INFO_LIST(FieldType::OLAP_FIELD_TYPE_JSONB),
};
- return array_type_Info_arr[leaf_type][iterations];
+ return array_type_Info_arr[int(leaf_type)][iterations];
}
// Produce a struct type info
@@ -186,23 +186,23 @@ const TypeInfo* get_struct_type_info(std::vector<FieldType> field_types) {
// TODO(xy): Support the type info of the nested struct
TypeInfoPtr get_type_info(segment_v2::ColumnMetaPB* column_meta_pb) {
FieldType type = (FieldType)column_meta_pb->type();
- if (UNLIKELY(type == OLAP_FIELD_TYPE_STRUCT)) {
+ if (UNLIKELY(type == FieldType::OLAP_FIELD_TYPE_STRUCT)) {
std::vector<FieldType> field_types;
for (uint32_t i = 0; i < column_meta_pb->children_columns_size(); i++) {
const auto* child_column = &column_meta_pb->children_columns(i);
field_types.push_back((FieldType)child_column->type());
}
return create_dynamic_type_info_ptr(get_struct_type_info(field_types));
- } else if (UNLIKELY(type == OLAP_FIELD_TYPE_ARRAY)) {
+ } else if (UNLIKELY(type == FieldType::OLAP_FIELD_TYPE_ARRAY)) {
int32_t iterations = 0;
const auto* child_column = &column_meta_pb->children_columns(0);
- while (child_column->type() == OLAP_FIELD_TYPE_ARRAY) {
+ while (child_column->type() == int(FieldType::OLAP_FIELD_TYPE_ARRAY)) {
iterations++;
child_column = &child_column->children_columns(0);
}
return create_static_type_info_ptr(
get_array_type_info((FieldType)child_column->type(), iterations));
- } else if (UNLIKELY(type == OLAP_FIELD_TYPE_MAP)) {
+ } else if (UNLIKELY(type == FieldType::OLAP_FIELD_TYPE_MAP)) {
segment_v2::ColumnMetaPB key_meta = column_meta_pb->children_columns(0);
TypeInfoPtr key_type_info = get_type_info(&key_meta);
segment_v2::ColumnMetaPB value_meta = column_meta_pb->children_columns(1);
@@ -235,22 +235,22 @@ TypeInfoPtr create_type_info_ptr(const TypeInfo* type_info, bool should_reclaim_
// TODO: Support the type info of the nested array with more than 9 depths.
TypeInfoPtr get_type_info(const TabletColumn* col) {
auto type = col->type();
- if (UNLIKELY(type == OLAP_FIELD_TYPE_STRUCT)) {
+ if (UNLIKELY(type == FieldType::OLAP_FIELD_TYPE_STRUCT)) {
std::vector<FieldType> field_types;
for (uint32_t i = 0; i < col->get_subtype_count(); i++) {
const auto* child_column = &col->get_sub_column(i);
field_types.push_back(child_column->type());
}
return create_dynamic_type_info_ptr(get_struct_type_info(field_types));
- } else if (UNLIKELY(type == OLAP_FIELD_TYPE_ARRAY)) {
+ } else if (UNLIKELY(type == FieldType::OLAP_FIELD_TYPE_ARRAY)) {
int32_t iterations = 0;
const auto* child_column = &col->get_sub_column(0);
- while (child_column->type() == OLAP_FIELD_TYPE_ARRAY) {
+ while (child_column->type() == FieldType::OLAP_FIELD_TYPE_ARRAY) {
iterations++;
child_column = &child_column->get_sub_column(0);
}
return create_static_type_info_ptr(get_array_type_info(child_column->type(), iterations));
- } else if (UNLIKELY(type == OLAP_FIELD_TYPE_MAP)) {
+ } else if (UNLIKELY(type == FieldType::OLAP_FIELD_TYPE_MAP)) {
const auto* key_column = &col->get_sub_column(0);
TypeInfoPtr key_type = get_type_info(key_column);
const auto* val_column = &col->get_sub_column(1);
@@ -264,12 +264,12 @@ TypeInfoPtr get_type_info(const TabletColumn* col) {
TypeInfoPtr clone_type_info(const TypeInfo* type_info) {
auto type = type_info->type();
- if (UNLIKELY(type == OLAP_FIELD_TYPE_MAP)) {
+ if (UNLIKELY(type == FieldType::OLAP_FIELD_TYPE_MAP)) {
const auto map_type_info = dynamic_cast<const MapTypeInfo*>(type_info);
return create_dynamic_type_info_ptr(
new MapTypeInfo(clone_type_info(map_type_info->get_key_type_info()),
clone_type_info(map_type_info->get_value_type_info())));
- } else if (UNLIKELY(type == OLAP_FIELD_TYPE_STRUCT)) {
+ } else if (UNLIKELY(type == FieldType::OLAP_FIELD_TYPE_STRUCT)) {
const auto struct_type_info = dynamic_cast<const StructTypeInfo*>(type_info);
std::vector<TypeInfoPtr> clone_type_infos;
const std::vector<TypeInfoPtr>* sub_type_infos = struct_type_info->type_infos();
@@ -278,7 +278,7 @@ TypeInfoPtr clone_type_info(const TypeInfo* type_info) {
clone_type_infos.push_back(clone_type_info((*sub_type_infos)[i].get()));
}
return create_dynamic_type_info_ptr(new StructTypeInfo(clone_type_infos));
- } else if (UNLIKELY(type == OLAP_FIELD_TYPE_ARRAY)) {
+ } else if (UNLIKELY(type == FieldType::OLAP_FIELD_TYPE_ARRAY)) {
const auto array_type_info = dynamic_cast<const ArrayTypeInfo*>(type_info);
return create_dynamic_type_info_ptr(
new ArrayTypeInfo(clone_type_info(array_type_info->item_type_info())));
diff --git a/be/src/olap/types.h b/be/src/olap/types.h
index 56c71a0052..6b35729551 100644
--- a/be/src/olap/types.h
+++ b/be/src/olap/types.h
@@ -251,7 +251,7 @@ public:
*base += nulls_size + src_value->length() * _item_type_info->size();
// Direct copy item.
- if (_item_type_info->type() == OLAP_FIELD_TYPE_ARRAY) {
+ if (_item_type_info->type() == FieldType::OLAP_FIELD_TYPE_ARRAY) {
for (uint32_t i = 0; i < src_value->length(); ++i) {
if (dest_value->is_null_at(i)) {
continue;
@@ -312,7 +312,7 @@ public:
size_t size() const override { return sizeof(CollectionValue); }
- FieldType type() const override { return OLAP_FIELD_TYPE_ARRAY; }
+ FieldType type() const override { return FieldType::OLAP_FIELD_TYPE_ARRAY; }
inline const TypeInfo* item_type_info() const { return _item_type_info.get(); }
@@ -400,7 +400,7 @@ public:
size_t size() const override { return sizeof(MapValue); }
- FieldType type() const override { return OLAP_FIELD_TYPE_MAP; }
+ FieldType type() const override { return FieldType::OLAP_FIELD_TYPE_MAP; }
inline const TypeInfo* get_key_type_info() const { return _key_type_info.get(); }
inline const TypeInfo* get_value_type_info() const { return _value_type_info.get(); }
@@ -528,10 +528,10 @@ public:
}
auto dest_address = dest_value->mutable_child_value(i);
auto src_address = src_value->child_value(i);
- if (_type_infos[i]->type() == OLAP_FIELD_TYPE_STRUCT) {
+ if (_type_infos[i]->type() == FieldType::OLAP_FIELD_TYPE_STRUCT) {
dynamic_cast<const StructTypeInfo*>(_type_infos[i].get())
->direct_copy(base, dest_address, src_address);
- } else if (_type_infos[i]->type() == OLAP_FIELD_TYPE_ARRAY) {
+ } else if (_type_infos[i]->type() == FieldType::OLAP_FIELD_TYPE_ARRAY) {
dynamic_cast<const ArrayTypeInfo*>(_type_infos[i].get())
->direct_copy(base, dest_address, src_address);
} else {
@@ -579,7 +579,7 @@ public:
size_t size() const override { return sizeof(StructValue); }
- FieldType type() const override { return OLAP_FIELD_TYPE_STRUCT; }
+ FieldType type() const override { return FieldType::OLAP_FIELD_TYPE_STRUCT; }
inline const std::vector<TypeInfoPtr>* type_infos() const { return &_type_infos; }
@@ -606,136 +606,136 @@ template <FieldType field_type>
struct CppTypeTraits {};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_BOOL> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_BOOL> {
using CppType = bool;
using UnsignedCppType = bool;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_TINYINT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_TINYINT> {
using CppType = int8_t;
using UnsignedCppType = uint8_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_SMALLINT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_SMALLINT> {
using CppType = int16_t;
using UnsignedCppType = uint16_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_INT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_INT> {
using CppType = int32_t;
using UnsignedCppType = uint32_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_UNSIGNED_INT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT> {
using CppType = uint32_t;
using UnsignedCppType = uint32_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_BIGINT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_BIGINT> {
using CppType = int64_t;
using UnsignedCppType = uint64_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_UNSIGNED_BIGINT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT> {
using CppType = uint64_t;
using UnsignedCppType = uint64_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_LARGEINT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_LARGEINT> {
using CppType = int128_t;
using UnsignedCppType = uint128_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_FLOAT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_FLOAT> {
using CppType = float;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_DOUBLE> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DOUBLE> {
using CppType = double;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_DECIMAL> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL> {
using CppType = decimal12_t;
using UnsignedCppType = decimal12_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_DECIMAL32> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL32> {
using CppType = int32_t;
using UnsignedCppType = uint32_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_DECIMAL64> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL64> {
using CppType = int64_t;
using UnsignedCppType = uint64_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_DECIMAL128I> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL128I> {
using CppType = int128_t;
using UnsignedCppType = uint128_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_DATE> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATE> {
using CppType = uint24_t;
using UnsignedCppType = uint24_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_DATEV2> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATEV2> {
using CppType = uint32_t;
using UnsignedCppType = uint32_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_TIMEV2> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_TIMEV2> {
using CppType = uint64_t;
using UnsignedCppType = uint64_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_DATETIMEV2> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIMEV2> {
using CppType = uint64_t;
using UnsignedCppType = uint64_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_DATETIME> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIME> {
using CppType = int64_t;
using UnsignedCppType = uint64_t;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_CHAR> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_CHAR> {
using CppType = Slice;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_VARCHAR> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_VARCHAR> {
using CppType = Slice;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_STRING> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_STRING> {
using CppType = Slice;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_JSONB> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_JSONB> {
using CppType = Slice;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_HLL> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_HLL> {
using CppType = Slice;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_OBJECT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_OBJECT> {
using CppType = Slice;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_QUANTILE_STATE> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE> {
using CppType = Slice;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_STRUCT> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_STRUCT> {
using CppType = StructValue;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_ARRAY> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_ARRAY> {
using CppType = CollectionValue;
};
template <>
-struct CppTypeTraits<OLAP_FIELD_TYPE_MAP> {
+struct CppTypeTraits<FieldType::OLAP_FIELD_TYPE_MAP> {
using CppType = MapValue;
};
template <FieldType field_type>
@@ -743,7 +743,7 @@ struct BaseFieldtypeTraits : public CppTypeTraits<field_type> {
using CppType = typename CppTypeTraits<field_type>::CppType;
static inline CppType get_cpp_type_value(const void* address) {
- if constexpr (field_type == OLAP_FIELD_TYPE_LARGEINT) {
+ if constexpr (field_type == FieldType::OLAP_FIELD_TYPE_LARGEINT) {
return get_int128_from_unalign(address);
}
return *reinterpret_cast<const CppType*>(address);
@@ -798,8 +798,8 @@ struct BaseFieldtypeTraits : public CppTypeTraits<field_type> {
}
};
-// Using NumericFieldtypeTraits to Derived code for OLAP_FIELD_TYPE_XXXINT, OLAP_FIELD_TYPE_FLOAT,
-// OLAP_FIELD_TYPE_DOUBLE, to reduce redundant code
+// Using NumericFieldtypeTraits to Derived code for FieldType::OLAP_FIELD_TYPE_XXXINT, FieldType::OLAP_FIELD_TYPE_FLOAT,
+// FieldType::OLAP_FIELD_TYPE_DOUBLE, to reduce redundant code
template <FieldType fieldType, bool isArithmetic>
struct NumericFieldtypeTraits : public BaseFieldtypeTraits<fieldType> {
using CppType = typename CppTypeTraits<fieldType>::CppType;
@@ -821,7 +821,8 @@ struct FieldTypeTraits
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_BOOL> : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_BOOL> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_BOOL>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_BOOL> {
static std::string to_string(const void* src) {
char buf[1024] = {'\0'};
snprintf(buf, sizeof(buf), "%d", *reinterpret_cast<const bool*>(src));
@@ -832,8 +833,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_BOOL> : public BaseFieldtypeTraits<OLAP_F
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_LARGEINT>
- : public NumericFieldtypeTraits<OLAP_FIELD_TYPE_LARGEINT, true> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_LARGEINT>
+ : public NumericFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_LARGEINT, true> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
int128_t value = 0;
@@ -931,8 +932,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_LARGEINT>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_FLOAT>
- : public NumericFieldtypeTraits<OLAP_FIELD_TYPE_FLOAT, true> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_FLOAT>
+ : public NumericFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_FLOAT, true> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
CppType value = 0.0f;
@@ -953,8 +954,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_FLOAT>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_DOUBLE>
- : public NumericFieldtypeTraits<OLAP_FIELD_TYPE_DOUBLE, true> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DOUBLE>
+ : public NumericFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_DOUBLE, true> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
CppType value = 0.0;
@@ -975,8 +976,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DOUBLE>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_DECIMAL>
- : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_DECIMAL> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
CppType* data_ptr = reinterpret_cast<CppType*>(buf);
@@ -999,8 +1000,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DECIMAL>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_DECIMAL32>
- : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_DECIMAL32> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL32>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL32> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
StringParser::ParseResult result = StringParser::PARSE_SUCCESS;
@@ -1024,8 +1025,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DECIMAL32>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_DECIMAL64>
- : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_DECIMAL64> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL64>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL64> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
StringParser::ParseResult result = StringParser::PARSE_SUCCESS;
@@ -1048,8 +1049,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DECIMAL64>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_DECIMAL128I>
- : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_DECIMAL128I> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL128I>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_DECIMAL128I> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
StringParser::ParseResult result = StringParser::PARSE_SUCCESS;
@@ -1080,7 +1081,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DECIMAL128I>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_DATE> : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_DATE> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DATE>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_DATE> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
tm time_tm;
@@ -1112,8 +1114,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DATE> : public BaseFieldtypeTraits<OLAP_F
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_DATEV2>
- : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_DATEV2> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DATEV2>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_DATEV2> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
tm time_tm;
@@ -1152,8 +1154,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DATEV2>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_DATETIMEV2>
- : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_DATETIMEV2> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIMEV2>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIMEV2> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
doris::vectorized::DateV2Value<doris::vectorized::DateTimeV2ValueType> datetimev2_value;
@@ -1193,8 +1195,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DATETIMEV2>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_DATETIME>
- : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_DATETIME> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIME>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_DATETIME> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
tm time_tm;
@@ -1240,7 +1242,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_DATETIME>
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_CHAR> : public BaseFieldtypeTraits<OLAP_FIELD_TYPE_CHAR> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_CHAR>
+ : public BaseFieldtypeTraits<FieldType::OLAP_FIELD_TYPE_CHAR> {
static int cmp(const void* left, const void* right) {
auto l_slice = reinterpret_cast<const Slice*>(left);
auto r_slice = reinterpret_cast<const Slice*>(right);
@@ -1310,7 +1313,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_CHAR> : public BaseFieldtypeTraits<OLAP_F
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_VARCHAR> : public FieldTypeTraits<OLAP_FIELD_TYPE_CHAR> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_VARCHAR>
+ : public FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_CHAR> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
size_t value_len = scan_key.length();
@@ -1333,7 +1337,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_VARCHAR> : public FieldTypeTraits<OLAP_FI
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_STRING> : public FieldTypeTraits<OLAP_FIELD_TYPE_CHAR> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_STRING>
+ : public FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_CHAR> {
static Status from_string(void* buf, const std::string& scan_key, const int precision,
const int scale) {
size_t value_len = scan_key.length();
@@ -1356,7 +1361,8 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_STRING> : public FieldTypeTraits<OLAP_FIE
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_JSONB> : public FieldTypeTraits<OLAP_FIELD_TYPE_VARCHAR> {
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_JSONB>
+ : public FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_VARCHAR> {
static int cmp(const void* left, const void* right) {
LOG(WARNING) << "can not compare JSONB values";
return -1; // always update ?
@@ -1380,14 +1386,16 @@ struct FieldTypeTraits<OLAP_FIELD_TYPE_JSONB> : public FieldTypeTraits<OLAP_FIEL
};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_HLL> : public FieldTypeTraits<OLAP_FIELD_TYPE_VARCHAR> {};
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_HLL>
+ : public FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_VARCHAR> {};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_OBJECT> : public FieldTypeTraits<OLAP_FIELD_TYPE_VARCHAR> {};
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_OBJECT>
+ : public FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_VARCHAR> {};
template <>
-struct FieldTypeTraits<OLAP_FIELD_TYPE_QUANTILE_STATE>
- : public FieldTypeTraits<OLAP_FIELD_TYPE_VARCHAR> {};
+struct FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE>
+ : public FieldTypeTraits<FieldType::OLAP_FIELD_TYPE_VARCHAR> {};
// Instantiate this template to get static access to the type traits.
template <FieldType field_type>
@@ -1414,7 +1422,7 @@ inline const TypeInfo* get_collection_type_info() {
// nested array type is unsupported for sub_type of collection
template <>
-inline const TypeInfo* get_collection_type_info<OLAP_FIELD_TYPE_ARRAY>() {
+inline const TypeInfo* get_collection_type_info<FieldType::OLAP_FIELD_TYPE_ARRAY>() {
return nullptr;
}
diff --git a/be/src/olap/utils.h b/be/src/olap/utils.h
index 1ccaec98ee..71be36cb71 100644
--- a/be/src/olap/utils.h
+++ b/be/src/olap/utils.h
@@ -238,22 +238,31 @@ bool valid_datetime(const std::string& value_str, const uint32_t scale);
bool valid_bool(const std::string& value_str);
constexpr bool is_string_type(const FieldType& field_type) {
- return field_type == OLAP_FIELD_TYPE_VARCHAR || field_type == OLAP_FIELD_TYPE_CHAR ||
- field_type == OLAP_FIELD_TYPE_STRING;
+ return field_type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ field_type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ field_type == FieldType::OLAP_FIELD_TYPE_STRING;
}
constexpr bool is_numeric_type(const FieldType& field_type) {
- return field_type == OLAP_FIELD_TYPE_INT || field_type == OLAP_FIELD_TYPE_UNSIGNED_INT ||
- field_type == OLAP_FIELD_TYPE_BIGINT || field_type == OLAP_FIELD_TYPE_SMALLINT ||
- field_type == OLAP_FIELD_TYPE_UNSIGNED_TINYINT ||
- field_type == OLAP_FIELD_TYPE_UNSIGNED_SMALLINT ||
- field_type == OLAP_FIELD_TYPE_TINYINT || field_type == OLAP_FIELD_TYPE_DOUBLE ||
- field_type == OLAP_FIELD_TYPE_FLOAT || field_type == OLAP_FIELD_TYPE_DATE ||
- field_type == OLAP_FIELD_TYPE_DATEV2 || field_type == OLAP_FIELD_TYPE_DATETIME ||
- field_type == OLAP_FIELD_TYPE_DATETIMEV2 || field_type == OLAP_FIELD_TYPE_LARGEINT ||
- field_type == OLAP_FIELD_TYPE_DECIMAL || field_type == OLAP_FIELD_TYPE_DECIMAL32 ||
- field_type == OLAP_FIELD_TYPE_DECIMAL64 || field_type == OLAP_FIELD_TYPE_DECIMAL128I ||
- field_type == OLAP_FIELD_TYPE_BOOL;
+ return field_type == FieldType::OLAP_FIELD_TYPE_INT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_BIGINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_SMALLINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_TINYINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DOUBLE ||
+ field_type == FieldType::OLAP_FIELD_TYPE_FLOAT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DATE ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DATEV2 ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DATETIME ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DATETIMEV2 ||
+ field_type == FieldType::OLAP_FIELD_TYPE_LARGEINT ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DECIMAL ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DECIMAL32 ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DECIMAL64 ||
+ field_type == FieldType::OLAP_FIELD_TYPE_DECIMAL128I ||
+ field_type == FieldType::OLAP_FIELD_TYPE_BOOL;
}
// Util used to get string name of thrift enum item
diff --git a/be/src/olap/wrapper_field.cpp b/be/src/olap/wrapper_field.cpp
index c6dbbd0f1d..6f227e1775 100644
--- a/be/src/olap/wrapper_field.cpp
+++ b/be/src/olap/wrapper_field.cpp
@@ -24,11 +24,12 @@ namespace doris {
const size_t DEFAULT_STRING_LENGTH = 50;
WrapperField* WrapperField::create(const TabletColumn& column, uint32_t len) {
- bool is_string_type =
- (column.type() == OLAP_FIELD_TYPE_CHAR || column.type() == OLAP_FIELD_TYPE_VARCHAR ||
- column.type() == OLAP_FIELD_TYPE_HLL || column.type() == OLAP_FIELD_TYPE_OBJECT ||
- column.type() == OLAP_FIELD_TYPE_STRING);
- size_t max_length = column.type() == OLAP_FIELD_TYPE_STRING
+ bool is_string_type = (column.type() == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ column.type() == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ column.type() == FieldType::OLAP_FIELD_TYPE_HLL ||
+ column.type() == FieldType::OLAP_FIELD_TYPE_OBJECT ||
+ column.type() == FieldType::OLAP_FIELD_TYPE_STRING);
+ size_t max_length = column.type() == FieldType::OLAP_FIELD_TYPE_STRING
? config::string_type_length_soft_limit_bytes
: OLAP_VARCHAR_MAX_LENGTH;
if (is_string_type && len > max_length) {
@@ -43,15 +44,16 @@ WrapperField* WrapperField::create(const TabletColumn& column, uint32_t len) {
}
size_t variable_len = 0;
- if (column.type() == OLAP_FIELD_TYPE_CHAR) {
+ if (column.type() == FieldType::OLAP_FIELD_TYPE_CHAR) {
variable_len = std::max(len, (uint32_t)(column.length()));
- } else if (column.type() == OLAP_FIELD_TYPE_VARCHAR || column.type() == OLAP_FIELD_TYPE_HLL) {
+ } else if (column.type() == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ column.type() == FieldType::OLAP_FIELD_TYPE_HLL) {
// column.length is the serialized varchar length
// the first sizeof(VarcharLengthType) bytes is the length of varchar
// variable_len is the real length of varchar
variable_len =
std::max(len, static_cast<uint32_t>(column.length() - sizeof(VarcharLengthType)));
- } else if (column.type() == OLAP_FIELD_TYPE_STRING) {
+ } else if (column.type() == FieldType::OLAP_FIELD_TYPE_STRING) {
variable_len = len;
} else {
variable_len = column.length();
@@ -67,9 +69,11 @@ WrapperField* WrapperField::create_by_type(const FieldType& type, int32_t var_le
return nullptr;
}
bool is_string_type =
- (type == OLAP_FIELD_TYPE_CHAR || type == OLAP_FIELD_TYPE_VARCHAR ||
- type == OLAP_FIELD_TYPE_HLL || type == OLAP_FIELD_TYPE_OBJECT ||
- type == OLAP_FIELD_TYPE_STRING || type == OLAP_FIELD_TYPE_QUANTILE_STATE);
+ (type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ type == FieldType::OLAP_FIELD_TYPE_VARCHAR || type == FieldType::OLAP_FIELD_TYPE_HLL ||
+ type == FieldType::OLAP_FIELD_TYPE_OBJECT ||
+ type == FieldType::OLAP_FIELD_TYPE_STRING ||
+ type == FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE);
auto wrapper = new WrapperField(rep, var_length, is_string_type);
return wrapper;
}
@@ -90,7 +94,7 @@ WrapperField::WrapperField(Field* rep, size_t variable_len, bool is_string_type)
_string_content.reset(new char[slice->size]);
slice->data = _string_content.get();
}
- if (_rep->type() == OLAP_FIELD_TYPE_STRING) {
+ if (_rep->type() == FieldType::OLAP_FIELD_TYPE_STRING) {
_long_text_buf = (char*)malloc(RowCursor::DEFAULT_TEXT_LENGTH * sizeof(char));
rep->set_long_text_buf(&_long_text_buf);
}
diff --git a/be/src/vec/columns/column_dictionary.h b/be/src/vec/columns/column_dictionary.h
index 29fd33f5b1..c8bf6ea17b 100644
--- a/be/src/vec/columns/column_dictionary.h
+++ b/be/src/vec/columns/column_dictionary.h
@@ -326,7 +326,7 @@ public:
inline StringRef get_shrink_value(value_type code) const {
StringRef result = _dict.get_value(code);
- if (_type == OLAP_FIELD_TYPE_CHAR) {
+ if (_type == FieldType::OLAP_FIELD_TYPE_CHAR) {
result.size = strnlen(result.data, result.size);
}
return result;
@@ -386,7 +386,7 @@ public:
// For dictionary data of char type, sv.size is the schema length,
// so use strnlen to remove the 0 at the end to get the actual length.
int32_t len = sv.size;
- if (type == OLAP_FIELD_TYPE_CHAR) {
+ if (type == FieldType::OLAP_FIELD_TYPE_CHAR) {
len = strnlen(sv.data, sv.size);
}
uint32_t hash_val = HashUtil::murmur_hash3_32(sv.data, len, 0);
diff --git a/be/src/vec/common/schema_util.cpp b/be/src/vec/common/schema_util.cpp
index 8a74ebf476..48e13019e2 100644
--- a/be/src/vec/common/schema_util.cpp
+++ b/be/src/vec/common/schema_util.cpp
@@ -91,19 +91,22 @@ bool is_conversion_required_between_integers(const IDataType& lhs, const IDataTy
bool is_conversion_required_between_integers(FieldType lhs, FieldType rhs) {
// We only support signed integers for semi-structure data at present
// TODO add unsigned integers
- if (lhs == OLAP_FIELD_TYPE_BIGINT) {
- return !(rhs == OLAP_FIELD_TYPE_TINYINT || rhs == OLAP_FIELD_TYPE_SMALLINT ||
- rhs == OLAP_FIELD_TYPE_INT || rhs == OLAP_FIELD_TYPE_BIGINT);
+ if (lhs == FieldType::OLAP_FIELD_TYPE_BIGINT) {
+ return !(rhs == FieldType::OLAP_FIELD_TYPE_TINYINT ||
+ rhs == FieldType::OLAP_FIELD_TYPE_SMALLINT ||
+ rhs == FieldType::OLAP_FIELD_TYPE_INT || rhs == FieldType::OLAP_FIELD_TYPE_BIGINT);
}
- if (lhs == OLAP_FIELD_TYPE_INT) {
- return !(rhs == OLAP_FIELD_TYPE_TINYINT || rhs == OLAP_FIELD_TYPE_SMALLINT ||
- rhs == OLAP_FIELD_TYPE_INT);
+ if (lhs == FieldType::OLAP_FIELD_TYPE_INT) {
+ return !(rhs == FieldType::OLAP_FIELD_TYPE_TINYINT ||
+ rhs == FieldType::OLAP_FIELD_TYPE_SMALLINT ||
+ rhs == FieldType::OLAP_FIELD_TYPE_INT);
}
- if (lhs == OLAP_FIELD_TYPE_SMALLINT) {
- return !(rhs == OLAP_FIELD_TYPE_TINYINT || rhs == OLAP_FIELD_TYPE_SMALLINT);
+ if (lhs == FieldType::OLAP_FIELD_TYPE_SMALLINT) {
+ return !(rhs == FieldType::OLAP_FIELD_TYPE_TINYINT ||
+ rhs == FieldType::OLAP_FIELD_TYPE_SMALLINT);
}
- if (lhs == OLAP_FIELD_TYPE_TINYINT) {
- return !(rhs == OLAP_FIELD_TYPE_TINYINT);
+ if (lhs == FieldType::OLAP_FIELD_TYPE_TINYINT) {
+ return !(rhs == FieldType::OLAP_FIELD_TYPE_TINYINT);
}
return true;
}
diff --git a/be/src/vec/data_types/data_type_factory.cpp b/be/src/vec/data_types/data_type_factory.cpp
index 2cb1f73aae..a14776fdbe 100644
--- a/be/src/vec/data_types/data_type_factory.cpp
+++ b/be/src/vec/data_types/data_type_factory.cpp
@@ -31,15 +31,15 @@ namespace doris::vectorized {
DataTypePtr DataTypeFactory::create_data_type(const doris::Field& col_desc) {
DataTypePtr nested = nullptr;
- if (col_desc.type() == OLAP_FIELD_TYPE_ARRAY) {
+ if (col_desc.type() == FieldType::OLAP_FIELD_TYPE_ARRAY) {
DCHECK(col_desc.get_sub_field_count() == 1);
nested = std::make_shared<DataTypeArray>(create_data_type(*col_desc.get_sub_field(0)));
- } else if (col_desc.type() == OLAP_FIELD_TYPE_MAP) {
+ } else if (col_desc.type() == FieldType::OLAP_FIELD_TYPE_MAP) {
DCHECK(col_desc.get_sub_field_count() == 2);
nested = std::make_shared<vectorized::DataTypeMap>(
create_data_type(*col_desc.get_sub_field(0)),
create_data_type(*col_desc.get_sub_field(1)));
- } else if (col_desc.type() == OLAP_FIELD_TYPE_STRUCT) {
+ } else if (col_desc.type() == FieldType::OLAP_FIELD_TYPE_STRUCT) {
DCHECK(col_desc.get_sub_field_count() >= 1);
size_t field_size = col_desc.get_sub_field_count();
DataTypes dataTypes;
@@ -64,15 +64,15 @@ DataTypePtr DataTypeFactory::create_data_type(const doris::Field& col_desc) {
DataTypePtr DataTypeFactory::create_data_type(const TabletColumn& col_desc, bool is_nullable) {
DataTypePtr nested = nullptr;
- if (col_desc.type() == OLAP_FIELD_TYPE_ARRAY) {
+ if (col_desc.type() == FieldType::OLAP_FIELD_TYPE_ARRAY) {
DCHECK(col_desc.get_subtype_count() == 1);
nested = std::make_shared<DataTypeArray>(create_data_type(col_desc.get_sub_column(0)));
- } else if (col_desc.type() == OLAP_FIELD_TYPE_MAP) {
+ } else if (col_desc.type() == FieldType::OLAP_FIELD_TYPE_MAP) {
DCHECK(col_desc.get_subtype_count() == 2);
nested = std::make_shared<vectorized::DataTypeMap>(
create_data_type(col_desc.get_sub_column(0)),
create_data_type(col_desc.get_sub_column(1)));
- } else if (col_desc.type() == OLAP_FIELD_TYPE_STRUCT) {
+ } else if (col_desc.type() == FieldType::OLAP_FIELD_TYPE_STRUCT) {
DCHECK(col_desc.get_subtype_count() >= 1);
size_t col_size = col_desc.get_subtype_count();
DataTypes dataTypes;
@@ -309,65 +309,65 @@ DataTypePtr DataTypeFactory::_create_primitive_data_type(const FieldType& type,
int scale) const {
DataTypePtr result = nullptr;
switch (type) {
- case OLAP_FIELD_TYPE_BOOL:
+ case FieldType::OLAP_FIELD_TYPE_BOOL:
result = std::make_shared<vectorized::DataTypeUInt8>();
break;
- case OLAP_FIELD_TYPE_TINYINT:
+ case FieldType::OLAP_FIELD_TYPE_TINYINT:
result = std::make_shared<vectorized::DataTypeInt8>();
break;
- case OLAP_FIELD_TYPE_SMALLINT:
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT:
result = std::make_shared<vectorized::DataTypeInt16>();
break;
- case OLAP_FIELD_TYPE_INT:
+ case FieldType::OLAP_FIELD_TYPE_INT:
result = std::make_shared<vectorized::DataTypeInt32>();
break;
- case OLAP_FIELD_TYPE_FLOAT:
+ case FieldType::OLAP_FIELD_TYPE_FLOAT:
result = std::make_shared<vectorized::DataTypeFloat32>();
break;
- case OLAP_FIELD_TYPE_BIGINT:
+ case FieldType::OLAP_FIELD_TYPE_BIGINT:
result = std::make_shared<vectorized::DataTypeInt64>();
break;
- case OLAP_FIELD_TYPE_LARGEINT:
+ case FieldType::OLAP_FIELD_TYPE_LARGEINT:
result = std::make_shared<vectorized::DataTypeInt128>();
break;
- case OLAP_FIELD_TYPE_DATE:
+ case FieldType::OLAP_FIELD_TYPE_DATE:
result = std::make_shared<vectorized::DataTypeDate>();
break;
- case OLAP_FIELD_TYPE_DATEV2:
+ case FieldType::OLAP_FIELD_TYPE_DATEV2:
result = std::make_shared<vectorized::DataTypeDateV2>();
break;
- case OLAP_FIELD_TYPE_DATETIMEV2:
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2:
result = vectorized::create_datetimev2(scale);
break;
- case OLAP_FIELD_TYPE_DATETIME:
+ case FieldType::OLAP_FIELD_TYPE_DATETIME:
result = std::make_shared<vectorized::DataTypeDateTime>();
break;
- case OLAP_FIELD_TYPE_DOUBLE:
+ case FieldType::OLAP_FIELD_TYPE_DOUBLE:
result = std::make_shared<vectorized::DataTypeFloat64>();
break;
- case OLAP_FIELD_TYPE_CHAR:
- case OLAP_FIELD_TYPE_VARCHAR:
- case OLAP_FIELD_TYPE_STRING:
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
+ case FieldType::OLAP_FIELD_TYPE_STRING:
result = std::make_shared<vectorized::DataTypeString>();
break;
- case OLAP_FIELD_TYPE_JSONB:
+ case FieldType::OLAP_FIELD_TYPE_JSONB:
result = std::make_shared<vectorized::DataTypeJsonb>();
break;
- case OLAP_FIELD_TYPE_HLL:
+ case FieldType::OLAP_FIELD_TYPE_HLL:
result = std::make_shared<vectorized::DataTypeHLL>();
break;
- case OLAP_FIELD_TYPE_OBJECT:
+ case FieldType::OLAP_FIELD_TYPE_OBJECT:
result = std::make_shared<vectorized::DataTypeBitMap>();
break;
- case OLAP_FIELD_TYPE_DECIMAL:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL:
result = std::make_shared<vectorized::DataTypeDecimal<vectorized::Decimal128>>(27, 9);
break;
- case OLAP_FIELD_TYPE_QUANTILE_STATE:
+ case FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE:
result = std::make_shared<vectorized::DataTypeQuantileStateDouble>();
break;
- case OLAP_FIELD_TYPE_DECIMAL32:
- case OLAP_FIELD_TYPE_DECIMAL64:
- case OLAP_FIELD_TYPE_DECIMAL128I:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
result = vectorized::create_decimal(precision, scale, false);
break;
default:
diff --git a/be/src/vec/jsonb/serialize.cpp b/be/src/vec/jsonb/serialize.cpp
index 6739ada85b..1d06b0873f 100644
--- a/be/src/vec/jsonb/serialize.cpp
+++ b/be/src/vec/jsonb/serialize.cpp
@@ -29,7 +29,7 @@ namespace doris::vectorized {
static inline bool is_column_null_at(int row, const IColumn* column, const doris::FieldType& type,
const StringRef& data_ref) {
- if (type != OLAP_FIELD_TYPE_ARRAY) {
+ if (type != FieldType::OLAP_FIELD_TYPE_ARRAY) {
return data_ref.data == nullptr;
} else {
Field array;
@@ -39,11 +39,11 @@ static inline bool is_column_null_at(int row, const IColumn* column, const doris
}
static bool is_jsonb_blob_type(FieldType type) {
- return type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_CHAR ||
- type == OLAP_FIELD_TYPE_STRING || type == OLAP_FIELD_TYPE_STRUCT ||
- type == OLAP_FIELD_TYPE_ARRAY || type == OLAP_FIELD_TYPE_MAP ||
- type == OLAP_FIELD_TYPE_HLL || type == OLAP_FIELD_TYPE_OBJECT ||
- type == OLAP_FIELD_TYPE_JSONB;
+ return type == FieldType::OLAP_FIELD_TYPE_VARCHAR || type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ type == FieldType::OLAP_FIELD_TYPE_STRING || type == FieldType::OLAP_FIELD_TYPE_STRUCT ||
+ type == FieldType::OLAP_FIELD_TYPE_ARRAY || type == FieldType::OLAP_FIELD_TYPE_MAP ||
+ type == FieldType::OLAP_FIELD_TYPE_HLL || type == FieldType::OLAP_FIELD_TYPE_OBJECT ||
+ type == FieldType::OLAP_FIELD_TYPE_JSONB;
}
// jsonb -> column value
@@ -168,7 +168,7 @@ static void serialize_column(Arena* mem_pool, const TabletColumn& tablet_column,
jsonb_writer.writeStartBinary();
jsonb_writer.writeBinary(value.data, value.size);
jsonb_writer.writeEndBinary();
- } else if (tablet_column.type() == OLAP_FIELD_TYPE_OBJECT) {
+ } else if (tablet_column.type() == FieldType::OLAP_FIELD_TYPE_OBJECT) {
auto bitmap_value = (BitmapValue*)(data_ref.data);
auto size = bitmap_value->getSizeInBytes();
// serialize the content of string
@@ -177,7 +177,7 @@ static void serialize_column(Arena* mem_pool, const TabletColumn& tablet_column,
jsonb_writer.writeStartBinary();
jsonb_writer.writeBinary(reinterpret_cast<const char*>(ptr), size);
jsonb_writer.writeEndBinary();
- } else if (tablet_column.type() == OLAP_FIELD_TYPE_HLL) {
+ } else if (tablet_column.type() == FieldType::OLAP_FIELD_TYPE_HLL) {
auto hll_value = (HyperLogLog*)(data_ref.data);
auto size = hll_value->max_serialized_size();
auto ptr = reinterpret_cast<char*>(mem_pool->alloc(size));
@@ -191,89 +191,90 @@ static void serialize_column(Arena* mem_pool, const TabletColumn& tablet_column,
jsonb_writer.writeEndBinary();
} else {
switch (tablet_column.type()) {
- case OLAP_FIELD_TYPE_BOOL: {
+ case FieldType::OLAP_FIELD_TYPE_BOOL: {
int8_t val = *reinterpret_cast<const int8_t*>(data_ref.data);
jsonb_writer.writeInt8(val);
break;
}
- case OLAP_FIELD_TYPE_TINYINT: {
+ case FieldType::OLAP_FIELD_TYPE_TINYINT: {
int8_t val = *reinterpret_cast<const int8_t*>(data_ref.data);
jsonb_writer.writeInt8(val);
break;
}
- case OLAP_FIELD_TYPE_SMALLINT: {
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT: {
int16_t val = *reinterpret_cast<const int16_t*>(data_ref.data);
jsonb_writer.writeInt16(val);
break;
}
- case OLAP_FIELD_TYPE_INT: {
+ case FieldType::OLAP_FIELD_TYPE_INT: {
int32_t val = *reinterpret_cast<const int32_t*>(data_ref.data);
jsonb_writer.writeInt32(val);
break;
}
- case OLAP_FIELD_TYPE_BIGINT: {
+ case FieldType::OLAP_FIELD_TYPE_BIGINT: {
int64_t val = *reinterpret_cast<const int64_t*>(data_ref.data);
jsonb_writer.writeInt64(val);
break;
}
- case OLAP_FIELD_TYPE_LARGEINT: {
+ case FieldType::OLAP_FIELD_TYPE_LARGEINT: {
__int128_t val = *reinterpret_cast<const __int128_t*>(data_ref.data);
jsonb_writer.writeInt128(val);
break;
}
- case OLAP_FIELD_TYPE_FLOAT: {
+ case FieldType::OLAP_FIELD_TYPE_FLOAT: {
float val = *reinterpret_cast<const float*>(data_ref.data);
jsonb_writer.writeFloat(val);
break;
}
- case OLAP_FIELD_TYPE_DOUBLE: {
+ case FieldType::OLAP_FIELD_TYPE_DOUBLE: {
double val = *reinterpret_cast<const double*>(data_ref.data);
jsonb_writer.writeDouble(val);
break;
}
- case OLAP_FIELD_TYPE_DATE: {
+ case FieldType::OLAP_FIELD_TYPE_DATE: {
const auto* datetime_cur = reinterpret_cast<const VecDateTimeValue*>(data_ref.data);
jsonb_writer.writeInt32(datetime_cur->to_olap_date());
break;
}
- case OLAP_FIELD_TYPE_DATETIME: {
+ case FieldType::OLAP_FIELD_TYPE_DATETIME: {
const auto* datetime_cur = reinterpret_cast<const VecDateTimeValue*>(data_ref.data);
jsonb_writer.writeInt64(datetime_cur->to_olap_datetime());
break;
}
- case OLAP_FIELD_TYPE_DATEV2: {
+ case FieldType::OLAP_FIELD_TYPE_DATEV2: {
uint32_t val = *reinterpret_cast<const uint32_t*>(data_ref.data);
jsonb_writer.writeInt32(val);
break;
}
- case OLAP_FIELD_TYPE_DATETIMEV2: {
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: {
uint64_t val = *reinterpret_cast<const uint64_t*>(data_ref.data);
jsonb_writer.writeInt64(val);
break;
}
- case OLAP_FIELD_TYPE_DECIMAL32: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32: {
Decimal32::NativeType val =
*reinterpret_cast<const Decimal32::NativeType*>(data_ref.data);
jsonb_writer.writeInt32(val);
break;
}
- case OLAP_FIELD_TYPE_DECIMAL64: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64: {
Decimal64::NativeType val =
*reinterpret_cast<const Decimal64::NativeType*>(data_ref.data);
jsonb_writer.writeInt64(val);
break;
}
- case OLAP_FIELD_TYPE_DECIMAL128I: {
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I: {
Decimal128I::NativeType val =
*reinterpret_cast<const Decimal128I::NativeType*>(data_ref.data);
jsonb_writer.writeInt128(val);
break;
}
- case OLAP_FIELD_TYPE_DECIMAL:
- LOG(FATAL) << "OLAP_FIELD_TYPE_DECIMAL not implemented use DecimalV3 instead";
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL:
+ LOG(FATAL)
+ << "FieldType::OLAP_FIELD_TYPE_DECIMAL not implemented use DecimalV3 instead";
break;
default:
- LOG(FATAL) << "unknow type " << tablet_column.type();
+ LOG(FATAL) << "unknow type " << int(tablet_column.type());
break;
}
}
diff --git a/be/src/vec/olap/olap_data_convertor.cpp b/be/src/vec/olap/olap_data_convertor.cpp
index 1e95d58c6d..f0d1cff777 100644
--- a/be/src/vec/olap/olap_data_convertor.cpp
+++ b/be/src/vec/olap/olap_data_convertor.cpp
@@ -143,7 +143,7 @@ OlapBlockDataConvertor::create_olap_column_data_convertor(const TabletColumn& co
create_olap_column_data_convertor(value_column));
}
default: {
- DCHECK(false) << "Invalid type in RowBlockV2:" << column.type();
+ DCHECK(false) << "Invalid type in olap data convertor:" << int(column.type());
return nullptr;
}
}
diff --git a/be/src/vec/olap/vgeneric_iterators.cpp b/be/src/vec/olap/vgeneric_iterators.cpp
index 1ea4f2e5fb..b26cde0841 100644
--- a/be/src/vec/olap/vgeneric_iterators.cpp
+++ b/be/src/vec/olap/vgeneric_iterators.cpp
@@ -201,23 +201,23 @@ public:
size_t data_len = 0;
const auto* col_schema = _schema.column(j);
switch (col_schema->type()) {
- case OLAP_FIELD_TYPE_SMALLINT:
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT:
*(int16_t*)data = _rows_returned + j;
data_len = sizeof(int16_t);
break;
- case OLAP_FIELD_TYPE_INT:
+ case FieldType::OLAP_FIELD_TYPE_INT:
*(int32_t*)data = _rows_returned + j;
data_len = sizeof(int32_t);
break;
- case OLAP_FIELD_TYPE_BIGINT:
+ case FieldType::OLAP_FIELD_TYPE_BIGINT:
*(int64_t*)data = _rows_returned + j;
data_len = sizeof(int64_t);
break;
- case OLAP_FIELD_TYPE_FLOAT:
+ case FieldType::OLAP_FIELD_TYPE_FLOAT:
*(float*)data = _rows_returned + j;
data_len = sizeof(float);
break;
- case OLAP_FIELD_TYPE_DOUBLE:
+ case FieldType::OLAP_FIELD_TYPE_DOUBLE:
*(double*)data = _rows_returned + j;
data_len = sizeof(double);
break;
diff --git a/be/test/olap/key_coder_test.cpp b/be/test/olap/key_coder_test.cpp
index a8b80fc570..18fcdb404d 100644
--- a/be/test/olap/key_coder_test.cpp
+++ b/be/test/olap/key_coder_test.cpp
@@ -98,20 +98,20 @@ void test_integer_encode() {
}
TEST_F(KeyCoderTest, test_int) {
- test_integer_encode<OLAP_FIELD_TYPE_TINYINT>();
- test_integer_encode<OLAP_FIELD_TYPE_SMALLINT>();
- test_integer_encode<OLAP_FIELD_TYPE_INT>();
- test_integer_encode<OLAP_FIELD_TYPE_UNSIGNED_INT>();
- test_integer_encode<OLAP_FIELD_TYPE_BIGINT>();
- test_integer_encode<OLAP_FIELD_TYPE_UNSIGNED_BIGINT>();
- test_integer_encode<OLAP_FIELD_TYPE_LARGEINT>();
-
- test_integer_encode<OLAP_FIELD_TYPE_DATETIME>();
+ test_integer_encode<FieldType::OLAP_FIELD_TYPE_TINYINT>();
+ test_integer_encode<FieldType::OLAP_FIELD_TYPE_SMALLINT>();
+ test_integer_encode<FieldType::OLAP_FIELD_TYPE_INT>();
+ test_integer_encode<FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT>();
+ test_integer_encode<FieldType::OLAP_FIELD_TYPE_BIGINT>();
+ test_integer_encode<FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT>();
+ test_integer_encode<FieldType::OLAP_FIELD_TYPE_LARGEINT>();
+
+ test_integer_encode<FieldType::OLAP_FIELD_TYPE_DATETIME>();
}
TEST_F(KeyCoderTest, test_date) {
using CppType = uint24_t;
- auto key_coder = get_key_coder(OLAP_FIELD_TYPE_DATE);
+ auto key_coder = get_key_coder(FieldType::OLAP_FIELD_TYPE_DATE);
{
std::string buf;
@@ -170,7 +170,7 @@ TEST_F(KeyCoderTest, test_date) {
}
TEST_F(KeyCoderTest, test_decimal) {
- auto key_coder = get_key_coder(OLAP_FIELD_TYPE_DECIMAL);
+ auto key_coder = get_key_coder(FieldType::OLAP_FIELD_TYPE_DECIMAL);
decimal12_t val1 = {1, 100000000};
std::string buf1;
@@ -214,7 +214,7 @@ TEST_F(KeyCoderTest, test_decimal) {
}
TEST_F(KeyCoderTest, test_char) {
- auto key_coder = get_key_coder(OLAP_FIELD_TYPE_CHAR);
+ auto key_coder = get_key_coder(FieldType::OLAP_FIELD_TYPE_CHAR);
char buf[] = "1234567890";
Slice slice(buf, 10);
@@ -249,7 +249,7 @@ TEST_F(KeyCoderTest, test_char) {
}
TEST_F(KeyCoderTest, test_varchar) {
- auto key_coder = get_key_coder(OLAP_FIELD_TYPE_VARCHAR);
+ auto key_coder = get_key_coder(FieldType::OLAP_FIELD_TYPE_VARCHAR);
char buf[] = "1234567890";
Slice slice(buf, 10);
diff --git a/be/test/olap/memtable_flush_executor_test.cpp b/be/test/olap/memtable_flush_executor_test.cpp
index 4eed9c2c77..1f26a4a307 100644
--- a/be/test/olap/memtable_flush_executor_test.cpp
+++ b/be/test/olap/memtable_flush_executor_test.cpp
@@ -75,9 +75,10 @@ void tear_down() {
Schema create_schema() {
std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_SMALLINT, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_INT, true);
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_SUM, OLAP_FIELD_TYPE_BIGINT, true);
+ col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, FieldType::OLAP_FIELD_TYPE_SMALLINT,
+ true);
+ col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, FieldType::OLAP_FIELD_TYPE_INT, true);
+ col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_SUM, FieldType::OLAP_FIELD_TYPE_BIGINT, true);
Schema schema(col_schemas, 2);
return schema;
}
diff --git a/be/test/olap/rowset/segment_v2/binary_dict_page_test.cpp b/be/test/olap/rowset/segment_v2/binary_dict_page_test.cpp
index 46b90e8e2d..87097fe1aa 100644
--- a/be/test/olap/rowset/segment_v2/binary_dict_page_test.cpp
+++ b/be/test/olap/rowset/segment_v2/binary_dict_page_test.cpp
@@ -66,9 +66,9 @@ public:
Status status = page_builder.get_dictionary_page(&dict_slice);
EXPECT_TRUE(status.ok());
PageDecoderOptions dict_decoder_options;
- std::unique_ptr<BinaryPlainPageDecoder<OLAP_FIELD_TYPE_VARCHAR>> dict_page_decoder(
- new BinaryPlainPageDecoder<OLAP_FIELD_TYPE_VARCHAR>(dict_slice.slice(),
- dict_decoder_options));
+ std::unique_ptr<BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_VARCHAR>>
+ dict_page_decoder(new BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_VARCHAR>(
+ dict_slice.slice(), dict_decoder_options));
status = dict_page_decoder->init();
EXPECT_TRUE(status.ok());
// because every slice is unique
@@ -95,7 +95,7 @@ public:
//check values
vectorized::Arena pool;
- auto type_info = get_scalar_type_info(OLAP_FIELD_TYPE_VARCHAR);
+ auto type_info = get_scalar_type_info(FieldType::OLAP_FIELD_TYPE_VARCHAR);
size_t size = slices.size();
std::unique_ptr<ColumnVectorBatch> cvb;
ColumnVectorBatch::create(size, false, type_info, nullptr, &cvb);
@@ -173,9 +173,10 @@ public:
int slice_index = random() % results.size();
//int slice_index = 1;
PageDecoderOptions dict_decoder_options;
- std::unique_ptr<BinaryPlainPageDecoder<OLAP_FIELD_TYPE_VARCHAR>> dict_page_decoder(
- new BinaryPlainPageDecoder<OLAP_FIELD_TYPE_VARCHAR>(dict_slice.slice(),
- dict_decoder_options));
+ std::unique_ptr<BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_VARCHAR>>
+ dict_page_decoder(
+ new BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_VARCHAR>(
+ dict_slice.slice(), dict_decoder_options));
status = dict_page_decoder->init();
EXPECT_TRUE(status.ok());
@@ -199,7 +200,7 @@ public:
//check values
vectorized::Arena pool;
- auto type_info = get_scalar_type_info(OLAP_FIELD_TYPE_VARCHAR);
+ auto type_info = get_scalar_type_info(FieldType::OLAP_FIELD_TYPE_VARCHAR);
std::unique_ptr<ColumnVectorBatch> cvb;
ColumnVectorBatch::create(1, false, type_info, nullptr, &cvb);
ColumnBlock column_block(cvb.get(), &pool);
diff --git a/be/test/olap/rowset/segment_v2/binary_plain_page_test.cpp b/be/test/olap/rowset/segment_v2/binary_plain_page_test.cpp
index 3670519db4..45d824c731 100644
--- a/be/test/olap/rowset/segment_v2/binary_plain_page_test.cpp
+++ b/be/test/olap/rowset/segment_v2/binary_plain_page_test.cpp
@@ -72,8 +72,9 @@ public:
vectorized::Arena pool;
size_t size = 3;
std::unique_ptr<ColumnVectorBatch> cvb;
- ColumnVectorBatch::create(size, true, get_scalar_type_info(OLAP_FIELD_TYPE_VARCHAR),
- nullptr, &cvb);
+ ColumnVectorBatch::create(size, true,
+ get_scalar_type_info(FieldType::OLAP_FIELD_TYPE_VARCHAR), nullptr,
+ &cvb);
ColumnBlock block(cvb.get(), &pool);
ColumnBlockView column_block_view(&block);
@@ -88,8 +89,8 @@ public:
EXPECT_EQ("Doris", value[2].to_string());
std::unique_ptr<ColumnVectorBatch> cvb2;
- ColumnVectorBatch::create(1, true, get_scalar_type_info(OLAP_FIELD_TYPE_VARCHAR), nullptr,
- &cvb2);
+ ColumnVectorBatch::create(1, true, get_scalar_type_info(FieldType::OLAP_FIELD_TYPE_VARCHAR),
+ nullptr, &cvb2);
ColumnBlock block2(cvb2.get(), &pool);
ColumnBlockView column_block_view2(&block2);
@@ -105,8 +106,8 @@ public:
};
TEST_F(BinaryPlainPageTest, TestBinaryPlainPageBuilderSeekByValueSmallPage) {
- TestBinarySeekByValueSmallPage<BinaryPlainPageBuilder<OLAP_FIELD_TYPE_VARCHAR>,
- BinaryPlainPageDecoder<OLAP_FIELD_TYPE_VARCHAR>>();
+ TestBinarySeekByValueSmallPage<BinaryPlainPageBuilder<FieldType::OLAP_FIELD_TYPE_VARCHAR>,
+ BinaryPlainPageDecoder<FieldType::OLAP_FIELD_TYPE_VARCHAR>>();
}
} // namespace segment_v2
diff --git a/be/test/olap/rowset/segment_v2/binary_prefix_page_test.cpp b/be/test/olap/rowset/segment_v2/binary_prefix_page_test.cpp
index 97884c23a2..07329f18fe 100644
--- a/be/test/olap/rowset/segment_v2/binary_prefix_page_test.cpp
+++ b/be/test/olap/rowset/segment_v2/binary_prefix_page_test.cpp
@@ -75,7 +75,7 @@ public:
//check values
vectorized::Arena pool;
- auto type_info = get_scalar_type_info(OLAP_FIELD_TYPE_VARCHAR);
+ auto type_info = get_scalar_type_info(FieldType::OLAP_FIELD_TYPE_VARCHAR);
size_t size = slices.size();
std::unique_ptr<ColumnVectorBatch> cvb;
ColumnVectorBatch::create(size, false, type_info, nullptr, &cvb);
@@ -96,7 +96,7 @@ public:
while (true) {
//check values
vectorized::Arena pool;
- auto type_info = get_scalar_type_info(OLAP_FIELD_TYPE_VARCHAR);
+ auto type_info = get_scalar_type_info(FieldType::OLAP_FIELD_TYPE_VARCHAR);
std::unique_ptr<ColumnVectorBatch> cvb;
size_t size = 6;
ColumnVectorBatch::create(size, false, type_info, nullptr, &cvb);
@@ -186,7 +186,7 @@ public:
EXPECT_TRUE(ret.ok());
// because every slice is unique
EXPECT_EQ(slices.size(), page_decoder->count());
- auto type_info = get_scalar_type_info(OLAP_FIELD_TYPE_VARCHAR);
+ auto type_info = get_scalar_type_info(FieldType::OLAP_FIELD_TYPE_VARCHAR);
size_t size = slices.size();
{
diff --git a/be/test/olap/rowset/segment_v2/bitmap_index_test.cpp b/be/test/olap/rowset/segment_v2/bitmap_index_test.cpp
index b9548b4957..a99d734f78 100644
--- a/be/test/olap/rowset/segment_v2/bitmap_index_test.cpp
+++ b/be/test/olap/rowset/segment_v2/bitmap_index_test.cpp
@@ -91,12 +91,12 @@ TEST_F(BitmapIndexTest, test_invert) {
std::string file_name = kTestDir + "/invert";
ColumnIndexMetaPB meta;
- write_index_file<OLAP_FIELD_TYPE_INT>(file_name, io::global_local_filesystem(), val,
- num_uint8_rows, 0, &meta);
+ write_index_file<FieldType::OLAP_FIELD_TYPE_INT>(file_name, io::global_local_filesystem(), val,
+ num_uint8_rows, 0, &meta);
{
BitmapIndexReader* reader = nullptr;
BitmapIndexIterator* iter = nullptr;
- get_bitmap_reader_iter<OLAP_FIELD_TYPE_INT>(file_name, meta, &reader, &iter);
+ get_bitmap_reader_iter<FieldType::OLAP_FIELD_TYPE_INT>(file_name, meta, &reader, &iter);
EXPECT_FALSE(iter == nullptr);
int value = 2;
@@ -146,13 +146,13 @@ TEST_F(BitmapIndexTest, test_invert_2) {
std::string file_name = kTestDir + "/invert2";
ColumnIndexMetaPB meta;
- write_index_file<OLAP_FIELD_TYPE_INT>(file_name, io::global_local_filesystem(), val,
- num_uint8_rows, 0, &meta);
+ write_index_file<FieldType::OLAP_FIELD_TYPE_INT>(file_name, io::global_local_filesystem(), val,
+ num_uint8_rows, 0, &meta);
{
BitmapIndexReader* reader = nullptr;
BitmapIndexIterator* iter = nullptr;
- get_bitmap_reader_iter<OLAP_FIELD_TYPE_INT>(file_name, meta, &reader, &iter);
+ get_bitmap_reader_iter<FieldType::OLAP_FIELD_TYPE_INT>(file_name, meta, &reader, &iter);
int value = 1026;
bool exact_match;
@@ -183,12 +183,12 @@ TEST_F(BitmapIndexTest, test_multi_pages) {
std::string file_name = kTestDir + "/mul";
ColumnIndexMetaPB meta;
- write_index_file<OLAP_FIELD_TYPE_BIGINT>(file_name, io::global_local_filesystem(), val,
- num_uint8_rows, 0, &meta);
+ write_index_file<FieldType::OLAP_FIELD_TYPE_BIGINT>(file_name, io::global_local_filesystem(),
+ val, num_uint8_rows, 0, &meta);
{
BitmapIndexReader* reader = nullptr;
BitmapIndexIterator* iter = nullptr;
- get_bitmap_reader_iter<OLAP_FIELD_TYPE_BIGINT>(file_name, meta, &reader, &iter);
+ get_bitmap_reader_iter<FieldType::OLAP_FIELD_TYPE_BIGINT>(file_name, meta, &reader, &iter);
int64_t value = 2019;
bool exact_match;
@@ -215,12 +215,12 @@ TEST_F(BitmapIndexTest, test_null) {
std::string file_name = kTestDir + "/null";
ColumnIndexMetaPB meta;
- write_index_file<OLAP_FIELD_TYPE_BIGINT>(file_name, io::global_local_filesystem(), val,
- num_uint8_rows, 30, &meta);
+ write_index_file<FieldType::OLAP_FIELD_TYPE_BIGINT>(file_name, io::global_local_filesystem(),
+ val, num_uint8_rows, 30, &meta);
{
BitmapIndexReader* reader = nullptr;
BitmapIndexIterator* iter = nullptr;
- get_bitmap_reader_iter<OLAP_FIELD_TYPE_BIGINT>(file_name, meta, &reader, &iter);
+ get_bitmap_reader_iter<FieldType::OLAP_FIELD_TYPE_BIGINT>(file_name, meta, &reader, &iter);
Roaring bitmap;
iter->read_null_bitmap(&bitmap);
diff --git a/be/test/olap/rowset/segment_v2/bitshuffle_page_test.cpp b/be/test/olap/rowset/segment_v2/bitshuffle_page_test.cpp
index ff9c595233..bf4623c26b 100644
--- a/be/test/olap/rowset/segment_v2/bitshuffle_page_test.cpp
+++ b/be/test/olap/rowset/segment_v2/bitshuffle_page_test.cpp
@@ -178,10 +178,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderRandom) {
ints.get()[i] = random();
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_INT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(ints.get(), size);
}
TEST_F(BitShufflePageTest, TestBitShuffleInt64BlockEncoderRandom) {
@@ -192,10 +192,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt64BlockEncoderRandom) {
ints.get()[i] = random();
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_BIGINT,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_BIGINT>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_BIGINT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_BIGINT,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_BIGINT>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_BIGINT>>(ints.get(), size);
}
TEST_F(BitShufflePageTest, TestBitShuffleFloatBlockEncoderRandom) {
@@ -206,10 +206,11 @@ TEST_F(BitShufflePageTest, TestBitShuffleFloatBlockEncoderRandom) {
floats.get()[i] = random() + static_cast<float>(random()) / static_cast<float>(INT_MAX);
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_FLOAT,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_FLOAT>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_FLOAT>>(
- floats.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_FLOAT,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_FLOAT>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_FLOAT>>(floats.get(),
+ size);
}
TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderRandom) {
@@ -220,10 +221,11 @@ TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderRandom) {
doubles.get()[i] = random() + static_cast<double>(random()) / INT_MAX;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_DOUBLE,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_DOUBLE>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_DOUBLE>>(
- doubles.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_DOUBLE,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_DOUBLE>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_DOUBLE>>(doubles.get(),
+ size);
}
TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderEqual) {
@@ -234,10 +236,11 @@ TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderEqual) {
doubles.get()[i] = 19880217.19890323;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_DOUBLE,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_DOUBLE>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_DOUBLE>>(
- doubles.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_DOUBLE,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_DOUBLE>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_DOUBLE>>(doubles.get(),
+ size);
}
TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderSequence) {
@@ -251,10 +254,11 @@ TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderSequence) {
doubles.get()[i] = base;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_DOUBLE,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_DOUBLE>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_DOUBLE>>(
- doubles.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_DOUBLE,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_DOUBLE>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_DOUBLE>>(doubles.get(),
+ size);
}
TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderEqual) {
@@ -265,10 +269,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderEqual) {
ints.get()[i] = 12345;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_INT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(ints.get(), size);
}
TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderMaxNumberEqual) {
@@ -279,10 +283,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderMaxNumberEqual) {
ints.get()[i] = 1234567890;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_INT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(ints.get(), size);
}
TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderSequence) {
@@ -294,10 +298,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderSequence) {
ints.get()[i] = ++number;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_INT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(ints.get(), size);
}
TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderMaxNumberSequence) {
@@ -310,10 +314,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderMaxNumberSequence) {
++number;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_INT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(ints.get(), size);
}
TEST_F(BitShufflePageTest, TestBitShuffleFloatBlockEncoderSeekValue) {
@@ -325,9 +329,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleFloatBlockEncoderSeekValue) {
float small_than_smallest = 99.9;
float bigger_than_biggest = 1111.1;
- test_seek_at_or_after_value_template<OLAP_FIELD_TYPE_FLOAT,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_FLOAT>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_FLOAT>>(
+ test_seek_at_or_after_value_template<
+ FieldType::OLAP_FIELD_TYPE_FLOAT,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_FLOAT>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_FLOAT>>(
floats.get(), size, &small_than_smallest, &bigger_than_biggest);
}
@@ -340,9 +345,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderSeekValue) {
double small_than_smallest = 99.9;
double bigger_than_biggest = 1111.1;
- test_seek_at_or_after_value_template<OLAP_FIELD_TYPE_DOUBLE,
- segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_DOUBLE>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_DOUBLE>>(
+ test_seek_at_or_after_value_template<
+ FieldType::OLAP_FIELD_TYPE_DOUBLE,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_DOUBLE>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_DOUBLE>>(
doubles.get(), size, &small_than_smallest, &bigger_than_biggest);
}
@@ -356,8 +362,9 @@ TEST_F(BitShufflePageTest, TestBitShuffleDecimal12BlockEncoderSeekValue) {
decimal12_t small_than_smallest = {99, 9};
decimal12_t bigger_than_biggest = {1111, 1};
test_seek_at_or_after_value_template<
- OLAP_FIELD_TYPE_DECIMAL, segment_v2::BitshufflePageBuilder<OLAP_FIELD_TYPE_DECIMAL>,
- segment_v2::BitShufflePageDecoder<OLAP_FIELD_TYPE_DECIMAL>>(
+ FieldType::OLAP_FIELD_TYPE_DECIMAL,
+ segment_v2::BitshufflePageBuilder<FieldType::OLAP_FIELD_TYPE_DECIMAL>,
+ segment_v2::BitShufflePageDecoder<FieldType::OLAP_FIELD_TYPE_DECIMAL>>(
decimals.get(), size, &small_than_smallest, &bigger_than_biggest);
}
diff --git a/be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp b/be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp
index c66b8e91f9..004bf3749f 100644
--- a/be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp
+++ b/be/test/olap/rowset/segment_v2/bloom_filter_index_reader_writer_test.cpp
@@ -159,8 +159,8 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_int) {
std::string file_name = "bloom_filter_int";
int not_exist_value = 18888;
- test_bloom_filter_index_reader_writer_template<OLAP_FIELD_TYPE_INT>(file_name, val, num, 1,
- ¬_exist_value);
+ test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_INT>(
+ file_name, val, num, 1, ¬_exist_value);
delete[] val;
}
@@ -174,8 +174,8 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_bigint) {
std::string file_name = "bloom_filter_bigint";
int64_t not_exist_value = 18888;
- test_bloom_filter_index_reader_writer_template<OLAP_FIELD_TYPE_BIGINT>(file_name, val, num, 1,
- ¬_exist_value);
+ test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_BIGINT>(
+ file_name, val, num, 1, ¬_exist_value);
delete[] val;
}
@@ -189,8 +189,8 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_largeint) {
std::string file_name = "bloom_filter_largeint";
int128_t not_exist_value = 18888;
- test_bloom_filter_index_reader_writer_template<OLAP_FIELD_TYPE_LARGEINT>(file_name, val, num, 1,
- ¬_exist_value);
+ test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_LARGEINT>(
+ file_name, val, num, 1, ¬_exist_value);
delete[] val;
}
@@ -208,7 +208,7 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_varchar_type) {
}
std::string file_name = "bloom_filter_varchar";
Slice not_exist_value("value_not_exist");
- test_bloom_filter_index_reader_writer_template<OLAP_FIELD_TYPE_VARCHAR>(
+ test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_VARCHAR>(
file_name, slices, num, 1, ¬_exist_value, true);
delete[] val;
delete[] slices;
@@ -228,8 +228,8 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_char) {
}
std::string file_name = "bloom_filter_char";
Slice not_exist_value("char_value_not_exist");
- test_bloom_filter_index_reader_writer_template<OLAP_FIELD_TYPE_CHAR>(file_name, slices, num, 1,
- ¬_exist_value, true);
+ test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_CHAR>(
+ file_name, slices, num, 1, ¬_exist_value, true);
delete[] val;
delete[] slices;
}
@@ -244,8 +244,8 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_date) {
std::string file_name = "bloom_filter_date";
uint24_t not_exist_value = 18888;
- test_bloom_filter_index_reader_writer_template<OLAP_FIELD_TYPE_DATE>(file_name, val, num, 1,
- ¬_exist_value);
+ test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATE>(
+ file_name, val, num, 1, ¬_exist_value);
delete[] val;
}
@@ -259,8 +259,8 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_datetime) {
std::string file_name = "bloom_filter_datetime";
int64_t not_exist_value = 18888;
- test_bloom_filter_index_reader_writer_template<OLAP_FIELD_TYPE_DATETIME>(file_name, val, num, 1,
- ¬_exist_value);
+ test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DATETIME>(
+ file_name, val, num, 1, ¬_exist_value);
delete[] val;
}
@@ -274,8 +274,8 @@ TEST_F(BloomFilterIndexReaderWriterTest, test_decimal) {
std::string file_name = "bloom_filter_decimal";
decimal12_t not_exist_value = {666, 666};
- test_bloom_filter_index_reader_writer_template<OLAP_FIELD_TYPE_DECIMAL>(file_name, val, num, 1,
- ¬_exist_value);
+ test_bloom_filter_index_reader_writer_template<FieldType::OLAP_FIELD_TYPE_DECIMAL>(
+ file_name, val, num, 1, ¬_exist_value);
delete[] val;
}
diff --git a/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp b/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp
index 862b51ac33..8e0bb664e0 100644
--- a/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp
+++ b/be/test/olap/rowset/segment_v2/column_reader_writer_test.cpp
@@ -85,7 +85,7 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows,
writer_opts.meta->set_column_id(0);
writer_opts.meta->set_unique_id(0);
writer_opts.meta->set_type(type);
- if (type == OLAP_FIELD_TYPE_CHAR || type == OLAP_FIELD_TYPE_VARCHAR) {
+ if (type == FieldType::OLAP_FIELD_TYPE_CHAR || type == FieldType::OLAP_FIELD_TYPE_VARCHAR) {
writer_opts.meta->set_length(10);
} else {
writer_opts.meta->set_length(0);
@@ -96,9 +96,9 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows,
writer_opts.need_zone_map = true;
TabletColumn column(OLAP_FIELD_AGGREGATION_NONE, type);
- if (type == OLAP_FIELD_TYPE_VARCHAR) {
+ if (type == FieldType::OLAP_FIELD_TYPE_VARCHAR) {
column = create_varchar_key(1);
- } else if (type == OLAP_FIELD_TYPE_CHAR) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_CHAR) {
column = create_char_key(1);
}
std::unique_ptr<ColumnWriter> writer;
@@ -160,7 +160,8 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows,
for (int j = 0; j < rows_read; ++j) {
EXPECT_EQ(BitmapTest(src_is_null, idx), col.is_null(j));
if (!col.is_null(j)) {
- if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_CHAR) {
+ if (type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ type == FieldType::OLAP_FIELD_TYPE_CHAR) {
Slice* src_slice = (Slice*)src_data;
EXPECT_EQ(src_slice[idx].to_string(),
reinterpret_cast<const Slice*>(col.cell_ptr(j))->to_string())
@@ -215,7 +216,8 @@ void test_nullable_data(uint8_t* src_data, uint8_t* src_is_null, int num_rows,
for (int j = 0; j < rows_read; ++j) {
EXPECT_EQ(BitmapTest(src_is_null, idx), col.is_null(j));
if (!col.is_null(j)) {
- if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_CHAR) {
+ if (type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ type == FieldType::OLAP_FIELD_TYPE_CHAR) {
Slice* src_slice = (Slice*)src_data;
EXPECT_EQ(src_slice[idx].to_string(),
reinterpret_cast<const Slice*>(col.cell_ptr(j))->to_string());
@@ -236,9 +238,10 @@ void test_array_nullable_data(CollectionValue* src_data, uint8_t* src_is_null, i
std::string test_name) {
CollectionValue* src = src_data;
ColumnMetaPB meta;
- TabletColumn list_column(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_ARRAY);
+ TabletColumn list_column(OLAP_FIELD_AGGREGATION_NONE, FieldType::OLAP_FIELD_TYPE_ARRAY);
int32 item_length = 0;
- if (item_type == OLAP_FIELD_TYPE_CHAR || item_type == OLAP_FIELD_TYPE_VARCHAR) {
+ if (item_type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ item_type == FieldType::OLAP_FIELD_TYPE_VARCHAR) {
item_length = 10;
}
TabletColumn item_column(OLAP_FIELD_AGGREGATION_NONE, item_type, true, 0, item_length);
@@ -257,7 +260,7 @@ void test_array_nullable_data(CollectionValue* src_data, uint8_t* src_is_null, i
writer_opts.meta = &meta;
writer_opts.meta->set_column_id(0);
writer_opts.meta->set_unique_id(0);
- writer_opts.meta->set_type(OLAP_FIELD_TYPE_ARRAY);
+ writer_opts.meta->set_type(FieldType::OLAP_FIELD_TYPE_ARRAY);
writer_opts.meta->set_length(0);
writer_opts.meta->set_encoding(array_encoding);
writer_opts.meta->set_compression(segment_v2::CompressionTypePB::LZ4F);
@@ -399,7 +402,7 @@ TEST_F(ColumnReaderWriterTest, test_array_type) {
array_val[array_index].set_length(3);
}
}
- test_array_nullable_data<OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE, BIT_SHUFFLE>(
+ test_array_nullable_data<FieldType::OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE, BIT_SHUFFLE>(
array_val, array_is_null, num_array, "null_array_bs");
delete[] array_val;
@@ -412,7 +415,8 @@ TEST_F(ColumnReaderWriterTest, test_array_type) {
for (int i = 0; i < 3; ++i) {
item_is_null[i] = i == 1;
if (i != 1) {
- set_column_value_by_type(OLAP_FIELD_TYPE_VARCHAR, i, (char*)&varchar_vals[i], &_pool);
+ set_column_value_by_type(FieldType::OLAP_FIELD_TYPE_VARCHAR, i, (char*)&varchar_vals[i],
+ &_pool);
}
}
for (int i = 0; i < num_array; ++i) {
@@ -425,7 +429,7 @@ TEST_F(ColumnReaderWriterTest, test_array_type) {
array_val[i].set_null_signs(item_is_null);
array_val[i].set_length(3);
}
- test_array_nullable_data<OLAP_FIELD_TYPE_VARCHAR, DICT_ENCODING, BIT_SHUFFLE>(
+ test_array_nullable_data<FieldType::OLAP_FIELD_TYPE_VARCHAR, DICT_ENCODING, BIT_SHUFFLE>(
array_val, array_is_null, num_array, "null_array_chars");
delete[] array_val;
@@ -466,12 +470,13 @@ void test_read_default_value(string value, void* result) {
st = iter.next_batch(&rows_read, &dst, &has_null);
EXPECT_TRUE(st.ok());
for (int j = 0; j < rows_read; ++j) {
- if (type == OLAP_FIELD_TYPE_CHAR) {
+ if (type == FieldType::OLAP_FIELD_TYPE_CHAR) {
EXPECT_EQ(*(string*)result,
reinterpret_cast<const Slice*>(col.cell_ptr(j))->to_string())
<< "j:" << j;
- } else if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_HLL ||
- type == OLAP_FIELD_TYPE_OBJECT) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ type == FieldType::OLAP_FIELD_TYPE_HLL ||
+ type == FieldType::OLAP_FIELD_TYPE_OBJECT) {
EXPECT_EQ(value, reinterpret_cast<const Slice*>(col.cell_ptr(j))->to_string())
<< "j:" << j;
} else {
@@ -498,12 +503,13 @@ void test_read_default_value(string value, void* result) {
st = iter.next_batch(&rows_read, &dst, &has_null);
EXPECT_TRUE(st.ok());
for (int j = 0; j < rows_read; ++j) {
- if (type == OLAP_FIELD_TYPE_CHAR) {
+ if (type == FieldType::OLAP_FIELD_TYPE_CHAR) {
EXPECT_EQ(*(string*)result,
reinterpret_cast<const Slice*>(col.cell_ptr(j))->to_string())
<< "j:" << j;
- } else if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_HLL ||
- type == OLAP_FIELD_TYPE_OBJECT) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ type == FieldType::OLAP_FIELD_TYPE_HLL ||
+ type == FieldType::OLAP_FIELD_TYPE_OBJECT) {
EXPECT_EQ(value,
reinterpret_cast<const Slice*>(col.cell_ptr(j))->to_string());
} else {
@@ -517,25 +523,25 @@ void test_read_default_value(string value, void* result) {
}
static vectorized::MutableColumnPtr create_vectorized_column_ptr(FieldType type) {
- if (type == OLAP_FIELD_TYPE_INT) {
+ if (type == FieldType::OLAP_FIELD_TYPE_INT) {
return vectorized::DataTypeInt32().create_column();
- } else if (type == OLAP_FIELD_TYPE_SMALLINT) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_SMALLINT) {
return vectorized::DataTypeInt16().create_column();
- } else if (type == OLAP_FIELD_TYPE_BIGINT) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_BIGINT) {
return vectorized::DataTypeInt64().create_column();
- } else if (type == OLAP_FIELD_TYPE_LARGEINT) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_LARGEINT) {
return vectorized::DataTypeInt128().create_column();
- } else if (type == OLAP_FIELD_TYPE_FLOAT) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_FLOAT) {
return vectorized::DataTypeFloat32().create_column();
- } else if (type == OLAP_FIELD_TYPE_DOUBLE) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_DOUBLE) {
return vectorized::DataTypeFloat64().create_column();
- } else if (type == OLAP_FIELD_TYPE_CHAR) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_CHAR) {
return vectorized::DataTypeString().create_column();
- } else if (type == OLAP_FIELD_TYPE_DATE) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_DATE) {
return vectorized::DataTypeDate().create_column();
- } else if (type == OLAP_FIELD_TYPE_DATETIME) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_DATETIME) {
return vectorized::DataTypeDateTime().create_column();
- } else if (type == OLAP_FIELD_TYPE_DECIMAL) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_DECIMAL) {
return vectorized::DataTypeDecimal<vectorized::Decimal128>(27, 9).create_column();
}
return vectorized::DataTypeNothing().create_column();
@@ -569,10 +575,12 @@ void test_v_read_default_value(string value, void* result) {
EXPECT_TRUE(st.ok());
for (int j = 0; j < rows_read; ++j) {
- if (type == OLAP_FIELD_TYPE_CHAR) {
- } else if (type == OLAP_FIELD_TYPE_VARCHAR || type == OLAP_FIELD_TYPE_HLL ||
- type == OLAP_FIELD_TYPE_OBJECT) {
- } else if (type == OLAP_FIELD_TYPE_DATE || type == OLAP_FIELD_TYPE_DATETIME) {
+ if (type == FieldType::OLAP_FIELD_TYPE_CHAR) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_VARCHAR ||
+ type == FieldType::OLAP_FIELD_TYPE_HLL ||
+ type == FieldType::OLAP_FIELD_TYPE_OBJECT) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_DATE ||
+ type == FieldType::OLAP_FIELD_TYPE_DATETIME) {
StringRef sr = mcp->get_data_at(j);
EXPECT_EQ(sr.size, sizeof(vectorized::Int64));
@@ -582,7 +590,7 @@ void test_v_read_default_value(string value, void* result) {
value.to_string(buf);
int ret = strcmp(buf, (char*)result);
EXPECT_EQ(ret, 0);
- } else if (type == OLAP_FIELD_TYPE_DECIMAL) {
+ } else if (type == FieldType::OLAP_FIELD_TYPE_DECIMAL) {
StringRef sr = mcp->get_data_at(j);
EXPECT_EQ(sr.size, sizeof(vectorized::Int128));
@@ -611,16 +619,16 @@ TEST_F(ColumnReaderWriterTest, test_nullable) {
BitmapChange(is_null, i, (i % 4) == 0);
}
- test_nullable_data<OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE>(val, is_null, num_uint8_rows,
- "null_tiny_bs");
- test_nullable_data<OLAP_FIELD_TYPE_SMALLINT, BIT_SHUFFLE>(val, is_null, num_uint8_rows / 2,
- "null_smallint_bs");
- test_nullable_data<OLAP_FIELD_TYPE_INT, BIT_SHUFFLE>(val, is_null, num_uint8_rows / 4,
- "null_int_bs");
- test_nullable_data<OLAP_FIELD_TYPE_BIGINT, BIT_SHUFFLE>(val, is_null, num_uint8_rows / 8,
- "null_bigint_bs");
- test_nullable_data<OLAP_FIELD_TYPE_LARGEINT, BIT_SHUFFLE>(val, is_null, num_uint8_rows / 16,
- "null_largeint_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE>(
+ val, is_null, num_uint8_rows, "null_tiny_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_SMALLINT, BIT_SHUFFLE>(
+ val, is_null, num_uint8_rows / 2, "null_smallint_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_INT, BIT_SHUFFLE>(
+ val, is_null, num_uint8_rows / 4, "null_int_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_BIGINT, BIT_SHUFFLE>(
+ val, is_null, num_uint8_rows / 8, "null_bigint_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_LARGEINT, BIT_SHUFFLE>(
+ val, is_null, num_uint8_rows / 16, "null_largeint_bs");
// test for the case where most values are not null
uint8_t* is_null_sparse = new uint8_t[num_uint8_rows];
@@ -633,26 +641,26 @@ TEST_F(ColumnReaderWriterTest, test_nullable) {
}
BitmapChange(is_null_sparse, i, v);
}
- test_nullable_data<OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE>(val, is_null_sparse, num_uint8_rows,
- "sparse_null_tiny_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE>(
+ val, is_null_sparse, num_uint8_rows, "sparse_null_tiny_bs");
float* float_vals = new float[num_uint8_rows];
for (int i = 0; i < num_uint8_rows; ++i) {
float_vals[i] = i;
is_null[i] = ((i % 16) == 0);
}
- test_nullable_data<OLAP_FIELD_TYPE_FLOAT, BIT_SHUFFLE>((uint8_t*)float_vals, is_null,
- num_uint8_rows, "null_float_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_FLOAT, BIT_SHUFFLE>(
+ (uint8_t*)float_vals, is_null, num_uint8_rows, "null_float_bs");
double* double_vals = new double[num_uint8_rows];
for (int i = 0; i < num_uint8_rows; ++i) {
double_vals[i] = i;
is_null[i] = ((i % 16) == 0);
}
- test_nullable_data<OLAP_FIELD_TYPE_DOUBLE, BIT_SHUFFLE>((uint8_t*)double_vals, is_null,
- num_uint8_rows, "null_double_bs");
- // test_nullable_data<OLAP_FIELD_TYPE_FLOAT, BIT_SHUFFLE>(val, is_null, num_uint8_rows / 4, "null_float_bs");
- // test_nullable_data<OLAP_FIELD_TYPE_DOUBLE, BIT_SHUFFLE>(val, is_null, num_uint8_rows / 8, "null_double_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_DOUBLE, BIT_SHUFFLE>(
+ (uint8_t*)double_vals, is_null, num_uint8_rows, "null_double_bs");
+ // test_nullable_data<FieldType::OLAP_FIELD_TYPE_FLOAT, BIT_SHUFFLE>(val, is_null, num_uint8_rows / 4, "null_float_bs");
+ // test_nullable_data<FieldType::OLAP_FIELD_TYPE_DOUBLE, BIT_SHUFFLE>(val, is_null, num_uint8_rows / 8, "null_double_bs");
delete[] val;
delete[] is_null;
delete[] is_null_sparse;
@@ -676,30 +684,32 @@ TEST_F(ColumnReaderWriterTest, test_types) {
datetime_vals[i] = i + 33;
decimal_vals[i] = {i, i}; // 1.000000001
- set_column_value_by_type(OLAP_FIELD_TYPE_VARCHAR, i, (char*)&varchar_vals[i], &_pool);
- set_column_value_by_type(OLAP_FIELD_TYPE_CHAR, i, (char*)&char_vals[i], &_pool, 8);
+ set_column_value_by_type(FieldType::OLAP_FIELD_TYPE_VARCHAR, i, (char*)&varchar_vals[i],
+ &_pool);
+ set_column_value_by_type(FieldType::OLAP_FIELD_TYPE_CHAR, i, (char*)&char_vals[i], &_pool,
+ 8);
BitmapChange(is_null, i, (i % 4) == 0);
}
- test_nullable_data<OLAP_FIELD_TYPE_CHAR, DICT_ENCODING>((uint8_t*)char_vals, is_null,
- num_uint8_rows, "null_char_bs");
- test_nullable_data<OLAP_FIELD_TYPE_VARCHAR, DICT_ENCODING>((uint8_t*)varchar_vals, is_null,
- num_uint8_rows, "null_varchar_bs");
- test_nullable_data<OLAP_FIELD_TYPE_BOOL, BIT_SHUFFLE>((uint8_t*)bool_vals, is_null,
- num_uint8_rows, "null_bool_bs");
- test_nullable_data<OLAP_FIELD_TYPE_DATE, BIT_SHUFFLE>((uint8_t*)date_vals, is_null,
- num_uint8_rows / 3, "null_date_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_CHAR, DICT_ENCODING>(
+ (uint8_t*)char_vals, is_null, num_uint8_rows, "null_char_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_VARCHAR, DICT_ENCODING>(
+ (uint8_t*)varchar_vals, is_null, num_uint8_rows, "null_varchar_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_BOOL, BIT_SHUFFLE>(
+ (uint8_t*)bool_vals, is_null, num_uint8_rows, "null_bool_bs");
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_DATE, BIT_SHUFFLE>(
+ (uint8_t*)date_vals, is_null, num_uint8_rows / 3, "null_date_bs");
for (int i = 0; i < num_uint8_rows; ++i) {
BitmapChange(is_null, i, (i % 16) == 0);
}
- test_nullable_data<OLAP_FIELD_TYPE_DATETIME, BIT_SHUFFLE>(
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_DATETIME, BIT_SHUFFLE>(
(uint8_t*)datetime_vals, is_null, num_uint8_rows / 8, "null_datetime_bs");
for (int i = 0; i < num_uint8_rows; ++i) {
BitmapChange(is_null, i, (i % 24) == 0);
}
- test_nullable_data<OLAP_FIELD_TYPE_DECIMAL, BIT_SHUFFLE>(
+ test_nullable_data<FieldType::OLAP_FIELD_TYPE_DECIMAL, BIT_SHUFFLE>(
(uint8_t*)decimal_vals, is_null, num_uint8_rows / 12, "null_decimal_bs");
delete[] char_vals;
@@ -714,88 +724,88 @@ TEST_F(ColumnReaderWriterTest, test_types) {
TEST_F(ColumnReaderWriterTest, test_default_value) {
std::string v_int("1");
int32_t result = 1;
- test_read_default_value<OLAP_FIELD_TYPE_TINYINT>(v_int, &result);
- test_read_default_value<OLAP_FIELD_TYPE_SMALLINT>(v_int, &result);
- test_read_default_value<OLAP_FIELD_TYPE_INT>(v_int, &result);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_TINYINT>(v_int, &result);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_SMALLINT>(v_int, &result);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_INT>(v_int, &result);
std::string v_bigint("9223372036854775807");
int64_t result_bigint = std::numeric_limits<int64_t>::max();
- test_read_default_value<OLAP_FIELD_TYPE_BIGINT>(v_bigint, &result_bigint);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_BIGINT>(v_bigint, &result_bigint);
int128_t result_largeint = std::numeric_limits<int64_t>::max();
- test_read_default_value<OLAP_FIELD_TYPE_LARGEINT>(v_bigint, &result_largeint);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_LARGEINT>(v_bigint, &result_largeint);
std::string v_float("1.00");
float result2 = 1.00;
- test_read_default_value<OLAP_FIELD_TYPE_FLOAT>(v_float, &result2);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_FLOAT>(v_float, &result2);
std::string v_double("1.00");
double result3 = 1.00;
- test_read_default_value<OLAP_FIELD_TYPE_DOUBLE>(v_double, &result3);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_DOUBLE>(v_double, &result3);
std::string v_varchar("varchar");
- test_read_default_value<OLAP_FIELD_TYPE_VARCHAR>(v_varchar, &v_varchar);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_VARCHAR>(v_varchar, &v_varchar);
std::string v_char("char");
- test_read_default_value<OLAP_FIELD_TYPE_CHAR>(v_char, &v_char);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_CHAR>(v_char, &v_char);
char* c = (char*)malloc(1);
c[0] = 0;
std::string v_object(c, 1);
- test_read_default_value<OLAP_FIELD_TYPE_HLL>(v_object, &v_object);
- test_read_default_value<OLAP_FIELD_TYPE_OBJECT>(v_object, &v_object);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_HLL>(v_object, &v_object);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_OBJECT>(v_object, &v_object);
free(c);
std::string v_date("2019-11-12");
uint24_t result_date(1034092);
- test_read_default_value<OLAP_FIELD_TYPE_DATE>(v_date, &result_date);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_DATE>(v_date, &result_date);
std::string v_datetime("2019-11-12 12:01:08");
int64_t result_datetime = 20191112120108;
- test_read_default_value<OLAP_FIELD_TYPE_DATETIME>(v_datetime, &result_datetime);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_DATETIME>(v_datetime, &result_datetime);
std::string v_decimal("102418.000000002");
decimal12_t decimal = {102418, 2};
- test_read_default_value<OLAP_FIELD_TYPE_DECIMAL>(v_decimal, &decimal);
+ test_read_default_value<FieldType::OLAP_FIELD_TYPE_DECIMAL>(v_decimal, &decimal);
}
TEST_F(ColumnReaderWriterTest, test_v_default_value) {
std::string v_int("1");
int32_t result = 1;
- test_v_read_default_value<OLAP_FIELD_TYPE_INT>(v_int, &result);
+ test_v_read_default_value<FieldType::OLAP_FIELD_TYPE_INT>(v_int, &result);
std::string v_bigint("9223372036854775807");
int64_t result_bigint = std::numeric_limits<int64_t>::max();
- test_v_read_default_value<OLAP_FIELD_TYPE_BIGINT>(v_bigint, &result_bigint);
+ test_v_read_default_value<FieldType::OLAP_FIELD_TYPE_BIGINT>(v_bigint, &result_bigint);
int128_t result_largeint = std::numeric_limits<int64_t>::max();
- test_v_read_default_value<OLAP_FIELD_TYPE_LARGEINT>(v_bigint, &result_largeint);
+ test_v_read_default_value<FieldType::OLAP_FIELD_TYPE_LARGEINT>(v_bigint, &result_largeint);
std::string v_float("1.00");
float result_float = 1.00;
- test_v_read_default_value<OLAP_FIELD_TYPE_FLOAT>(v_float, &result_float);
+ test_v_read_default_value<FieldType::OLAP_FIELD_TYPE_FLOAT>(v_float, &result_float);
std::string v_double("1.99");
double result_double = 1.99;
- test_v_read_default_value<OLAP_FIELD_TYPE_DOUBLE>(v_double, &result_double);
+ test_v_read_default_value<FieldType::OLAP_FIELD_TYPE_DOUBLE>(v_double, &result_double);
std::string v_date("2019-11-12");
char result_date[] = "2019-11-12";
- test_v_read_default_value<OLAP_FIELD_TYPE_DATE>(v_date, result_date);
+ test_v_read_default_value<FieldType::OLAP_FIELD_TYPE_DATE>(v_date, result_date);
std::string v_datetime("2019-11-12 12:01:08");
char result_datetime[] = "2019-11-12 12:01:08";
- test_v_read_default_value<OLAP_FIELD_TYPE_DATETIME>(v_datetime, &result_datetime);
+ test_v_read_default_value<FieldType::OLAP_FIELD_TYPE_DATETIME>(v_datetime, &result_datetime);
std::string v_decimal("102418.000000002");
decimal12_t decimal = {102418, 2};
- test_v_read_default_value<OLAP_FIELD_TYPE_DECIMAL>(v_decimal, &decimal);
+ test_v_read_default_value<FieldType::OLAP_FIELD_TYPE_DECIMAL>(v_decimal, &decimal);
}
TEST_F(ColumnReaderWriterTest, test_single_empty_array) {
size_t num_array = 1;
std::unique_ptr<uint8_t[]> array_is_null(new uint8_t[BitmapSize(num_array)]());
CollectionValue array(0);
- test_array_nullable_data<OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE, BIT_SHUFFLE>(
+ test_array_nullable_data<FieldType::OLAP_FIELD_TYPE_TINYINT, BIT_SHUFFLE, BIT_SHUFFLE>(
&array, array_is_null.get(), num_array, "test_single_empty_array");
}
@@ -811,7 +821,7 @@ TEST_F(ColumnReaderWriterTest, test_mixed_empty_arrays) {
new (&collection_values[i]) CollectionValue(&data, 3, false, nullptr);
}
}
- test_array_nullable_data<OLAP_FIELD_TYPE_INT, BIT_SHUFFLE, BIT_SHUFFLE>(
+ test_array_nullable_data<FieldType::OLAP_FIELD_TYPE_INT, BIT_SHUFFLE, BIT_SHUFFLE>(
collection_values.get(), array_is_null.get(), num_array, "test_mixed_empty_arrays");
}
diff --git a/be/test/olap/rowset/segment_v2/encoding_info_test.cpp b/be/test/olap/rowset/segment_v2/encoding_info_test.cpp
index 7396967c56..530c619695 100644
--- a/be/test/olap/rowset/segment_v2/encoding_info_test.cpp
+++ b/be/test/olap/rowset/segment_v2/encoding_info_test.cpp
@@ -35,7 +35,7 @@ public:
};
TEST_F(EncodingInfoTest, normal) {
- const auto* type_info = get_scalar_type_info<OLAP_FIELD_TYPE_BIGINT>();
+ const auto* type_info = get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_BIGINT>();
const EncodingInfo* encoding_info = nullptr;
auto status = EncodingInfo::get(type_info, PLAIN_ENCODING, &encoding_info);
EXPECT_TRUE(status.ok());
@@ -43,7 +43,7 @@ TEST_F(EncodingInfoTest, normal) {
}
TEST_F(EncodingInfoTest, no_encoding) {
- const auto* type_info = get_scalar_type_info<OLAP_FIELD_TYPE_BIGINT>();
+ const auto* type_info = get_scalar_type_info<FieldType::OLAP_FIELD_TYPE_BIGINT>();
const EncodingInfo* encoding_info = nullptr;
auto status = EncodingInfo::get(type_info, DICT_ENCODING, &encoding_info);
EXPECT_FALSE(status.ok());
diff --git a/be/test/olap/rowset/segment_v2/frame_of_reference_page_test.cpp b/be/test/olap/rowset/segment_v2/frame_of_reference_page_test.cpp
index 7542700e16..500d638aa6 100644
--- a/be/test/olap/rowset/segment_v2/frame_of_reference_page_test.cpp
+++ b/be/test/olap/rowset/segment_v2/frame_of_reference_page_test.cpp
@@ -77,7 +77,7 @@ public:
for (uint i = 0; i < size; i++) {
if (src[i] != values[i]) {
- if constexpr (Type == OLAP_FIELD_TYPE_LARGEINT) {
+ if constexpr (Type == FieldType::OLAP_FIELD_TYPE_LARGEINT) {
FAIL() << "Fail at index " << i
<< " inserted=" << LargeIntValue::to_string(src[i])
<< " got=" << LargeIntValue::to_string(values[i]);
@@ -108,10 +108,11 @@ TEST_F(FrameOfReferencePageTest, TestInt32BlockEncoderRandom) {
ints.get()[i] = random();
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_INT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(ints.get(),
+ size);
}
TEST_F(FrameOfReferencePageTest, TestInt32BlockEncoderEqual) {
@@ -122,10 +123,11 @@ TEST_F(FrameOfReferencePageTest, TestInt32BlockEncoderEqual) {
ints.get()[i] = 12345;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_INT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(ints.get(),
+ size);
}
TEST_F(FrameOfReferencePageTest, TestInt32BlockEncoderSequence) {
@@ -136,10 +138,11 @@ TEST_F(FrameOfReferencePageTest, TestInt32BlockEncoderSequence) {
ints.get()[i] = 12345 + i;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_INT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(ints.get(),
+ size);
}
TEST_F(FrameOfReferencePageTest, TestInt64BlockEncoderSequence) {
@@ -151,13 +154,16 @@ TEST_F(FrameOfReferencePageTest, TestInt64BlockEncoderSequence) {
}
test_encode_decode_page_template<
- OLAP_FIELD_TYPE_BIGINT, segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_BIGINT>,
- segment_v2::FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_BIGINT>>(ints.get(), size);
+ FieldType::OLAP_FIELD_TYPE_BIGINT,
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_BIGINT>,
+ segment_v2::FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_BIGINT>>(ints.get(),
+ size);
test_encode_decode_page_template<
- OLAP_FIELD_TYPE_DATETIME,
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_DATETIME>,
- segment_v2::FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_DATETIME>>(ints.get(), size);
+ FieldType::OLAP_FIELD_TYPE_DATETIME,
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_DATETIME>,
+ segment_v2::FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_DATETIME>>(
+ ints.get(), size);
}
TEST_F(FrameOfReferencePageTest, TestInt24BlockEncoderSequence) {
@@ -170,10 +176,11 @@ TEST_F(FrameOfReferencePageTest, TestInt24BlockEncoderSequence) {
ints.get()[i] = first_value + i;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_DATE,
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_DATE>,
- segment_v2::FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_DATE>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_DATE,
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_DATE>,
+ segment_v2::FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_DATE>>(ints.get(),
+ size);
}
TEST_F(FrameOfReferencePageTest, TestInt128BlockEncoderSequence) {
@@ -187,9 +194,10 @@ TEST_F(FrameOfReferencePageTest, TestInt128BlockEncoderSequence) {
}
test_encode_decode_page_template<
- OLAP_FIELD_TYPE_LARGEINT,
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_LARGEINT>,
- segment_v2::FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_LARGEINT>>(ints.get(), size);
+ FieldType::OLAP_FIELD_TYPE_LARGEINT,
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_LARGEINT>,
+ segment_v2::FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_LARGEINT>>(
+ ints.get(), size);
}
TEST_F(FrameOfReferencePageTest, TestInt24BlockEncoderMinMax) {
@@ -197,10 +205,11 @@ TEST_F(FrameOfReferencePageTest, TestInt24BlockEncoderMinMax) {
ints.get()[0] = 0;
ints.get()[1] = 0xFFFFFF;
- test_encode_decode_page_template<OLAP_FIELD_TYPE_DATE,
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_DATE>,
- segment_v2::FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_DATE>>(
- ints.get(), 2);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_DATE,
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_DATE>,
+ segment_v2::FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_DATE>>(ints.get(),
+ 2);
}
TEST_F(FrameOfReferencePageTest, TestInt128BlockEncoderMinMax) {
@@ -209,9 +218,10 @@ TEST_F(FrameOfReferencePageTest, TestInt128BlockEncoderMinMax) {
ints.get()[1] = numeric_limits<int128_t>::max();
test_encode_decode_page_template<
- OLAP_FIELD_TYPE_LARGEINT,
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_LARGEINT>,
- segment_v2::FrameOfReferencePageDecoder<OLAP_FIELD_TYPE_LARGEINT>>(ints.get(), 2);
+ FieldType::OLAP_FIELD_TYPE_LARGEINT,
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_LARGEINT>,
+ segment_v2::FrameOfReferencePageDecoder<FieldType::OLAP_FIELD_TYPE_LARGEINT>>(
+ ints.get(), 2);
}
TEST_F(FrameOfReferencePageTest, TestInt32SequenceBlockEncoderSize) {
@@ -222,7 +232,8 @@ TEST_F(FrameOfReferencePageTest, TestInt32SequenceBlockEncoderSize) {
}
PageBuilderOptions builder_options;
builder_options.data_page_size = 256 * 1024;
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_INT> page_builder(builder_options);
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_INT> page_builder(
+ builder_options);
page_builder.add(reinterpret_cast<const uint8_t*>(ints.get()), &size);
OwnedSlice s = page_builder.finish();
// body: 4 bytes min value + 128 * 1 /8 packing value = 20
@@ -238,7 +249,8 @@ TEST_F(FrameOfReferencePageTest, TestFirstLastValue) {
}
PageBuilderOptions builder_options;
builder_options.data_page_size = 256 * 1024;
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_INT> page_builder(builder_options);
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_INT> page_builder(
+ builder_options);
page_builder.add(reinterpret_cast<const uint8_t*>(ints.get()), &size);
OwnedSlice s = page_builder.finish();
int32_t first_value = -1;
@@ -257,7 +269,8 @@ TEST_F(FrameOfReferencePageTest, TestInt32NormalBlockEncoderSize) {
}
PageBuilderOptions builder_options;
builder_options.data_page_size = 256 * 1024;
- segment_v2::FrameOfReferencePageBuilder<OLAP_FIELD_TYPE_INT> page_builder(builder_options);
+ segment_v2::FrameOfReferencePageBuilder<FieldType::OLAP_FIELD_TYPE_INT> page_builder(
+ builder_options);
page_builder.add(reinterpret_cast<const uint8_t*>(ints.get()), &size);
OwnedSlice s = page_builder.finish();
// body: 4 bytes min value + 128 * 7 /8 packing value = 116
diff --git a/be/test/olap/rowset/segment_v2/plain_page_test.cpp b/be/test/olap/rowset/segment_v2/plain_page_test.cpp
index 11dfbee3f0..22e2e7b03b 100644
--- a/be/test/olap/rowset/segment_v2/plain_page_test.cpp
+++ b/be/test/olap/rowset/segment_v2/plain_page_test.cpp
@@ -172,10 +172,10 @@ TEST_F(PlainPageTest, TestInt32PlainPageRandom) {
ints.get()[i] = random();
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_INT>>(ints.get(),
- size);
+ test_encode_decode_page_template<FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(
+ ints.get(), size);
}
TEST_F(PlainPageTest, TestInt32PlainPageSeekValue) {
@@ -187,9 +187,10 @@ TEST_F(PlainPageTest, TestInt32PlainPageSeekValue) {
int32_t small_than_smallest = 99;
int32_t bigger_than_biggest = 1111;
- test_seek_at_or_after_value_template<OLAP_FIELD_TYPE_INT,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_INT>>(
+ test_seek_at_or_after_value_template<
+ FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(
ints.get(), size, &small_than_smallest, &bigger_than_biggest);
}
@@ -200,10 +201,10 @@ TEST_F(PlainPageTest, TestInt64PlainPageRandom) {
ints.get()[i] = random();
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_BIGINT,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_BIGINT>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_BIGINT>>(
- ints.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_BIGINT,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_BIGINT>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_BIGINT>>(ints.get(), size);
}
TEST_F(PlainPageTest, TestInt64PlainPageSeekValue) {
@@ -215,9 +216,10 @@ TEST_F(PlainPageTest, TestInt64PlainPageSeekValue) {
int64_t small_than_smallest = 99;
int64_t bigger_than_biggest = 1111;
- test_seek_at_or_after_value_template<OLAP_FIELD_TYPE_BIGINT,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_BIGINT>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_BIGINT>>(
+ test_seek_at_or_after_value_template<
+ FieldType::OLAP_FIELD_TYPE_BIGINT,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_BIGINT>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_BIGINT>>(
ints.get(), size, &small_than_smallest, &bigger_than_biggest);
}
@@ -229,10 +231,10 @@ TEST_F(PlainPageTest, TestPlainFloatBlockEncoderRandom) {
floats.get()[i] = random() + static_cast<float>(random()) / static_cast<float>(INT_MAX);
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_FLOAT,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_FLOAT>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_FLOAT>>(
- floats.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_FLOAT,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_FLOAT>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_FLOAT>>(floats.get(), size);
}
TEST_F(PlainPageTest, TestDoublePageEncoderRandom) {
@@ -241,10 +243,10 @@ TEST_F(PlainPageTest, TestDoublePageEncoderRandom) {
for (int i = 0; i < size; i++) {
doubles.get()[i] = random() + static_cast<double>(random()) / INT_MAX;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_DOUBLE,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_DOUBLE>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_DOUBLE>>(
- doubles.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_DOUBLE,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_DOUBLE>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_DOUBLE>>(doubles.get(), size);
}
TEST_F(PlainPageTest, TestDoublePageEncoderEqual) {
@@ -255,10 +257,10 @@ TEST_F(PlainPageTest, TestDoublePageEncoderEqual) {
doubles.get()[i] = 19880217.19890323;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_DOUBLE,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_DOUBLE>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_DOUBLE>>(
- doubles.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_DOUBLE,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_DOUBLE>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_DOUBLE>>(doubles.get(), size);
}
TEST_F(PlainPageTest, TestDoublePageEncoderSequence) {
@@ -272,10 +274,10 @@ TEST_F(PlainPageTest, TestDoublePageEncoderSequence) {
doubles.get()[i] = base;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_DOUBLE,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_DOUBLE>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_DOUBLE>>(
- doubles.get(), size);
+ test_encode_decode_page_template<
+ FieldType::OLAP_FIELD_TYPE_DOUBLE,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_DOUBLE>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_DOUBLE>>(doubles.get(), size);
}
TEST_F(PlainPageTest, TestPlainInt32PageEncoderEqual) {
@@ -286,10 +288,10 @@ TEST_F(PlainPageTest, TestPlainInt32PageEncoderEqual) {
ints.get()[i] = 12345;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_INT>>(ints.get(),
- size);
+ test_encode_decode_page_template<FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(
+ ints.get(), size);
}
TEST_F(PlainPageTest, TestInt32PageEncoderSequence) {
@@ -301,10 +303,10 @@ TEST_F(PlainPageTest, TestInt32PageEncoderSequence) {
ints.get()[i] = ++number;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_INT>>(ints.get(),
- size);
+ test_encode_decode_page_template<FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(
+ ints.get(), size);
}
TEST_F(PlainPageTest, TestBoolPlainPageSeekValue) {
@@ -312,22 +314,25 @@ TEST_F(PlainPageTest, TestBoolPlainPageSeekValue) {
bools.get()[0] = false;
bools.get()[1] = true;
- test_seek_at_or_after_value_template<OLAP_FIELD_TYPE_BOOL,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_BOOL>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_BOOL>>(
- bools.get(), 2, nullptr, nullptr);
+ test_seek_at_or_after_value_template<
+ FieldType::OLAP_FIELD_TYPE_BOOL,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_BOOL>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_BOOL>>(bools.get(), 2, nullptr,
+ nullptr);
bool t = true;
- test_seek_at_or_after_value_template<OLAP_FIELD_TYPE_BOOL,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_BOOL>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_BOOL>>(
- bools.get(), 1, nullptr, &t);
+ test_seek_at_or_after_value_template<
+ FieldType::OLAP_FIELD_TYPE_BOOL,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_BOOL>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_BOOL>>(bools.get(), 1, nullptr,
+ &t);
t = false;
- test_seek_at_or_after_value_template<OLAP_FIELD_TYPE_BOOL,
- segment_v2::PlainPageBuilder<OLAP_FIELD_TYPE_BOOL>,
- segment_v2::PlainPageDecoder<OLAP_FIELD_TYPE_BOOL>>(
- &bools.get()[1], 1, &t, nullptr);
+ test_seek_at_or_after_value_template<
+ FieldType::OLAP_FIELD_TYPE_BOOL,
+ segment_v2::PlainPageBuilder<FieldType::OLAP_FIELD_TYPE_BOOL>,
+ segment_v2::PlainPageDecoder<FieldType::OLAP_FIELD_TYPE_BOOL>>(&bools.get()[1], 1, &t,
+ nullptr);
}
} // namespace segment_v2
diff --git a/be/test/olap/rowset/segment_v2/rle_page_test.cpp b/be/test/olap/rowset/segment_v2/rle_page_test.cpp
index 7f31e17de8..ae7996f4a4 100644
--- a/be/test/olap/rowset/segment_v2/rle_page_test.cpp
+++ b/be/test/olap/rowset/segment_v2/rle_page_test.cpp
@@ -111,10 +111,10 @@ TEST_F(RlePageTest, TestRleInt32BlockEncoderRandom) {
ints.get()[i] = random();
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::RlePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::RlePageDecoder<OLAP_FIELD_TYPE_INT>>(ints.get(),
- size);
+ test_encode_decode_page_template<FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::RlePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::RlePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(
+ ints.get(), size);
}
TEST_F(RlePageTest, TestRleInt32BlockEncoderEqual) {
@@ -125,10 +125,10 @@ TEST_F(RlePageTest, TestRleInt32BlockEncoderEqual) {
ints.get()[i] = 12345;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::RlePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::RlePageDecoder<OLAP_FIELD_TYPE_INT>>(ints.get(),
- size);
+ test_encode_decode_page_template<FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::RlePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::RlePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(
+ ints.get(), size);
}
TEST_F(RlePageTest, TestRleInt32BlockEncoderSequence) {
@@ -139,10 +139,10 @@ TEST_F(RlePageTest, TestRleInt32BlockEncoderSequence) {
ints.get()[i] = 12345 + i;
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_INT,
- segment_v2::RlePageBuilder<OLAP_FIELD_TYPE_INT>,
- segment_v2::RlePageDecoder<OLAP_FIELD_TYPE_INT>>(ints.get(),
- size);
+ test_encode_decode_page_template<FieldType::OLAP_FIELD_TYPE_INT,
+ segment_v2::RlePageBuilder<FieldType::OLAP_FIELD_TYPE_INT>,
+ segment_v2::RlePageDecoder<FieldType::OLAP_FIELD_TYPE_INT>>(
+ ints.get(), size);
}
TEST_F(RlePageTest, TestRleInt32BlockEncoderSize) {
@@ -154,7 +154,7 @@ TEST_F(RlePageTest, TestRleInt32BlockEncoderSize) {
}
PageBuilderOptions builder_options;
builder_options.data_page_size = 256 * 1024;
- segment_v2::RlePageBuilder<OLAP_FIELD_TYPE_INT> rle_page_builder(builder_options);
+ segment_v2::RlePageBuilder<FieldType::OLAP_FIELD_TYPE_INT> rle_page_builder(builder_options);
rle_page_builder.add(reinterpret_cast<const uint8_t*>(ints.get()), &size);
OwnedSlice s = rle_page_builder.finish();
// 4 bytes header
@@ -175,10 +175,10 @@ TEST_F(RlePageTest, TestRleBoolBlockEncoderRandom) {
}
}
- test_encode_decode_page_template<OLAP_FIELD_TYPE_BOOL,
- segment_v2::RlePageBuilder<OLAP_FIELD_TYPE_BOOL>,
- segment_v2::RlePageDecoder<OLAP_FIELD_TYPE_BOOL>>(bools.get(),
- size);
+ test_encode_decode_page_template<FieldType::OLAP_FIELD_TYPE_BOOL,
+ segment_v2::RlePageBuilder<FieldType::OLAP_FIELD_TYPE_BOOL>,
+ segment_v2::RlePageDecoder<FieldType::OLAP_FIELD_TYPE_BOOL>>(
+ bools.get(), size);
}
TEST_F(RlePageTest, TestRleBoolBlockEncoderSize) {
@@ -190,7 +190,7 @@ TEST_F(RlePageTest, TestRleBoolBlockEncoderSize) {
}
PageBuilderOptions builder_options;
builder_options.data_page_size = 256 * 1024;
- segment_v2::RlePageBuilder<OLAP_FIELD_TYPE_BOOL> rle_page_builder(builder_options);
+ segment_v2::RlePageBuilder<FieldType::OLAP_FIELD_TYPE_BOOL> rle_page_builder(builder_options);
rle_page_builder.add(reinterpret_cast<const uint8_t*>(bools.get()), &size);
OwnedSlice s = rle_page_builder.finish();
// 4 bytes header
diff --git a/be/test/olap/storage_types_test.cpp b/be/test/olap/storage_types_test.cpp
index 0440cd1768..1aebecfe9f 100644
--- a/be/test/olap/storage_types_test.cpp
+++ b/be/test/olap/storage_types_test.cpp
@@ -103,44 +103,45 @@ void test_char(Slice src_val) {
}
template <>
-void common_test<OLAP_FIELD_TYPE_CHAR>(Slice src_val) {
- test_char<OLAP_FIELD_TYPE_VARCHAR>(src_val);
+void common_test<FieldType::OLAP_FIELD_TYPE_CHAR>(Slice src_val) {
+ test_char<FieldType::OLAP_FIELD_TYPE_VARCHAR>(src_val);
}
template <>
-void common_test<OLAP_FIELD_TYPE_VARCHAR>(Slice src_val) {
- test_char<OLAP_FIELD_TYPE_VARCHAR>(src_val);
+void common_test<FieldType::OLAP_FIELD_TYPE_VARCHAR>(Slice src_val) {
+ test_char<FieldType::OLAP_FIELD_TYPE_VARCHAR>(src_val);
}
TEST(TypesTest, copy_and_equal) {
- common_test<OLAP_FIELD_TYPE_BOOL>(true);
- common_test<OLAP_FIELD_TYPE_TINYINT>(112);
- common_test<OLAP_FIELD_TYPE_SMALLINT>(static_cast<short>(54321));
- common_test<OLAP_FIELD_TYPE_INT>(-123454321);
- common_test<OLAP_FIELD_TYPE_UNSIGNED_INT>(1234543212L);
- common_test<OLAP_FIELD_TYPE_BIGINT>(123454321123456789L);
+ common_test<FieldType::OLAP_FIELD_TYPE_BOOL>(true);
+ common_test<FieldType::OLAP_FIELD_TYPE_TINYINT>(112);
+ common_test<FieldType::OLAP_FIELD_TYPE_SMALLINT>(static_cast<short>(54321));
+ common_test<FieldType::OLAP_FIELD_TYPE_INT>(-123454321);
+ common_test<FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT>(1234543212L);
+ common_test<FieldType::OLAP_FIELD_TYPE_BIGINT>(123454321123456789L);
__int128 int128_val = 1234567899L;
- common_test<OLAP_FIELD_TYPE_LARGEINT>(int128_val);
- common_test<OLAP_FIELD_TYPE_FLOAT>(1.11);
- common_test<OLAP_FIELD_TYPE_DOUBLE>(12221.11);
+ common_test<FieldType::OLAP_FIELD_TYPE_LARGEINT>(int128_val);
+ common_test<FieldType::OLAP_FIELD_TYPE_FLOAT>(1.11);
+ common_test<FieldType::OLAP_FIELD_TYPE_DOUBLE>(12221.11);
decimal12_t decimal_val = {123, 2345};
- common_test<OLAP_FIELD_TYPE_DECIMAL>(decimal_val);
+ common_test<FieldType::OLAP_FIELD_TYPE_DECIMAL>(decimal_val);
- common_test<OLAP_FIELD_TYPE_DATE>((1988 << 9) | (2 << 5) | 1);
- common_test<OLAP_FIELD_TYPE_DATETIME>(19880201010203L);
+ common_test<FieldType::OLAP_FIELD_TYPE_DATE>((1988 << 9) | (2 << 5) | 1);
+ common_test<FieldType::OLAP_FIELD_TYPE_DATETIME>(19880201010203L);
- common_test<OLAP_FIELD_TYPE_DATEV2>((1988 << 9) | (2 << 5) | 1);
+ common_test<FieldType::OLAP_FIELD_TYPE_DATEV2>((1988 << 9) | (2 << 5) | 1);
Slice slice("12345abcde");
- common_test<OLAP_FIELD_TYPE_CHAR>(slice);
- common_test<OLAP_FIELD_TYPE_VARCHAR>(slice);
+ common_test<FieldType::OLAP_FIELD_TYPE_CHAR>(slice);
+ common_test<FieldType::OLAP_FIELD_TYPE_VARCHAR>(slice);
}
template <FieldType item_type>
void common_test_array(CollectionValue src_val) {
- TabletColumn list_column(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_ARRAY);
+ TabletColumn list_column(OLAP_FIELD_AGGREGATION_NONE, FieldType::OLAP_FIELD_TYPE_ARRAY);
int32 item_length = 0;
- if (item_type == OLAP_FIELD_TYPE_CHAR || item_type == OLAP_FIELD_TYPE_VARCHAR) {
+ if (item_type == FieldType::OLAP_FIELD_TYPE_CHAR ||
+ item_type == FieldType::OLAP_FIELD_TYPE_VARCHAR) {
item_length = 10;
}
TabletColumn item_column(OLAP_FIELD_AGGREGATION_NONE, item_type, true, 0, item_length);
@@ -168,49 +169,60 @@ void common_test_array(CollectionValue src_val) {
TEST(ArrayTypeTest, copy_and_equal) {
bool bool_array[3] = {true, false, true};
bool null_signs[3] = {true, true, true};
- common_test_array<OLAP_FIELD_TYPE_BOOL>(CollectionValue(bool_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_BOOL>(CollectionValue(bool_array, 3, null_signs));
uint8_t tiny_int_array[3] = {3, 4, 5};
- common_test_array<OLAP_FIELD_TYPE_TINYINT>(CollectionValue(tiny_int_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_TINYINT>(
+ CollectionValue(tiny_int_array, 3, null_signs));
int16_t small_int_array[3] = {123, 234, 345};
- common_test_array<OLAP_FIELD_TYPE_SMALLINT>(CollectionValue(small_int_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_SMALLINT>(
+ CollectionValue(small_int_array, 3, null_signs));
int32_t int_array[3] = {-123454321, 123454321, 323412343};
- common_test_array<OLAP_FIELD_TYPE_INT>(CollectionValue(int_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_INT>(CollectionValue(int_array, 3, null_signs));
uint32_t uint_array[3] = {123454321, 2342341, 52435234};
- common_test_array<OLAP_FIELD_TYPE_UNSIGNED_INT>(CollectionValue(uint_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT>(
+ CollectionValue(uint_array, 3, null_signs));
int64_t bigint_array[3] = {123454321123456789L, 23534543234L, -123454321123456789L};
- common_test_array<OLAP_FIELD_TYPE_BIGINT>(CollectionValue(bigint_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_BIGINT>(
+ CollectionValue(bigint_array, 3, null_signs));
__int128 large_int_array[3] = {1234567899L, 1234567899L, -12345631899L};
- common_test_array<OLAP_FIELD_TYPE_LARGEINT>(CollectionValue(large_int_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_LARGEINT>(
+ CollectionValue(large_int_array, 3, null_signs));
float float_array[3] = {1.11, 2.22, -3.33};
- common_test_array<OLAP_FIELD_TYPE_FLOAT>(CollectionValue(float_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_FLOAT>(
+ CollectionValue(float_array, 3, null_signs));
double double_array[3] = {12221.11, 12221.11, -12221.11};
- common_test_array<OLAP_FIELD_TYPE_DOUBLE>(CollectionValue(double_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_DOUBLE>(
+ CollectionValue(double_array, 3, null_signs));
decimal12_t decimal_array[3] = {{123, 234}, {345, 453}, {4524, 2123}};
- common_test_array<OLAP_FIELD_TYPE_DECIMAL>(CollectionValue(decimal_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_DECIMAL>(
+ CollectionValue(decimal_array, 3, null_signs));
uint24_t date_array[3] = {(1988 << 9) | (2 << 5) | 1, (1998 << 9) | (2 << 5) | 1,
(2008 << 9) | (2 << 5) | 1};
- common_test_array<OLAP_FIELD_TYPE_DATE>(CollectionValue(date_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_DATE>(CollectionValue(date_array, 3, null_signs));
uint32_t date_v2_array[3] = {(1988 << 9) | (2 << 5) | 1, (1998 << 9) | (2 << 5) | 1,
(2008 << 9) | (2 << 5) | 1};
- common_test_array<OLAP_FIELD_TYPE_DATEV2>(CollectionValue(date_v2_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_DATEV2>(
+ CollectionValue(date_v2_array, 3, null_signs));
int64_t datetime_array[3] = {19880201010203L, 19980201010203L, 20080204010203L};
- common_test_array<OLAP_FIELD_TYPE_DATETIME>(CollectionValue(datetime_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_DATETIME>(
+ CollectionValue(datetime_array, 3, null_signs));
Slice char_array[3] = {"12345abcde", "12345abcde", "asdf322"};
- common_test_array<OLAP_FIELD_TYPE_CHAR>(CollectionValue(char_array, 3, null_signs));
- common_test_array<OLAP_FIELD_TYPE_VARCHAR>(CollectionValue(char_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_CHAR>(CollectionValue(char_array, 3, null_signs));
+ common_test_array<FieldType::OLAP_FIELD_TYPE_VARCHAR>(
+ CollectionValue(char_array, 3, null_signs));
}
} // namespace doris
diff --git a/be/test/olap/tablet_schema_helper.cpp b/be/test/olap/tablet_schema_helper.cpp
index 78aa4c3ca2..a3ddf2e71f 100644
--- a/be/test/olap/tablet_schema_helper.cpp
+++ b/be/test/olap/tablet_schema_helper.cpp
@@ -24,7 +24,7 @@ TabletColumn create_int_key(int32_t id, bool is_nullable, bool is_bf_column,
TabletColumn column;
column._unique_id = id;
column._col_name = std::to_string(id);
- column._type = OLAP_FIELD_TYPE_INT;
+ column._type = FieldType::OLAP_FIELD_TYPE_INT;
column._is_key = true;
column._is_nullable = is_nullable;
column._length = 4;
@@ -40,7 +40,7 @@ TabletColumn create_int_value(int32_t id, FieldAggregationMethod agg_method, boo
TabletColumn column;
column._unique_id = id;
column._col_name = std::to_string(id);
- column._type = OLAP_FIELD_TYPE_INT;
+ column._type = FieldType::OLAP_FIELD_TYPE_INT;
column._is_key = false;
column._aggregation = agg_method;
column._is_nullable = is_nullable;
@@ -59,7 +59,7 @@ TabletColumn create_char_key(int32_t id, bool is_nullable) {
TabletColumn column;
column._unique_id = id;
column._col_name = std::to_string(id);
- column._type = OLAP_FIELD_TYPE_CHAR;
+ column._type = FieldType::OLAP_FIELD_TYPE_CHAR;
column._is_key = true;
column._is_nullable = is_nullable;
column._length = 8;
@@ -71,7 +71,7 @@ TabletColumn create_varchar_key(int32_t id, bool is_nullable) {
TabletColumn column;
column._unique_id = id;
column._col_name = std::to_string(id);
- column._type = OLAP_FIELD_TYPE_VARCHAR;
+ column._type = FieldType::OLAP_FIELD_TYPE_VARCHAR;
column._is_key = true;
column._is_nullable = is_nullable;
column._length = 65533;
@@ -83,7 +83,7 @@ TabletColumn create_string_key(int32_t id, bool is_nullable) {
TabletColumn column;
column._unique_id = id;
column._col_name = std::to_string(id);
- column._type = OLAP_FIELD_TYPE_STRING;
+ column._type = FieldType::OLAP_FIELD_TYPE_STRING;
column._is_key = true;
column._is_nullable = is_nullable;
column._length = 2147483643;
@@ -93,7 +93,7 @@ TabletColumn create_string_key(int32_t id, bool is_nullable) {
void set_column_value_by_type(FieldType fieldType, int src, char* target, vectorized::Arena* pool,
size_t _length) {
- if (fieldType == OLAP_FIELD_TYPE_CHAR) {
+ if (fieldType == FieldType::OLAP_FIELD_TYPE_CHAR) {
std::string s = std::to_string(src);
const char* src_value = s.c_str();
int src_len = s.size();
@@ -103,7 +103,7 @@ void set_column_value_by_type(FieldType fieldType, int src, char* target, vector
dest_slice->data = pool->alloc(dest_slice->size);
memcpy(dest_slice->data, src_value, src_len);
memset(dest_slice->data + src_len, 0, dest_slice->size - src_len);
- } else if (fieldType == OLAP_FIELD_TYPE_VARCHAR) {
+ } else if (fieldType == FieldType::OLAP_FIELD_TYPE_VARCHAR) {
std::string s = std::to_string(src);
const char* src_value = s.c_str();
int src_len = s.size();
@@ -112,7 +112,7 @@ void set_column_value_by_type(FieldType fieldType, int src, char* target, vector
dest_slice->size = src_len;
dest_slice->data = pool->alloc(src_len);
memcpy(dest_slice->data, src_value, src_len);
- } else if (fieldType == OLAP_FIELD_TYPE_STRING) {
+ } else if (fieldType == FieldType::OLAP_FIELD_TYPE_STRING) {
std::string s = std::to_string(src);
const char* src_value = s.c_str();
int src_len = s.size();
@@ -127,7 +127,7 @@ void set_column_value_by_type(FieldType fieldType, int src, char* target, vector
}
void set_column_value_by_type(FieldType fieldType, const std::string& src, char* target,
vectorized::Arena* pool, size_t _length) {
- if (fieldType == OLAP_FIELD_TYPE_CHAR) {
+ if (fieldType == FieldType::OLAP_FIELD_TYPE_CHAR) {
const char* src_value = src.c_str();
int src_len = src.size();
@@ -136,7 +136,7 @@ void set_column_value_by_type(FieldType fieldType, const std::string& src, char*
dest_slice->data = pool->alloc(dest_slice->size);
memcpy(dest_slice->data, src_value, src_len);
memset(dest_slice->data + src_len, 0, dest_slice->size - src_len);
- } else if (fieldType == OLAP_FIELD_TYPE_VARCHAR) {
+ } else if (fieldType == FieldType::OLAP_FIELD_TYPE_VARCHAR) {
const char* src_value = src.c_str();
int src_len = src.size();
@@ -144,7 +144,7 @@ void set_column_value_by_type(FieldType fieldType, const std::string& src, char*
dest_slice->size = src_len;
dest_slice->data = pool->alloc(src_len);
memcpy(dest_slice->data, src_value, src_len);
- } else if (fieldType == OLAP_FIELD_TYPE_STRING) {
+ } else if (fieldType == FieldType::OLAP_FIELD_TYPE_STRING) {
const char* src_value = src.c_str();
int src_len = src.size();
diff --git a/be/test/testutil/test_util.cpp b/be/test/testutil/test_util.cpp
index d7883fc9e2..8b4d8d50bd 100644
--- a/be/test/testutil/test_util.cpp
+++ b/be/test/testutil/test_util.cpp
@@ -109,11 +109,11 @@ std::string rand_rng_string(size_t length) {
return s;
}
std::string rand_rng_by_type(FieldType fieldType) {
- if (fieldType == OLAP_FIELD_TYPE_CHAR) {
+ if (fieldType == FieldType::OLAP_FIELD_TYPE_CHAR) {
return rand_rng_string(rand_rng_int(1, 8));
- } else if (fieldType == OLAP_FIELD_TYPE_VARCHAR) {
+ } else if (fieldType == FieldType::OLAP_FIELD_TYPE_VARCHAR) {
return rand_rng_string(rand_rng_int(1, 128));
- } else if (fieldType == OLAP_FIELD_TYPE_STRING) {
+ } else if (fieldType == FieldType::OLAP_FIELD_TYPE_STRING) {
return rand_rng_string(rand_rng_int(1, 100000));
} else {
return std::to_string(rand_rng_int(1, 1000000));
diff --git a/be/test/vec/exec/vgeneric_iterators_test.cpp b/be/test/vec/exec/vgeneric_iterators_test.cpp
index 930e1804d8..1df2ad265f 100644
--- a/be/test/vec/exec/vgeneric_iterators_test.cpp
+++ b/be/test/vec/exec/vgeneric_iterators_test.cpp
@@ -38,11 +38,12 @@ public:
Schema create_schema() {
std::vector<TabletColumn> col_schemas;
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_SMALLINT, true);
+ col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, FieldType::OLAP_FIELD_TYPE_SMALLINT,
+ true);
// c2: int
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, OLAP_FIELD_TYPE_INT, true);
+ col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_NONE, FieldType::OLAP_FIELD_TYPE_INT, true);
// c3: big int
- col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_SUM, OLAP_FIELD_TYPE_BIGINT, true);
+ col_schemas.emplace_back(OLAP_FIELD_AGGREGATION_SUM, FieldType::OLAP_FIELD_TYPE_BIGINT, true);
Schema schema(col_schemas, 2);
return schema;
@@ -244,23 +245,23 @@ public:
size_t data_len = 0;
const auto* col_schema = _schema.column(j);
switch (col_schema->type()) {
- case OLAP_FIELD_TYPE_SMALLINT:
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT:
*(int16_t*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1;
data_len = sizeof(int16_t);
break;
- case OLAP_FIELD_TYPE_INT:
+ case FieldType::OLAP_FIELD_TYPE_INT:
*(int32_t*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1;
data_len = sizeof(int32_t);
break;
- case OLAP_FIELD_TYPE_BIGINT:
+ case FieldType::OLAP_FIELD_TYPE_BIGINT:
*(int64_t*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1;
data_len = sizeof(int64_t);
break;
- case OLAP_FIELD_TYPE_FLOAT:
+ case FieldType::OLAP_FIELD_TYPE_FLOAT:
*(float*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1;
data_len = sizeof(float);
break;
- case OLAP_FIELD_TYPE_DOUBLE:
+ case FieldType::OLAP_FIELD_TYPE_DOUBLE:
*(double*)data = j == _seq_col_idx ? _seq_col_rows_returned : 1;
data_len = sizeof(double);
break;
diff --git a/be/test/vec/jsonb/serialize_test.cpp b/be/test/vec/jsonb/serialize_test.cpp
index 5b42d335e9..c6f17fa9f0 100644
--- a/be/test/vec/jsonb/serialize_test.cpp
+++ b/be/test/vec/jsonb/serialize_test.cpp
@@ -88,10 +88,10 @@ TEST(BlockSerializeTest, Array) {
TabletColumn c2;
c1.set_name("k1");
c1.set_unique_id(1);
- c1.set_type(OLAP_FIELD_TYPE_ARRAY);
+ c1.set_type(FieldType::OLAP_FIELD_TYPE_ARRAY);
c2.set_name("k2");
c2.set_unique_id(2);
- c2.set_type(OLAP_FIELD_TYPE_ARRAY);
+ c2.set_type(FieldType::OLAP_FIELD_TYPE_ARRAY);
schema.append_column(c1);
schema.append_column(c2);
// array int and array string
@@ -138,13 +138,13 @@ TEST(BlockSerializeTest, JsonbBlock) {
vectorized::Block block;
TabletSchema schema;
std::vector<std::tuple<std::string, FieldType, int, PrimitiveType>> cols {
- {"k1", OLAP_FIELD_TYPE_INT, 1, TYPE_INT},
- {"k2", OLAP_FIELD_TYPE_STRING, 2, TYPE_STRING},
- {"k3", OLAP_FIELD_TYPE_DECIMAL128I, 3, TYPE_DECIMAL128I},
- {"k4", OLAP_FIELD_TYPE_STRING, 4, TYPE_STRING},
- {"k5", OLAP_FIELD_TYPE_DECIMAL128I, 5, TYPE_DECIMAL128I},
- {"k6", OLAP_FIELD_TYPE_INT, 6, TYPE_INT},
- {"k9", OLAP_FIELD_TYPE_DATEV2, 9, TYPE_DATEV2}};
+ {"k1", FieldType::OLAP_FIELD_TYPE_INT, 1, TYPE_INT},
+ {"k2", FieldType::OLAP_FIELD_TYPE_STRING, 2, TYPE_STRING},
+ {"k3", FieldType::OLAP_FIELD_TYPE_DECIMAL128I, 3, TYPE_DECIMAL128I},
+ {"k4", FieldType::OLAP_FIELD_TYPE_STRING, 4, TYPE_STRING},
+ {"k5", FieldType::OLAP_FIELD_TYPE_DECIMAL128I, 5, TYPE_DECIMAL128I},
+ {"k6", FieldType::OLAP_FIELD_TYPE_INT, 6, TYPE_INT},
+ {"k9", FieldType::OLAP_FIELD_TYPE_DATEV2, 9, TYPE_DATEV2}};
for (auto t : cols) {
TabletColumn c;
c.set_name(std::get<0>(t));
---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@doris.apache.org
For additional commands, e-mail: commits-help@doris.apache.org