From c9b4eaea763ac9dcf3d30a58da6ac199ee34e645 Mon Sep 17 00:00:00 2001 From: Pxl Date: Mon, 10 Apr 2023 08:53:44 +0800 Subject: [PATCH] [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 +- .../rowset/segment_v2/binary_dict_page.cpp | 20 +- .../olap/rowset/segment_v2/binary_dict_page.h | 6 +- .../rowset/segment_v2/binary_plain_page.h | 6 +- .../rowset/segment_v2/bitmap_index_reader.h | 2 +- .../rowset/segment_v2/bitmap_index_writer.cpp | 78 ++++---- .../olap/rowset/segment_v2/bitshuffle_page.h | 3 +- .../segment_v2/bloom_filter_index_reader.h | 2 +- .../segment_v2/bloom_filter_index_writer.cpp | 56 +++--- .../olap/rowset/segment_v2/column_reader.cpp | 63 +++--- .../olap/rowset/segment_v2/column_writer.cpp | 27 +-- .../olap/rowset/segment_v2/encoding_info.cpp | 166 ++++++++-------- .../segment_v2/indexed_column_reader.cpp | 3 +- .../segment_v2/indexed_column_writer.cpp | 6 +- .../segment_v2/inverted_index_writer.cpp | 92 ++++----- .../rowset/segment_v2/ordinal_page_index.cpp | 8 +- be/src/olap/rowset/segment_v2/rle_page.h | 4 +- .../rowset/segment_v2/segment_iterator.cpp | 17 +- .../olap/rowset/segment_v2/segment_iterator.h | 10 +- .../olap/rowset/segment_v2/segment_writer.cpp | 2 +- .../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 | 24 +-- be/test/olap/memtable_flush_executor_test.cpp | 7 +- .../segment_v2/binary_dict_page_test.cpp | 17 +- .../segment_v2/binary_plain_page_test.cpp | 13 +- .../segment_v2/binary_prefix_page_test.cpp | 6 +- .../rowset/segment_v2/bitmap_index_test.cpp | 24 +-- .../segment_v2/bitshuffle_page_test.cpp | 103 +++++----- .../bloom_filter_index_reader_writer_test.cpp | 30 +-- .../segment_v2/column_reader_writer_test.cpp | 182 +++++++++--------- .../rowset/segment_v2/encoding_info_test.cpp | 4 +- .../frame_of_reference_page_test.cpp | 83 ++++---- .../rowset/segment_v2/plain_page_test.cpp | 105 +++++----- .../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, 1233 insertions(+), 1113 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(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(column_id, filter, be_exec_version, column); } - case OLAP_FIELD_TYPE_BOOL: { + case FieldType::OLAP_FIELD_TYPE_BOOL: { return create_olap_column_predicate(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(value_str); - case OLAP_FIELD_TYPE_SMALLINT: + case FieldType::OLAP_FIELD_TYPE_SMALLINT: return valid_signed_number(value_str); - case OLAP_FIELD_TYPE_INT: + case FieldType::OLAP_FIELD_TYPE_INT: return valid_signed_number(value_str); - case OLAP_FIELD_TYPE_BIGINT: + case FieldType::OLAP_FIELD_TYPE_BIGINT: return valid_signed_number(value_str); - case OLAP_FIELD_TYPE_LARGEINT: + case FieldType::OLAP_FIELD_TYPE_LARGEINT: return valid_signed_number(value_str); - case OLAP_FIELD_TYPE_UNSIGNED_TINYINT: + case FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT: return valid_unsigned_number(value_str); - case OLAP_FIELD_TYPE_UNSIGNED_SMALLINT: + case FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT: return valid_unsigned_number(value_str); - case OLAP_FIELD_TYPE_UNSIGNED_INT: + case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT: return valid_unsigned_number(value_str); - case OLAP_FIELD_TYPE_UNSIGNED_BIGINT: + case FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT: return valid_unsigned_number(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(); 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(dst->mutable_cell_ptr()); auto src_slice = reinterpret_cast(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(buf); if (slice->size < value_string.size()) { *_long_text_buf = static_cast(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 sub_field( @@ -553,13 +553,13 @@ public: } return local; } - case OLAP_FIELD_TYPE_ARRAY: { + case FieldType::OLAP_FIELD_TYPE_ARRAY: { std::unique_ptr 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 key_field(FieldFactory::create(column.get_sub_column(0))); std::unique_ptr 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 sub_field( @@ -610,13 +610,13 @@ public: } return local; } - case OLAP_FIELD_TYPE_ARRAY: { + case FieldType::OLAP_FIELD_TYPE_ARRAY: { std::unique_ptr 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 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(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); - add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); + add_mapping(); } template 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 { +class KeyCoderTraits { public: - using CppType = typename CppTypeTraits::CppType; - using UnsignedCppType = typename CppTypeTraits::UnsignedCppType; + using CppType = typename CppTypeTraits::CppType; + using UnsignedCppType = + typename CppTypeTraits::UnsignedCppType; public: static void full_encode_ascending(const void* value, std::string* buf) { @@ -169,10 +170,11 @@ public: }; template <> -class KeyCoderTraits { +class KeyCoderTraits { public: - using CppType = typename CppTypeTraits::CppType; - using UnsignedCppType = typename CppTypeTraits::UnsignedCppType; + using CppType = typename CppTypeTraits::CppType; + using UnsignedCppType = + typename CppTypeTraits::UnsignedCppType; public: static void full_encode_ascending(const void* value, std::string* buf) { @@ -202,10 +204,11 @@ public: }; template <> -class KeyCoderTraits { +class KeyCoderTraits { public: - using CppType = typename CppTypeTraits::CppType; - using UnsignedCppType = typename CppTypeTraits::UnsignedCppType; + using CppType = typename CppTypeTraits::CppType; + using UnsignedCppType = + typename CppTypeTraits::UnsignedCppType; public: static void full_encode_ascending(const void* value, std::string* buf) { @@ -235,13 +238,15 @@ public: }; template <> -class KeyCoderTraits { +class KeyCoderTraits { public: static void full_encode_ascending(const void* value, std::string* buf) { decimal12_t decimal_val; memcpy(&decimal_val, value, sizeof(decimal12_t)); - KeyCoderTraits::full_encode_ascending(&decimal_val.integer, buf); - KeyCoderTraits::full_encode_ascending(&decimal_val.fraction, buf); + KeyCoderTraits::full_encode_ascending( + &decimal_val.integer, buf); + KeyCoderTraits::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::decode_ascending( + RETURN_IF_ERROR(KeyCoderTraits::decode_ascending( encoded_key, sizeof(decimal_val.integer), (uint8_t*)&decimal_val.integer)); - RETURN_IF_ERROR(KeyCoderTraits::decode_ascending( + RETURN_IF_ERROR(KeyCoderTraits::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 { +class KeyCoderTraits { public: static void full_encode_ascending(const void* value, std::string* buf) { auto slice = reinterpret_cast(value); @@ -282,7 +287,7 @@ public: }; template <> -class KeyCoderTraits { +class KeyCoderTraits { public: static void full_encode_ascending(const void* value, std::string* buf) { auto slice = reinterpret_cast(value); @@ -302,7 +307,7 @@ public: }; template <> -class KeyCoderTraits { +class KeyCoderTraits { public: static void full_encode_ascending(const void* value, std::string* buf) { auto slice = reinterpret_cast(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; } // , 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 std::unique_ptr> get_creator(const FieldType& type) { switch (type) { - case OLAP_FIELD_TYPE_TINYINT: { + case FieldType::OLAP_FIELD_TYPE_TINYINT: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_SMALLINT: { + case FieldType::OLAP_FIELD_TYPE_SMALLINT: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_INT: { + case FieldType::OLAP_FIELD_TYPE_INT: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_BIGINT: { + case FieldType::OLAP_FIELD_TYPE_BIGINT: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_LARGEINT: { + case FieldType::OLAP_FIELD_TYPE_LARGEINT: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_FLOAT: { + case FieldType::OLAP_FIELD_TYPE_FLOAT: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_DOUBLE: { + case FieldType::OLAP_FIELD_TYPE_DOUBLE: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_DECIMAL: { + case FieldType::OLAP_FIELD_TYPE_DECIMAL: { return std::make_unique>( [](const std::string& condition) { decimal12_t value = {0, 0}; @@ -186,39 +186,39 @@ std::unique_ptr> get_creator(const FieldType& ty return value; }); } - case OLAP_FIELD_TYPE_DECIMAL32: { + case FieldType::OLAP_FIELD_TYPE_DECIMAL32: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_DECIMAL64: { + case FieldType::OLAP_FIELD_TYPE_DECIMAL64: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_DECIMAL128I: { + case FieldType::OLAP_FIELD_TYPE_DECIMAL128I: { return std::make_unique>(); } - case OLAP_FIELD_TYPE_CHAR: { + case FieldType::OLAP_FIELD_TYPE_CHAR: { return std::make_unique>(); } - 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>(); } - case OLAP_FIELD_TYPE_DATE: { + case FieldType::OLAP_FIELD_TYPE_DATE: { return std::make_unique>( timestamp_from_date); } - case OLAP_FIELD_TYPE_DATEV2: { + case FieldType::OLAP_FIELD_TYPE_DATEV2: { return std::make_unique>( timestamp_from_date_v2); } - case OLAP_FIELD_TYPE_DATETIME: { + case FieldType::OLAP_FIELD_TYPE_DATETIME: { return std::make_unique>( timestamp_from_datetime); } - case OLAP_FIELD_TYPE_DATETIMEV2: { + case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: { return std::make_unique>( timestamp_from_datetime_v2); } - case OLAP_FIELD_TYPE_BOOL: { + case FieldType::OLAP_FIELD_TYPE_BOOL: { return std::make_unique>( [](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(); + const auto* type_info = get_scalar_type_info(); 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& columns) { return Status::Error(); } _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(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(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(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(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(options)); + _data_page_builder.reset(new BitshufflePageBuilder(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(dict_builder_options)); + _dict_builder.reset( + new BinaryPlainPageBuilder(dict_builder_options)); reset(); } @@ -60,8 +61,8 @@ Status BinaryDictPageBuilder::add(const uint8_t* vals, size_t* count) { const Slice* src = reinterpret_cast(vals); size_t num_added = 0; uint32_t value_code = -1; - auto* actual_builder = - down_cast*>(_data_page_builder.get()); + auto* actual_builder = down_cast*>( + _data_page_builder.get()); if (_data_page_builder->count() == 0) { _first_value.assign_copy(reinterpret_cast(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(_options)); + _data_page_builder.reset( + new BinaryPlainPageBuilder(_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(_data, _options)); + _bit_shuffle_ptr = + new BitShufflePageDecoder(_data, _options)); } else if (_encoding_type == PLAIN_ENCODING) { DCHECK_EQ(_encoding_type, PLAIN_ENCODING); - _data_page_decoder.reset(new BinaryPlainPageDecoder(_data, _options)); + _data_page_decoder.reset( + new BinaryPlainPageDecoder(_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*)dict_decoder; + _dict_decoder = (BinaryPlainPageDecoder*)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 _data_page_builder; - std::unique_ptr> _dict_builder; + std::unique_ptr> _dict_builder; EncodingTypePB _encoding_type; struct HashOfSlice { @@ -123,8 +123,8 @@ private: Slice _data; PageDecoderOptions _options; std::unique_ptr _data_page_decoder; - BinaryPlainPageDecoder* _dict_decoder = nullptr; - BitShufflePageDecoder* _bit_shuffle_ptr = nullptr; + BinaryPlainPageDecoder* _dict_decoder = nullptr; + BitShufflePageDecoder* _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(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()), + _type_info(get_scalar_type_info()), _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(); + const auto* bitmap_type_info = + get_scalar_type_info(); 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* res) { FieldType type = type_info->type(); switch (type) { - case OLAP_FIELD_TYPE_TINYINT: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_TINYINT: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_SMALLINT: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_SMALLINT: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_INT: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_INT: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_UNSIGNED_INT: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_BIGINT: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_BIGINT: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_CHAR: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_CHAR: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_VARCHAR: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_VARCHAR: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_STRING: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_STRING: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_DATE: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_DATE: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_DATETIME: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_DATETIME: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_DATEV2: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_DATEV2: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_DATETIMEV2: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_LARGEINT: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_LARGEINT: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_DECIMAL: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_DECIMAL: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_DECIMAL32: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_DECIMAL32: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_DECIMAL64: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_DECIMAL64: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_DECIMAL128I: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_DECIMAL128I: + res->reset(new BitmapIndexWriterImpl(type_info)); break; - case OLAP_FIELD_TYPE_BOOL: - res->reset(new BitmapIndexWriterImpl(type_info)); + case FieldType::OLAP_FIELD_TYPE_BOOL: + res->reset(new BitmapIndexWriterImpl(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()), + _type_info(get_scalar_type_info()), _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(); + const auto* bf_type_info = get_scalar_type_info(); 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(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* 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>( - dict_data); + _dict_decoder = std::make_unique< + BinaryPlainPageDecoder>(dict_data); RETURN_IF_ERROR(_dict_decoder->init()); - auto* pd_decoder = - (BinaryPlainPageDecoder*)_dict_decoder.get(); + auto* pd_decoder = (BinaryPlainPageDecoder*) + _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::CppType)); //uint24_t - std::string str = FieldTypeTraits::to_string(mem_value); + assert(type_size == + sizeof(FieldTypeTraits::CppType)); //uint24_t + std::string str = FieldTypeTraits::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::CppType)); //int64_t - std::string str = FieldTypeTraits::to_string(mem_value); + assert(type_size == + sizeof(FieldTypeTraits::CppType)); //int64_t + std::string str = + FieldTypeTraits::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::CppType)); //decimal12_t + sizeof(FieldTypeTraits::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(*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()->size()); + get_scalar_type_info()->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()->size()); + get_scalar_type_info()->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()->size()); + get_scalar_type_info()->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()->size()); + get_scalar_type_info()->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()->size()); + get_scalar_type_info()->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& pair) const { - return (pair.first << 5) ^ pair.second; + return (int(pair.first) << 6) ^ pair.second; } }; @@ -83,14 +84,14 @@ struct TypeEncodingTraits -struct TypeEncodingTraits { +struct TypeEncodingTraits { static Status create_page_builder(const PageBuilderOptions& opts, PageBuilder** builder) { - *builder = new RlePageBuilder(opts); + *builder = new RlePageBuilder(opts); return Status::OK(); } static Status create_page_decoder(const Slice& data, const PageDecoderOptions& opts, PageDecoder** decoder) { - *decoder = new RlePageDecoder(data, opts); + *decoder = new RlePageDecoder(data, opts); return Status::OK(); } }; @@ -109,43 +110,44 @@ struct TypeEncodingTraits { }; template <> -struct TypeEncodingTraits::CppType> { +struct TypeEncodingTraits::CppType> { static Status create_page_builder(const PageBuilderOptions& opts, PageBuilder** builder) { - *builder = new FrameOfReferencePageBuilder(opts); + *builder = new FrameOfReferencePageBuilder(opts); return Status::OK(); } static Status create_page_decoder(const Slice& data, const PageDecoderOptions& opts, PageDecoder** decoder) { - *decoder = new FrameOfReferencePageDecoder(data, opts); + *decoder = new FrameOfReferencePageDecoder(data, opts); return Status::OK(); } }; template <> -struct TypeEncodingTraits::CppType> { +struct TypeEncodingTraits::CppType> { static Status create_page_builder(const PageBuilderOptions& opts, PageBuilder** builder) { - *builder = new FrameOfReferencePageBuilder(opts); + *builder = new FrameOfReferencePageBuilder(opts); return Status::OK(); } static Status create_page_decoder(const Slice& data, const PageDecoderOptions& opts, PageDecoder** decoder) { - *decoder = new FrameOfReferencePageDecoder(data, opts); + *decoder = new FrameOfReferencePageDecoder(data, opts); return Status::OK(); } }; template <> -struct TypeEncodingTraits::CppType> { +struct TypeEncodingTraits::CppType> { static Status create_page_builder(const PageBuilderOptions& opts, PageBuilder** builder) { - *builder = new FrameOfReferencePageBuilder(opts); + *builder = new FrameOfReferencePageBuilder(opts); return Status::OK(); } static Status create_page_decoder(const Slice& data, const PageDecoderOptions& opts, PageDecoder** decoder) { - *decoder = new FrameOfReferencePageDecoder(data, opts); + *decoder = + new FrameOfReferencePageDecoder(data, opts); return Status::OK(); } }; @@ -222,103 +224,103 @@ private: _encoding_map.emplace(key, encoding.release()); } - std::unordered_map> _default_encoding_type_map; + std::unordered_map _default_encoding_type_map; // default encoding for each type which optimizes value seek - std::unordered_map> _value_seek_encoding_map; + std::unordered_map _value_seek_encoding_map; std::unordered_map, EncodingInfo*, EncodingMapHash> _encoding_map; }; EncodingInfoResolver::EncodingInfoResolver() { - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); - _add_map(); - _add_map(); + _add_map(); + _add_map(); + _add_map(); - _add_map(); + _add_map(); - _add_map(); + _add_map(); - _add_map(); + _add_map(); } 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::full_encode_ascending(&idx, &key); + KeyCoderTraits::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::full_encode_ascending(&first_ordinal, - &key); + KeyCoderTraits::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(typeinfo); typeinfo = array_typeinfo->item_type_info(); type = typeinfo->type(); } switch (type) { - case OLAP_FIELD_TYPE_CHAR: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_CHAR: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_VARCHAR: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_VARCHAR: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_STRING: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_STRING: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_DATETIME: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_DATETIME: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_DATE: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_DATE: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_DATETIMEV2: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: { + *res = std::make_unique< + InvertedIndexColumnWriterImpl>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_DATEV2: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_DATEV2: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_TINYINT: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_TINYINT: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_SMALLINT: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_SMALLINT: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_UNSIGNED_INT: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT: { + *res = std::make_unique< + InvertedIndexColumnWriterImpl>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_INT: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_INT: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_LARGEINT: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_LARGEINT: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_DECIMAL: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_DECIMAL: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_DECIMAL32: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_DECIMAL32: { + *res = std::make_unique< + InvertedIndexColumnWriterImpl>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_DECIMAL64: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_DECIMAL64: { + *res = std::make_unique< + InvertedIndexColumnWriterImpl>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_DECIMAL128I: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_DECIMAL128I: { + *res = std::make_unique< + InvertedIndexColumnWriterImpl>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_BOOL: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_BOOL: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_DOUBLE: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_DOUBLE: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_FLOAT: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_FLOAT: { + *res = std::make_unique>( field_name, segment_file_name, dir, fs, index_meta); break; } - case OLAP_FIELD_TYPE_BIGINT: { - *res = std::make_unique>( + case FieldType::OLAP_FIELD_TYPE_BIGINT: { + *res = std::make_unique>( 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::full_encode_ascending(&ordinal, &key); + KeyCoderTraits::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::decode_ascending( - &key, sizeof(ordinal_t), (uint8_t*)&ordinal)); + RETURN_IF_ERROR( + KeyCoderTraits::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 or Array> @@ -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(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::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(); + const auto* type_info = get_scalar_type_info(); 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& res) { switch (field->type()) { #define M(NAME) \ - case OLAP_FIELD_##NAME: { \ + case FieldType::OLAP_FIELD_##NAME: { \ res.reset(new TypedZoneMapIndexWriter(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(field)); return Status::OK(); } - case OLAP_FIELD_TYPE_BOOL: { + case FieldType::OLAP_FIELD_TYPE_BOOL: { res.reset(new TypedZoneMapIndexWriter(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::create(); break; - case OLAP_FIELD_TYPE_TINYINT: + case FieldType::OLAP_FIELD_TYPE_TINYINT: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_SMALLINT: + case FieldType::OLAP_FIELD_TYPE_SMALLINT: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_INT: + case FieldType::OLAP_FIELD_TYPE_INT: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_FLOAT: + case FieldType::OLAP_FIELD_TYPE_FLOAT: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_DOUBLE: + case FieldType::OLAP_FIELD_TYPE_DOUBLE: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_BIGINT: + case FieldType::OLAP_FIELD_TYPE_BIGINT: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_LARGEINT: + case FieldType::OLAP_FIELD_TYPE_LARGEINT: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_DATE: + case FieldType::OLAP_FIELD_TYPE_DATE: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_DATEV2: + case FieldType::OLAP_FIELD_TYPE_DATEV2: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_DATETIMEV2: + case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_DATETIME: + case FieldType::OLAP_FIELD_TYPE_DATETIME: ptr = doris::vectorized::PredicateColumnType::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::create( field.type()); @@ -167,24 +167,24 @@ vectorized::IColumn::MutablePtr Schema::get_predicate_column_ptr(const Field& fi ptr = doris::vectorized::PredicateColumnType::create(); } break; - case OLAP_FIELD_TYPE_DECIMAL: + case FieldType::OLAP_FIELD_TYPE_DECIMAL: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_DECIMAL32: + case FieldType::OLAP_FIELD_TYPE_DECIMAL32: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_DECIMAL64: + case FieldType::OLAP_FIELD_TYPE_DECIMAL64: ptr = doris::vectorized::PredicateColumnType::create(); break; - case OLAP_FIELD_TYPE_DECIMAL128I: + case FieldType::OLAP_FIELD_TYPE_DECIMAL128I: ptr = doris::vectorized::PredicateColumnType::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::set_to_max)(void*) = nullptr; +void (*FieldTypeTraits::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(), + get_scalar_type_info(), nullptr, - get_scalar_type_info(), + get_scalar_type_info(), nullptr, - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), nullptr, - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), nullptr, nullptr, nullptr, nullptr, nullptr, - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), - get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), + get_scalar_type_info(), }; - 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 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 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 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(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(type_info); std::vector clone_type_infos; const std::vector* 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(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(_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(_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* type_infos() const { return &_type_infos; } @@ -606,136 +606,136 @@ template struct CppTypeTraits {}; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = bool; using UnsignedCppType = bool; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = int8_t; using UnsignedCppType = uint8_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = int16_t; using UnsignedCppType = uint16_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = int32_t; using UnsignedCppType = uint32_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = uint32_t; using UnsignedCppType = uint32_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = int64_t; using UnsignedCppType = uint64_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = uint64_t; using UnsignedCppType = uint64_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = int128_t; using UnsignedCppType = uint128_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = float; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = double; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = decimal12_t; using UnsignedCppType = decimal12_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = int32_t; using UnsignedCppType = uint32_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = int64_t; using UnsignedCppType = uint64_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = int128_t; using UnsignedCppType = uint128_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = uint24_t; using UnsignedCppType = uint24_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = uint32_t; using UnsignedCppType = uint32_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = uint64_t; using UnsignedCppType = uint64_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = uint64_t; using UnsignedCppType = uint64_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = int64_t; using UnsignedCppType = uint64_t; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = Slice; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = Slice; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = Slice; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = Slice; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = Slice; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = Slice; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = Slice; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = StructValue; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = CollectionValue; }; template <> -struct CppTypeTraits { +struct CppTypeTraits { using CppType = MapValue; }; template @@ -743,7 +743,7 @@ struct BaseFieldtypeTraits : public CppTypeTraits { using CppType = typename CppTypeTraits::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(address); @@ -798,8 +798,8 @@ struct BaseFieldtypeTraits : public CppTypeTraits { } }; -// 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 struct NumericFieldtypeTraits : public BaseFieldtypeTraits { using CppType = typename CppTypeTraits::CppType; @@ -821,7 +821,8 @@ struct FieldTypeTraits }; template <> -struct FieldTypeTraits : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { static std::string to_string(const void* src) { char buf[1024] = {'\0'}; snprintf(buf, sizeof(buf), "%d", *reinterpret_cast(src)); @@ -832,8 +833,8 @@ struct FieldTypeTraits : public BaseFieldtypeTraits -struct FieldTypeTraits - : public NumericFieldtypeTraits { +struct FieldTypeTraits + : public NumericFieldtypeTraits { 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 }; template <> -struct FieldTypeTraits - : public NumericFieldtypeTraits { +struct FieldTypeTraits + : public NumericFieldtypeTraits { 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 }; template <> -struct FieldTypeTraits - : public NumericFieldtypeTraits { +struct FieldTypeTraits + : public NumericFieldtypeTraits { 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 }; template <> -struct FieldTypeTraits - : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { static Status from_string(void* buf, const std::string& scan_key, const int precision, const int scale) { CppType* data_ptr = reinterpret_cast(buf); @@ -999,8 +1000,8 @@ struct FieldTypeTraits }; template <> -struct FieldTypeTraits - : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { 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 }; template <> -struct FieldTypeTraits - : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { 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 }; template <> -struct FieldTypeTraits - : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { 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 }; template <> -struct FieldTypeTraits : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { 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 : public BaseFieldtypeTraits -struct FieldTypeTraits - : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { 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 }; template <> -struct FieldTypeTraits - : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { static Status from_string(void* buf, const std::string& scan_key, const int precision, const int scale) { doris::vectorized::DateV2Value datetimev2_value; @@ -1193,8 +1195,8 @@ struct FieldTypeTraits }; template <> -struct FieldTypeTraits - : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { 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 }; template <> -struct FieldTypeTraits : public BaseFieldtypeTraits { +struct FieldTypeTraits + : public BaseFieldtypeTraits { static int cmp(const void* left, const void* right) { auto l_slice = reinterpret_cast(left); auto r_slice = reinterpret_cast(right); @@ -1310,7 +1313,8 @@ struct FieldTypeTraits : public BaseFieldtypeTraits -struct FieldTypeTraits : public FieldTypeTraits { +struct FieldTypeTraits + : public FieldTypeTraits { 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 : public FieldTypeTraits -struct FieldTypeTraits : public FieldTypeTraits { +struct FieldTypeTraits + : public FieldTypeTraits { 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 : public FieldTypeTraits -struct FieldTypeTraits : public FieldTypeTraits { +struct FieldTypeTraits + : public FieldTypeTraits { 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 : public FieldTypeTraits -struct FieldTypeTraits : public FieldTypeTraits {}; +struct FieldTypeTraits + : public FieldTypeTraits {}; template <> -struct FieldTypeTraits : public FieldTypeTraits {}; +struct FieldTypeTraits + : public FieldTypeTraits {}; template <> -struct FieldTypeTraits - : public FieldTypeTraits {}; +struct FieldTypeTraits + : public FieldTypeTraits {}; // Instantiate this template to get static access to the type traits. template @@ -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() { +inline const TypeInfo* get_collection_type_info() { 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(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(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( 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(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( 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(); break; - case OLAP_FIELD_TYPE_TINYINT: + case FieldType::OLAP_FIELD_TYPE_TINYINT: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_SMALLINT: + case FieldType::OLAP_FIELD_TYPE_SMALLINT: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_INT: + case FieldType::OLAP_FIELD_TYPE_INT: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_FLOAT: + case FieldType::OLAP_FIELD_TYPE_FLOAT: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_BIGINT: + case FieldType::OLAP_FIELD_TYPE_BIGINT: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_LARGEINT: + case FieldType::OLAP_FIELD_TYPE_LARGEINT: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_DATE: + case FieldType::OLAP_FIELD_TYPE_DATE: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_DATEV2: + case FieldType::OLAP_FIELD_TYPE_DATEV2: result = std::make_shared(); 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(); break; - case OLAP_FIELD_TYPE_DOUBLE: + case FieldType::OLAP_FIELD_TYPE_DOUBLE: result = std::make_shared(); 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(); break; - case OLAP_FIELD_TYPE_JSONB: + case FieldType::OLAP_FIELD_TYPE_JSONB: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_HLL: + case FieldType::OLAP_FIELD_TYPE_HLL: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_OBJECT: + case FieldType::OLAP_FIELD_TYPE_OBJECT: result = std::make_shared(); break; - case OLAP_FIELD_TYPE_DECIMAL: + case FieldType::OLAP_FIELD_TYPE_DECIMAL: result = std::make_shared>(27, 9); break; - case OLAP_FIELD_TYPE_QUANTILE_STATE: + case FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE: result = std::make_shared(); 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(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(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(data_ref.data); jsonb_writer.writeInt8(val); break; } - case OLAP_FIELD_TYPE_TINYINT: { + case FieldType::OLAP_FIELD_TYPE_TINYINT: { int8_t val = *reinterpret_cast(data_ref.data); jsonb_writer.writeInt8(val); break; } - case OLAP_FIELD_TYPE_SMALLINT: { + case FieldType::OLAP_FIELD_TYPE_SMALLINT: { int16_t val = *reinterpret_cast(data_ref.data); jsonb_writer.writeInt16(val); break; } - case OLAP_FIELD_TYPE_INT: { + case FieldType::OLAP_FIELD_TYPE_INT: { int32_t val = *reinterpret_cast(data_ref.data); jsonb_writer.writeInt32(val); break; } - case OLAP_FIELD_TYPE_BIGINT: { + case FieldType::OLAP_FIELD_TYPE_BIGINT: { int64_t val = *reinterpret_cast(data_ref.data); jsonb_writer.writeInt64(val); break; } - case OLAP_FIELD_TYPE_LARGEINT: { + case FieldType::OLAP_FIELD_TYPE_LARGEINT: { __int128_t val = *reinterpret_cast(data_ref.data); jsonb_writer.writeInt128(val); break; } - case OLAP_FIELD_TYPE_FLOAT: { + case FieldType::OLAP_FIELD_TYPE_FLOAT: { float val = *reinterpret_cast(data_ref.data); jsonb_writer.writeFloat(val); break; } - case OLAP_FIELD_TYPE_DOUBLE: { + case FieldType::OLAP_FIELD_TYPE_DOUBLE: { double val = *reinterpret_cast(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(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(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(data_ref.data); jsonb_writer.writeInt32(val); break; } - case OLAP_FIELD_TYPE_DATETIMEV2: { + case FieldType::OLAP_FIELD_TYPE_DATETIMEV2: { uint64_t val = *reinterpret_cast(data_ref.data); jsonb_writer.writeInt64(val); break; } - case OLAP_FIELD_TYPE_DECIMAL32: { + case FieldType::OLAP_FIELD_TYPE_DECIMAL32: { Decimal32::NativeType val = *reinterpret_cast(data_ref.data); jsonb_writer.writeInt32(val); break; } - case OLAP_FIELD_TYPE_DECIMAL64: { + case FieldType::OLAP_FIELD_TYPE_DECIMAL64: { Decimal64::NativeType val = *reinterpret_cast(data_ref.data); jsonb_writer.writeInt64(val); break; } - case OLAP_FIELD_TYPE_DECIMAL128I: { + case FieldType::OLAP_FIELD_TYPE_DECIMAL128I: { Decimal128I::NativeType val = *reinterpret_cast(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(); - test_integer_encode(); - test_integer_encode(); - test_integer_encode(); - test_integer_encode(); - test_integer_encode(); - test_integer_encode(); + test_integer_encode(); + test_integer_encode(); + test_integer_encode(); + test_integer_encode(); + test_integer_encode(); + test_integer_encode(); + test_integer_encode(); - test_integer_encode(); + test_integer_encode(); } 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 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> dict_page_decoder( - new BinaryPlainPageDecoder(dict_slice.slice(), - dict_decoder_options)); + std::unique_ptr> + dict_page_decoder(new BinaryPlainPageDecoder( + 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 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> dict_page_decoder( - new BinaryPlainPageDecoder(dict_slice.slice(), - dict_decoder_options)); + std::unique_ptr> + dict_page_decoder( + new BinaryPlainPageDecoder( + 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 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 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 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, - BinaryPlainPageDecoder>(); + TestBinarySeekByValueSmallPage, + BinaryPlainPageDecoder>(); } } // 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 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 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(file_name, io::global_local_filesystem(), val, - num_uint8_rows, 0, &meta); + write_index_file(file_name, io::global_local_filesystem(), val, + num_uint8_rows, 0, &meta); { BitmapIndexReader* reader = nullptr; BitmapIndexIterator* iter = nullptr; - get_bitmap_reader_iter(file_name, meta, &reader, &iter); + get_bitmap_reader_iter(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(file_name, io::global_local_filesystem(), val, - num_uint8_rows, 0, &meta); + write_index_file(file_name, io::global_local_filesystem(), val, + num_uint8_rows, 0, &meta); { BitmapIndexReader* reader = nullptr; BitmapIndexIterator* iter = nullptr; - get_bitmap_reader_iter(file_name, meta, &reader, &iter); + get_bitmap_reader_iter(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(file_name, io::global_local_filesystem(), val, - num_uint8_rows, 0, &meta); + write_index_file(file_name, io::global_local_filesystem(), + val, num_uint8_rows, 0, &meta); { BitmapIndexReader* reader = nullptr; BitmapIndexIterator* iter = nullptr; - get_bitmap_reader_iter(file_name, meta, &reader, &iter); + get_bitmap_reader_iter(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(file_name, io::global_local_filesystem(), val, - num_uint8_rows, 30, &meta); + write_index_file(file_name, io::global_local_filesystem(), + val, num_uint8_rows, 30, &meta); { BitmapIndexReader* reader = nullptr; BitmapIndexIterator* iter = nullptr; - get_bitmap_reader_iter(file_name, meta, &reader, &iter); + get_bitmap_reader_iter(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, - segment_v2::BitShufflePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_INT, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(ints.get(), size); } TEST_F(BitShufflePageTest, TestBitShuffleInt64BlockEncoderRandom) { @@ -192,10 +192,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt64BlockEncoderRandom) { ints.get()[i] = random(); } - test_encode_decode_page_template, - segment_v2::BitShufflePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_BIGINT, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(ints.get(), size); } TEST_F(BitShufflePageTest, TestBitShuffleFloatBlockEncoderRandom) { @@ -206,10 +206,11 @@ TEST_F(BitShufflePageTest, TestBitShuffleFloatBlockEncoderRandom) { floats.get()[i] = random() + static_cast(random()) / static_cast(INT_MAX); } - test_encode_decode_page_template, - segment_v2::BitShufflePageDecoder>( - floats.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_FLOAT, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(floats.get(), + size); } TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderRandom) { @@ -220,10 +221,11 @@ TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderRandom) { doubles.get()[i] = random() + static_cast(random()) / INT_MAX; } - test_encode_decode_page_template, - segment_v2::BitShufflePageDecoder>( - doubles.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_DOUBLE, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(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, - segment_v2::BitShufflePageDecoder>( - doubles.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_DOUBLE, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(doubles.get(), + size); } TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderSequence) { @@ -251,10 +254,11 @@ TEST_F(BitShufflePageTest, TestBitShuffleDoubleBlockEncoderSequence) { doubles.get()[i] = base; } - test_encode_decode_page_template, - segment_v2::BitShufflePageDecoder>( - doubles.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_DOUBLE, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(doubles.get(), + size); } TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderEqual) { @@ -265,10 +269,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderEqual) { ints.get()[i] = 12345; } - test_encode_decode_page_template, - segment_v2::BitShufflePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_INT, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(ints.get(), size); } TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderMaxNumberEqual) { @@ -279,10 +283,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderMaxNumberEqual) { ints.get()[i] = 1234567890; } - test_encode_decode_page_template, - segment_v2::BitShufflePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_INT, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(ints.get(), size); } TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderSequence) { @@ -294,10 +298,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderSequence) { ints.get()[i] = ++number; } - test_encode_decode_page_template, - segment_v2::BitShufflePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_INT, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(ints.get(), size); } TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderMaxNumberSequence) { @@ -310,10 +314,10 @@ TEST_F(BitShufflePageTest, TestBitShuffleInt32BlockEncoderMaxNumberSequence) { ++number; } - test_encode_decode_page_template, - segment_v2::BitShufflePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_INT, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>(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, - segment_v2::BitShufflePageDecoder>( + test_seek_at_or_after_value_template< + FieldType::OLAP_FIELD_TYPE_FLOAT, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>( 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, - segment_v2::BitShufflePageDecoder>( + test_seek_at_or_after_value_template< + FieldType::OLAP_FIELD_TYPE_DOUBLE, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>( 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, - segment_v2::BitShufflePageDecoder>( + FieldType::OLAP_FIELD_TYPE_DECIMAL, + segment_v2::BitshufflePageBuilder, + segment_v2::BitShufflePageDecoder>( 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(file_name, val, num, 1, - ¬_exist_value); + test_bloom_filter_index_reader_writer_template( + 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(file_name, val, num, 1, - ¬_exist_value); + test_bloom_filter_index_reader_writer_template( + 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(file_name, val, num, 1, - ¬_exist_value); + test_bloom_filter_index_reader_writer_template( + 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( + test_bloom_filter_index_reader_writer_template( 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(file_name, slices, num, 1, - ¬_exist_value, true); + test_bloom_filter_index_reader_writer_template( + 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(file_name, val, num, 1, - ¬_exist_value); + test_bloom_filter_index_reader_writer_template( + 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(file_name, val, num, 1, - ¬_exist_value); + test_bloom_filter_index_reader_writer_template( + 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(file_name, val, num, 1, - ¬_exist_value); + test_bloom_filter_index_reader_writer_template( + 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 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(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(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( + test_array_nullable_data( 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( + test_array_nullable_data( 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(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(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(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(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(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(val, is_null, num_uint8_rows, - "null_tiny_bs"); - test_nullable_data(val, is_null, num_uint8_rows / 2, - "null_smallint_bs"); - test_nullable_data(val, is_null, num_uint8_rows / 4, - "null_int_bs"); - test_nullable_data(val, is_null, num_uint8_rows / 8, - "null_bigint_bs"); - test_nullable_data(val, is_null, num_uint8_rows / 16, - "null_largeint_bs"); + test_nullable_data( + val, is_null, num_uint8_rows, "null_tiny_bs"); + test_nullable_data( + val, is_null, num_uint8_rows / 2, "null_smallint_bs"); + test_nullable_data( + val, is_null, num_uint8_rows / 4, "null_int_bs"); + test_nullable_data( + val, is_null, num_uint8_rows / 8, "null_bigint_bs"); + test_nullable_data( + 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(val, is_null_sparse, num_uint8_rows, - "sparse_null_tiny_bs"); + test_nullable_data( + 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((uint8_t*)float_vals, is_null, - num_uint8_rows, "null_float_bs"); + test_nullable_data( + (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((uint8_t*)double_vals, is_null, - num_uint8_rows, "null_double_bs"); - // test_nullable_data(val, is_null, num_uint8_rows / 4, "null_float_bs"); - // test_nullable_data(val, is_null, num_uint8_rows / 8, "null_double_bs"); + test_nullable_data( + (uint8_t*)double_vals, is_null, num_uint8_rows, "null_double_bs"); + // test_nullable_data(val, is_null, num_uint8_rows / 4, "null_float_bs"); + // test_nullable_data(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((uint8_t*)char_vals, is_null, - num_uint8_rows, "null_char_bs"); - test_nullable_data((uint8_t*)varchar_vals, is_null, - num_uint8_rows, "null_varchar_bs"); - test_nullable_data((uint8_t*)bool_vals, is_null, - num_uint8_rows, "null_bool_bs"); - test_nullable_data((uint8_t*)date_vals, is_null, - num_uint8_rows / 3, "null_date_bs"); + test_nullable_data( + (uint8_t*)char_vals, is_null, num_uint8_rows, "null_char_bs"); + test_nullable_data( + (uint8_t*)varchar_vals, is_null, num_uint8_rows, "null_varchar_bs"); + test_nullable_data( + (uint8_t*)bool_vals, is_null, num_uint8_rows, "null_bool_bs"); + test_nullable_data( + (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( + test_nullable_data( (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( + test_nullable_data( (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(v_int, &result); - test_read_default_value(v_int, &result); - test_read_default_value(v_int, &result); + test_read_default_value(v_int, &result); + test_read_default_value(v_int, &result); + test_read_default_value(v_int, &result); std::string v_bigint("9223372036854775807"); int64_t result_bigint = std::numeric_limits::max(); - test_read_default_value(v_bigint, &result_bigint); + test_read_default_value(v_bigint, &result_bigint); int128_t result_largeint = std::numeric_limits::max(); - test_read_default_value(v_bigint, &result_largeint); + test_read_default_value(v_bigint, &result_largeint); std::string v_float("1.00"); float result2 = 1.00; - test_read_default_value(v_float, &result2); + test_read_default_value(v_float, &result2); std::string v_double("1.00"); double result3 = 1.00; - test_read_default_value(v_double, &result3); + test_read_default_value(v_double, &result3); std::string v_varchar("varchar"); - test_read_default_value(v_varchar, &v_varchar); + test_read_default_value(v_varchar, &v_varchar); std::string v_char("char"); - test_read_default_value(v_char, &v_char); + test_read_default_value(v_char, &v_char); char* c = (char*)malloc(1); c[0] = 0; std::string v_object(c, 1); - test_read_default_value(v_object, &v_object); - test_read_default_value(v_object, &v_object); + test_read_default_value(v_object, &v_object); + test_read_default_value(v_object, &v_object); free(c); std::string v_date("2019-11-12"); uint24_t result_date(1034092); - test_read_default_value(v_date, &result_date); + test_read_default_value(v_date, &result_date); std::string v_datetime("2019-11-12 12:01:08"); int64_t result_datetime = 20191112120108; - test_read_default_value(v_datetime, &result_datetime); + test_read_default_value(v_datetime, &result_datetime); std::string v_decimal("102418.000000002"); decimal12_t decimal = {102418, 2}; - test_read_default_value(v_decimal, &decimal); + test_read_default_value(v_decimal, &decimal); } TEST_F(ColumnReaderWriterTest, test_v_default_value) { std::string v_int("1"); int32_t result = 1; - test_v_read_default_value(v_int, &result); + test_v_read_default_value(v_int, &result); std::string v_bigint("9223372036854775807"); int64_t result_bigint = std::numeric_limits::max(); - test_v_read_default_value(v_bigint, &result_bigint); + test_v_read_default_value(v_bigint, &result_bigint); int128_t result_largeint = std::numeric_limits::max(); - test_v_read_default_value(v_bigint, &result_largeint); + test_v_read_default_value(v_bigint, &result_largeint); std::string v_float("1.00"); float result_float = 1.00; - test_v_read_default_value(v_float, &result_float); + test_v_read_default_value(v_float, &result_float); std::string v_double("1.99"); double result_double = 1.99; - test_v_read_default_value(v_double, &result_double); + test_v_read_default_value(v_double, &result_double); std::string v_date("2019-11-12"); char result_date[] = "2019-11-12"; - test_v_read_default_value(v_date, result_date); + test_v_read_default_value(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(v_datetime, &result_datetime); + test_v_read_default_value(v_datetime, &result_datetime); std::string v_decimal("102418.000000002"); decimal12_t decimal = {102418, 2}; - test_v_read_default_value(v_decimal, &decimal); + test_v_read_default_value(v_decimal, &decimal); } TEST_F(ColumnReaderWriterTest, test_single_empty_array) { size_t num_array = 1; std::unique_ptr array_is_null(new uint8_t[BitmapSize(num_array)]()); CollectionValue array(0); - test_array_nullable_data( + test_array_nullable_data( &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( + test_array_nullable_data( 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(); + const auto* type_info = get_scalar_type_info(); 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(); + const auto* type_info = get_scalar_type_info(); 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, - segment_v2::FrameOfReferencePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_INT, + segment_v2::FrameOfReferencePageBuilder, + segment_v2::FrameOfReferencePageDecoder>(ints.get(), + size); } TEST_F(FrameOfReferencePageTest, TestInt32BlockEncoderEqual) { @@ -122,10 +123,11 @@ TEST_F(FrameOfReferencePageTest, TestInt32BlockEncoderEqual) { ints.get()[i] = 12345; } - test_encode_decode_page_template, - segment_v2::FrameOfReferencePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_INT, + segment_v2::FrameOfReferencePageBuilder, + segment_v2::FrameOfReferencePageDecoder>(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, - segment_v2::FrameOfReferencePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_INT, + segment_v2::FrameOfReferencePageBuilder, + segment_v2::FrameOfReferencePageDecoder>(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, - segment_v2::FrameOfReferencePageDecoder>(ints.get(), size); + FieldType::OLAP_FIELD_TYPE_BIGINT, + segment_v2::FrameOfReferencePageBuilder, + segment_v2::FrameOfReferencePageDecoder>(ints.get(), + size); test_encode_decode_page_template< - OLAP_FIELD_TYPE_DATETIME, - segment_v2::FrameOfReferencePageBuilder, - segment_v2::FrameOfReferencePageDecoder>(ints.get(), size); + FieldType::OLAP_FIELD_TYPE_DATETIME, + segment_v2::FrameOfReferencePageBuilder, + segment_v2::FrameOfReferencePageDecoder>( + 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, - segment_v2::FrameOfReferencePageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_DATE, + segment_v2::FrameOfReferencePageBuilder, + segment_v2::FrameOfReferencePageDecoder>(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, - segment_v2::FrameOfReferencePageDecoder>(ints.get(), size); + FieldType::OLAP_FIELD_TYPE_LARGEINT, + segment_v2::FrameOfReferencePageBuilder, + segment_v2::FrameOfReferencePageDecoder>( + 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, - segment_v2::FrameOfReferencePageDecoder>( - ints.get(), 2); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_DATE, + segment_v2::FrameOfReferencePageBuilder, + segment_v2::FrameOfReferencePageDecoder>(ints.get(), + 2); } TEST_F(FrameOfReferencePageTest, TestInt128BlockEncoderMinMax) { @@ -209,9 +218,10 @@ TEST_F(FrameOfReferencePageTest, TestInt128BlockEncoderMinMax) { ints.get()[1] = numeric_limits::max(); test_encode_decode_page_template< - OLAP_FIELD_TYPE_LARGEINT, - segment_v2::FrameOfReferencePageBuilder, - segment_v2::FrameOfReferencePageDecoder>(ints.get(), 2); + FieldType::OLAP_FIELD_TYPE_LARGEINT, + segment_v2::FrameOfReferencePageBuilder, + segment_v2::FrameOfReferencePageDecoder>( + 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 page_builder(builder_options); + segment_v2::FrameOfReferencePageBuilder page_builder( + builder_options); page_builder.add(reinterpret_cast(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 page_builder(builder_options); + segment_v2::FrameOfReferencePageBuilder page_builder( + builder_options); page_builder.add(reinterpret_cast(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 page_builder(builder_options); + segment_v2::FrameOfReferencePageBuilder page_builder( + builder_options); page_builder.add(reinterpret_cast(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, - segment_v2::PlainPageDecoder>(ints.get(), - size); + test_encode_decode_page_template, + segment_v2::PlainPageDecoder>( + 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, - segment_v2::PlainPageDecoder>( + test_seek_at_or_after_value_template< + FieldType::OLAP_FIELD_TYPE_INT, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>( 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, - segment_v2::PlainPageDecoder>( - ints.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_BIGINT, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>(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, - segment_v2::PlainPageDecoder>( + test_seek_at_or_after_value_template< + FieldType::OLAP_FIELD_TYPE_BIGINT, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>( ints.get(), size, &small_than_smallest, &bigger_than_biggest); } @@ -229,10 +231,10 @@ TEST_F(PlainPageTest, TestPlainFloatBlockEncoderRandom) { floats.get()[i] = random() + static_cast(random()) / static_cast(INT_MAX); } - test_encode_decode_page_template, - segment_v2::PlainPageDecoder>( - floats.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_FLOAT, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>(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(random()) / INT_MAX; } - test_encode_decode_page_template, - segment_v2::PlainPageDecoder>( - doubles.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_DOUBLE, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>(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, - segment_v2::PlainPageDecoder>( - doubles.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_DOUBLE, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>(doubles.get(), size); } TEST_F(PlainPageTest, TestDoublePageEncoderSequence) { @@ -272,10 +274,10 @@ TEST_F(PlainPageTest, TestDoublePageEncoderSequence) { doubles.get()[i] = base; } - test_encode_decode_page_template, - segment_v2::PlainPageDecoder>( - doubles.get(), size); + test_encode_decode_page_template< + FieldType::OLAP_FIELD_TYPE_DOUBLE, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>(doubles.get(), size); } TEST_F(PlainPageTest, TestPlainInt32PageEncoderEqual) { @@ -286,10 +288,10 @@ TEST_F(PlainPageTest, TestPlainInt32PageEncoderEqual) { ints.get()[i] = 12345; } - test_encode_decode_page_template, - segment_v2::PlainPageDecoder>(ints.get(), - size); + test_encode_decode_page_template, + segment_v2::PlainPageDecoder>( + ints.get(), size); } TEST_F(PlainPageTest, TestInt32PageEncoderSequence) { @@ -301,10 +303,10 @@ TEST_F(PlainPageTest, TestInt32PageEncoderSequence) { ints.get()[i] = ++number; } - test_encode_decode_page_template, - segment_v2::PlainPageDecoder>(ints.get(), - size); + test_encode_decode_page_template, + segment_v2::PlainPageDecoder>( + 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, - segment_v2::PlainPageDecoder>( - bools.get(), 2, nullptr, nullptr); + test_seek_at_or_after_value_template< + FieldType::OLAP_FIELD_TYPE_BOOL, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>(bools.get(), 2, nullptr, + nullptr); bool t = true; - test_seek_at_or_after_value_template, - segment_v2::PlainPageDecoder>( - bools.get(), 1, nullptr, &t); + test_seek_at_or_after_value_template< + FieldType::OLAP_FIELD_TYPE_BOOL, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>(bools.get(), 1, nullptr, + &t); t = false; - test_seek_at_or_after_value_template, - segment_v2::PlainPageDecoder>( - &bools.get()[1], 1, &t, nullptr); + test_seek_at_or_after_value_template< + FieldType::OLAP_FIELD_TYPE_BOOL, + segment_v2::PlainPageBuilder, + segment_v2::PlainPageDecoder>(&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, - segment_v2::RlePageDecoder>(ints.get(), - size); + test_encode_decode_page_template, + segment_v2::RlePageDecoder>( + ints.get(), size); } TEST_F(RlePageTest, TestRleInt32BlockEncoderEqual) { @@ -125,10 +125,10 @@ TEST_F(RlePageTest, TestRleInt32BlockEncoderEqual) { ints.get()[i] = 12345; } - test_encode_decode_page_template, - segment_v2::RlePageDecoder>(ints.get(), - size); + test_encode_decode_page_template, + segment_v2::RlePageDecoder>( + 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, - segment_v2::RlePageDecoder>(ints.get(), - size); + test_encode_decode_page_template, + segment_v2::RlePageDecoder>( + 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 rle_page_builder(builder_options); + segment_v2::RlePageBuilder rle_page_builder(builder_options); rle_page_builder.add(reinterpret_cast(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, - segment_v2::RlePageDecoder>(bools.get(), - size); + test_encode_decode_page_template, + segment_v2::RlePageDecoder>( + 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 rle_page_builder(builder_options); + segment_v2::RlePageBuilder rle_page_builder(builder_options); rle_page_builder.add(reinterpret_cast(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(Slice src_val) { - test_char(src_val); +void common_test(Slice src_val) { + test_char(src_val); } template <> -void common_test(Slice src_val) { - test_char(src_val); +void common_test(Slice src_val) { + test_char(src_val); } TEST(TypesTest, copy_and_equal) { - common_test(true); - common_test(112); - common_test(static_cast(54321)); - common_test(-123454321); - common_test(1234543212L); - common_test(123454321123456789L); + common_test(true); + common_test(112); + common_test(static_cast(54321)); + common_test(-123454321); + common_test(1234543212L); + common_test(123454321123456789L); __int128 int128_val = 1234567899L; - common_test(int128_val); - common_test(1.11); - common_test(12221.11); + common_test(int128_val); + common_test(1.11); + common_test(12221.11); decimal12_t decimal_val = {123, 2345}; - common_test(decimal_val); + common_test(decimal_val); - common_test((1988 << 9) | (2 << 5) | 1); - common_test(19880201010203L); + common_test((1988 << 9) | (2 << 5) | 1); + common_test(19880201010203L); - common_test((1988 << 9) | (2 << 5) | 1); + common_test((1988 << 9) | (2 << 5) | 1); Slice slice("12345abcde"); - common_test(slice); - common_test(slice); + common_test(slice); + common_test(slice); } template 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(CollectionValue(bool_array, 3, null_signs)); + common_test_array(CollectionValue(bool_array, 3, null_signs)); uint8_t tiny_int_array[3] = {3, 4, 5}; - common_test_array(CollectionValue(tiny_int_array, 3, null_signs)); + common_test_array( + CollectionValue(tiny_int_array, 3, null_signs)); int16_t small_int_array[3] = {123, 234, 345}; - common_test_array(CollectionValue(small_int_array, 3, null_signs)); + common_test_array( + CollectionValue(small_int_array, 3, null_signs)); int32_t int_array[3] = {-123454321, 123454321, 323412343}; - common_test_array(CollectionValue(int_array, 3, null_signs)); + common_test_array(CollectionValue(int_array, 3, null_signs)); uint32_t uint_array[3] = {123454321, 2342341, 52435234}; - common_test_array(CollectionValue(uint_array, 3, null_signs)); + common_test_array( + CollectionValue(uint_array, 3, null_signs)); int64_t bigint_array[3] = {123454321123456789L, 23534543234L, -123454321123456789L}; - common_test_array(CollectionValue(bigint_array, 3, null_signs)); + common_test_array( + CollectionValue(bigint_array, 3, null_signs)); __int128 large_int_array[3] = {1234567899L, 1234567899L, -12345631899L}; - common_test_array(CollectionValue(large_int_array, 3, null_signs)); + common_test_array( + CollectionValue(large_int_array, 3, null_signs)); float float_array[3] = {1.11, 2.22, -3.33}; - common_test_array(CollectionValue(float_array, 3, null_signs)); + common_test_array( + CollectionValue(float_array, 3, null_signs)); double double_array[3] = {12221.11, 12221.11, -12221.11}; - common_test_array(CollectionValue(double_array, 3, null_signs)); + common_test_array( + CollectionValue(double_array, 3, null_signs)); decimal12_t decimal_array[3] = {{123, 234}, {345, 453}, {4524, 2123}}; - common_test_array(CollectionValue(decimal_array, 3, null_signs)); + common_test_array( + 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(CollectionValue(date_array, 3, null_signs)); + common_test_array(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(CollectionValue(date_v2_array, 3, null_signs)); + common_test_array( + CollectionValue(date_v2_array, 3, null_signs)); int64_t datetime_array[3] = {19880201010203L, 19980201010203L, 20080204010203L}; - common_test_array(CollectionValue(datetime_array, 3, null_signs)); + common_test_array( + CollectionValue(datetime_array, 3, null_signs)); Slice char_array[3] = {"12345abcde", "12345abcde", "asdf322"}; - common_test_array(CollectionValue(char_array, 3, null_signs)); - common_test_array(CollectionValue(char_array, 3, null_signs)); + common_test_array(CollectionValue(char_array, 3, null_signs)); + common_test_array( + 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 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> 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));