This is an automated email from the ASF dual-hosted git repository.
yiguolei pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/doris.git
The following commit(s) were added to refs/heads/master by this push:
new 007e75666b5 [refactor](be) move storage field type conversion to core
(#65717)
007e75666b5 is described below
commit 007e75666b5e20cb0a70c3f63e39cd8756345aa4
Author: Chenyang Sun <[email protected]>
AuthorDate: Fri Jul 17 12:01:45 2026 +0800
[refactor](be) move storage field type conversion to core (#65717)
### What problem does this PR solve?
Issue Number: close #xxx
Related PR: #xxx
Problem Summary:
### Release note
None
### Check List (For Author)
- Test <!-- At least one of them must be included. -->
- [ ] Regression test
- [x] Unit Test
- [ ] Manual test (add detailed scripts or steps below)
- [ ] No need to test or manual test. Explain why:
- [ ] This is a refactor/code format and no logic has been changed.
- [ ] Previous test can cover this change.
- [ ] No code files have been changed.
- [ ] Other reason <!-- Add your reason? -->
- Behavior changed:
- [ ] No.
- [ ] Yes. <!-- Explain the behavior change -->
- Does this need documentation?
- [ ] No.
- [ ] Yes. <!-- Add document PR link here. eg:
https://github.com/apache/doris-website/pull/1214 -->
### Check List (For Reviewer who merge this PR)
- [ ] Confirm the release note
- [ ] Confirm test cases
- [ ] Confirm document
- [ ] Add branch pick label <!-- Add branch pick label that this PR
should merge into -->
---
be/src/core/column/column_variant.cpp | 3 +-
be/src/core/data_type/data_type.cpp | 4 +-
be/src/core/data_type/data_type.h | 1 +
be/src/core/data_type/define_primitive_type.h | 3 +
be/src/core/data_type/storage_field_type.cpp | 202 +++++++++++++++++++++
be/src/core/data_type/storage_field_type.h | 32 ++++
.../data_type_serde/data_type_decimal_serde.cpp | 4 +-
.../data_type_serde/data_type_number_serde.cpp | 3 +-
be/src/core/data_type_serde/data_type_serde.cpp | 4 +-
be/src/exec/common/variant_util.cpp | 9 +-
be/src/storage/olap_common.h | 4 +-
be/src/storage/segment/column_reader.h | 3 +-
be/src/storage/tablet/tablet_schema.cpp | 130 +------------
be/src/storage/tablet/tablet_schema.h | 2 -
be/test/core/data_type/storage_field_type_test.cpp | 171 +++++++++++++++++
15 files changed, 432 insertions(+), 143 deletions(-)
diff --git a/be/src/core/column/column_variant.cpp
b/be/src/core/column/column_variant.cpp
index ec34c619cdc..39cf985e7f0 100644
--- a/be/src/core/column/column_variant.cpp
+++ b/be/src/core/column/column_variant.cpp
@@ -59,6 +59,7 @@
#include "core/data_type/define_primitive_type.h"
#include "core/data_type/get_least_supertype.h"
#include "core/data_type/primitive_type.h"
+#include "core/data_type/storage_field_type.h"
#include "core/field.h"
#include "core/string_buffer.hpp"
#include "core/types.h"
@@ -2746,7 +2747,7 @@ void
ColumnVariant::Subcolumn::deserialize_from_binary_column(const ColumnString
const auto& data_ref = value->get_data_at(row);
const auto* start_data = reinterpret_cast<const uint8_t*>(data_ref.data);
const PrimitiveType type =
-
TabletColumn::get_primitive_type_by_field_type(static_cast<FieldType>(*start_data));
+
storage_field_type_to_primitive_type(static_cast<FieldType>(*start_data));
auto check_end = [&](const uint8_t* end_ptr) {
DCHECK_EQ(end_ptr - reinterpret_cast<const uint8_t*>(data_ref.data),
data_ref.size);
};
diff --git a/be/src/core/data_type/data_type.cpp
b/be/src/core/data_type/data_type.cpp
index 94f7b6c38c9..941a0377b05 100644
--- a/be/src/core/data_type/data_type.cpp
+++ b/be/src/core/data_type/data_type.cpp
@@ -32,9 +32,9 @@
#include "core/column/column.h"
#include "core/column/column_const.h"
#include "core/data_type/define_primitive_type.h"
+#include "core/data_type/storage_field_type.h"
#include "core/data_type_serde/data_type_serde.h"
#include "core/field.h"
-#include "storage/tablet/tablet_schema.h"
namespace doris {
class BufferWritable;
@@ -47,7 +47,7 @@ IDataType::IDataType() = default;
IDataType::~IDataType() = default;
doris::FieldType IDataType::get_storage_field_type() const {
- return TabletColumn::get_field_type_by_type(get_primitive_type());
+ return primitive_type_to_storage_field_type(get_primitive_type());
}
String IDataType::get_name() const {
diff --git a/be/src/core/data_type/data_type.h
b/be/src/core/data_type/data_type.h
index 253bd8e49f9..e1042bf4161 100644
--- a/be/src/core/data_type/data_type.h
+++ b/be/src/core/data_type/data_type.h
@@ -38,6 +38,7 @@
#include "core/cow.h"
#include "core/data_type/define_primitive_type.h"
#include "core/data_type/primitive_type.h"
+#include "core/data_type/storage_field_type.h"
#include "core/data_type_serde/data_type_serde.h"
#include "core/types.h"
diff --git a/be/src/core/data_type/define_primitive_type.h
b/be/src/core/data_type/define_primitive_type.h
index b47218afc1b..852b68a96b5 100644
--- a/be/src/core/data_type/define_primitive_type.h
+++ b/be/src/core/data_type/define_primitive_type.h
@@ -23,6 +23,9 @@ namespace doris {
using PrimitiveNative = uint8_t;
+// Compute-layer types. When adding a new value, decide how it maps to
FieldType and explicitly
+// define its behavior in primitive_type_to_storage_field_type() and
+// storage_field_type_to_primitive_type(), either by providing a mapping or by
throwing.
enum PrimitiveType : PrimitiveNative {
INVALID_TYPE = 0,
TYPE_NULL, /* 1 */
diff --git a/be/src/core/data_type/storage_field_type.cpp
b/be/src/core/data_type/storage_field_type.cpp
new file mode 100644
index 00000000000..269015401dc
--- /dev/null
+++ b/be/src/core/data_type/storage_field_type.cpp
@@ -0,0 +1,202 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "core/data_type/storage_field_type.h"
+
+#include "common/exception.h"
+#include "storage/olap_common.h"
+
+namespace doris {
+
+// NOLINTNEXTLINE(readability-function-size): keep the exhaustive mapping
together for auditability.
+FieldType primitive_type_to_storage_field_type(PrimitiveType type) {
+ switch (type) {
+ case PrimitiveType::INVALID_TYPE:
+ return FieldType::OLAP_FIELD_TYPE_UNKNOWN;
+ case PrimitiveType::TYPE_NULL:
+ return FieldType::OLAP_FIELD_TYPE_NONE;
+ case PrimitiveType::TYPE_BOOLEAN:
+ return FieldType::OLAP_FIELD_TYPE_BOOL;
+ case PrimitiveType::TYPE_TINYINT:
+ return FieldType::OLAP_FIELD_TYPE_TINYINT;
+ case PrimitiveType::TYPE_SMALLINT:
+ return FieldType::OLAP_FIELD_TYPE_SMALLINT;
+ case PrimitiveType::TYPE_INT:
+ return FieldType::OLAP_FIELD_TYPE_INT;
+ case PrimitiveType::TYPE_BIGINT:
+ return FieldType::OLAP_FIELD_TYPE_BIGINT;
+ case PrimitiveType::TYPE_LARGEINT:
+ return FieldType::OLAP_FIELD_TYPE_LARGEINT;
+ case PrimitiveType::TYPE_FLOAT:
+ return FieldType::OLAP_FIELD_TYPE_FLOAT;
+ case PrimitiveType::TYPE_DOUBLE:
+ return FieldType::OLAP_FIELD_TYPE_DOUBLE;
+ case PrimitiveType::TYPE_VARCHAR:
+ return FieldType::OLAP_FIELD_TYPE_VARCHAR;
+ case PrimitiveType::TYPE_DATE:
+ return FieldType::OLAP_FIELD_TYPE_DATE;
+ case PrimitiveType::TYPE_DATETIME:
+ return FieldType::OLAP_FIELD_TYPE_DATETIME;
+ case PrimitiveType::TYPE_CHAR:
+ return FieldType::OLAP_FIELD_TYPE_CHAR;
+ case PrimitiveType::TYPE_STRUCT:
+ return FieldType::OLAP_FIELD_TYPE_STRUCT;
+ case PrimitiveType::TYPE_ARRAY:
+ return FieldType::OLAP_FIELD_TYPE_ARRAY;
+ case PrimitiveType::TYPE_MAP:
+ return FieldType::OLAP_FIELD_TYPE_MAP;
+ case PrimitiveType::TYPE_HLL:
+ return FieldType::OLAP_FIELD_TYPE_HLL;
+ case PrimitiveType::TYPE_DECIMALV2:
+ return FieldType::OLAP_FIELD_TYPE_DECIMAL;
+ case PrimitiveType::TYPE_BITMAP:
+ return FieldType::OLAP_FIELD_TYPE_BITMAP;
+ case PrimitiveType::TYPE_STRING:
+ return FieldType::OLAP_FIELD_TYPE_STRING;
+ case PrimitiveType::TYPE_QUANTILE_STATE:
+ return FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE;
+ case PrimitiveType::TYPE_DATEV2:
+ return FieldType::OLAP_FIELD_TYPE_DATEV2;
+ case PrimitiveType::TYPE_DATETIMEV2:
+ return FieldType::OLAP_FIELD_TYPE_DATETIMEV2;
+ case PrimitiveType::TYPE_TIMEV2:
+ return FieldType::OLAP_FIELD_TYPE_TIMEV2;
+ case PrimitiveType::TYPE_DECIMAL32:
+ return FieldType::OLAP_FIELD_TYPE_DECIMAL32;
+ case PrimitiveType::TYPE_DECIMAL64:
+ return FieldType::OLAP_FIELD_TYPE_DECIMAL64;
+ case PrimitiveType::TYPE_DECIMAL128I:
+ return FieldType::OLAP_FIELD_TYPE_DECIMAL128I;
+ case PrimitiveType::TYPE_JSONB:
+ return FieldType::OLAP_FIELD_TYPE_JSONB;
+ case PrimitiveType::TYPE_VARIANT:
+ return FieldType::OLAP_FIELD_TYPE_VARIANT;
+ case PrimitiveType::TYPE_AGG_STATE:
+ return FieldType::OLAP_FIELD_TYPE_AGG_STATE;
+ case PrimitiveType::TYPE_DECIMAL256:
+ return FieldType::OLAP_FIELD_TYPE_DECIMAL256;
+ case PrimitiveType::TYPE_IPV4:
+ return FieldType::OLAP_FIELD_TYPE_IPV4;
+ case PrimitiveType::TYPE_IPV6:
+ return FieldType::OLAP_FIELD_TYPE_IPV6;
+ case PrimitiveType::TYPE_UINT32:
+ return FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT;
+ case PrimitiveType::TYPE_UINT64:
+ return FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT;
+ case PrimitiveType::TYPE_TIMESTAMPTZ:
+ return FieldType::OLAP_FIELD_TYPE_TIMESTAMPTZ;
+ case PrimitiveType::TYPE_BINARY:
+ case static_cast<PrimitiveType>(14): // TYPE_DECIMAL (deprecated)
+ case static_cast<PrimitiveType>(21): // TYPE_TIME (deprecated)
+ case static_cast<PrimitiveType>(33): // TYPE_LAMBDA_FUNCTION (deprecated)
+ case PrimitiveType::TYPE_FIXED_LENGTH_OBJECT:
+ case PrimitiveType::TYPE_VARBINARY:
+ break;
+ }
+
+ throw Exception(ErrorCode::INTERNAL_ERROR, "Cannot convert PrimitiveType
{} to FieldType",
+ static_cast<int>(type));
+}
+
+// NOLINTNEXTLINE(readability-function-size): keep the exhaustive mapping
together for auditability.
+PrimitiveType storage_field_type_to_primitive_type(FieldType type) {
+ switch (type) {
+ case FieldType::OLAP_FIELD_TYPE_TINYINT:
+ return PrimitiveType::TYPE_TINYINT;
+ case FieldType::OLAP_FIELD_TYPE_SMALLINT:
+ return PrimitiveType::TYPE_SMALLINT;
+ case FieldType::OLAP_FIELD_TYPE_INT:
+ return PrimitiveType::TYPE_INT;
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT:
+ return PrimitiveType::TYPE_UINT32;
+ case FieldType::OLAP_FIELD_TYPE_BIGINT:
+ return PrimitiveType::TYPE_BIGINT;
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT:
+ return PrimitiveType::TYPE_UINT64;
+ case FieldType::OLAP_FIELD_TYPE_LARGEINT:
+ return PrimitiveType::TYPE_LARGEINT;
+ case FieldType::OLAP_FIELD_TYPE_FLOAT:
+ return PrimitiveType::TYPE_FLOAT;
+ case FieldType::OLAP_FIELD_TYPE_DOUBLE:
+ return PrimitiveType::TYPE_DOUBLE;
+ case FieldType::OLAP_FIELD_TYPE_CHAR:
+ return PrimitiveType::TYPE_CHAR;
+ case FieldType::OLAP_FIELD_TYPE_DATE:
+ return PrimitiveType::TYPE_DATE;
+ case FieldType::OLAP_FIELD_TYPE_DATETIME:
+ return PrimitiveType::TYPE_DATETIME;
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL:
+ return PrimitiveType::TYPE_DECIMALV2;
+ case FieldType::OLAP_FIELD_TYPE_VARCHAR:
+ return PrimitiveType::TYPE_VARCHAR;
+ case FieldType::OLAP_FIELD_TYPE_STRUCT:
+ return PrimitiveType::TYPE_STRUCT;
+ case FieldType::OLAP_FIELD_TYPE_ARRAY:
+ return PrimitiveType::TYPE_ARRAY;
+ case FieldType::OLAP_FIELD_TYPE_MAP:
+ return PrimitiveType::TYPE_MAP;
+ case FieldType::OLAP_FIELD_TYPE_UNKNOWN:
+ return PrimitiveType::INVALID_TYPE;
+ case FieldType::OLAP_FIELD_TYPE_NONE:
+ return PrimitiveType::TYPE_NULL;
+ case FieldType::OLAP_FIELD_TYPE_HLL:
+ return PrimitiveType::TYPE_HLL;
+ case FieldType::OLAP_FIELD_TYPE_BOOL:
+ return PrimitiveType::TYPE_BOOLEAN;
+ case FieldType::OLAP_FIELD_TYPE_BITMAP:
+ return PrimitiveType::TYPE_BITMAP;
+ case FieldType::OLAP_FIELD_TYPE_STRING:
+ return PrimitiveType::TYPE_STRING;
+ case FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE:
+ return PrimitiveType::TYPE_QUANTILE_STATE;
+ case FieldType::OLAP_FIELD_TYPE_DATEV2:
+ return PrimitiveType::TYPE_DATEV2;
+ case FieldType::OLAP_FIELD_TYPE_DATETIMEV2:
+ return PrimitiveType::TYPE_DATETIMEV2;
+ case FieldType::OLAP_FIELD_TYPE_TIMEV2:
+ return PrimitiveType::TYPE_TIMEV2;
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL32:
+ return PrimitiveType::TYPE_DECIMAL32;
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL64:
+ return PrimitiveType::TYPE_DECIMAL64;
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL128I:
+ return PrimitiveType::TYPE_DECIMAL128I;
+ case FieldType::OLAP_FIELD_TYPE_JSONB:
+ return PrimitiveType::TYPE_JSONB;
+ case FieldType::OLAP_FIELD_TYPE_VARIANT:
+ return PrimitiveType::TYPE_VARIANT;
+ case FieldType::OLAP_FIELD_TYPE_AGG_STATE:
+ return PrimitiveType::TYPE_AGG_STATE;
+ case FieldType::OLAP_FIELD_TYPE_DECIMAL256:
+ return PrimitiveType::TYPE_DECIMAL256;
+ case FieldType::OLAP_FIELD_TYPE_IPV4:
+ return PrimitiveType::TYPE_IPV4;
+ case FieldType::OLAP_FIELD_TYPE_IPV6:
+ return PrimitiveType::TYPE_IPV6;
+ case FieldType::OLAP_FIELD_TYPE_TIMESTAMPTZ:
+ return PrimitiveType::TYPE_TIMESTAMPTZ;
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT:
+ case FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT:
+ case FieldType::OLAP_FIELD_TYPE_DISCRETE_DOUBLE:
+ break;
+ }
+
+ throw Exception(ErrorCode::INTERNAL_ERROR, "Cannot convert FieldType {} to
PrimitiveType",
+ static_cast<int>(type));
+}
+
+} // namespace doris
diff --git a/be/src/core/data_type/storage_field_type.h
b/be/src/core/data_type/storage_field_type.h
new file mode 100644
index 00000000000..a1d48e53eea
--- /dev/null
+++ b/be/src/core/data_type/storage_field_type.h
@@ -0,0 +1,32 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#pragma once
+
+#include "core/data_type/define_primitive_type.h"
+
+namespace doris {
+
+enum class FieldType;
+
+// Throws Exception when the primitive type has no storage field type mapping.
+[[nodiscard]] FieldType primitive_type_to_storage_field_type(PrimitiveType
type);
+
+// Throws Exception when the storage field type has no primitive type mapping.
+[[nodiscard]] PrimitiveType storage_field_type_to_primitive_type(FieldType
type);
+
+} // namespace doris
diff --git a/be/src/core/data_type_serde/data_type_decimal_serde.cpp
b/be/src/core/data_type_serde/data_type_decimal_serde.cpp
index 35208450c39..221213b899a 100644
--- a/be/src/core/data_type_serde/data_type_decimal_serde.cpp
+++ b/be/src/core/data_type_serde/data_type_decimal_serde.cpp
@@ -33,6 +33,7 @@
#include "core/column/column_decimal.h"
#include "core/data_type/data_type_decimal.h"
#include "core/data_type/define_primitive_type.h"
+#include "core/data_type/storage_field_type.h"
#include "core/data_type_serde/arrow_validation.h"
#include "core/data_type_serde/decoded_column_view.h"
#include "core/types.h"
@@ -40,7 +41,6 @@
#include "exprs/function/cast/cast_to_decimal.h"
#include "exprs/function/cast/cast_to_string.h"
#include "orc/Int128.hh"
-#include "storage/tablet/tablet_schema.h"
#include "util/jsonb_document.h"
#include "util/jsonb_document_cast.h"
#include "util/jsonb_writer.h"
@@ -853,7 +853,7 @@ template <PrimitiveType T>
void DataTypeDecimalSerDe<T>::write_one_cell_to_binary(const IColumn&
src_column,
ColumnString::Chars&
chars,
int64_t row_num) const {
- const uint8_t type = (const
uint8_t)TabletColumn::get_field_type_by_type(T);
+ const uint8_t type =
static_cast<uint8_t>(primitive_type_to_storage_field_type(T));
const auto& data_ref = assert_cast<const
ColumnDecimal<T>&>(src_column).get_data_at(row_num);
const auto& prec = static_cast<uint8_t>(precision);
const auto& sc = static_cast<uint8_t>(scale);
diff --git a/be/src/core/data_type_serde/data_type_number_serde.cpp
b/be/src/core/data_type_serde/data_type_number_serde.cpp
index 55b156b01f9..6d589637f8a 100644
--- a/be/src/core/data_type_serde/data_type_number_serde.cpp
+++ b/be/src/core/data_type_serde/data_type_number_serde.cpp
@@ -29,6 +29,7 @@
#include "core/column/column_nullable.h"
#include "core/data_type/define_primitive_type.h"
#include "core/data_type/primitive_type.h"
+#include "core/data_type/storage_field_type.h"
#include "core/data_type_serde/arrow_validation.h"
#include "core/data_type_serde/data_type_serde.h"
#include "core/data_type_serde/decoded_column_view.h"
@@ -1124,7 +1125,7 @@ template <PrimitiveType T>
void DataTypeNumberSerDe<T>::write_one_cell_to_binary(const IColumn&
src_column,
ColumnString::Chars&
chars,
int64_t row_num) const {
- const uint8_t type = (const
uint8_t)TabletColumn::get_field_type_by_type(T);
+ const uint8_t type =
static_cast<uint8_t>(primitive_type_to_storage_field_type(T));
const auto& data_ref = assert_cast<const
ColumnType&>(src_column).get_data_at(row_num);
const size_t old_size = chars.size();
diff --git a/be/src/core/data_type_serde/data_type_serde.cpp
b/be/src/core/data_type_serde/data_type_serde.cpp
index 16526bc172b..6c41b4e9f14 100644
--- a/be/src/core/data_type_serde/data_type_serde.cpp
+++ b/be/src/core/data_type_serde/data_type_serde.cpp
@@ -42,6 +42,7 @@
#include "core/data_type/data_type_map.h"
#include "core/data_type/data_type_nullable.h"
#include "core/data_type/data_type_struct.h"
+#include "core/data_type/storage_field_type.h"
#include "core/data_type_serde/data_type_array_serde.h"
#include "core/data_type_serde/data_type_datetimev2_serde.h"
#include "core/data_type_serde/data_type_datev2_serde.h"
@@ -57,6 +58,7 @@
#include "core/value/vdatetime_value.h"
#include "exprs/function/cast/cast_base.h"
#include "runtime/descriptors.h"
+#include "storage/olap_common.h"
#include "util/jsonb_document.h"
#include "util/jsonb_writer.h"
namespace doris {
@@ -1130,7 +1132,7 @@ const uint8_t*
DataTypeSerDe::deserialize_binary_to_column(const uint8_t* data,
const uint8_t* DataTypeSerDe::deserialize_binary_to_field(const uint8_t* data,
Field& field,
FieldInfo& info) {
const FieldType type = static_cast<FieldType>(*data++);
- info.scalar_type_id = TabletColumn::get_primitive_type_by_field_type(type);
+ info.scalar_type_id = storage_field_type_to_primitive_type(type);
const uint8_t* end = data;
switch (type) {
#define HANDLE_SIMPLE_SERDE(FT, SERDE) \
diff --git a/be/src/exec/common/variant_util.cpp
b/be/src/exec/common/variant_util.cpp
index 4ba50f5f57d..86c274875da 100644
--- a/be/src/exec/common/variant_util.cpp
+++ b/be/src/exec/common/variant_util.cpp
@@ -72,6 +72,7 @@
#include "core/data_type/define_primitive_type.h"
#include "core/data_type/get_least_supertype.h"
#include "core/data_type/primitive_type.h"
+#include "core/data_type/storage_field_type.h"
#include "core/field.h"
#include "core/typeid_cast.h"
#include "core/types.h"
@@ -1902,26 +1903,26 @@ static void append_field_to_binary_chars(const Field&
field, ColumnString::Chars
}
case PrimitiveType::TYPE_BOOLEAN: {
append_binary_type(chars,
-
TabletColumn::get_field_type_by_type(PrimitiveType::TYPE_BOOLEAN));
+
primitive_type_to_storage_field_type(PrimitiveType::TYPE_BOOLEAN));
const auto v =
static_cast<UInt8>(field.get<PrimitiveType::TYPE_BOOLEAN>());
append_binary_bytes(chars, &v, sizeof(UInt8));
return;
}
case PrimitiveType::TYPE_BIGINT: {
- append_binary_type(chars,
TabletColumn::get_field_type_by_type(PrimitiveType::TYPE_BIGINT));
+ append_binary_type(chars,
primitive_type_to_storage_field_type(PrimitiveType::TYPE_BIGINT));
const auto v = field.get<PrimitiveType::TYPE_BIGINT>();
append_binary_bytes(chars, &v, sizeof(Int64));
return;
}
case PrimitiveType::TYPE_LARGEINT: {
append_binary_type(chars,
-
TabletColumn::get_field_type_by_type(PrimitiveType::TYPE_LARGEINT));
+
primitive_type_to_storage_field_type(PrimitiveType::TYPE_LARGEINT));
const auto v = field.get<PrimitiveType::TYPE_LARGEINT>();
append_binary_bytes(chars, &v, sizeof(int128_t));
return;
}
case PrimitiveType::TYPE_DOUBLE: {
- append_binary_type(chars,
TabletColumn::get_field_type_by_type(PrimitiveType::TYPE_DOUBLE));
+ append_binary_type(chars,
primitive_type_to_storage_field_type(PrimitiveType::TYPE_DOUBLE));
const auto v = field.get<PrimitiveType::TYPE_DOUBLE>();
append_binary_bytes(chars, &v, sizeof(Float64));
return;
diff --git a/be/src/storage/olap_common.h b/be/src/storage/olap_common.h
index b34f6ce15ea..c13963b3bff 100644
--- a/be/src/storage/olap_common.h
+++ b/be/src/storage/olap_common.h
@@ -122,7 +122,9 @@ struct TabletSize {
// Storage-engine cell types, used by TabletColumn / KeyCoder and the
// data_type traits chain. When adding a new value, also extend CppTypeTraits,
-// FieldTypeTraits and the field_type_size() switch in storage/types.h.
+// FieldTypeTraits and the field_type_size() switch in storage/types.h. Decide
how it maps to
+// PrimitiveType and explicitly define its behavior in
primitive_type_to_storage_field_type() and
+// storage_field_type_to_primitive_type(), either by providing a mapping or by
throwing.
enum class FieldType {
OLAP_FIELD_TYPE_TINYINT = 1, // MYSQL_TYPE_TINY
OLAP_FIELD_TYPE_UNSIGNED_TINYINT = 2,
diff --git a/be/src/storage/segment/column_reader.h
b/be/src/storage/segment/column_reader.h
index 777f8eddf02..327c44c4fee 100644
--- a/be/src/storage/segment/column_reader.h
+++ b/be/src/storage/segment/column_reader.h
@@ -37,6 +37,7 @@
#include "common/status.h" // for Status
#include "core/column/column_array.h" // ColumnArray
#include "core/data_type/data_type.h"
+#include "core/data_type/storage_field_type.h"
#include "io/cache/cached_remote_file_reader.h"
#include "io/fs/file_reader_writer_fwd.h"
#include "io/io_common.h"
@@ -1094,7 +1095,7 @@ public:
// when config::enable_column_type_check is on (default true), so derive
the real OLAP type from
// the constant value to avoid a spurious "different type between schema
and column reader" error.
FieldType get_meta_type() override {
- return TabletColumn::get_field_type_by_type(_value.get_type());
+ return primitive_type_to_storage_field_type(_value.get_type());
}
Status match_condition(const AndBlockColumnPredicate* col_predicates,
diff --git a/be/src/storage/tablet/tablet_schema.cpp
b/be/src/storage/tablet/tablet_schema.cpp
index 3158b229837..8dec9913f88 100644
--- a/be/src/storage/tablet/tablet_schema.cpp
+++ b/be/src/storage/tablet/tablet_schema.cpp
@@ -55,134 +55,6 @@
#include "util/json/path_in_data.h"
namespace doris {
-FieldType TabletColumn::get_field_type_by_type(PrimitiveType primitiveType) {
- switch (primitiveType) {
- case PrimitiveType::INVALID_TYPE:
- return FieldType::OLAP_FIELD_TYPE_UNKNOWN;
- case PrimitiveType::TYPE_NULL:
- return FieldType::OLAP_FIELD_TYPE_NONE;
- case PrimitiveType::TYPE_BOOLEAN:
- return FieldType::OLAP_FIELD_TYPE_BOOL;
- case PrimitiveType::TYPE_TINYINT:
- return FieldType::OLAP_FIELD_TYPE_TINYINT;
- case PrimitiveType::TYPE_SMALLINT:
- return FieldType::OLAP_FIELD_TYPE_SMALLINT;
- case PrimitiveType::TYPE_INT:
- return FieldType::OLAP_FIELD_TYPE_INT;
- case PrimitiveType::TYPE_BIGINT:
- return FieldType::OLAP_FIELD_TYPE_BIGINT;
- case PrimitiveType::TYPE_LARGEINT:
- return FieldType::OLAP_FIELD_TYPE_LARGEINT;
- case PrimitiveType::TYPE_FLOAT:
- return FieldType::OLAP_FIELD_TYPE_FLOAT;
- case PrimitiveType::TYPE_DOUBLE:
- return FieldType::OLAP_FIELD_TYPE_DOUBLE;
- case PrimitiveType::TYPE_VARCHAR:
- return FieldType::OLAP_FIELD_TYPE_VARCHAR;
- case PrimitiveType::TYPE_DATE:
- return FieldType::OLAP_FIELD_TYPE_DATE;
- case PrimitiveType::TYPE_DATETIME:
- return FieldType::OLAP_FIELD_TYPE_DATETIME;
- case PrimitiveType::TYPE_BINARY:
- return FieldType::OLAP_FIELD_TYPE_UNKNOWN; // Not implemented
- case PrimitiveType::TYPE_CHAR:
- return FieldType::OLAP_FIELD_TYPE_CHAR;
- case PrimitiveType::TYPE_STRUCT:
- return FieldType::OLAP_FIELD_TYPE_STRUCT;
- case PrimitiveType::TYPE_ARRAY:
- return FieldType::OLAP_FIELD_TYPE_ARRAY;
- case PrimitiveType::TYPE_MAP:
- return FieldType::OLAP_FIELD_TYPE_MAP;
- case PrimitiveType::TYPE_HLL:
- return FieldType::OLAP_FIELD_TYPE_HLL;
- case PrimitiveType::TYPE_DECIMALV2:
- return FieldType::OLAP_FIELD_TYPE_UNKNOWN; // Not implemented
- case PrimitiveType::TYPE_BITMAP:
- return FieldType::OLAP_FIELD_TYPE_BITMAP;
- case PrimitiveType::TYPE_STRING:
- return FieldType::OLAP_FIELD_TYPE_STRING;
- case PrimitiveType::TYPE_QUANTILE_STATE:
- return FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE;
- case PrimitiveType::TYPE_DATEV2:
- return FieldType::OLAP_FIELD_TYPE_DATEV2;
- case PrimitiveType::TYPE_DATETIMEV2:
- return FieldType::OLAP_FIELD_TYPE_DATETIMEV2;
- case PrimitiveType::TYPE_TIMESTAMPTZ:
- return FieldType::OLAP_FIELD_TYPE_TIMESTAMPTZ;
- case PrimitiveType::TYPE_TIMEV2:
- return FieldType::OLAP_FIELD_TYPE_TIMEV2;
- case PrimitiveType::TYPE_DECIMAL32:
- return FieldType::OLAP_FIELD_TYPE_DECIMAL32;
- case PrimitiveType::TYPE_DECIMAL64:
- return FieldType::OLAP_FIELD_TYPE_DECIMAL64;
- case PrimitiveType::TYPE_DECIMAL128I:
- return FieldType::OLAP_FIELD_TYPE_DECIMAL128I;
- case PrimitiveType::TYPE_DECIMAL256:
- return FieldType::OLAP_FIELD_TYPE_DECIMAL256;
- case PrimitiveType::TYPE_JSONB:
- return FieldType::OLAP_FIELD_TYPE_JSONB;
- case PrimitiveType::TYPE_VARIANT:
- return FieldType::OLAP_FIELD_TYPE_VARIANT;
- case PrimitiveType::TYPE_IPV4:
- return FieldType::OLAP_FIELD_TYPE_IPV4;
- case PrimitiveType::TYPE_IPV6:
- return FieldType::OLAP_FIELD_TYPE_IPV6;
- case PrimitiveType::TYPE_AGG_STATE:
- return FieldType::OLAP_FIELD_TYPE_AGG_STATE;
- default:
- return FieldType::OLAP_FIELD_TYPE_UNKNOWN;
- }
-}
-
-PrimitiveType TabletColumn::get_primitive_type_by_field_type(FieldType type) {
- static const PrimitiveType mapping[] = {
- /* 0 */ PrimitiveType::INVALID_TYPE,
- /* 1 OLAP_FIELD_TYPE_TINYINT */
PrimitiveType::TYPE_TINYINT,
- /* 2 OLAP_FIELD_TYPE_UNSIGNED_TINYINT */
PrimitiveType::INVALID_TYPE,
- /* 3 OLAP_FIELD_TYPE_SMALLINT */
PrimitiveType::TYPE_SMALLINT,
- /* 4 OLAP_FIELD_TYPE_UNSIGNED_SMALLINT */
PrimitiveType::INVALID_TYPE,
- /* 5 OLAP_FIELD_TYPE_INT */ PrimitiveType::TYPE_INT,
- /* 6 OLAP_FIELD_TYPE_UNSIGNED_INT */
PrimitiveType::INVALID_TYPE,
- /* 7 OLAP_FIELD_TYPE_BIGINT */
PrimitiveType::TYPE_BIGINT,
- /* 8 OLAP_FIELD_TYPE_UNSIGNED_BIGINT */
PrimitiveType::INVALID_TYPE,
- /* 9 OLAP_FIELD_TYPE_LARGEINT */
PrimitiveType::TYPE_LARGEINT,
- /* 10 OLAP_FIELD_TYPE_FLOAT */
PrimitiveType::TYPE_FLOAT,
- /* 11 OLAP_FIELD_TYPE_DOUBLE */
PrimitiveType::TYPE_DOUBLE,
- /* 12 OLAP_FIELD_TYPE_DISCRETE_DOUBLE */
PrimitiveType::INVALID_TYPE,
- /* 13 OLAP_FIELD_TYPE_CHAR */
PrimitiveType::TYPE_CHAR,
- /* 14 OLAP_FIELD_TYPE_DATE */
PrimitiveType::TYPE_DATE,
- /* 15 OLAP_FIELD_TYPE_DATETIME */
PrimitiveType::TYPE_DATETIME,
- /* 16 OLAP_FIELD_TYPE_DECIMAL */
PrimitiveType::INVALID_TYPE,
- /* 17 OLAP_FIELD_TYPE_VARCHAR */
PrimitiveType::TYPE_VARCHAR,
- /* 18 OLAP_FIELD_TYPE_STRUCT */
PrimitiveType::TYPE_STRUCT,
- /* 19 OLAP_FIELD_TYPE_ARRAY */
PrimitiveType::TYPE_ARRAY,
- /* 20 OLAP_FIELD_TYPE_MAP */ PrimitiveType::TYPE_MAP,
- /* 21 OLAP_FIELD_TYPE_UNKNOWN */
PrimitiveType::INVALID_TYPE,
- /* 22 OLAP_FIELD_TYPE_NONE */
PrimitiveType::TYPE_NULL,
- /* 23 OLAP_FIELD_TYPE_HLL */ PrimitiveType::TYPE_HLL,
- /* 24 OLAP_FIELD_TYPE_BOOL */
PrimitiveType::TYPE_BOOLEAN,
- /* 25 OLAP_FIELD_TYPE_BITMAP */
PrimitiveType::TYPE_BITMAP,
- /* 26 OLAP_FIELD_TYPE_STRING */
PrimitiveType::TYPE_STRING,
- /* 27 OLAP_FIELD_TYPE_QUANTILE_STATE */
PrimitiveType::TYPE_QUANTILE_STATE,
- /* 28 OLAP_FIELD_TYPE_DATEV2 */
PrimitiveType::TYPE_DATEV2,
- /* 29 OLAP_FIELD_TYPE_DATETIMEV2 */
PrimitiveType::TYPE_DATETIMEV2,
- /* 30 OLAP_FIELD_TYPE_TIMEV2 */
PrimitiveType::TYPE_TIMEV2,
- /* 31 OLAP_FIELD_TYPE_DECIMAL32 */
PrimitiveType::TYPE_DECIMAL32,
- /* 32 OLAP_FIELD_TYPE_DECIMAL64 */
PrimitiveType::TYPE_DECIMAL64,
- /* 33 OLAP_FIELD_TYPE_DECIMAL128I */
PrimitiveType::TYPE_DECIMAL128I,
- /* 34 OLAP_FIELD_TYPE_JSONB */
PrimitiveType::TYPE_JSONB,
- /* 35 OLAP_FIELD_TYPE_VARIANT */
PrimitiveType::TYPE_VARIANT,
- /* 36 OLAP_FIELD_TYPE_AGG_STATE */
PrimitiveType::TYPE_AGG_STATE,
- /* 37 OLAP_FIELD_TYPE_DECIMAL256 */
PrimitiveType::TYPE_DECIMAL256,
- /* 38 OLAP_FIELD_TYPE_IPV4 */
PrimitiveType::TYPE_IPV4,
- /* 39 OLAP_FIELD_TYPE_IPV6 */
PrimitiveType::TYPE_IPV6,
- /* 40 OLAP_FIELD_TYPE_TIMESTAMPTZ */
PrimitiveType::TYPE_TIMESTAMPTZ,
- };
-
- int idx = static_cast<int>(type);
- return mapping[idx];
-}
-
FieldType TabletColumn::get_field_type_by_string(const std::string& type_str) {
std::string upper_type_str = type_str;
std::transform(type_str.begin(), type_str.end(), upper_type_str.begin(),
@@ -238,6 +110,8 @@ FieldType TabletColumn::get_field_type_by_string(const
std::string& type_str) {
} else if (0 == upper_type_str.compare("DECIMAL256")) {
type = FieldType::OLAP_FIELD_TYPE_DECIMAL256;
} else if (0 == upper_type_str.compare(0, 7, "DECIMAL")) {
+ // Keep this generic prefix match after all specific DECIMAL types;
otherwise DECIMAL32,
+ // DECIMAL64, DECIMAL128I, and DECIMAL256 would all be classified as
DECIMAL.
type = FieldType::OLAP_FIELD_TYPE_DECIMAL;
} else if (0 == upper_type_str.compare(0, 7, "VARCHAR")) {
type = FieldType::OLAP_FIELD_TYPE_VARCHAR;
diff --git a/be/src/storage/tablet/tablet_schema.h
b/be/src/storage/tablet/tablet_schema.h
index bf4598e2bb9..caa7c9b54f6 100644
--- a/be/src/storage/tablet/tablet_schema.h
+++ b/be/src/storage/tablet/tablet_schema.h
@@ -180,8 +180,6 @@ public:
static std::string get_string_by_field_type(FieldType type);
static std::string get_string_by_aggregation_type(FieldAggregationMethod
aggregation_type);
static FieldType get_field_type_by_string(const std::string& str);
- static FieldType get_field_type_by_type(PrimitiveType type);
- static PrimitiveType get_primitive_type_by_field_type(FieldType type);
static FieldAggregationMethod get_aggregation_type_by_string(const
std::string& str);
static uint32_t get_field_length_by_type(TPrimitiveType::type type,
uint32_t string_length);
bool is_row_store_column() const;
diff --git a/be/test/core/data_type/storage_field_type_test.cpp
b/be/test/core/data_type/storage_field_type_test.cpp
new file mode 100644
index 00000000000..af621ceb9c6
--- /dev/null
+++ b/be/test/core/data_type/storage_field_type_test.cpp
@@ -0,0 +1,171 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements. See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership. The ASF licenses this file
+// to you under the Apache License, Version 2.0 (the
+// "License"); you may not use this file except in compliance
+// with the License. You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing,
+// software distributed under the License is distributed on an
+// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+// KIND, either express or implied. See the License for the
+// specific language governing permissions and limitations
+// under the License.
+
+#include "core/data_type/storage_field_type.h"
+
+#include <gtest/gtest.h>
+
+#include <array>
+#include <cstddef>
+
+#include "common/exception.h"
+#include "storage/olap_common.h"
+
+namespace doris {
+
+namespace {
+
+struct TypePair {
+ PrimitiveType primitive_type;
+ FieldType field_type;
+};
+
+constexpr std::array supported_mappings {
+ TypePair {PrimitiveType::INVALID_TYPE,
FieldType::OLAP_FIELD_TYPE_UNKNOWN},
+ TypePair {PrimitiveType::TYPE_NULL, FieldType::OLAP_FIELD_TYPE_NONE},
+ TypePair {PrimitiveType::TYPE_BOOLEAN,
FieldType::OLAP_FIELD_TYPE_BOOL},
+ TypePair {PrimitiveType::TYPE_TINYINT,
FieldType::OLAP_FIELD_TYPE_TINYINT},
+ TypePair {PrimitiveType::TYPE_SMALLINT,
FieldType::OLAP_FIELD_TYPE_SMALLINT},
+ TypePair {PrimitiveType::TYPE_INT, FieldType::OLAP_FIELD_TYPE_INT},
+ TypePair {PrimitiveType::TYPE_BIGINT,
FieldType::OLAP_FIELD_TYPE_BIGINT},
+ TypePair {PrimitiveType::TYPE_LARGEINT,
FieldType::OLAP_FIELD_TYPE_LARGEINT},
+ TypePair {PrimitiveType::TYPE_FLOAT, FieldType::OLAP_FIELD_TYPE_FLOAT},
+ TypePair {PrimitiveType::TYPE_DOUBLE,
FieldType::OLAP_FIELD_TYPE_DOUBLE},
+ TypePair {PrimitiveType::TYPE_VARCHAR,
FieldType::OLAP_FIELD_TYPE_VARCHAR},
+ TypePair {PrimitiveType::TYPE_DATE, FieldType::OLAP_FIELD_TYPE_DATE},
+ TypePair {PrimitiveType::TYPE_DATETIME,
FieldType::OLAP_FIELD_TYPE_DATETIME},
+ TypePair {PrimitiveType::TYPE_CHAR, FieldType::OLAP_FIELD_TYPE_CHAR},
+ TypePair {PrimitiveType::TYPE_STRUCT,
FieldType::OLAP_FIELD_TYPE_STRUCT},
+ TypePair {PrimitiveType::TYPE_ARRAY, FieldType::OLAP_FIELD_TYPE_ARRAY},
+ TypePair {PrimitiveType::TYPE_MAP, FieldType::OLAP_FIELD_TYPE_MAP},
+ TypePair {PrimitiveType::TYPE_HLL, FieldType::OLAP_FIELD_TYPE_HLL},
+ TypePair {PrimitiveType::TYPE_DECIMALV2,
FieldType::OLAP_FIELD_TYPE_DECIMAL},
+ TypePair {PrimitiveType::TYPE_BITMAP,
FieldType::OLAP_FIELD_TYPE_BITMAP},
+ TypePair {PrimitiveType::TYPE_STRING,
FieldType::OLAP_FIELD_TYPE_STRING},
+ TypePair {PrimitiveType::TYPE_QUANTILE_STATE,
FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE},
+ TypePair {PrimitiveType::TYPE_DATEV2,
FieldType::OLAP_FIELD_TYPE_DATEV2},
+ TypePair {PrimitiveType::TYPE_DATETIMEV2,
FieldType::OLAP_FIELD_TYPE_DATETIMEV2},
+ TypePair {PrimitiveType::TYPE_TIMEV2,
FieldType::OLAP_FIELD_TYPE_TIMEV2},
+ TypePair {PrimitiveType::TYPE_DECIMAL32,
FieldType::OLAP_FIELD_TYPE_DECIMAL32},
+ TypePair {PrimitiveType::TYPE_DECIMAL64,
FieldType::OLAP_FIELD_TYPE_DECIMAL64},
+ TypePair {PrimitiveType::TYPE_DECIMAL128I,
FieldType::OLAP_FIELD_TYPE_DECIMAL128I},
+ TypePair {PrimitiveType::TYPE_JSONB, FieldType::OLAP_FIELD_TYPE_JSONB},
+ TypePair {PrimitiveType::TYPE_VARIANT,
FieldType::OLAP_FIELD_TYPE_VARIANT},
+ TypePair {PrimitiveType::TYPE_AGG_STATE,
FieldType::OLAP_FIELD_TYPE_AGG_STATE},
+ TypePair {PrimitiveType::TYPE_DECIMAL256,
FieldType::OLAP_FIELD_TYPE_DECIMAL256},
+ TypePair {PrimitiveType::TYPE_IPV4, FieldType::OLAP_FIELD_TYPE_IPV4},
+ TypePair {PrimitiveType::TYPE_IPV6, FieldType::OLAP_FIELD_TYPE_IPV6},
+ TypePair {PrimitiveType::TYPE_UINT32,
FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT},
+ TypePair {PrimitiveType::TYPE_UINT64,
FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT},
+ TypePair {PrimitiveType::TYPE_TIMESTAMPTZ,
FieldType::OLAP_FIELD_TYPE_TIMESTAMPTZ},
+};
+
+TEST(StorageFieldTypeTest, SupportedMappingsRoundTrip) {
+ for (const auto& [primitive_type, field_type] : supported_mappings) {
+ SCOPED_TRACE(static_cast<int>(primitive_type));
+ EXPECT_EQ(primitive_type_to_storage_field_type(primitive_type),
field_type);
+ EXPECT_EQ(storage_field_type_to_primitive_type(field_type),
primitive_type);
+ }
+}
+
+TEST(StorageFieldTypeTest, UnsupportedPrimitiveTypesThrow) {
+ constexpr std::array unsupported_types {
+ PrimitiveType::TYPE_BINARY,
+ static_cast<PrimitiveType>(14), // TYPE_DECIMAL (deprecated)
+ static_cast<PrimitiveType>(21), // TYPE_TIME (deprecated)
+ static_cast<PrimitiveType>(33), // TYPE_LAMBDA_FUNCTION
(deprecated)
+ PrimitiveType::TYPE_FIXED_LENGTH_OBJECT,
+ PrimitiveType::TYPE_VARBINARY,
+ static_cast<PrimitiveType>(43),
+ static_cast<PrimitiveType>(255),
+ };
+
+ for (const auto type : unsupported_types) {
+ SCOPED_TRACE(static_cast<int>(type));
+ EXPECT_THROW((void)primitive_type_to_storage_field_type(type),
Exception);
+ }
+}
+
+TEST(StorageFieldTypeTest, UnsupportedOrInvalidFieldTypesThrow) {
+ constexpr std::array unsupported_types {
+ FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT,
+ FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT,
+ FieldType::OLAP_FIELD_TYPE_DISCRETE_DOUBLE,
+ static_cast<FieldType>(-1),
+ static_cast<FieldType>(0),
+ static_cast<FieldType>(41),
+ static_cast<FieldType>(255),
+ };
+
+ for (const auto type : unsupported_types) {
+ SCOPED_TRACE(static_cast<int>(type));
+ EXPECT_THROW((void)storage_field_type_to_primitive_type(type),
Exception);
+ }
+}
+
+TEST(StorageFieldTypeTest, PersistedFieldTypeValuesStayStable) {
+ constexpr std::array persisted_types {
+ FieldType::OLAP_FIELD_TYPE_TINYINT,
+ FieldType::OLAP_FIELD_TYPE_UNSIGNED_TINYINT,
+ FieldType::OLAP_FIELD_TYPE_SMALLINT,
+ FieldType::OLAP_FIELD_TYPE_UNSIGNED_SMALLINT,
+ FieldType::OLAP_FIELD_TYPE_INT,
+ FieldType::OLAP_FIELD_TYPE_UNSIGNED_INT,
+ FieldType::OLAP_FIELD_TYPE_BIGINT,
+ FieldType::OLAP_FIELD_TYPE_UNSIGNED_BIGINT,
+ FieldType::OLAP_FIELD_TYPE_LARGEINT,
+ FieldType::OLAP_FIELD_TYPE_FLOAT,
+ FieldType::OLAP_FIELD_TYPE_DOUBLE,
+ FieldType::OLAP_FIELD_TYPE_DISCRETE_DOUBLE,
+ FieldType::OLAP_FIELD_TYPE_CHAR,
+ FieldType::OLAP_FIELD_TYPE_DATE,
+ FieldType::OLAP_FIELD_TYPE_DATETIME,
+ FieldType::OLAP_FIELD_TYPE_DECIMAL,
+ FieldType::OLAP_FIELD_TYPE_VARCHAR,
+ FieldType::OLAP_FIELD_TYPE_STRUCT,
+ FieldType::OLAP_FIELD_TYPE_ARRAY,
+ FieldType::OLAP_FIELD_TYPE_MAP,
+ FieldType::OLAP_FIELD_TYPE_UNKNOWN,
+ FieldType::OLAP_FIELD_TYPE_NONE,
+ FieldType::OLAP_FIELD_TYPE_HLL,
+ FieldType::OLAP_FIELD_TYPE_BOOL,
+ FieldType::OLAP_FIELD_TYPE_BITMAP,
+ FieldType::OLAP_FIELD_TYPE_STRING,
+ FieldType::OLAP_FIELD_TYPE_QUANTILE_STATE,
+ FieldType::OLAP_FIELD_TYPE_DATEV2,
+ FieldType::OLAP_FIELD_TYPE_DATETIMEV2,
+ FieldType::OLAP_FIELD_TYPE_TIMEV2,
+ FieldType::OLAP_FIELD_TYPE_DECIMAL32,
+ FieldType::OLAP_FIELD_TYPE_DECIMAL64,
+ FieldType::OLAP_FIELD_TYPE_DECIMAL128I,
+ FieldType::OLAP_FIELD_TYPE_JSONB,
+ FieldType::OLAP_FIELD_TYPE_VARIANT,
+ FieldType::OLAP_FIELD_TYPE_AGG_STATE,
+ FieldType::OLAP_FIELD_TYPE_DECIMAL256,
+ FieldType::OLAP_FIELD_TYPE_IPV4,
+ FieldType::OLAP_FIELD_TYPE_IPV6,
+ FieldType::OLAP_FIELD_TYPE_TIMESTAMPTZ,
+ };
+
+ for (size_t i = 0; i < persisted_types.size(); ++i) {
+ EXPECT_EQ(static_cast<size_t>(persisted_types[i]), i + 1);
+ }
+}
+
+} // namespace
+
+} // namespace doris
---------------------------------------------------------------------
To unsubscribe, e-mail: [email protected]
For additional commands, e-mail: [email protected]
