diff --git a/be/src/olap/comparison_predicate.h b/be/src/olap/comparison_predicate.h index 534c9f12a661f1..cfc738d36f49c6 100644 --- a/be/src/olap/comparison_predicate.h +++ b/be/src/olap/comparison_predicate.h @@ -171,13 +171,13 @@ class ComparisonPredicateBase final : public ColumnPredicate { T min_value; T max_value; if constexpr (is_string_type(Type)) { - auto& tmp_min = min_field.template get(); - auto& tmp_max = max_field.template get(); + auto& tmp_min = min_field.template get(); + auto& tmp_max = max_field.template get(); min_value = StringRef(tmp_min.data(), tmp_min.size()); max_value = StringRef(tmp_max.data(), tmp_max.size()); } else { - min_value = min_field.template get(); - max_value = max_field.template get(); + min_value = min_field.template get(); + max_value = max_field.template get(); } if constexpr (PT == PredicateType::EQ) { diff --git a/be/src/olap/in_list_predicate.h b/be/src/olap/in_list_predicate.h index 1d10cb213b7521..cbf62dc9753333 100644 --- a/be/src/olap/in_list_predicate.h +++ b/be/src/olap/in_list_predicate.h @@ -258,13 +258,13 @@ class InListPredicateBase final : public ColumnPredicate { T min_value; T max_value; if constexpr (is_string_type(Type)) { - auto& tmp_min = min_field.template get(); - auto& tmp_max = max_field.template get(); + auto& tmp_min = min_field.template get(); + auto& tmp_max = max_field.template get(); min_value = StringRef(tmp_min.data(), tmp_min.size()); max_value = StringRef(tmp_max.data(), tmp_max.size()); } else { - min_value = min_field.template get(); - max_value = max_field.template get(); + min_value = min_field.template get(); + max_value = max_field.template get(); } if constexpr (PT == PredicateType::IN_LIST) { diff --git a/be/src/olap/rowset/segment_v2/column_reader.cpp b/be/src/olap/rowset/segment_v2/column_reader.cpp index fa5299df2f0030..ca779b85f64513 100644 --- a/be/src/olap/rowset/segment_v2/column_reader.cpp +++ b/be/src/olap/rowset/segment_v2/column_reader.cpp @@ -345,7 +345,7 @@ void ColumnReader::check_data_by_zone_map_for_test(const vectorized::MutableColu vectorized::Field field; dst->get(i, field); DCHECK(!field.is_null()); - const auto v = field.get(); + const auto v = field.get(); DCHECK_GE(v, min_v); DCHECK_LE(v, max_v); } diff --git a/be/src/olap/rowset/segment_v2/inverted_index_reader.h b/be/src/olap/rowset/segment_v2/inverted_index_reader.h index 28184cd03b8e88..8e93ed87f21987 100644 --- a/be/src/olap/rowset/segment_v2/inverted_index_reader.h +++ b/be/src/olap/rowset/segment_v2/inverted_index_reader.h @@ -393,7 +393,7 @@ class InvertedIndexQueryParamFactory { if constexpr (is_string_type(PT)) { if constexpr (std::is_same_v) { - const auto& str = doris::vectorized::get(*value); + const auto& str = value->template get(); param->set_value(str); } else if constexpr (std::is_same_v) { param->set_value(value); @@ -405,7 +405,7 @@ class InvertedIndexQueryParamFactory { } else { CPP_TYPE cpp_val; if constexpr (std::is_same_v) { - auto field_val = value->template get::CppType>(); + auto field_val = value->template get(); cpp_val = static_cast(field_val); } else { cpp_val = static_cast(*value); diff --git a/be/src/runtime/decimalv2_value.h b/be/src/runtime/decimalv2_value.h index 01902b841ab37a..4412db5d021d19 100644 --- a/be/src/runtime/decimalv2_value.h +++ b/be/src/runtime/decimalv2_value.h @@ -28,6 +28,7 @@ #include #include +#include "runtime/define_primitive_type.h" #include "util/hash_util.hpp" #include "vec/core/extended_types.h" @@ -52,6 +53,7 @@ enum DecimalRoundMode { HALF_UP = 1, HALF_EVEN = 2, CEILING = 3, FLOOR = 4, TRUN class DecimalV2Value { public: + static constexpr PrimitiveType PType = TYPE_DECIMALV2; using NativeType = __int128_t; friend DecimalV2Value operator+(const DecimalV2Value& v1, const DecimalV2Value& v2); friend DecimalV2Value operator-(const DecimalV2Value& v1, const DecimalV2Value& v2); @@ -76,6 +78,7 @@ class DecimalV2Value { static const int128_t MAX_DECIMAL_VALUE = static_cast(MAX_INT64) * ONE_BILLION + MAX_FRAC_VALUE; + static constexpr int max_string_length() { return PRECISION + 1; } DecimalV2Value() = default; const int128_t& value() const { return _value; } diff --git a/be/src/runtime/primitive_type.h b/be/src/runtime/primitive_type.h index c503721cfe0e30..1eeea667392d39 100644 --- a/be/src/runtime/primitive_type.h +++ b/be/src/runtime/primitive_type.h @@ -275,7 +275,7 @@ template <> struct PrimitiveTypeTraits { using CppType = bool; using StorageFieldType = CppType; - using CppNativeType = bool; + using CppNativeType = CppType; using ColumnItemType = vectorized::UInt8; using DataType = vectorized::DataTypeBool; using ColumnType = vectorized::ColumnUInt8; @@ -424,7 +424,7 @@ struct PrimitiveTypeTraits { /// Different with compute layer, the DecimalV1 was stored as decimal12_t(12 bytes). using StorageFieldType = decimal12_t; using CppNativeType = vectorized::Int128; - using ColumnItemType = vectorized::Decimal128V2; + using ColumnItemType = CppType; using DataType = vectorized::DataTypeDecimalV2; using ColumnType = vectorized::ColumnDecimal128V2; }; diff --git a/be/src/runtime/runtime_predicate.cpp b/be/src/runtime/runtime_predicate.cpp index 40855755fe29d4..3a5ec350001557 100644 --- a/be/src/runtime/runtime_predicate.cpp +++ b/be/src/runtime/runtime_predicate.cpp @@ -77,33 +77,33 @@ Status RuntimePredicate::init_target( StringRef RuntimePredicate::_get_string_ref(const Field& field, const PrimitiveType type) { switch (type) { case PrimitiveType::TYPE_BOOLEAN: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_TINYINT: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_SMALLINT: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_INT: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_BIGINT: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_LARGEINT: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_CHAR: case PrimitiveType::TYPE_VARCHAR: case PrimitiveType::TYPE_STRING: { - const auto& v = field.get(); + const auto& v = field.get(); auto length = v.size(); char* buffer = _predicate_arena.alloc(length); memset(buffer, 0, length); @@ -112,61 +112,61 @@ StringRef RuntimePredicate::_get_string_ref(const Field& field, const PrimitiveT return {buffer, length}; } case PrimitiveType::TYPE_DATEV2: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_DATETIMEV2: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_TIMESTAMPTZ: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); break; } case PrimitiveType::TYPE_DATE: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_DATETIME: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_TIMEV2: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_DECIMAL32: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_DECIMAL64: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_DECIMALV2: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_DECIMAL128I: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_DECIMAL256: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_IPV4: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case PrimitiveType::TYPE_IPV6: { - const auto& v = field.get::CppType>(); + const auto& v = field.get(); return StringRef((char*)&v, sizeof(v)); } case doris::PrimitiveType::TYPE_VARBINARY: { // For VARBINARY type, use StringViewField to store binary data - const auto& v = field.get(); + const auto& v = field.get(); auto length = v.size(); char* buffer = _predicate_arena.alloc(length); memset(buffer, 0, length); diff --git a/be/src/vec/aggregate_functions/aggregate_function_avg.h b/be/src/vec/aggregate_functions/aggregate_function_avg.h index 9bba12b52e8390..e6031f7c26278b 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_avg.h +++ b/be/src/vec/aggregate_functions/aggregate_function_avg.h @@ -72,8 +72,7 @@ struct AggregateFunctionAvgData { DecimalV2Value decimal_val_count(count, 0); DecimalV2Value decimal_val_sum(sum * multiplier); DecimalV2Value cal_ret = decimal_val_sum / decimal_val_count; - Decimal128V2 ret(cal_ret.value()); - return ret; + return cal_ret; } else { if constexpr (T == TYPE_DECIMAL256) { return static_cast(sum * multiplier / @@ -127,10 +126,10 @@ class AggregateFunctionAvg final UnaryExpression, NullableAggregateFunction { public: - using ResultType = PrimitiveTypeTraits::ColumnItemType; - using ResultDataType = PrimitiveTypeTraits::DataType; - using ColVecType = PrimitiveTypeTraits::ColumnType; - using ColVecResult = PrimitiveTypeTraits::ColumnType; + using ResultType = typename PrimitiveTypeTraits::ColumnItemType; + using ResultDataType = typename PrimitiveTypeTraits::DataType; + using ColVecType = typename PrimitiveTypeTraits::ColumnType; + using ColVecResult = typename PrimitiveTypeTraits::ColumnType; // The result calculated by PercentileApprox is an approximate value, // so the underlying storage uses float. The following calls will involve // an implicit cast to float. @@ -175,14 +174,18 @@ class AggregateFunctionAvg final const auto& column = assert_cast(*columns[0]); if constexpr (is_add) { - if constexpr (is_decimal(T)) { + if constexpr (T == TYPE_DECIMALV2) { + this->data(place).sum += column.get_data()[row_num]; + } else if constexpr (is_decimal(T)) { this->data(place).sum += column.get_data()[row_num].value; } else { this->data(place).sum += (DataType)column.get_data()[row_num]; } ++this->data(place).count; } else { - if constexpr (is_decimal(T)) { + if constexpr (T == TYPE_DECIMALV2) { + this->data(place).sum += -column.get_data()[row_num]; + } else if constexpr (is_decimal(T)) { this->data(place).sum -= column.get_data()[row_num].value; } else { this->data(place).sum -= (DataType)column.get_data()[row_num]; @@ -203,7 +206,9 @@ class AggregateFunctionAvg final NO_SANITIZE_UNDEFINED void merge(AggregateDataPtr __restrict place, ConstAggregateDataPtr rhs, Arena&) const override { - if constexpr (is_decimal(T)) { + if constexpr (T == TYPE_DECIMALV2) { + this->data(place).sum += this->data(rhs).sum; + } else if constexpr (is_decimal(T)) { this->data(place).sum += this->data(rhs).sum.value; } else { this->data(place).sum += this->data(rhs).sum; diff --git a/be/src/vec/aggregate_functions/aggregate_function_map.h b/be/src/vec/aggregate_functions/aggregate_function_map.h index c7f4457a2a8a16..fc45e55ade908a 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_map.h +++ b/be/src/vec/aggregate_functions/aggregate_function_map.h @@ -67,8 +67,8 @@ struct AggregateFunctionMapAggData { void add(const Field& key_, const Field& value) { DCHECK(!key_.is_null()); - auto key_array = vectorized::get(key_); - auto value_array = vectorized::get(value); + auto key_array = key_.get(); + auto value_array = value.get(); const auto count = key_array.size(); DCHECK_EQ(count, value_array.size()); @@ -76,11 +76,11 @@ struct AggregateFunctionMapAggData { for (size_t i = 0; i != count; ++i) { StringRef key; if constexpr (is_string_type(K)) { - auto& string = key_array[i].get(); + auto& string = key_array[i].get(); key.data = string.data(); key.size = string.size(); } else { - auto& k = key_array[i].get(); + auto& k = key_array[i].get(); key.data = reinterpret_cast(&k); key.size = sizeof(k); } @@ -266,7 +266,7 @@ class AggregateFunctionMapAgg final const auto& col = assert_cast(column); auto* data = &(this->data(places)); for (size_t i = 0; i != num_rows; ++i) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); data->add(map[0], map[1]); } } @@ -284,7 +284,7 @@ class AggregateFunctionMapAgg final auto& col = assert_cast(column); const size_t num_rows = column.size(); for (size_t i = 0; i != num_rows; ++i) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); this->data(place).add(map[0], map[1]); } } @@ -296,7 +296,7 @@ class AggregateFunctionMapAgg final << ", begin:" << begin << ", end:" << end << ", column.size():" << column.size(); const auto& col = assert_cast(column); for (size_t i = begin; i <= end; ++i) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); this->data(place).add(map[0], map[1]); } } @@ -306,7 +306,7 @@ class AggregateFunctionMapAgg final const size_t num_rows) const override { const auto& col = assert_cast(*column); for (size_t i = 0; i != num_rows; ++i) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); this->data(places[i] + offset).add(map[0], map[1]); } } @@ -317,7 +317,7 @@ class AggregateFunctionMapAgg final const auto& col = assert_cast(*column); for (size_t i = 0; i != num_rows; ++i) { if (places[i]) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); this->data(places[i] + offset).add(map[0], map[1]); } } diff --git a/be/src/vec/aggregate_functions/aggregate_function_map_v2.h b/be/src/vec/aggregate_functions/aggregate_function_map_v2.h index 70d4811a1331f8..0c806219dc335c 100644 --- a/be/src/vec/aggregate_functions/aggregate_function_map_v2.h +++ b/be/src/vec/aggregate_functions/aggregate_function_map_v2.h @@ -65,8 +65,8 @@ struct AggregateFunctionMapAggDataV2 { void add(const Field& key_, const Field& value) { DCHECK(!key_.is_null()); - auto key_array = vectorized::get(key_); - auto value_array = vectorized::get(value); + auto key_array = key_.get(); + auto value_array = value.get(); const auto count = key_array.size(); DCHECK_EQ(count, value_array.size()); @@ -240,7 +240,7 @@ class AggregateFunctionMapAggV2 final const auto& col = assert_cast(column); auto* data = &(this->data(places)); for (size_t i = 0; i != num_rows; ++i) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); data->add(map[0], map[1]); } } @@ -258,7 +258,7 @@ class AggregateFunctionMapAggV2 final const auto& col = assert_cast(column); const size_t num_rows = column.size(); for (size_t i = 0; i != num_rows; ++i) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); this->data(place).add(map[0], map[1]); } } @@ -270,7 +270,7 @@ class AggregateFunctionMapAggV2 final << ", begin:" << begin << ", end:" << end << ", column.size():" << column.size(); const auto& col = assert_cast(column); for (size_t i = begin; i <= end; ++i) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); this->data(place).add(map[0], map[1]); } } @@ -280,7 +280,7 @@ class AggregateFunctionMapAggV2 final const size_t num_rows) const override { const auto& col = assert_cast(*column); for (size_t i = 0; i != num_rows; ++i) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); this->data(places[i] + offset).add(map[0], map[1]); } } @@ -291,7 +291,7 @@ class AggregateFunctionMapAggV2 final const auto& col = assert_cast(*column); for (size_t i = 0; i != num_rows; ++i) { if (places[i]) { - auto map = doris::vectorized::get(col[i]); + auto map = col[i].get(); this->data(places[i] + offset).add(map[0], map[1]); } } diff --git a/be/src/vec/columns/column_array.cpp b/be/src/vec/columns/column_array.cpp index 084073de7e9d6c..6bffff92e8ea94 100644 --- a/be/src/vec/columns/column_array.cpp +++ b/be/src/vec/columns/column_array.cpp @@ -166,7 +166,7 @@ void ColumnArray::get(size_t n, Field& res) const { size, n, max_array_size_as_field); res = Field::create_field(Array(size)); - Array& res_arr = doris::vectorized::get(res); + Array& res_arr = res.get(); for (size_t i = 0; i < size; ++i) get_data().get(offset + i, res_arr[i]); } @@ -478,7 +478,7 @@ void ColumnArray::insert(const Field& x) { get_data().insert(Field::create_field(Null())); get_offsets().push_back(get_offsets().back() + 1); } else { - const auto& array = doris::vectorized::get(x); + const auto& array = x.get(); size_t size = array.size(); for (size_t i = 0; i < size; ++i) { get_data().insert(array[i]); diff --git a/be/src/vec/columns/column_complex.h b/be/src/vec/columns/column_complex.h index 8557900b7a0c78..f61ad61de5b351 100644 --- a/be/src/vec/columns/column_complex.h +++ b/be/src/vec/columns/column_complex.h @@ -128,7 +128,7 @@ class ColumnComplexType final : public COWHelper> MutableColumnPtr clone_resized(size_t size) const override; void insert(const Field& x) override { - const value_type& s = doris::vectorized::get(x); + const value_type& s = x.get(); data.push_back(s); } diff --git a/be/src/vec/columns/column_const.h b/be/src/vec/columns/column_const.h index c494cab779b7df..298c06b1b3cbfd 100644 --- a/be/src/vec/columns/column_const.h +++ b/be/src/vec/columns/column_const.h @@ -281,7 +281,7 @@ class ColumnConst final : public COWHelper { template typename PrimitiveTypeTraits::CppType get_value() const { // Here the cast is correct, relevant code is rather tricky. - return get_field().get::CppType>(); + return get_field().get(); } void replace_column_data(const IColumn& rhs, size_t row, size_t self_row = 0) override { diff --git a/be/src/vec/columns/column_decimal.cpp b/be/src/vec/columns/column_decimal.cpp index a4f9ecf2db60f8..8af5616bf6922e 100644 --- a/be/src/vec/columns/column_decimal.cpp +++ b/be/src/vec/columns/column_decimal.cpp @@ -537,12 +537,20 @@ void ColumnDecimal::replace_column_null_data(const uint8_t* __restrict null_m } template -ColumnDecimal::CppNativeType ColumnDecimal::get_intergral_part(size_t n) const { - return data[n].value / DataTypeDecimal::get_scale_multiplier(scale); +typename ColumnDecimal::CppNativeType ColumnDecimal::get_intergral_part(size_t n) const { + if constexpr (T == TYPE_DECIMALV2) { + return data[n].value() / DataTypeDecimal::get_scale_multiplier(scale); + } else { + return data[n].value / DataTypeDecimal::get_scale_multiplier(scale); + } } template -ColumnDecimal::CppNativeType ColumnDecimal::get_fractional_part(size_t n) const { - return data[n].value % DataTypeDecimal::get_scale_multiplier(scale); +typename ColumnDecimal::CppNativeType ColumnDecimal::get_fractional_part(size_t n) const { + if constexpr (T == TYPE_DECIMALV2) { + return data[n].value() % DataTypeDecimal::get_scale_multiplier(scale); + } else { + return data[n].value % DataTypeDecimal::get_scale_multiplier(scale); + } } template class ColumnDecimal; diff --git a/be/src/vec/columns/column_decimal.h b/be/src/vec/columns/column_decimal.h index 8471efd835936f..b0224840a20363 100644 --- a/be/src/vec/columns/column_decimal.h +++ b/be/src/vec/columns/column_decimal.h @@ -141,9 +141,7 @@ class ColumnDecimal final : public COWHelper> { void insert_data(const char* pos, size_t /*length*/) override; void insert_default() override { data.push_back(value_type()); } - void insert(const Field& x) override { - data.push_back(x.template get::ColumnItemType>()); - } + void insert(const Field& x) override { data.push_back(x.template get()); } void insert_range_from(const IColumn& src, size_t start, size_t length) override; void insert_many_defaults(size_t length) override { @@ -198,7 +196,6 @@ class ColumnDecimal final : public COWHelper> { return StringRef(reinterpret_cast(&data[n]), sizeof(data[n])); } void get(size_t n, Field& res) const override { res = (*this)[n]; } - Int64 get_int(size_t n) const override { return Int64(data[n].value * scale); } void clear() override { data.clear(); } diff --git a/be/src/vec/columns/column_fixed_length_object.h b/be/src/vec/columns/column_fixed_length_object.h index 172129fa21286c..8b207a96a07bbf 100644 --- a/be/src/vec/columns/column_fixed_length_object.h +++ b/be/src/vec/columns/column_fixed_length_object.h @@ -120,8 +120,8 @@ class ColumnFixedLengthObject final : public COWHelper(x).length(), _item_size); - insert_data(vectorized::get(x).data(), _item_size); + DCHECK_EQ(x.get().length(), _item_size); + insert_data(x.get().data(), _item_size); } void insert_range_from(const IColumn& src, size_t start, size_t length) override { diff --git a/be/src/vec/columns/column_map.cpp b/be/src/vec/columns/column_map.cpp index 9bc8a9157f0c10..3e93a6185bcaca 100644 --- a/be/src/vec/columns/column_map.cpp +++ b/be/src/vec/columns/column_map.cpp @@ -135,10 +135,10 @@ void ColumnMap::get(size_t n, Field& res) const { void ColumnMap::insert(const Field& x) { DCHECK_EQ(x.get_type(), PrimitiveType::TYPE_MAP); - const auto& map = doris::vectorized::get(x); + const auto& map = x.get(); CHECK_EQ(map.size(), 2); - const auto& k_f = doris::vectorized::get(map[0]); - const auto& v_f = doris::vectorized::get(map[1]); + const auto& k_f = map[0].get(); + const auto& v_f = map[1].get(); size_t element_size = k_f.size(); diff --git a/be/src/vec/columns/column_string.cpp b/be/src/vec/columns/column_string.cpp index 03ca5b3e6a1f15..b94add09be5483 100644 --- a/be/src/vec/columns/column_string.cpp +++ b/be/src/vec/columns/column_string.cpp @@ -745,15 +745,15 @@ void ColumnStr::insert(const Field& x) { StringRef s; if (x.get_type() == PrimitiveType::TYPE_JSONB) { // Handle JsonbField - const auto& real_field = vectorized::get(x); + const auto& real_field = x.get(); s = StringRef(real_field.get_value(), real_field.get_size()); } else { DCHECK(is_string_type(x.get_type())); // If `x.get_type()` is not String, such as UInt64, may get the error // `string column length is too large: total_length=13744632839234567870` // because `(x).size() = 13744632839234567870` - s.data = vectorized::get(x).data(); - s.size = vectorized::get(x).size(); + s.data = x.get().data(); + s.size = x.get().size(); } const size_t old_size = chars.size(); const size_t size_to_append = s.size; diff --git a/be/src/vec/columns/column_struct.cpp b/be/src/vec/columns/column_struct.cpp index 01ddde624564ee..1d0cb9302e0863 100644 --- a/be/src/vec/columns/column_struct.cpp +++ b/be/src/vec/columns/column_struct.cpp @@ -109,7 +109,7 @@ void ColumnStruct::get(size_t n, Field& res) const { const size_t tuple_size = columns.size(); res = Field::create_field(Tuple()); - Tuple& res_tuple = res.get(); + auto& res_tuple = res.get(); res_tuple.reserve(tuple_size); for (size_t i = 0; i < tuple_size; ++i) { @@ -119,7 +119,7 @@ void ColumnStruct::get(size_t n, Field& res) const { void ColumnStruct::insert(const Field& x) { DCHECK_EQ(x.get_type(), PrimitiveType::TYPE_STRUCT); - const auto& tuple = x.get(); + const auto& tuple = x.get(); const size_t tuple_size = columns.size(); if (tuple.size() != tuple_size) { throw doris::Exception(ErrorCode::INTERNAL_ERROR, diff --git a/be/src/vec/columns/column_varbinary.h b/be/src/vec/columns/column_varbinary.h index 9fe928fe08c97d..b121cb69707f82 100644 --- a/be/src/vec/columns/column_varbinary.h +++ b/be/src/vec/columns/column_varbinary.h @@ -77,8 +77,7 @@ class ColumnVarbinary final : public COWHelper { char* alloc(size_t length) { return _arena.alloc(length); } void insert(const Field& x) override { - const auto& value = - vectorized::get::CppType&>(x); + const auto& value = x.get(); insert_data(value.data(), value.size()); } diff --git a/be/src/vec/columns/column_variant.cpp b/be/src/vec/columns/column_variant.cpp index ecad7bb6b71d63..135c71bc01cc15 100644 --- a/be/src/vec/columns/column_variant.cpp +++ b/be/src/vec/columns/column_variant.cpp @@ -702,7 +702,7 @@ void ColumnVariant::insert_from(const IColumn& src, size_t n) { void ColumnVariant::try_insert(const Field& field) { size_t old_size = size(); - const auto& object = field.get(); + const auto& object = field.get(); for (const auto& [key, value] : object) { if (!has_subcolumn(key)) { bool succ = add_sub_column(key, old_size); @@ -875,7 +875,7 @@ void ColumnVariant::get(size_t n, Field& res) const { size()); } res = Field::create_field(VariantMap()); - auto& object = res.get(); + auto& object = res.get(); for (const auto& entry : subcolumns) { FieldWithDataType field; @@ -1453,7 +1453,7 @@ bool ColumnVariant::Subcolumn::is_empty_nested(size_t row) const { FieldWithDataType field; get(row, field); if (field.field.get_type() == PrimitiveType::TYPE_ARRAY) { - const auto& array = field.field.get(); + const auto& array = field.field.get(); bool only_nulls_inside = true; for (const auto& elem : array) { if (elem.get_type() != PrimitiveType::TYPE_NULL) { diff --git a/be/src/vec/columns/column_vector.cpp b/be/src/vec/columns/column_vector.cpp index f7159daaddcd8a..84f7ea00e38c34 100644 --- a/be/src/vec/columns/column_vector.cpp +++ b/be/src/vec/columns/column_vector.cpp @@ -356,63 +356,66 @@ MutableColumnPtr ColumnVector::clone_resized(size_t size) const { template void ColumnVector::insert(const Field& x) { + // TODO(gabriel): `x` must have the same type as `T` if all of nested types are BIGINT in Variant value_type tmp; switch (x.get_type()) { case TYPE_NULL: tmp = default_value(); break; case TYPE_BOOLEAN: - tmp = doris::vectorized::get::CppType>(x); + tmp = x.get(); break; case TYPE_TINYINT: - tmp = doris::vectorized::get::CppType>(x); + tmp = x.get(); break; case TYPE_SMALLINT: - tmp = (value_type) - doris::vectorized::get::CppType>(x); + tmp = (value_type)x.get(); break; case TYPE_INT: - tmp = (value_type)doris::vectorized::get::CppType>( - x); + tmp = (value_type)x.get(); break; case TYPE_BIGINT: - tmp = (value_type) - doris::vectorized::get::CppType>(x); + tmp = (value_type)x.get(); break; case TYPE_LARGEINT: - tmp = (value_type) - doris::vectorized::get::CppType>(x); + tmp = (value_type)x.get(); break; case TYPE_IPV4: - tmp = (value_type)doris::vectorized::get::CppType>( - x); + tmp = (value_type)x.get(); break; case TYPE_IPV6: - tmp = (value_type)doris::vectorized::get::CppType>( - x); + tmp = (value_type)x.get(); break; case TYPE_FLOAT: - tmp = (value_type)doris::vectorized::get::CppType>( - x); + tmp = x.get(); break; case TYPE_DOUBLE: - tmp = (value_type) - doris::vectorized::get::CppType>(x); + tmp = (value_type)x.get(); break; case TYPE_TIME: - tmp = (value_type)doris::vectorized::get::CppType>( - x); + tmp = (value_type)x.get(); break; case TYPE_TIMEV2: - tmp = (value_type) - doris::vectorized::get::CppType>(x); + tmp = (value_type)x.get(); break; - case TYPE_DATE: - case TYPE_DATETIME: + case TYPE_DATE: { + auto dt = x.get(); + tmp = *(value_type*)&dt; + break; + } + case TYPE_DATETIME: { + auto dt2 = x.get(); + tmp = *(value_type*)&dt2; + break; + } case TYPE_DATEV2: + tmp = (value_type)x.get().to_date_int_val(); + break; case TYPE_DATETIMEV2: + tmp = (value_type)x.get().to_date_int_val(); + break; case TYPE_TIMESTAMPTZ: - tmp = doris::vectorized::get::ColumnItemType>(x); + tmp = (value_type)x.get().to_date_int_val(); break; default: throw doris::Exception(ErrorCode::INTERNAL_ERROR, diff --git a/be/src/vec/common/field_visitors.h b/be/src/vec/common/field_visitors.h index e287b54155e17b..bd2dda57bfe683 100644 --- a/be/src/vec/common/field_visitors.h +++ b/be/src/vec/common/field_visitors.h @@ -43,80 +43,73 @@ template typename std::decay_t::ResultType apply_visitor(Visitor&& visitor, F&& field) { switch (field.get_type()) { case PrimitiveType::TYPE_NULL: - return visitor.template apply( - field.template get::CppType>()); + return visitor.template apply(field.template get()); case PrimitiveType::TYPE_DATETIMEV2: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_TIMESTAMPTZ: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_LARGEINT: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_DATETIME: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_DATE: - return visitor.template apply( - field.template get::CppType>()); + return visitor.template apply(field.template get()); case PrimitiveType::TYPE_BOOLEAN: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_TINYINT: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_SMALLINT: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_INT: - return visitor.template apply( - field.template get::CppType>()); + return visitor.template apply(field.template get()); case PrimitiveType::TYPE_BIGINT: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_FLOAT: - return visitor.template apply( - field.template get::CppType>()); + return visitor.template apply(field.template get()); case PrimitiveType::TYPE_DOUBLE: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_STRING: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_CHAR: - return visitor.template apply( - field.template get::CppType>()); + return visitor.template apply(field.template get()); case PrimitiveType::TYPE_VARCHAR: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_ARRAY: - return visitor.template apply( - field.template get::CppType>()); + return visitor.template apply(field.template get()); case PrimitiveType::TYPE_STRUCT: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_VARIANT: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_DECIMAL32: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_DECIMAL64: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_DECIMALV2: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_DECIMAL128I: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_DECIMAL256: return visitor.template apply( - field.template get::CppType>()); + field.template get()); case PrimitiveType::TYPE_JSONB: - return visitor.template apply( - field.template get::CppType>()); + return visitor.template apply(field.template get()); default: throw doris::Exception(ErrorCode::INTERNAL_ERROR, "Bad type of Field {}", static_cast(field.get_type())); diff --git a/be/src/vec/core/field.cpp b/be/src/vec/core/field.cpp index 35723e4acf1a62..1fcc9658c91b1c 100644 --- a/be/src/vec/core/field.cpp +++ b/be/src/vec/core/field.cpp @@ -119,140 +119,106 @@ void Field::create_concrete(const typename PrimitiveTypeTraits::CppType& x void Field::create(Field&& field) { switch (field.type) { case PrimitiveType::TYPE_NULL: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DATETIMEV2: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DATEV2: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_TIMESTAMPTZ: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DATETIME: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DATE: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_BOOLEAN: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_TINYINT: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_SMALLINT: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_INT: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_BIGINT: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_LARGEINT: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_IPV4: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_IPV6: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_FLOAT: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_TIMEV2: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DOUBLE: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_STRING: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_CHAR: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_VARCHAR: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_JSONB: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_ARRAY: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_STRUCT: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_MAP: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMAL32: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMAL64: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMALV2: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMAL128I: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMAL256: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_VARIANT: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_BITMAP: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_HLL: - create_concrete( - std::move(field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_QUANTILE_STATE: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_VARBINARY: - create_concrete(std::move( - field.template get::CppType>())); + create_concrete(std::move(field.template get())); return; default: throw Exception(Status::FatalError("type not supported, type={}", field.get_type_name())); @@ -282,148 +248,112 @@ Field& Field::operator=(const Field& rhs) { void Field::create(const Field& field) { switch (field.type) { case PrimitiveType::TYPE_NULL: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DATETIMEV2: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DATEV2: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_TIMESTAMPTZ: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DATETIME: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DATE: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_BOOLEAN: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_TINYINT: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_SMALLINT: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_INT: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_BIGINT: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_LARGEINT: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_IPV4: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_IPV6: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_FLOAT: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_TIMEV2: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DOUBLE: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_STRING: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_CHAR: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_VARCHAR: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_JSONB: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_ARRAY: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_STRUCT: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_MAP: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMAL32: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMAL64: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMALV2: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMAL128I: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMAL256: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_VARIANT: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_BITMAP: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_HLL: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_QUANTILE_STATE: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_UINT32: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_UINT64: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; case PrimitiveType::TYPE_VARBINARY: - create_concrete( - field.template get::CppType>()); + create_concrete(field.template get()); return; default: throw Exception(Status::FatalError("type not supported, type={}", field.get_type_name())); @@ -433,40 +363,40 @@ void Field::create(const Field& field) { void Field::destroy() { switch (type) { case PrimitiveType::TYPE_STRING: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_CHAR: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_VARCHAR: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_JSONB: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_ARRAY: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_STRUCT: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_MAP: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_VARIANT: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_BITMAP: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_HLL: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_QUANTILE_STATE: - destroy::CppType>(); + destroy(); break; case PrimitiveType::TYPE_VARBINARY: - destroy::CppType>(); + destroy(); break; default: break; @@ -479,140 +409,106 @@ void Field::destroy() { void Field::assign(Field&& field) { switch (field.type) { case PrimitiveType::TYPE_NULL: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DATETIMEV2: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DATETIME: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DATE: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DATEV2: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_TIMESTAMPTZ: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_BOOLEAN: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_TINYINT: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_SMALLINT: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_INT: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_BIGINT: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_LARGEINT: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_IPV4: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_IPV6: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_FLOAT: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_TIMEV2: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DOUBLE: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_STRING: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_CHAR: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_VARCHAR: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_JSONB: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_ARRAY: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_STRUCT: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_MAP: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMAL32: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMAL64: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMALV2: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMAL128I: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_DECIMAL256: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_VARIANT: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_BITMAP: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_HLL: - assign_concrete( - std::move(field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_QUANTILE_STATE: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; case PrimitiveType::TYPE_VARBINARY: - assign_concrete(std::move( - field.template get::CppType>())); + assign_concrete(std::move(field.template get())); return; default: throw Exception(Status::FatalError("type not supported, type={}", field.get_type_name())); @@ -622,148 +518,112 @@ void Field::assign(Field&& field) { void Field::assign(const Field& field) { switch (field.type) { case PrimitiveType::TYPE_NULL: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DATETIMEV2: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DATETIME: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DATE: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DATEV2: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_TIMESTAMPTZ: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_BOOLEAN: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_TINYINT: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_SMALLINT: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_INT: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_BIGINT: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_LARGEINT: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_IPV4: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_IPV6: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_FLOAT: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_TIMEV2: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DOUBLE: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_STRING: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_CHAR: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_VARCHAR: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_JSONB: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_ARRAY: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_STRUCT: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_MAP: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMAL32: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMAL64: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMALV2: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMAL128I: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_DECIMAL256: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_VARIANT: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_BITMAP: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_HLL: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_QUANTILE_STATE: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_UINT32: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_UINT64: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; case PrimitiveType::TYPE_VARBINARY: - assign_concrete( - field.template get::CppType>()); + assign_concrete(field.template get()); return; default: throw Exception(Status::FatalError("type not supported, type={}", field.get_type_name())); @@ -787,20 +647,105 @@ std::string Field::get_type_name() const { return type_to_string(type); } -#define MATCH_PRIMITIVE_TYPE(primite_type) \ - if (type == primite_type) { \ - const auto& v = get::CppType>(); \ - return std::string_view(reinterpret_cast(&v), sizeof(v)); \ +std::strong_ordering Field::operator<=>(const Field& rhs) const { + if (type == PrimitiveType::TYPE_NULL || rhs == PrimitiveType::TYPE_NULL) { + return type <=> rhs.type; + } + if (type != rhs.type) { + throw Exception(Status::FatalError("lhs type not equal with rhs, lhs={}, rhs={}", + get_type_name(), rhs.get_type_name())); + } + + switch (type) { + case PrimitiveType::TYPE_BITMAP: + case PrimitiveType::TYPE_HLL: + case PrimitiveType::TYPE_QUANTILE_STATE: + case PrimitiveType::INVALID_TYPE: + case PrimitiveType::TYPE_JSONB: + case PrimitiveType::TYPE_NULL: + case PrimitiveType::TYPE_ARRAY: + case PrimitiveType::TYPE_MAP: + case PrimitiveType::TYPE_STRUCT: + case PrimitiveType::TYPE_VARIANT: + return std::strong_ordering::equal; //TODO: throw Exception? + case PrimitiveType::TYPE_DATETIMEV2: + return get().to_date_int_val() <=> + rhs.get().to_date_int_val(); + case PrimitiveType::TYPE_DATEV2: + return get().to_date_int_val() <=> + rhs.get().to_date_int_val(); + case PrimitiveType::TYPE_TIMESTAMPTZ: + return get().to_date_int_val() <=> + rhs.get().to_date_int_val(); + case PrimitiveType::TYPE_DATE: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_DATETIME: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_BIGINT: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_BOOLEAN: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_TINYINT: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_SMALLINT: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_INT: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_LARGEINT: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_IPV6: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_IPV4: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_FLOAT: + return get() < rhs.get() ? std::strong_ordering::less + : get() == rhs.get() ? std::strong_ordering::equal + : std::strong_ordering::greater; + case PrimitiveType::TYPE_TIMEV2: + return get() < rhs.get() ? std::strong_ordering::less + : get() == rhs.get() ? std::strong_ordering::equal + : std::strong_ordering::greater; + case PrimitiveType::TYPE_DOUBLE: + return get() < rhs.get() ? std::strong_ordering::less + : get() == rhs.get() ? std::strong_ordering::equal + : std::strong_ordering::greater; + case PrimitiveType::TYPE_STRING: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_CHAR: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_VARCHAR: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_VARBINARY: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_DECIMAL32: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_DECIMAL64: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_DECIMALV2: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_DECIMAL128I: + return get() <=> rhs.get(); + case PrimitiveType::TYPE_DECIMAL256: + return get() <=> rhs.get(); + default: + throw Exception(Status::FatalError("Unsupported type: {}", get_type_name())); + } +} + +#define MATCH_PRIMITIVE_TYPE(primitive_type) \ + if (type == primitive_type) { \ + const auto& v = get(); \ + return std::string_view(reinterpret_cast(&v), sizeof(v)); \ } std::string_view Field::as_string_view() const { if (type == PrimitiveType::TYPE_STRING || type == PrimitiveType::TYPE_VARCHAR || type == PrimitiveType::TYPE_CHAR) { - const auto& s = get(); + const auto& s = get(); return {s.data(), s.size()}; } if (type == PrimitiveType::TYPE_VARBINARY) { - const auto& svf = get(); + const auto& svf = get(); return {svf.data(), svf.size()}; } // MATCH_PRIMITIVE_TYPE(INVALID_TYPE); diff --git a/be/src/vec/core/field.h b/be/src/vec/core/field.h index f993067d3e2f1b..1cb6d0c13a3f85 100644 --- a/be/src/vec/core/field.h +++ b/be/src/vec/core/field.h @@ -320,17 +320,27 @@ class Field { // The template parameter T needs to be consistent with `which`. // If not, use NearestFieldType<> externally. // Maybe modify this in the future, reference: https://github.com/ClickHouse/ClickHouse/pull/22003 - template - T& get() { - using TWithoutRef = std::remove_reference_t; - auto* MAY_ALIAS ptr = reinterpret_cast(&storage); + template + typename PrimitiveTypeTraits::CppType& get() { + DCHECK(T == type || + ((type == TYPE_CHAR || type == TYPE_VARCHAR || type == TYPE_STRING) && + (T == TYPE_CHAR || T == TYPE_VARCHAR || T == TYPE_STRING)) || + type == TYPE_NULL) + << "Type mismatch: requested " << int(T) << ", actual " << get_type_name(); + auto* MAY_ALIAS ptr = reinterpret_cast::CppType*>(&storage); return *ptr; } - template - const T& get() const { - using TWithoutRef = std::remove_reference_t; - const auto* MAY_ALIAS ptr = reinterpret_cast(&storage); + template + const typename PrimitiveTypeTraits::CppType& get() const { + // TODO(gabriel): Is it safe for null type? + DCHECK(T == type || + ((type == TYPE_CHAR || type == TYPE_VARCHAR || type == TYPE_STRING) && + (T == TYPE_CHAR || T == TYPE_VARCHAR || T == TYPE_STRING)) || + type == TYPE_NULL) + << "Type mismatch: requested " << int(T) << ", actual " << get_type_name(); + const auto* MAY_ALIAS ptr = + reinterpret_cast::CppType*>(&storage); return *ptr; } @@ -338,80 +348,7 @@ class Field { return operator<=>(rhs) == std::strong_ordering::equal; } - std::strong_ordering operator<=>(const Field& rhs) const { - if (type == PrimitiveType::TYPE_NULL || rhs == PrimitiveType::TYPE_NULL) { - return type <=> rhs.type; - } - if (type != rhs.type) { - throw Exception(Status::FatalError("lhs type not equal with rhs, lhs={}, rhs={}", - get_type_name(), rhs.get_type_name())); - } - - switch (type) { - case PrimitiveType::TYPE_BITMAP: - case PrimitiveType::TYPE_HLL: - case PrimitiveType::TYPE_QUANTILE_STATE: - case PrimitiveType::INVALID_TYPE: - case PrimitiveType::TYPE_JSONB: - case PrimitiveType::TYPE_NULL: - case PrimitiveType::TYPE_ARRAY: - case PrimitiveType::TYPE_MAP: - case PrimitiveType::TYPE_STRUCT: - case PrimitiveType::TYPE_VARIANT: - return std::strong_ordering::equal; //TODO: throw Exception? - case PrimitiveType::TYPE_DATETIMEV2: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_DATEV2: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_TIMESTAMPTZ: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_DATE: - case PrimitiveType::TYPE_DATETIME: - case PrimitiveType::TYPE_BIGINT: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_BOOLEAN: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_TINYINT: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_SMALLINT: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_INT: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_LARGEINT: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_IPV6: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_IPV4: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_FLOAT: - return get() < rhs.get() ? std::strong_ordering::less - : get() == rhs.get() ? std::strong_ordering::equal - : std::strong_ordering::greater; - case PrimitiveType::TYPE_TIMEV2: - case PrimitiveType::TYPE_DOUBLE: - return get() < rhs.get() ? std::strong_ordering::less - : get() == rhs.get() ? std::strong_ordering::equal - : std::strong_ordering::greater; - case PrimitiveType::TYPE_STRING: - case PrimitiveType::TYPE_CHAR: - case PrimitiveType::TYPE_VARCHAR: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_VARBINARY: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_DECIMAL32: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_DECIMAL64: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_DECIMALV2: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_DECIMAL128I: - return get() <=> rhs.get(); - case PrimitiveType::TYPE_DECIMAL256: - return get() <=> rhs.get(); - default: - throw Exception(Status::FatalError("Unsupported type: {}", get_type_name())); - } - } + std::strong_ordering operator<=>(const Field& rhs) const; std::string_view as_string_view() const; @@ -443,10 +380,14 @@ class Field { void destroy(); - template + template void destroy() { - T* MAY_ALIAS ptr = reinterpret_cast(&storage); - ptr->~T(); + using TargetType = typename PrimitiveTypeTraits::CppType; + DCHECK(T == type || ((type == TYPE_CHAR || type == TYPE_VARCHAR || type == TYPE_STRING) && + (T == TYPE_CHAR || T == TYPE_VARCHAR || T == TYPE_STRING))) + << "Type mismatch: requested " << int(T) << ", actual " << get_type_name(); + auto* MAY_ALIAS ptr = reinterpret_cast(&storage); + ptr->~TargetType(); } }; @@ -459,16 +400,6 @@ struct FieldWithDataType { int scale = -1; }; -template -T get(const Field& field) { - return field.template get(); -} - -template -T get(Field& field) { - return field.template get(); -} - } // namespace doris::vectorized template <> diff --git a/be/src/vec/core/types.h b/be/src/vec/core/types.h index ef3c838ed6e8b5..f96b1a9f28d3dd 100644 --- a/be/src/vec/core/types.h +++ b/be/src/vec/core/types.h @@ -513,6 +513,8 @@ template constexpr bool IsDecimal128V2 = false; template <> inline constexpr bool IsDecimal128V2 = true; +template <> +inline constexpr bool IsDecimal128V2 = true; template constexpr bool IsDecimal128V3 = false; @@ -561,6 +563,10 @@ struct NativeType { using Type = Int128; }; template <> +struct NativeType { + using Type = Int128; +}; +template <> struct NativeType { using Type = Int128; }; diff --git a/be/src/vec/data_types/convert_field_to_type.cpp b/be/src/vec/data_types/convert_field_to_type.cpp index dd8e27243eb9ac..bb62cc07da0b9d 100644 --- a/be/src/vec/data_types/convert_field_to_type.cpp +++ b/be/src/vec/data_types/convert_field_to_type.cpp @@ -54,96 +54,96 @@ template /// Field template parameter may be const or non-const Fie void dispatch(F&& f, const Field& field) { switch (field.get_type()) { case PrimitiveType::TYPE_NULL: - f(field.template get()); + f(field.template get()); return; case PrimitiveType::TYPE_DATETIMEV2: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_TIMESTAMPTZ: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_DATETIME: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_DATE: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_BOOLEAN: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_TINYINT: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_SMALLINT: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_INT: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_BIGINT: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_LARGEINT: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_IPV6: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_TIMEV2: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_FLOAT: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_DOUBLE: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_STRING: case PrimitiveType::TYPE_CHAR: case PrimitiveType::TYPE_VARCHAR: - f(field.template get()); + f(field.template get()); return; case PrimitiveType::TYPE_VARBINARY: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_JSONB: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_ARRAY: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_STRUCT: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_MAP: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_DECIMAL32: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_DECIMAL64: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_DECIMALV2: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_DECIMAL128I: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_DECIMAL256: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_VARIANT: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_BITMAP: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_HLL: - f(field.template get::CppType>()); + f(field.template get()); return; case PrimitiveType::TYPE_QUANTILE_STATE: - f(field.template get::CppType>()); + f(field.template get()); return; default: throw Exception(Status::FatalError("type not supported, type={}", field.get_type_name())); @@ -291,7 +291,7 @@ bool ConvertNumeric::cast(const Float64& from, UInt8& to) { } template <> -bool ConvertNumeric::cast(const UInt8& from, UInt8& to) { +bool ConvertNumeric::cast(const bool& from, UInt8& to) { to = from; return true; } @@ -346,7 +346,7 @@ bool ConvertNumeric::cast(const Float32& from, Int8& to) { } template <> -bool ConvertNumeric::cast(const UInt8& from, Int8& to) { +bool ConvertNumeric::cast(const bool& from, Int8& to) { auto params = create_cast_params(); return CastToInt::from_bool(from, to, params); } @@ -395,7 +395,7 @@ bool ConvertNumeric::cast(const Float32& from, Int16& to) { } template <> -bool ConvertNumeric::cast(const UInt8& from, Int16& to) { +bool ConvertNumeric::cast(const bool& from, Int16& to) { auto params = create_cast_params(); return CastToInt::from_bool(from, to, params); } @@ -444,7 +444,7 @@ bool ConvertNumeric::cast(const Float32& from, Int32& to) { } template <> -bool ConvertNumeric::cast(const UInt8& from, Int32& to) { +bool ConvertNumeric::cast(const bool& from, Int32& to) { auto params = create_cast_params(); return CastToInt::from_bool(from, to, params); } @@ -493,7 +493,7 @@ bool ConvertNumeric::cast(const Float32& from, Int64& to) { } template <> -bool ConvertNumeric::cast(const UInt8& from, Int64& to) { +bool ConvertNumeric::cast(const bool& from, Int64& to) { auto params = create_cast_params(); return CastToInt::from_bool(from, to, params); } @@ -542,7 +542,7 @@ bool ConvertNumeric::cast(const Float32& from, Int128& to) { } template <> -bool ConvertNumeric::cast(const UInt8& from, Int128& to) { +bool ConvertNumeric::cast(const bool& from, Int128& to) { auto params = create_cast_params(); return CastToInt::from_bool(from, to, params); } @@ -591,7 +591,7 @@ bool ConvertNumeric::cast(const Float32& from, Float32& to) { } template <> -bool ConvertNumeric::cast(const UInt8& from, Float32& to) { +bool ConvertNumeric::cast(const bool& from, Float32& to) { auto params = create_cast_params(); return CastToFloat::from_bool(from, to, params); } @@ -640,7 +640,7 @@ bool ConvertNumeric::cast(const Float32& from, Float64& to) { } template <> -bool ConvertNumeric::cast(const UInt8& from, Float64& to) { +bool ConvertNumeric::cast(const bool& from, Float64& to) { auto params = create_cast_params(); return CastToFloat::from_bool(from, to, params); } @@ -664,7 +664,7 @@ bool ConvertNumeric::cast(const Int32& from, Float64& to) { } namespace { -template +template Field convert_numeric_type_impl(const Field& from) { typename PrimitiveTypeTraits::ColumnItemType result; if (!ConvertNumeric::cast(from.get(), result)) { @@ -676,21 +676,21 @@ Field convert_numeric_type_impl(const Field& from) { template void convert_numric_type(const Field& from, const IDataType& type, Field* to) { if (from.get_type() == PrimitiveType::TYPE_BIGINT) { - *to = convert_numeric_type_impl(from); + *to = convert_numeric_type_impl(from); } else if (from.get_type() == PrimitiveType::TYPE_DOUBLE) { - *to = convert_numeric_type_impl(from); + *to = convert_numeric_type_impl(from); } else if (from.get_type() == PrimitiveType::TYPE_LARGEINT) { - *to = convert_numeric_type_impl(from); + *to = convert_numeric_type_impl(from); } else if (from.get_type() == PrimitiveType::TYPE_TINYINT) { - *to = convert_numeric_type_impl(from); + *to = convert_numeric_type_impl(from); } else if (from.get_type() == PrimitiveType::TYPE_SMALLINT) { - *to = convert_numeric_type_impl(from); + *to = convert_numeric_type_impl(from); } else if (from.get_type() == PrimitiveType::TYPE_INT) { - *to = convert_numeric_type_impl(from); + *to = convert_numeric_type_impl(from); } else if (from.get_type() == PrimitiveType::TYPE_FLOAT) { - *to = convert_numeric_type_impl(from); + *to = convert_numeric_type_impl(from); } else if (from.get_type() == PrimitiveType::TYPE_BOOLEAN) { - *to = convert_numeric_type_impl(from); + *to = convert_numeric_type_impl(from); } else { throw doris::Exception(ErrorCode::INVALID_ARGUMENT, "Type mismatch in IN or VALUES section. Expected: {}. Got: {}", @@ -736,7 +736,7 @@ void convert_field_to_typeImpl(const Field& src, const IDataType& type, return; } else if (const auto* type_array = typeid_cast(&type)) { if (src.get_type() == PrimitiveType::TYPE_ARRAY) { - const auto& src_arr = src.get(); + const auto& src_arr = src.get(); size_t src_arr_size = src_arr.size(); const auto& element_type = *(type_array->get_nested_type()); Array res(src_arr_size); diff --git a/be/src/vec/data_types/data_type_decimal.cpp b/be/src/vec/data_types/data_type_decimal.cpp index e5d31ca74d5f73..840b1f58024453 100644 --- a/be/src/vec/data_types/data_type_decimal.cpp +++ b/be/src/vec/data_types/data_type_decimal.cpp @@ -227,8 +227,14 @@ Status DataTypeDecimal::check_column(const IColumn& column) const { template bool DataTypeDecimal::parse_from_string(const std::string& str, FieldType* res) const { StringParser::ParseResult result = StringParser::PARSE_SUCCESS; - res->value = StringParser::string_to_decimal::get_primitive_type()>( - str.c_str(), cast_set(str.size()), precision, scale, &result); + if constexpr (T == TYPE_DECIMALV2) { + *res = DecimalV2Value( + StringParser::string_to_decimal::get_primitive_type()>( + str.c_str(), cast_set(str.size()), precision, scale, &result)); + } else { + res->value = StringParser::string_to_decimal::get_primitive_type()>( + str.c_str(), cast_set(str.size()), precision, scale, &result); + } return result == StringParser::PARSE_SUCCESS || result == StringParser::PARSE_UNDERFLOW; } diff --git a/be/src/vec/data_types/serde/data_type_array_serde.cpp b/be/src/vec/data_types/serde/data_type_array_serde.cpp index 2f744af92acf97..7d47c7f88a3204 100644 --- a/be/src/vec/data_types/serde/data_type_array_serde.cpp +++ b/be/src/vec/data_types/serde/data_type_array_serde.cpp @@ -505,7 +505,7 @@ const uint8_t* DataTypeArraySerDe::deserialize_binary_to_field(const uint8_t* da data += sizeof(size_t); field = Field::create_field(Array(nested_size)); info.num_dimensions++; - auto& array = field.get(); + auto& array = field.get(); PrimitiveType nested_type = PrimitiveType::TYPE_NULL; for (size_t i = 0; i < nested_size; ++i) { Field nested_field; diff --git a/be/src/vec/data_types/serde/data_type_decimal_serde.cpp b/be/src/vec/data_types/serde/data_type_decimal_serde.cpp index a06fb7a7564c86..8f9da029b18c33 100644 --- a/be/src/vec/data_types/serde/data_type_decimal_serde.cpp +++ b/be/src/vec/data_types/serde/data_type_decimal_serde.cpp @@ -160,15 +160,9 @@ Status DataTypeDecimalSerDe::serialize_one_cell_to_json(const IColumn& column row_num = result.second; auto& col = assert_cast&>(*ptr); - if constexpr (T != TYPE_DECIMALV2) { - FieldType value = col.get_element(row_num); - auto decimal_str = value.to_string(scale); - bw.write(decimal_str.data(), decimal_str.size()); - } else { - char buf[FieldType::max_string_length()]; - auto length = col.get_element(row_num).to_string(buf, scale, scale_multiplier); - bw.write(buf, length); - } + FieldType value = col.get_element(row_num); + auto decimal_str = value.to_string(scale); + bw.write(decimal_str.data(), decimal_str.size()); return Status::OK(); } @@ -396,14 +390,19 @@ Status DataTypeDecimalSerDe::write_column_to_orc(const std::string& timezone, orc::Decimal64VectorBatch>*>(orc_col_batch); for (size_t row_id = start; row_id < end; row_id++) { if (cur_batch->notNull[row_id] == 1) { - const auto& int_value = col_data[row_id].value; - if constexpr (use_int128) { + const auto& int_value = col_data[row_id]; + if constexpr (T == TYPE_DECIMALV2) { // orc::Int128 only support construct from two int64_t values // so we need to split the int128 value into two int64_t values - orc::Int128 value(int_value >> 64, (uint64_t)int_value); + orc::Int128 value(int_value.value() >> 64, (uint64_t)int_value.value()); + cur_batch->values[row_id] = value; + } else if constexpr (use_int128) { + // orc::Int128 only support construct from two int64_t values + // so we need to split the int128 value into two int64_t values + orc::Int128 value(int_value.value >> 64, (uint64_t)int_value.value); cur_batch->values[row_id] = value; } else { - cur_batch->values[row_id] = int_value; + cur_batch->values[row_id] = int_value.value; } } } @@ -598,7 +597,7 @@ void DataTypeDecimalSerDe::read_one_cell_from_jsonb(IColumn& column, const JsonbValue* arg) const { auto& col = reinterpret_cast&>(column); if constexpr (T == TYPE_DECIMALV2) { - col.insert_value(arg->unpack()->val()); + col.insert_value(DecimalV2Value(arg->unpack()->val())); } else if constexpr (T == TYPE_DECIMAL128I) { col.insert_value(arg->unpack()->val()); } else if constexpr (T == TYPE_DECIMAL32) { diff --git a/be/src/vec/exec/format/parquet/parquet_column_convert.h b/be/src/vec/exec/format/parquet/parquet_column_convert.h index 888d890dd9d37f..ceff33a22ab7bf 100644 --- a/be/src/vec/exec/format/parquet/parquet_column_convert.h +++ b/be/src/vec/exec/format/parquet/parquet_column_convert.h @@ -375,10 +375,10 @@ class Float16PhysicalConverter : public PhysicalToLogicalConverter { size_t start_idx = to_float_column->size(); to_float_column->resize(start_idx + num_values); auto& to_float_column_data = to_float_column->get_data(); - const uint8_t* ptr = src_data->get_data().data(); + const auto* ptr = src_data->get_data().data(); for (int i = 0; i < num_values; ++i) { size_t offset = i * _type_length; - const uint8_t* data_ptr = ptr + offset; + const auto* data_ptr = ptr + offset; uint16_t raw; memcpy(&raw, data_ptr, sizeof(uint16_t)); float value = half_to_float(raw); diff --git a/be/src/vec/exec/format/parquet/parquet_predicate.h b/be/src/vec/exec/format/parquet/parquet_predicate.h index c390a50cb3793e..bd6c5cd6c209c9 100644 --- a/be/src/vec/exec/format/parquet/parquet_predicate.h +++ b/be/src/vec/exec/format/parquet/parquet_predicate.h @@ -311,8 +311,8 @@ class ParquetPredicate { auto logical_prim_type = logical_data_type->get_primitive_type(); if (logical_prim_type == TYPE_FLOAT) { - auto& min_value = min_field->get::CppType>(); - auto& max_value = max_field->get::CppType>(); + auto& min_value = min_field->get(); + auto& max_value = max_field->get(); if (std::isnan(min_value) || std::isnan(max_value)) { return Status::DataQualityError("Can not use this parquet min/max value."); @@ -325,8 +325,8 @@ class ParquetPredicate { max_value = 0.0F; } } else if (logical_prim_type == TYPE_DOUBLE) { - auto& min_value = min_field->get::CppType>(); - auto& max_value = max_field->get::CppType>(); + auto& min_value = min_field->get(); + auto& max_value = max_field->get(); if (std::isnan(min_value) || std::isnan(max_value)) { return Status::DataQualityError("Can not use this parquet min/max value."); @@ -340,8 +340,8 @@ class ParquetPredicate { } } else if (col_schema->parquet_schema.type == tparquet::Type::type::INT96 || logical_prim_type == TYPE_DATETIMEV2) { - auto min_value = min_field->get::CppType>(); - auto max_value = min_field->get::CppType>(); + auto min_value = min_field->get(); + auto max_value = min_field->get(); // From Trino: Parquet INT96 timestamp values were compared incorrectly // for the purposes of producing statistics by older parquet writers, diff --git a/be/src/vec/exec/jni_connector.h b/be/src/vec/exec/jni_connector.h index 08ce188689c2f4..960629eb658dc6 100644 --- a/be/src/vec/exec/jni_connector.h +++ b/be/src/vec/exec/jni_connector.h @@ -362,6 +362,7 @@ class JniConnector : public ProfileCollector { std::vector& meta_data); template + requires(!std::is_same_v) static Status _fill_fixed_length_column(MutableColumnPtr& doris_column, CPP_TYPE* ptr, size_t num_rows) { auto& column_data = assert_cast(*doris_column).get_data(); @@ -371,6 +372,19 @@ class JniConnector : public ProfileCollector { return Status::OK(); } + template + requires(std::is_same_v) + static Status _fill_fixed_length_column(MutableColumnPtr& doris_column, CPP_TYPE* ptr, + size_t num_rows) { + auto& column_data = assert_cast(*doris_column).get_data(); + size_t origin_size = column_data.size(); + column_data.resize(origin_size + num_rows); + for (size_t i = 0; i < num_rows; i++) { + column_data[origin_size + i] = DecimalV2Value(ptr[i]); + } + return Status::OK(); + } + template static long _get_fixed_length_column_address(const IColumn& doris_column) { return (long)assert_cast(doris_column).get_data().data(); diff --git a/be/src/vec/exprs/varray_literal.cpp b/be/src/vec/exprs/varray_literal.cpp index 3b7ec30727e099..3c95b82b9e2e21 100644 --- a/be/src/vec/exprs/varray_literal.cpp +++ b/be/src/vec/exprs/varray_literal.cpp @@ -49,7 +49,7 @@ Status VArrayLiteral::prepare(RuntimeState* state, const RowDescriptor& row_desc Field item; auto child_literal = std::dynamic_pointer_cast(child); child_literal->get_column_ptr()->get(0, item); - array.get().push_back(item); + array.get().push_back(item); } _column_ptr = _data_type->create_column_const(1, array); return Status::OK(); diff --git a/be/src/vec/exprs/vexpr.cpp b/be/src/vec/exprs/vexpr.cpp index a28b963cd049eb..ce5a1df9904dd2 100644 --- a/be/src/vec/exprs/vexpr.cpp +++ b/be/src/vec/exprs/vexpr.cpp @@ -191,145 +191,137 @@ TExprNode create_texpr_node_from(const vectorized::Field& field, const Primitive TExprNode node; switch (type) { case TYPE_BOOLEAN: { - const auto& storage = - static_cast(field.get::CppType>()); + const auto& storage = static_cast(field.get()); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_TINYINT: { - const auto& storage = static_cast( - field.get::CppType>()); + const auto& storage = static_cast(field.get()); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_SMALLINT: { - const auto& storage = static_cast( - field.get::CppType>()); + const auto& storage = static_cast(field.get()); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_INT: { - const auto& storage = - static_cast(field.get::CppType>()); + const auto& storage = static_cast(field.get()); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_BIGINT: { - const auto& storage = static_cast( - field.get::CppType>()); + const auto& storage = static_cast(field.get()); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_LARGEINT: { - const auto& storage = static_cast( - field.get::CppType>()); + const auto& storage = static_cast(field.get()); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_FLOAT: { - const auto& storage = - static_cast(field.get::CppType>()); + const auto& storage = static_cast(field.get()); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_DOUBLE: { - const auto& storage = static_cast( - field.get::CppType>()); + const auto& storage = static_cast(field.get()); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_DATEV2: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_DATETIMEV2: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR( create_texpr_literal_node(&storage, &node, precision, scale)); break; } case TYPE_TIMESTAMPTZ: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR( create_texpr_literal_node(&storage, &node, precision, scale)); break; } case TYPE_DATE: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_DATETIME: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_DECIMALV2: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR( create_texpr_literal_node(&storage, &node, precision, scale)); break; } case TYPE_DECIMAL32: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR( create_texpr_literal_node(&storage, &node, precision, scale)); break; } case TYPE_DECIMAL64: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR( create_texpr_literal_node(&storage, &node, precision, scale)); break; } case TYPE_DECIMAL128I: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR( create_texpr_literal_node(&storage, &node, precision, scale)); break; } case TYPE_DECIMAL256: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR( create_texpr_literal_node(&storage, &node, precision, scale)); break; } case TYPE_CHAR: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_VARCHAR: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_STRING: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_IPV4: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_IPV6: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_TIMEV2: { - const auto& storage = field.get::CppType>(); + const auto& storage = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&storage, &node)); break; } case TYPE_VARBINARY: { - const auto& svf = field.get::CppType>(); + const auto& svf = field.get(); THROW_IF_ERROR(create_texpr_literal_node(&svf, &node)); break; } diff --git a/be/src/vec/exprs/vmap_literal.cpp b/be/src/vec/exprs/vmap_literal.cpp index ef3dc8debcdaa9..87f6e3d67912b9 100644 --- a/be/src/vec/exprs/vmap_literal.cpp +++ b/be/src/vec/exprs/vmap_literal.cpp @@ -56,11 +56,11 @@ Status VMapLiteral::prepare(RuntimeState* state, const RowDescriptor& row_desc, VExpr::expr_without_cast(_children[idx + 1])); val_literal->get_column_ptr()->get(0, vf); - keys.get().push_back(kf); - values.get().push_back(vf); + keys.get().push_back(kf); + values.get().push_back(vf); } - map.get().push_back(keys); - map.get().push_back(values); + map.get().push_back(keys); + map.get().push_back(values); _column_ptr = _data_type->create_column_const(1, map); return Status::OK(); diff --git a/be/src/vec/exprs/vstruct_literal.cpp b/be/src/vec/exprs/vstruct_literal.cpp index ee6f08b3002723..da5069c9dec6c5 100644 --- a/be/src/vec/exprs/vstruct_literal.cpp +++ b/be/src/vec/exprs/vstruct_literal.cpp @@ -43,7 +43,7 @@ Status VStructLiteral::prepare(RuntimeState* state, const RowDescriptor& row_des Field item; auto child_literal = std::dynamic_pointer_cast(child); child_literal->get_column_ptr()->get(0, item); - struct_field.get().push_back(item); + struct_field.get().push_back(item); } _column_ptr = _data_type->create_column_const(1, struct_field); return Status::OK(); diff --git a/be/src/vec/functions/ai/ai_functions.cpp b/be/src/vec/functions/ai/ai_functions.cpp index a05ead9fa9c92e..c24a8f32b102d4 100644 --- a/be/src/vec/functions/ai/ai_functions.cpp +++ b/be/src/vec/functions/ai/ai_functions.cpp @@ -55,7 +55,7 @@ Status FunctionAIClassify::build_prompt(const Block& block, const ColumnNumbers& for (size_t i = start; i < end; ++i) { Field field; data.get(i, field); - label_values.emplace_back(field.get()); + label_values.emplace_back(field.template get()); } std::string labels_str = "["; @@ -97,7 +97,7 @@ Status FunctionAIExtract::build_prompt(const Block& block, const ColumnNumbers& for (size_t i = start; i < end; ++i) { Field field; data.get(i, field); - label_values.emplace_back(field.get()); + label_values.emplace_back(field.template get()); } std::string labels_str = "["; @@ -148,7 +148,7 @@ Status FunctionAIMask::build_prompt(const Block& block, const ColumnNumbers& arg for (size_t i = start; i < end; ++i) { Field field; data.get(i, field); - label_values.emplace_back(field.get()); + label_values.emplace_back(field.template get()); } std::string labels_str = "["; diff --git a/be/src/vec/functions/array/function_arrays_overlap.h b/be/src/vec/functions/array/function_arrays_overlap.h index a75bed7197aae9..5300f50bdaa1cc 100644 --- a/be/src/vec/functions/array/function_arrays_overlap.h +++ b/be/src/vec/functions/array/function_arrays_overlap.h @@ -94,6 +94,43 @@ struct OverlapSetImpl { } }; +template <> +struct OverlapSetImpl { + using ElementNativeType = Int128; + using Set = phmap::flat_hash_set>; + Set set; + bool has_null = false; + + void insert_array(const IColumn* column, const UInt8* nullmap, size_t start, size_t size) { + const auto& vec = assert_cast(*column).get_data(); + for (size_t i = start; i < start + size; ++i) { + if (nullmap[i]) { + has_null = true; + continue; + } + set.insert(vec[i].value()); + } + } + + bool find_any(const IColumn* column, const UInt8* nullmap, size_t start, size_t size) { + const auto& vec = assert_cast(*column).get_data(); + for (size_t i = start; i < start + size; ++i) { + if (nullmap[i]) { + if (has_null) { + return true; + } else { + continue; + } + } + + if (set.contains(vec[i].value())) { + return true; + } + } + return false; + } +}; + template <> struct OverlapSetImpl { using Set = phmap::flat_hash_set>; @@ -210,7 +247,7 @@ class FunctionArraysOverlap : public IFunction { null_bitmap = null_bitmap_cache_handle.get_bitmap(); } std::unique_ptr query_param = nullptr; - const Array& query_val = param_value.get(); + const Array& query_val = param_value.get(); InvertedIndexParam param; param.column_name = data_type_with_name.first; diff --git a/be/src/vec/functions/binary_arithmetic.h b/be/src/vec/functions/binary_arithmetic.h index 42aaedbd8994b0..1681ed142f4c8e 100644 --- a/be/src/vec/functions/binary_arithmetic.h +++ b/be/src/vec/functions/binary_arithmetic.h @@ -135,15 +135,30 @@ struct PlusMinusDecimalImpl { auto column_result = ColumnDecimal::create(1, res_data_type.get_scale()); if (check_overflow_for_decimal) { - column_result->get_element(0) = - typename PrimitiveTypeTraits::ColumnItemType( - apply(a, b, *type_left, *type_right, res_data_type, - max_result_number, scale_diff_multiplier)); + if constexpr (ResultType == TYPE_DECIMALV2) { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType(apply( + a.value(), b.value(), *type_left, *type_right, res_data_type, + max_result_number, scale_diff_multiplier)); + } else { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType( + apply(a, b, *type_left, *type_right, res_data_type, + max_result_number, scale_diff_multiplier)); + } + } else { - column_result->get_element(0) = - typename PrimitiveTypeTraits::ColumnItemType( - apply(a, b, *type_left, *type_right, res_data_type, - max_result_number, scale_diff_multiplier)); + if constexpr (ResultType == TYPE_DECIMALV2) { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType(apply( + a.value(), b.value(), *type_left, *type_right, res_data_type, + max_result_number, scale_diff_multiplier)); + } else { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType( + apply(a, b, *type_left, *type_right, res_data_type, + max_result_number, scale_diff_multiplier)); + } } return column_result; } @@ -165,10 +180,18 @@ struct PlusMinusDecimalImpl { std::visit( [&](auto check_overflow_for_decimal) { for (size_t i = 0; i < column_left->size(); ++i) { - c[i] = typename DataTypeDecimal::FieldType( - apply(a[i], b, *type_left, *type_right, - res_data_type, max_result_number, - scale_diff_multiplier)); + if constexpr (ResultType == TYPE_DECIMALV2) { + c[i] = typename DataTypeDecimal::FieldType( + apply( + a[i].value(), b.value(), *type_left, *type_right, + res_data_type, max_result_number, + scale_diff_multiplier)); + } else { + c[i] = typename DataTypeDecimal::FieldType( + apply( + a[i], b, *type_left, *type_right, res_data_type, + max_result_number, scale_diff_multiplier)); + } } }, make_bool_variant(check_overflow_for_decimal)); @@ -192,10 +215,18 @@ struct PlusMinusDecimalImpl { std::visit( [&](auto check_overflow_for_decimal) { for (size_t i = 0; i < column_right->size(); ++i) { - c[i] = typename DataTypeDecimal::FieldType( - apply(a, b[i], *type_left, *type_right, - res_data_type, max_result_number, - scale_diff_multiplier)); + if constexpr (ResultType == TYPE_DECIMALV2) { + c[i] = typename DataTypeDecimal::FieldType( + apply( + a.value(), b[i].value(), *type_left, *type_right, + res_data_type, max_result_number, + scale_diff_multiplier)); + } else { + c[i] = typename DataTypeDecimal::FieldType( + apply( + a, b[i], *type_left, *type_right, res_data_type, + max_result_number, scale_diff_multiplier)); + } } }, make_bool_variant(check_overflow_for_decimal)); @@ -236,8 +267,9 @@ struct PlusMinusDecimalImpl { DecimalV2Value(b[i]).to_string(), DecimalV2Value(i128_mul_result).to_string(), "decimalv2"); } - c[i] = (i128_mul_result - sgn[i]) / DecimalV2Value::ONE_BILLION + sgn[i]; - if (c[i].value > max.value() || c[i].value < min.value()) { + c[i] = DecimalV2Value((i128_mul_result - sgn[i]) / DecimalV2Value::ONE_BILLION + + sgn[i]); + if (c[i].value() > max.value() || c[i].value() < min.value()) { throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, "Arithmetic overflow: {} {} {} = {}, result type: {}", DecimalV2Value(a[i]).to_string(), "add", @@ -245,9 +277,10 @@ struct PlusMinusDecimalImpl { DecimalV2Value(i128_mul_result).to_string(), "decimalv2"); } } else { - c[i] = (DecimalV2Value(a[i]).value() * DecimalV2Value(b[i]).value() - sgn[i]) / - DecimalV2Value::ONE_BILLION + - sgn[i]; + c[i] = DecimalV2Value( + (DecimalV2Value(a[i]).value() * DecimalV2Value(b[i]).value() - sgn[i]) / + DecimalV2Value::ONE_BILLION + + sgn[i]); } } } @@ -277,10 +310,18 @@ struct PlusMinusDecimalImpl { std::visit( [&](auto check_overflow_for_decimal) { for (size_t i = 0; i < sz; i++) { - c[i] = typename ColumnDecimal::value_type( - apply( - a[i], b[i], *type_left, *type_right, res_data_type, - max_result_number, scale_diff_multiplier)); + if constexpr (ResultType == TYPE_DECIMALV2) { + c[i] = typename ColumnDecimal::value_type( + apply( + a[i].value(), b[i].value(), *type_left, *type_right, + res_data_type, max_result_number, + scale_diff_multiplier)); + } else { + c[i] = typename ColumnDecimal::value_type( + apply( + a[i], b[i], *type_left, *type_right, res_data_type, + max_result_number, scale_diff_multiplier)); + } } }, make_bool_variant(check_overflow_for_decimal)); @@ -298,7 +339,7 @@ struct PlusMinusDecimalImpl { // Now, Doris only support decimal +-*/ decimal. if constexpr (check_overflow) { auto res = Impl::apply(DecimalV2Value(a), DecimalV2Value(b)).value(); - if (res > max_result_number.value || res < -max_result_number.value) { + if (res > max_result_number.value() || res < -max_result_number.value()) { throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, "Arithmetic overflow: {} {} {} = {}, result type: {}", DecimalV2Value(a).to_string(), "add", diff --git a/be/src/vec/functions/cast/cast_to_basic_number_common.h b/be/src/vec/functions/cast/cast_to_basic_number_common.h index ff597d238ad52a..993559b4d22138 100644 --- a/be/src/vec/functions/cast/cast_to_basic_number_common.h +++ b/be/src/vec/functions/cast/cast_to_basic_number_common.h @@ -151,7 +151,8 @@ struct CastToInt { template requires(IsCppTypeInt && - std::is_same_v::ColumnItemType>) + (std::is_same_v::ColumnItemType> || + std::is_same_v::CppType>)) static inline bool from_bool(FromCppT from, ToCppT& to, CastParameters& params) { CastUtil::static_cast_set(to, from); return true; @@ -224,7 +225,31 @@ struct CastToInt { } template - requires(IsCppTypeInt && IsDecimalNumber) + requires(IsCppTypeInt && IsDecimalV2) + static inline bool _from_decimal(FromCppT from, UInt32 from_precision, UInt32 from_scale, + ToCppT& to, + const typename FromCppT::NativeType& scale_multiplier, + bool narrow_integral, CastParameters& params) { + constexpr auto min_result = std::numeric_limits::lowest(); + constexpr auto max_result = std::numeric_limits::max(); + auto tmp = from.value() / scale_multiplier; + if (narrow_integral) { + if (tmp < min_result || tmp > max_result) { + params.status = Status::Error( + ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, + fmt::format("Arithmetic overflow when converting " + "value {} from type {} to type {}", + decimal_to_string(from.value(), from_scale), + type_to_string(FromCppT::PType), int_type_name)); + return false; + } + } + to = static_cast(tmp); + return true; + } + + template + requires(IsCppTypeInt && IsDecimalNumber && !IsDecimal128V2) static inline bool _from_decimal(FromCppT from, UInt32 from_precision, UInt32 from_scale, ToCppT& to, const typename FromCppT::NativeType& scale_multiplier, @@ -294,7 +319,8 @@ struct CastToFloat { } template requires(IsCppTypeFloat && - std::is_same_v::ColumnItemType>) + (std::is_same_v::ColumnItemType> || + std::is_same_v::CppType>)) static inline bool from_bool(const FromCppT& from, ToCppT& to, CastParameters& params) { CastUtil::static_cast_set(to, from); return true; @@ -325,7 +351,7 @@ struct CastToFloat { } } template - requires(IsCppTypeFloat && IsDecimalNumber) + requires(IsCppTypeFloat && IsDecimalNumber && !IsDecimalV2) static inline bool _from_decimalv3(const FromCppT& from, UInt32 from_scale, ToCppT& to, const typename FromCppT::NativeType& scale_multiplier, CastParameters& params) { @@ -333,6 +359,15 @@ struct CastToFloat { static_cast(scale_multiplier)); return true; } + template + requires(IsCppTypeFloat && IsDecimalV2) + static inline bool _from_decimalv3(const FromCppT& from, UInt32 from_scale, ToCppT& to, + const typename FromCppT::NativeType& scale_multiplier, + CastParameters& params) { + to = static_cast(static_cast(from.value()) / + static_cast(scale_multiplier)); + return true; + } // cast from date and datetime to float/double, will not overflow template requires(IsCppTypeFloat && (IsCppTypeDate || IsCppTypeDateTime)) diff --git a/be/src/vec/functions/cast/cast_to_boolean.h b/be/src/vec/functions/cast/cast_to_boolean.h index cce2926f8f27c5..99cbd79fb64147 100644 --- a/be/src/vec/functions/cast/cast_to_boolean.h +++ b/be/src/vec/functions/cast/cast_to_boolean.h @@ -92,9 +92,9 @@ inline bool CastToBool::from_decimal(const Decimal64& from, UInt8& to, UInt32, U } template <> -inline bool CastToBool::from_decimal(const Decimal128V2& from, UInt8& to, UInt32, UInt32, +inline bool CastToBool::from_decimal(const DecimalV2Value& from, UInt8& to, UInt32, UInt32, CastParameters&) { - to = (from.value != 0); + to = (from.value() != 0); return true; } diff --git a/be/src/vec/functions/cast/cast_to_decimal.h b/be/src/vec/functions/cast/cast_to_decimal.h index 330886f093c479..2e5222a9742a72 100644 --- a/be/src/vec/functions/cast/cast_to_decimal.h +++ b/be/src/vec/functions/cast/cast_to_decimal.h @@ -127,7 +127,7 @@ struct CastToDecimal { } template - requires(IsDecimalNumber && IsCppTypeFloat) + requires(IsDecimalNumber && IsCppTypeFloat && !IsDecimal128V2) static inline bool _from_float(const FromCppT& from, ToCppT& to, UInt32 to_precision, UInt32 to_scale, const typename ToCppT::NativeType& scale_multiplier, @@ -152,10 +152,40 @@ struct CastToDecimal { } return false; } - to.value = static_cast(static_cast( + to.value = static_cast(static_cast( from * static_cast(scale_multiplier) + ((from >= 0) ? 0.5 : -0.5))); return true; } + template + requires(IsDecimal128V2 && IsCppTypeFloat) + static inline bool _from_float(const FromCppT& from, ToCppT& to, UInt32 to_precision, + UInt32 to_scale, + const typename ToCppT::NativeType& scale_multiplier, + const typename ToCppT::NativeType& min_result, + const typename ToCppT::NativeType& max_result, + CastParameters& params) { + if (!std::isfinite(from)) { + params.status = Status(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, + "Decimal convert overflow. Cannot convert infinity or NaN " + "to decimal"); + return false; + } + // For decimal256, we need to use long double to avoid overflow when + // static casting the multiplier to floating type, and also to be as precise as possible; + // For other decimal types, we use double to be as precise as possible. + using DoubleType = std::conditional_t, long double, double>; + DoubleType tmp = from * static_cast(scale_multiplier); + if (tmp <= DoubleType(min_result) || tmp >= DoubleType(max_result)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR(from, "float/double", to_precision, + to_scale); + } + return false; + } + to = DecimalV2Value(static_cast(static_cast( + from * static_cast(scale_multiplier) + ((from >= 0) ? 0.5 : -0.5)))); + return true; + } template (from.value), scale_multiplier, - res)) { - if (params.is_strict) { - params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( - decimal_to_string(from.value, scale_from), - fmt::format("decimal({}, {})", precision_from, scale_from), - precision_to, scale_to); + if constexpr (IsDecimal128V2) { + if (common::mul_overflow(static_cast(from.value()), scale_multiplier, + res)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value(), scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + return false; + } else { + if (UNLIKELY(res > max_result || res < -max_result)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value(), scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + return false; + } else { + to = ToCppT(res); + } } - return false; } else { - if (UNLIKELY(res > max_result || res < -max_result)) { + if (common::mul_overflow(static_cast(from.value), scale_multiplier, + res)) { if (params.is_strict) { params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( decimal_to_string(from.value, scale_from), @@ -333,18 +378,41 @@ struct CastToDecimal { } return false; } else { - to = ToCppT(res); + if (UNLIKELY(res > max_result || res < -max_result)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value, scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + return false; + } else { + to = ToCppT(res); + } } } } else { - res = from.value * scale_multiplier; + if constexpr (IsDecimal128V2) { + res = from.value() * scale_multiplier; + } else { + res = from.value * scale_multiplier; + } if constexpr (narrow_integral) { if (UNLIKELY(res > max_result || res < -max_result)) { - if (params.is_strict) { - params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( - decimal_to_string(from.value, scale_from), - fmt::format("decimal({}, {})", precision_from, scale_from), - precision_to, scale_to); + if constexpr (IsDecimal128V2) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value(), scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + } else { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value, scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } } return false; } @@ -362,18 +430,33 @@ struct CastToDecimal { const typename ToCppT::NativeType& min_result, const typename ToCppT::NativeType& max_result, CastParameters& params) { - if constexpr (narrow_integral) { - if (UNLIKELY(from.value > max_result || from.value < -max_result)) { - if (params.is_strict) { - params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( - decimal_to_string(from.value, scale_from), - fmt::format("decimal({}, {})", precision_from, scale_from), - precision_to, scale_to); + if constexpr (IsDecimal128V2) { + if constexpr (narrow_integral) { + if (UNLIKELY(from.value() > max_result || from.value() < -max_result)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value(), scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + return false; } - return false; } + to = ToCppT(from.value()); + } else { + if constexpr (narrow_integral) { + if (UNLIKELY(from.value > max_result || from.value < -max_result)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value, scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + return false; + } + } + to = ToCppT(from.value); } - to = ToCppT(from.value); return true; } @@ -397,35 +480,69 @@ struct CastToDecimal { MaxNativeType res; if (from >= FromCppT(0)) { if constexpr (narrow_integral) { - res = (from.value + scale_multiplier / 2) / scale_multiplier; - if (UNLIKELY(res > max_result)) { - if (params.is_strict) { - params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( - decimal_to_string(from.value, scale_from), - fmt::format("decimal({}, {})", precision_from, scale_from), - precision_to, scale_to); + if constexpr (IsDecimal128V2) { + res = (from.value() + scale_multiplier / 2) / scale_multiplier; + if (UNLIKELY(res > max_result)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value(), scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + return false; + } + } else { + res = (from.value + scale_multiplier / 2) / scale_multiplier; + if (UNLIKELY(res > max_result)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value, scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + return false; } - return false; } to = ToCppT(res); } else { - to = ToCppT((from.value + scale_multiplier / 2) / scale_multiplier); + if constexpr (IsDecimal128V2) { + to = ToCppT((from.value() + scale_multiplier / 2) / scale_multiplier); + } else { + to = ToCppT((from.value + scale_multiplier / 2) / scale_multiplier); + } } } else { if constexpr (narrow_integral) { - res = (from.value - scale_multiplier / 2) / scale_multiplier; - if (UNLIKELY(res < -max_result)) { - if (params.is_strict) { - params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( - decimal_to_string(from.value, scale_from), - fmt::format("decimal({}, {})", precision_from, scale_from), - precision_to, scale_to); + if constexpr (IsDecimal128V2) { + res = (from.value() - scale_multiplier / 2) / scale_multiplier; + if (UNLIKELY(res < -max_result)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value(), scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + return false; + } + } else { + res = (from.value - scale_multiplier / 2) / scale_multiplier; + if (UNLIKELY(res < -max_result)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + decimal_to_string(from.value, scale_from), + fmt::format("decimal({}, {})", precision_from, scale_from), + precision_to, scale_to); + } + return false; } - return false; } to = ToCppT(res); } else { - to = ToCppT((from.value - scale_multiplier / 2) / scale_multiplier); + if constexpr (IsDecimal128V2) { + to = ToCppT((from.value() - scale_multiplier / 2) / scale_multiplier); + } else { + to = ToCppT((from.value - scale_multiplier / 2) / scale_multiplier); + } } } return true; @@ -435,7 +552,7 @@ struct CastToDecimal { typename MaxNativeType = std::conditional_t<(sizeof(FromCppT) > sizeof(typename ToCppT::NativeType)), FromCppT, typename ToCppT::NativeType>> - requires(IsDecimalNumber && + requires(IsDecimalNumber && !IsDecimal128V2 && (IsCppTypeInt || std::is_same_v)) static inline bool _from_int(const FromCppT& from, ToCppT& to, UInt32 precision, UInt32 scale, const MaxNativeType& scale_multiplier, @@ -477,6 +594,53 @@ struct CastToDecimal { return true; } + + template sizeof(typename ToCppT::NativeType)), + FromCppT, typename ToCppT::NativeType>> + requires(IsDecimalV2 && + (IsCppTypeInt || std::is_same_v)) + static inline bool _from_int(const FromCppT& from, ToCppT& to, UInt32 precision, UInt32 scale, + const MaxNativeType& scale_multiplier, + const typename ToCppT::NativeType& min_result, + const typename ToCppT::NativeType& max_result, + CastParameters& params) { + MaxNativeType tmp; + if constexpr (multiply_may_overflow) { + if (common::mul_overflow(static_cast(from), scale_multiplier, tmp)) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR(from, int_type_name, + precision, scale); + } + return false; + } + if constexpr (narrow_integral) { + if (tmp < min_result || tmp > max_result) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + from, int_type_name, precision, scale); + } + return false; + } + } + to = DecimalV2Value(static_cast(tmp)); + } else { + tmp = scale_multiplier * from; + if constexpr (narrow_integral) { + if (tmp < min_result || tmp > max_result) { + if (params.is_strict) { + params.status = DECIMAL_CONVERT_OVERFLOW_ERROR( + from, int_type_name, precision, scale); + } + return false; + } + } + to = DecimalV2Value(static_cast(tmp)); + } + + return true; + } }; // Casting from string to decimal types. diff --git a/be/src/vec/functions/cast/cast_to_int.h b/be/src/vec/functions/cast/cast_to_int.h index cdb7a6709afb96..3acc165dbfe006 100644 --- a/be/src/vec/functions/cast/cast_to_int.h +++ b/be/src/vec/functions/cast/cast_to_int.h @@ -182,7 +182,7 @@ class CastToImpl : public CastToBase { params.is_strict = (CastMode == CastModeType::StrictMode); size_t size = vec_from.size(); typename FromFieldType::NativeType scale_multiplier = - DataTypeDecimal::get_scale_multiplier(from_scale); + DataTypeDecimal::get_scale_multiplier(from_scale); for (size_t i = 0; i < size; i++) { if (!CastToInt::_from_decimal( diff --git a/be/src/vec/functions/cast/cast_to_string.h b/be/src/vec/functions/cast/cast_to_string.h index f70fdb3e961e47..f33cff79d25c0d 100644 --- a/be/src/vec/functions/cast/cast_to_string.h +++ b/be/src/vec/functions/cast/cast_to_string.h @@ -398,6 +398,13 @@ inline void CastToString::push_decimal(const Decimal128V2& from, UInt32 scale, B bw.write(str.data(), str.size()); } +template <> +inline void CastToString::push_decimal(const DecimalV2Value& from, UInt32 scale, + BufferWritable& bw) { + std::string str = from.to_string(scale); + bw.write(str.data(), str.size()); +} + // DATEV1 DATETIMEV1 inline std::string CastToString::from_date_or_datetime(const VecDateTimeValue& from) { char buf[64]; diff --git a/be/src/vec/functions/divide.cpp b/be/src/vec/functions/divide.cpp index 7f0cbc7990ea0b..8df81792fe543f 100644 --- a/be/src/vec/functions/divide.cpp +++ b/be/src/vec/functions/divide.cpp @@ -447,7 +447,7 @@ struct DivideDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr constant_constant( ArgA a, ArgB b, const typename PrimitiveTypeTraits::CppType& max_result_number, @@ -472,7 +472,32 @@ struct DivideDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr constant_constant( + ArgA a, ArgB b, + const typename PrimitiveTypeTraits::CppType& max_result_number, + const typename PrimitiveTypeTraits::CppType& scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + auto column_result = ColumnDecimal::create(1, res_data_type.get_scale()); + + auto null_map = ColumnUInt8::create(1, 0); + if (check_overflow_for_decimal) { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType( + apply(a.value(), b.value(), null_map->get_element(0), + max_result_number)); + } else { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType( + apply(a.value(), b.value(), null_map->get_element(0), + max_result_number)); + } + + return ColumnNullable::create(std::move(column_result), std::move(null_map)); + } + + template + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr vector_constant( ColumnPtr column_left, ArgB b, const typename PrimitiveTypeTraits::CppType& max_result_number, @@ -504,7 +529,39 @@ struct DivideDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr vector_constant( + ColumnPtr column_left, ArgB b, + const typename PrimitiveTypeTraits::CppType& max_result_number, + const typename PrimitiveTypeTraits::CppType& scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + const auto* column_left_ptr = assert_cast(column_left.get()); + auto column_result = + ColumnDecimal::create(column_left->size(), res_data_type.get_scale()); + DCHECK(column_left_ptr != nullptr); + + auto null_map = ColumnUInt8::create(column_left->size(), 0); + const auto& a = column_left_ptr->get_data().data(); + const auto& c = column_result->get_data().data(); + auto& n = null_map->get_data(); + auto sz = column_left->size(); + if (check_overflow_for_decimal) { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a[i].value(), b.value(), n[i], max_result_number)); + } + } else { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a[i].value(), b.value(), n[i], max_result_number)); + } + } + + return ColumnNullable::create(std::move(column_result), std::move(null_map)); + } + + template + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr constant_vector( ArgA a, ColumnPtr column_right, const typename PrimitiveTypeTraits::CppType& max_result_number, @@ -535,6 +592,38 @@ struct DivideDecimalImpl { return ColumnNullable::create(std::move(column_result), std::move(null_map)); } + template + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr constant_vector( + ArgA a, ColumnPtr column_right, + const typename PrimitiveTypeTraits::CppType& max_result_number, + const typename PrimitiveTypeTraits::CppType& scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + const auto* column_right_ptr = assert_cast(column_right.get()); + auto column_result = + ColumnDecimal::create(column_right->size(), res_data_type.get_scale()); + DCHECK(column_right_ptr != nullptr); + + auto null_map = ColumnUInt8::create(column_right->size(), 0); + const auto& b = column_right_ptr->get_data().data(); + const auto& c = column_result->get_data().data(); + auto& n = null_map->get_data(); + auto sz = column_right->size(); + if (check_overflow_for_decimal) { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a.value(), b[i].value(), n[i], max_result_number)); + } + } else { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a.value(), b[i].value(), n[i], max_result_number)); + } + } + + return ColumnNullable::create(std::move(column_result), std::move(null_map)); + } + template requires(is_decimal(ResultType)) static ColumnPtr vector_vector( @@ -559,13 +648,13 @@ struct DivideDecimalImpl { if constexpr (TypeA == TYPE_DECIMALV2) { if (check_overflow_for_decimal) { for (size_t i = 0; i < sz; ++i) { - c[i] = Decimal128V2( - apply(a[i], b[i], n[i], max_result_number)); + c[i] = DecimalV2Value(apply(a[i].value(), b[i].value(), + n[i], max_result_number)); } } else { for (size_t i = 0; i < sz; ++i) { - c[i] = Decimal128V2(apply(a[i].value, b[i].value, n[i], - max_result_number)); + c[i] = DecimalV2Value(apply(a[i].value(), b[i].value(), + n[i], max_result_number)); } } } else { diff --git a/be/src/vec/functions/function_datetime_floor_ceil.cpp b/be/src/vec/functions/function_datetime_floor_ceil.cpp index 4cf0f6af85e2dc..1a93d094919d63 100644 --- a/be/src/vec/functions/function_datetime_floor_ceil.cpp +++ b/be/src/vec/functions/function_datetime_floor_ceil.cpp @@ -98,9 +98,9 @@ struct YearFloor; template class FunctionDateTimeFloorCeil : public IFunction { public: - using DateType = PrimitiveTypeTraits::DataType; - using DateValueType = PrimitiveTypeTraits::CppType; - using NativeType = PrimitiveTypeTraits::CppNativeType; + using DateType = typename PrimitiveTypeTraits::DataType; + using DateValueType = typename PrimitiveTypeTraits::CppType; + using NativeType = typename PrimitiveTypeTraits::CppNativeType; using DeltaDataType = DataTypeInt32; // return date type = DateType static constexpr auto name = Flag::name; @@ -186,7 +186,7 @@ class FunctionDateTimeFloorCeil : public IFunction { if (remove_nullable(block.get_by_position(arguments[1]).type) ->get_primitive_type() == PrimitiveType::TYPE_INT) { // time_round(datetime,const(period)) - Int32 period = (*argument_columns[1])[0].get(); + Int32 period = (*argument_columns[1])[0].get(); bool period_is_null = block.get_by_position(arguments[1]).type->is_nullable() && block.get_by_position(arguments[1]).column->is_null_at(0); if (period < 1 && !period_is_null) [[unlikely]] { @@ -197,7 +197,7 @@ class FunctionDateTimeFloorCeil : public IFunction { } else { // time_round(datetime, const(origin)) vector_const_anchor(sources->get_data(), - (*argument_columns[1])[0].get(), + (*argument_columns[1])[0].get().to_date_int_val(), col_to->get_data(), result_null_map); } } else { @@ -217,8 +217,8 @@ class FunctionDateTimeFloorCeil : public IFunction { } else { // 3 arg, time_round(datetime, period, origin) if (col_const[1] && col_const[2]) { // time_round(datetime, const(period), const(origin)) - Int32 period = (*argument_columns[1])[0].get(); - NativeType origin = (*argument_columns[2])[0].get(); + Int32 period = (*argument_columns[1])[0].get(); + NativeType origin = (*argument_columns[2])[0].get().to_date_int_val(); bool period_is_null = block.get_by_position(arguments[1]).type->is_nullable() && block.get_by_position(arguments[1]).column->is_null_at(0); if (period < 1 && !period_is_null) [[unlikely]] { @@ -230,7 +230,7 @@ class FunctionDateTimeFloorCeil : public IFunction { const auto arg2_column = check_and_get_column>(*argument_columns[2]); // time_round(datetime, const(period), origin) - Int32 period = (*argument_columns[1])[0].get(); + Int32 period = (*argument_columns[1])[0].get(); bool period_is_null = block.get_by_position(arguments[1]).type->is_nullable() && block.get_by_position(arguments[1]).column->is_null_at(0); if (period < 1 && !period_is_null) [[unlikely]] { @@ -242,8 +242,8 @@ class FunctionDateTimeFloorCeil : public IFunction { const auto* arg1_column = check_and_get_column(*argument_columns[1]); // time_round(datetime, period, const(origin)) vector_vector_const(sources->get_data(), arg1_column->get_data(), - (*argument_columns[2])[0].get(), col_to->get_data(), - result_null_map); + (*argument_columns[2])[0].get().to_date_int_val(), + col_to->get_data(), result_null_map); } else { const auto* arg1_column = check_and_get_column(*argument_columns[1]); const auto arg2_column = diff --git a/be/src/vec/functions/function_dict_get_many.cpp b/be/src/vec/functions/function_dict_get_many.cpp index 744639b92684c3..8ac78fda495b05 100644 --- a/be/src/vec/functions/function_dict_get_many.cpp +++ b/be/src/vec/functions/function_dict_get_many.cpp @@ -97,10 +97,11 @@ class FunctionDictGetMany : public IFunction { // dict get many(name, array, struct) -> struct // get value names - const Array array_names = (*block.get_by_position(arguments[1]).column)[0].get(); + const Array array_names = + (*block.get_by_position(arguments[1]).column)[0].get(); std::vector attribute_names; for (auto field : array_names) { - attribute_names.push_back(field.get()); + attribute_names.push_back(field.template get()); } const auto dict = dict_state->dict; diff --git a/be/src/vec/functions/function_string.h b/be/src/vec/functions/function_string.h index 8fe2be2276390d..bfc51b12e11a8a 100644 --- a/be/src/vec/functions/function_string.h +++ b/be/src/vec/functions/function_string.h @@ -3212,8 +3212,7 @@ struct MoneyFormatDecimalImpl { size_t input_rows_count) { if (auto* decimalv2_column = check_and_get_column(*col_ptr)) { for (size_t i = 0; i < input_rows_count; i++) { - const Decimal128V2& dec128 = decimalv2_column->get_element(i); - DecimalV2Value value = DecimalV2Value(dec128.value); + const auto& value = decimalv2_column->get_element(i); // unified_frac_value has 3 digits auto unified_frac_value = value.frac_value() / 1000000; StringRef str = @@ -3443,8 +3442,7 @@ struct FormatRoundDecimalImpl { "The second argument is {}, it should be in range [0, 1024].", decimal_places); } - const Decimal128V2& dec128 = decimalv2_column->get_element(i); - auto value = DecimalV2Value(dec128.value); + const auto& value = decimalv2_column->get_element(i); // unified_frac_value has 3 digits auto unified_frac_value = value.frac_value() / 1000000; StringRef str = diff --git a/be/src/vec/functions/function_variant_type.cpp b/be/src/vec/functions/function_variant_type.cpp index 434fe3da938a5e..5faa4d3b395316 100644 --- a/be/src/vec/functions/function_variant_type.cpp +++ b/be/src/vec/functions/function_variant_type.cpp @@ -45,10 +45,10 @@ class FunctionVariantType : public IFunction { size_t row) const { std::map result; Field field = column[row]; - const auto& variant_map = field.get(); + const auto& variant_map = field.get(); for (const auto& [key, value] : variant_map) { if (key.empty() && value.base_scalar_type_id == PrimitiveType::TYPE_JSONB && - value.num_dimensions == 0 && value.field.get().get_size() == 0) { + value.num_dimensions == 0 && value.field.get().get_size() == 0) { // ignore empty jsonb root, it's tricky here continue; } diff --git a/be/src/vec/functions/functions_multi_string_position.cpp b/be/src/vec/functions/functions_multi_string_position.cpp index e23d97964c2080..d0f2223c869ea5 100644 --- a/be/src/vec/functions/functions_multi_string_position.cpp +++ b/be/src/vec/functions/functions_multi_string_position.cpp @@ -197,7 +197,8 @@ struct FunctionMultiSearchAllPositionsImpl { if (!is_string_type(needle.get_type())) { return Status::InvalidArgument("invalid type of needle {}", needle.get_type_name()); } - searchers.emplace_back(needle.get().data, needle.get().size); + searchers.emplace_back(needle.get().data(), + needle.get().size()); } const size_t haystack_size = haystack_offsets.size(); diff --git a/be/src/vec/functions/functions_multi_string_search.cpp b/be/src/vec/functions/functions_multi_string_search.cpp index bf9bc118fbdbd6..41cdc7463c3a2d 100644 --- a/be/src/vec/functions/functions_multi_string_search.cpp +++ b/be/src/vec/functions/functions_multi_string_search.cpp @@ -237,7 +237,8 @@ struct FunctionMultiMatchAnyImpl { std::vector needles; needles.reserve(needles_arr.size()); for (const auto& needle : needles_arr) { - needles.emplace_back(needle.get()); + const auto& tmp = needle.get(); + needles.emplace_back(StringRef {tmp.data(), tmp.size()}); } res.resize(haystack_offsets.size()); diff --git a/be/src/vec/functions/math.cpp b/be/src/vec/functions/math.cpp index e7673d2c700a44..deb298ee8586ef 100644 --- a/be/src/vec/functions/math.cpp +++ b/be/src/vec/functions/math.cpp @@ -216,7 +216,9 @@ struct AbsImpl { static constexpr PrimitiveType ResultType = NumberTraits::ResultOfAbs::Type; using DataType = typename PrimitiveTypeTraits::DataType; static inline typename PrimitiveTypeTraits::ColumnItemType apply(A a) { - if constexpr (IsDecimalNumber) { + if constexpr (IsDecimal128V2) { + return DecimalV2Value(a < A(0) ? A(-a) : a); + } else if constexpr (IsDecimalNumber) { return a < A(0) ? A(-a) : a; } else if constexpr (IsIntegralV) { return a < A(0) ? static_cast::ColumnItemType>( @@ -264,83 +266,20 @@ struct ResultOfPosAndNegTive { }; template <> -struct ResultOfPosAndNegTive { - static constexpr PrimitiveType ResultType = TYPE_DECIMAL128I; -}; - -template <> -struct ResultOfPosAndNegTive { - static constexpr PrimitiveType ResultType = TYPE_DECIMAL256; -}; - -template -struct ResultOfUnaryFunc; - -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_BOOLEAN; -}; - -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_TINYINT; -}; - -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_SMALLINT; -}; - -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_INT; -}; - -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_BIGINT; -}; - -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_LARGEINT; -}; - -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_DECIMAL32; -}; - -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_DECIMAL64; +struct ResultOfPosAndNegTive { + static constexpr PrimitiveType ResultType = TYPE_DECIMALV2; }; template <> -struct ResultOfUnaryFunc { +struct ResultOfPosAndNegTive { static constexpr PrimitiveType ResultType = TYPE_DECIMAL128I; }; template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_DECIMALV2; -}; - -template <> -struct ResultOfUnaryFunc { +struct ResultOfPosAndNegTive { static constexpr PrimitiveType ResultType = TYPE_DECIMAL256; }; -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_FLOAT; -}; - -template <> -struct ResultOfUnaryFunc { - static constexpr PrimitiveType ResultType = TYPE_DOUBLE; -}; - using FunctionAbsUInt8 = FunctionUnaryArithmetic, NameAbs, TYPE_BOOLEAN>; using FunctionAbsInt8 = FunctionUnaryArithmetic, NameAbs, TYPE_TINYINT>; using FunctionAbsInt16 = FunctionUnaryArithmetic, NameAbs, TYPE_SMALLINT>; @@ -352,7 +291,7 @@ using FunctionAbsDecimal64 = FunctionUnaryArithmetic, NameAbs using FunctionAbsDecimalV3 = FunctionUnaryArithmetic, NameAbs, TYPE_DECIMAL128I>; using FunctionAbsDecimalV2 = - FunctionUnaryArithmetic, NameAbs, TYPE_DECIMALV2>; + FunctionUnaryArithmetic, NameAbs, TYPE_DECIMALV2>; using FunctionAbsDecimal256 = FunctionUnaryArithmetic, NameAbs, TYPE_DECIMAL256>; using FunctionAbsFloat = FunctionUnaryArithmetic, NameAbs, TYPE_FLOAT>; @@ -377,7 +316,7 @@ using FunctionNegativeDouble = using FunctionNegativeBigInt = FunctionUnaryArithmetic, NameNegative, TYPE_BIGINT>; using FunctionNegativeDecimalV2 = - FunctionUnaryArithmetic, NameNegative, TYPE_DECIMALV2>; + FunctionUnaryArithmetic, NameNegative, TYPE_DECIMALV2>; using FunctionNegativeDecimal256 = FunctionUnaryArithmetic, NameNegative, TYPE_DECIMAL256>; using FunctionNegativeDecimalV3 = @@ -405,7 +344,7 @@ using FunctionPositiveDouble = using FunctionPositiveBigInt = FunctionUnaryArithmetic, NamePositive, TYPE_BIGINT>; using FunctionPositiveDecimalV2 = - FunctionUnaryArithmetic, NamePositive, TYPE_DECIMALV2>; + FunctionUnaryArithmetic, NamePositive, TYPE_DECIMALV2>; using FunctionPositiveDecimal256 = FunctionUnaryArithmetic, NamePositive, TYPE_DECIMAL256>; using FunctionPositiveDecimalV3 = diff --git a/be/src/vec/functions/modulo.cpp b/be/src/vec/functions/modulo.cpp index 6b909aa9e537e6..668fa1d204cc9a 100644 --- a/be/src/vec/functions/modulo.cpp +++ b/be/src/vec/functions/modulo.cpp @@ -587,7 +587,7 @@ struct ModDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr constant_constant( ArgA a, ArgB b, const typename PrimitiveTypeTraits::CppType& max_result_number, @@ -611,7 +611,31 @@ struct ModDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr constant_constant( + ArgA a, ArgB b, + const typename PrimitiveTypeTraits::CppType& max_result_number, + const typename PrimitiveTypeTraits::CppType& scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + auto column_result = ColumnDecimal::create(1, res_data_type.get_scale()); + + auto null_map = ColumnUInt8::create(1, 0); + if (check_overflow_for_decimal) { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType( + apply(a.value(), b.value(), null_map->get_element(0), + max_result_number)); + } else { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType( + apply(a.value(), b.value(), null_map->get_element(0), + max_result_number)); + } + return ColumnNullable::create(std::move(column_result), std::move(null_map)); + } + + template + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr vector_constant( ColumnPtr column_left, ArgB b, const typename PrimitiveTypeTraits::CppType& max_result_number, @@ -642,7 +666,38 @@ struct ModDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr vector_constant( + ColumnPtr column_left, ArgB b, + const typename PrimitiveTypeTraits::CppType& max_result_number, + const typename PrimitiveTypeTraits::CppType& scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + const auto* column_left_ptr = assert_cast(column_left.get()); + auto column_result = + ColumnDecimal::create(column_left->size(), res_data_type.get_scale()); + DCHECK(column_left_ptr != nullptr); + + auto null_map = ColumnUInt8::create(column_left->size(), 0); + const auto& a = column_left_ptr->get_data().data(); + const auto& c = column_result->get_data().data(); + auto& n = null_map->get_data(); + auto sz = column_left->size(); + if (check_overflow_for_decimal) { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a[i].value(), b.value(), n[i], max_result_number)); + } + } else { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a[i].value(), b.value(), n[i], max_result_number)); + } + } + return ColumnNullable::create(std::move(column_result), std::move(null_map)); + } + + template + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr constant_vector( ArgA a, ColumnPtr column_right, const typename PrimitiveTypeTraits::CppType& max_result_number, @@ -674,7 +729,39 @@ struct ModDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr constant_vector( + ArgA a, ColumnPtr column_right, + const typename PrimitiveTypeTraits::CppType& max_result_number, + const typename PrimitiveTypeTraits::CppType& scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + const auto* column_right_ptr = assert_cast(column_right.get()); + auto column_result = + ColumnDecimal::create(column_right->size(), res_data_type.get_scale()); + DCHECK(column_right_ptr != nullptr); + + auto null_map = ColumnUInt8::create(column_right->size(), 0); + const auto& b = column_right_ptr->get_data().data(); + const auto& c = column_result->get_data().data(); + auto& n = null_map->get_data(); + auto sz = column_right->size(); + if (check_overflow_for_decimal) { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a.value(), b[i].value(), n[i], max_result_number)); + } + } else { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a.value(), b[i].value(), n[i], max_result_number)); + } + } + + return ColumnNullable::create(std::move(column_result), std::move(null_map)); + } + + template + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr vector_vector( ColumnPtr column_left, ColumnPtr column_right, const typename PrimitiveTypeTraits::CppType max_result_number, @@ -694,30 +781,50 @@ struct ModDecimalImpl { const auto& c = column_result->get_data().data(); auto& n = null_map->get_data(); auto sz = column_right->size(); - if constexpr (DataTypeA::PType == TYPE_DECIMALV2) { - if (check_overflow_for_decimal) { - for (size_t i = 0; i < sz; ++i) { - c[i] = Decimal128V2(apply(a[i].value, b[i].value, n[i], - max_result_number)); - } - } else { - for (size_t i = 0; i < sz; ++i) { - c[i] = Decimal128V2(apply(a[i].value, b[i].value, n[i], - max_result_number)); - } + if (check_overflow_for_decimal) { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a[i].value, b[i].value, n[i], max_result_number)); } + } else { + for (size_t i = 0; i < sz; ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply(a[i].value, b[i].value, n[i], max_result_number)); + } + } + return ColumnNullable::create(std::move(column_result), std::move(null_map)); + } + + template + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr vector_vector( + ColumnPtr column_left, ColumnPtr column_right, + const typename PrimitiveTypeTraits::CppType max_result_number, + const typename PrimitiveTypeTraits::CppType scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + const auto* column_left_ptr = assert_cast(column_left.get()); + const auto* column_right_ptr = assert_cast(column_right.get()); + auto column_result = + ColumnDecimal::create(column_left->size(), res_data_type.get_scale()); + DCHECK(column_left_ptr != nullptr && column_right_ptr != nullptr); + + // function divide, modulo and pmod + auto null_map = ColumnUInt8::create(column_result->size(), 0); + const auto& a = column_left_ptr->get_data().data(); + const auto& b = column_right_ptr->get_data().data(); + const auto& c = column_result->get_data().data(); + auto& n = null_map->get_data(); + auto sz = column_right->size(); + if (check_overflow_for_decimal) { + for (size_t i = 0; i < sz; ++i) { + c[i] = DecimalV2Value(apply(a[i].value(), b[i].value(), n[i], + max_result_number)); + } } else { - if (check_overflow_for_decimal) { - for (size_t i = 0; i < sz; ++i) { - c[i] = typename DataTypeDecimal::FieldType(apply( - a[i].value, b[i].value, n[i], max_result_number)); - } - } else { - for (size_t i = 0; i < sz; ++i) { - c[i] = typename DataTypeDecimal::FieldType(apply( - a[i].value, b[i].value, n[i], max_result_number)); - } + for (size_t i = 0; i < sz; ++i) { + c[i] = DecimalV2Value(apply(a[i].value(), b[i].value(), n[i], + max_result_number)); } } return ColumnNullable::create(std::move(column_result), std::move(null_map)); diff --git a/be/src/vec/functions/multiply.cpp b/be/src/vec/functions/multiply.cpp index f3e9b40a464f43..74647fea41340c 100644 --- a/be/src/vec/functions/multiply.cpp +++ b/be/src/vec/functions/multiply.cpp @@ -132,7 +132,7 @@ struct MultiplyDecimalImpl { } template - requires(is_decimal(Result)) + requires(is_decimal(Result) && Result != TYPE_DECIMALV2) static inline typename PrimitiveTypeTraits::CppNativeType apply(ArgNativeTypeA a, ArgNativeTypeB b) { return static_cast::CppNativeType>( @@ -155,7 +155,7 @@ struct MultiplyDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr constant_constant( ArgA a, ArgB b, const DataTypeA* type_left, const DataTypeB* type_right, const typename PrimitiveTypeTraits::ColumnItemType& max_result_number, @@ -179,7 +179,31 @@ struct MultiplyDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr constant_constant( + ArgA a, ArgB b, const DataTypeA* type_left, const DataTypeB* type_right, + const typename PrimitiveTypeTraits::ColumnItemType& max_result_number, + const typename PrimitiveTypeTraits::ColumnItemType& scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + auto column_result = ColumnDecimal::create(1, res_data_type.get_scale()); + + if (check_overflow_for_decimal) { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType(apply( + a.value(), b.value(), *type_left, *type_right, res_data_type, + max_result_number, scale_diff_multiplier)); + } else { + column_result->get_element(0) = + typename PrimitiveTypeTraits::ColumnItemType(apply( + a.value(), b.value(), *type_left, *type_right, res_data_type, + max_result_number, scale_diff_multiplier)); + } + + return column_result; + } + + template + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr vector_constant( ColumnPtr column_left, ArgB b, const DataTypeA* type_left, const DataTypeB* type_right, const typename PrimitiveTypeTraits::ColumnItemType& max_result_number, @@ -209,7 +233,37 @@ struct MultiplyDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr vector_constant( + ColumnPtr column_left, ArgB b, const DataTypeA* type_left, const DataTypeB* type_right, + const typename PrimitiveTypeTraits::ColumnItemType& max_result_number, + const typename PrimitiveTypeTraits::ColumnItemType& scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + const auto* column_left_ptr = assert_cast(column_left.get()); + auto column_result = + ColumnDecimal::create(column_left->size(), res_data_type.get_scale()); + DCHECK(column_left_ptr != nullptr); + + bool need_adjust_scale = scale_diff_multiplier.value() > 1; + const auto& a = column_left_ptr->get_data(); + auto& c = column_result->get_data(); + std::visit( + [&](auto need_adjust_scale, auto check_overflow_for_decimal) { + for (size_t i = 0; i < column_left->size(); ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply( + a[i].value(), b.value(), *type_left, *type_right, + res_data_type, max_result_number, scale_diff_multiplier)); + } + }, + make_bool_variant(need_adjust_scale), + make_bool_variant(check_overflow_for_decimal)); + + return column_result; + } + + template + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ColumnPtr constant_vector( ArgA a, ColumnPtr column_right, const DataTypeA* type_left, const DataTypeB* type_right, const typename PrimitiveTypeTraits::ColumnItemType& max_result_number, @@ -236,6 +290,34 @@ struct MultiplyDecimalImpl { return column_result; } + template + requires(ResultType == TYPE_DECIMALV2) + static ColumnPtr constant_vector( + ArgA a, ColumnPtr column_right, const DataTypeA* type_left, const DataTypeB* type_right, + const typename PrimitiveTypeTraits::ColumnItemType& max_result_number, + const typename PrimitiveTypeTraits::ColumnItemType& scale_diff_multiplier, + const DataTypeDecimal& res_data_type, bool check_overflow_for_decimal) { + const auto* column_right_ptr = assert_cast(column_right.get()); + auto column_result = + ColumnDecimal::create(column_right->size(), res_data_type.get_scale()); + + bool need_adjust_scale = scale_diff_multiplier.value() > 1; + auto& b = column_right_ptr->get_data(); + auto& c = column_result->get_data(); + std::visit( + [&](auto need_adjust_scale, auto check_overflow_for_decimal) { + for (size_t i = 0; i < column_right->size(); ++i) { + c[i] = typename DataTypeDecimal::FieldType( + apply( + a.value(), b[i].value(), *type_left, *type_right, + res_data_type, max_result_number, scale_diff_multiplier)); + } + }, + make_bool_variant(need_adjust_scale), + make_bool_variant(check_overflow_for_decimal)); + return column_result; + } + /* select 999999999999999999999999999 * 999999999999999999999999999; 999999999999999999999999998000000000.000000000000000001 54 digits @@ -271,8 +353,9 @@ struct MultiplyDecimalImpl { DecimalV2Value(b[i]).to_string(), DecimalV2Value(i128_mul_result).to_string(), "decimalv2"); } - c[i] = (i128_mul_result - sgn[i]) / DecimalV2Value::ONE_BILLION + sgn[i]; - if (c[i].value > max.value() || c[i].value < min.value()) { + c[i] = DecimalV2Value((i128_mul_result - sgn[i]) / DecimalV2Value::ONE_BILLION + + sgn[i]); + if (c[i].value() > max.value() || c[i].value() < min.value()) { throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, "Arithmetic overflow: {} {} {} = {}, result type: {}", DecimalV2Value(a[i]).to_string(), "multiply", @@ -280,9 +363,10 @@ struct MultiplyDecimalImpl { DecimalV2Value(i128_mul_result).to_string(), "decimalv2"); } } else { - c[i] = (DecimalV2Value(a[i]).value() * DecimalV2Value(b[i]).value() - sgn[i]) / - DecimalV2Value::ONE_BILLION + - sgn[i]; + c[i] = DecimalV2Value( + (DecimalV2Value(a[i]).value() * DecimalV2Value(b[i]).value() - sgn[i]) / + DecimalV2Value::ONE_BILLION + + sgn[i]); } } } @@ -349,95 +433,55 @@ struct MultiplyDecimalImpl { } template - requires(is_decimal(ResultType)) + requires(is_decimal(ResultType) && ResultType != TYPE_DECIMALV2) static ALWAYS_INLINE typename PrimitiveTypeTraits::CppNativeType apply( ArgNativeTypeA a, ArgNativeTypeB b, const DataTypeA& type_left, const DataTypeB& type_right, const DataTypeDecimal& type_result, const typename PrimitiveTypeTraits::ColumnItemType& max_result_number, const typename PrimitiveTypeTraits::ColumnItemType& scale_diff_multiplier) { - if constexpr (ResultType == TYPE_DECIMALV2) { - // Now, Doris only support decimal +-*/ decimal. - if constexpr (check_overflow) { - auto res = apply(DecimalV2Value(a), DecimalV2Value(b)).value(); - if (res > max_result_number.value || res < -max_result_number.value) { - throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, - "Arithmetic overflow: {} {} {} = {}, result type: {}", - DecimalV2Value(a).to_string(), "multiply", - DecimalV2Value(b).to_string(), DecimalV2Value(res).to_string(), - type_to_string(ResultType)); - } - return res; - } else { - return apply(DecimalV2Value(a), DecimalV2Value(b)).value(); - } - } else { - typename PrimitiveTypeTraits::CppNativeType res; - if constexpr (check_overflow) { - // TODO handle overflow gracefully - if (UNLIKELY(apply(a, b, res))) { - // multiply - if constexpr (ResultType == TYPE_DECIMAL128I) { - wide::Int256 res256 = apply(a, b); - if constexpr (need_adjust_scale) { - if (res256 > 0) { - res256 = (res256 + scale_diff_multiplier.value / 2) / - scale_diff_multiplier.value; - - } else { - res256 = (res256 - scale_diff_multiplier.value / 2) / - scale_diff_multiplier.value; - } - } - // check if final result is overflow - if (res256 > wide::Int256(max_result_number.value) || - res256 < wide::Int256(-max_result_number.value)) { - auto result_str = - DataTypeDecimal256 {BeConsts::MAX_DECIMAL256_PRECISION, - type_result.get_scale()} - .to_string(Decimal256(res256)); - throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, - "Arithmetic overflow: {} {} {} = {}, result type: {}", - type_left.to_string(ArgA(a)), "multiply", - type_right.to_string(ArgB(b)), result_str, - type_result.get_name()); - } else { - res = res256; - } - } else { - auto result_str = DataTypeDecimal256 {BeConsts::MAX_DECIMAL256_PRECISION, - type_result.get_scale()} - .to_string(Decimal256(res)); - throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, - "Arithmetic overflow: {} {} {} = {}, result type: {}", - type_left.to_string(ArgA(a)), "multiply", - type_right.to_string(ArgB(b)), result_str, - type_result.get_name()); - } - } else { - // round to final result precision + typename PrimitiveTypeTraits::CppNativeType res; + if constexpr (check_overflow) { + // TODO handle overflow gracefully + if (UNLIKELY(apply(a, b, res))) { + // multiply + if constexpr (ResultType == TYPE_DECIMAL128I) { + wide::Int256 res256 = apply(a, b); if constexpr (need_adjust_scale) { - if (res >= 0) { - res = (res + scale_diff_multiplier.value / 2) / - scale_diff_multiplier.value; + if (res256 > 0) { + res256 = (res256 + scale_diff_multiplier.value / 2) / + scale_diff_multiplier.value; + } else { - res = (res - scale_diff_multiplier.value / 2) / - scale_diff_multiplier.value; + res256 = (res256 - scale_diff_multiplier.value / 2) / + scale_diff_multiplier.value; } } - if (res > max_result_number.value || res < -max_result_number.value) { + // check if final result is overflow + if (res256 > wide::Int256(max_result_number.value) || + res256 < wide::Int256(-max_result_number.value)) { auto result_str = DataTypeDecimal256 {BeConsts::MAX_DECIMAL256_PRECISION, type_result.get_scale()} - .to_string(Decimal256(res)); + .to_string(Decimal256(res256)); throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, "Arithmetic overflow: {} {} {} = {}, result type: {}", type_left.to_string(ArgA(a)), "multiply", type_right.to_string(ArgB(b)), result_str, type_result.get_name()); + } else { + res = res256; } + } else { + auto result_str = DataTypeDecimal256 {BeConsts::MAX_DECIMAL256_PRECISION, + type_result.get_scale()} + .to_string(Decimal256(res)); + throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, + "Arithmetic overflow: {} {} {} = {}, result type: {}", + type_left.to_string(ArgA(a)), "multiply", + type_right.to_string(ArgB(b)), result_str, + type_result.get_name()); } - return res; } else { - res = apply(a, b); + // round to final result precision if constexpr (need_adjust_scale) { if (res >= 0) { res = (res + scale_diff_multiplier.value / 2) / scale_diff_multiplier.value; @@ -445,8 +489,51 @@ struct MultiplyDecimalImpl { res = (res - scale_diff_multiplier.value / 2) / scale_diff_multiplier.value; } } - return res; + if (res > max_result_number.value || res < -max_result_number.value) { + auto result_str = DataTypeDecimal256 {BeConsts::MAX_DECIMAL256_PRECISION, + type_result.get_scale()} + .to_string(Decimal256(res)); + throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, + "Arithmetic overflow: {} {} {} = {}, result type: {}", + type_left.to_string(ArgA(a)), "multiply", + type_right.to_string(ArgB(b)), result_str, + type_result.get_name()); + } } + return res; + } else { + res = apply(a, b); + if constexpr (need_adjust_scale) { + if (res >= 0) { + res = (res + scale_diff_multiplier.value / 2) / scale_diff_multiplier.value; + } else { + res = (res - scale_diff_multiplier.value / 2) / scale_diff_multiplier.value; + } + } + return res; + } + } + + template + requires(ResultType == TYPE_DECIMALV2) + static ALWAYS_INLINE typename PrimitiveTypeTraits::CppNativeType apply( + ArgNativeTypeA a, ArgNativeTypeB b, const DataTypeA& type_left, + const DataTypeB& type_right, const DataTypeDecimal& type_result, + const typename PrimitiveTypeTraits::ColumnItemType& max_result_number, + const typename PrimitiveTypeTraits::ColumnItemType& scale_diff_multiplier) { + // Now, Doris only support decimal +-*/ decimal. + if constexpr (check_overflow) { + auto res = apply(DecimalV2Value(a), DecimalV2Value(b)).value(); + if (res > max_result_number.value() || res < -max_result_number.value()) { + throw Exception(ErrorCode::ARITHMETIC_OVERFLOW_ERRROR, + "Arithmetic overflow: {} {} {} = {}, result type: {}", + DecimalV2Value(a).to_string(), "multiply", + DecimalV2Value(b).to_string(), DecimalV2Value(res).to_string(), + type_to_string(ResultType)); + } + return res; + } else { + return apply(DecimalV2Value(a), DecimalV2Value(b)).value(); } } diff --git a/be/src/vec/functions/random.cpp b/be/src/vec/functions/random.cpp index 7bcd3b145e1f91..4b9301ab36e402 100644 --- a/be/src/vec/functions/random.cpp +++ b/be/src/vec/functions/random.cpp @@ -74,7 +74,8 @@ class Random : public IFunction { } uint32_t seed = 0; if (!context->get_constant_col(0)->column_ptr->is_null_at(0)) { - seed = (uint32_t)(*context->get_constant_col(0)->column_ptr)[0].get(); + seed = (uint32_t)(*context->get_constant_col(0)->column_ptr)[0] + .get(); } generator->seed(seed); } else if (context->get_num_args() == 2) { diff --git a/be/src/vec/functions/round.h b/be/src/vec/functions/round.h index 7f8bbfe6e83382..11f150235b54c1 100644 --- a/be/src/vec/functions/round.h +++ b/be/src/vec/functions/round.h @@ -457,6 +457,42 @@ struct Dispatcher { } } + return col_res; + } else if constexpr (T == TYPE_DECIMALV2) { + const auto* const decimal_col = + check_and_get_column::ColumnType>(col_general); + const auto& vec_src = decimal_col->get_data(); + const size_t input_rows_count = vec_src.size(); + auto col_res = PrimitiveTypeTraits::ColumnType::create(vec_src.size(), result_scale); + auto& vec_res = col_res->get_data(); + + if (!vec_res.empty()) { + FunctionRoundingImpl::apply( + decimal_col->get_data(), decimal_col->get_scale(), vec_res, scale_arg); + } + // We need to always make sure result decimal's scale is as expected as its in plan + // So we need to append enough zero to result. + + // Case 0: scale_arg <= -(integer part digits count) + // do nothing, because result is 0 + // Case 1: scale_arg <= 0 && scale_arg > -(integer part digits count) + // decimal parts has been erased, so add them back by multiply 10^(result_scale) + // Case 2: scale_arg > 0 && scale_arg < result_scale + // decimal part now has scale_arg digits, so multiply 10^(result_scale - scal_arg) + // Case 3: scale_arg >= input_scale + // do nothing + + if (scale_arg <= 0) { + for (size_t i = 0; i < input_rows_count; ++i) { + vec_res[i] = DecimalV2Value(vec_res[i].value() * int_exp10(result_scale)); + } + } else if (scale_arg > 0 && scale_arg < result_scale) { + for (size_t i = 0; i < input_rows_count; ++i) { + vec_res[i] = DecimalV2Value(vec_res[i].value() * + int_exp10(result_scale - scale_arg)); + } + } + return col_res; } else if constexpr (is_decimal(T)) { const auto* const decimal_col = @@ -536,6 +572,42 @@ struct Dispatcher { vec_res[i]); } } + return col_res; + } else if constexpr (T == TYPE_DECIMALV2) { + const auto* decimal_col = + assert_cast::ColumnType*>(col_general); + const Int32 input_scale = decimal_col->get_scale(); + auto col_res = + PrimitiveTypeTraits::ColumnType::create(input_row_count, result_scale); + + for (size_t i = 0; i < input_row_count; ++i) { + DecimalRoundingImpl::apply( + decimal_col->get_element(i).value(), input_scale, + col_res->get_element(i).value(), col_scale_i32.get_data()[i]); + } + + for (size_t i = 0; i < input_row_count; ++i) { + // For func(ColumnDecimal, ColumnInt32), we should always have same scale with source Decimal column + // So we need this check to make sure the result have correct digits count + // + // Case 0: scale_arg <= -(integer part digits count) + // do nothing, because result is 0 + // Case 1: scale_arg <= 0 && scale_arg > -(integer part digits count) + // decimal parts has been erased, so add them back by multiply 10^(scale_arg) + // Case 2: scale_arg > 0 && scale_arg < result_scale + // decimal part now has scale_arg digits, so multiply 10^(result_scale - scal_arg) + // Case 3: scale_arg >= input_scale + // do nothing + const Int32 scale_arg = col_scale_i32.get_data()[i]; + if (scale_arg <= 0) { + col_res->get_element(i) = DecimalV2Value(col_res->get_element(i).value() * + int_exp10(result_scale)); + } else if (scale_arg > 0 && scale_arg < result_scale) { + col_res->get_element(i) = DecimalV2Value(col_res->get_element(i).value() * + int_exp10(result_scale - scale_arg)); + } + } + return col_res; } else if constexpr (is_decimal(T)) { const auto* decimal_col = @@ -593,7 +665,45 @@ struct Dispatcher { } } - if constexpr (is_decimal(T)) { + if constexpr (T == TYPE_DECIMALV2) { + const typename PrimitiveTypeTraits::ColumnType& data_col_general = + assert_cast::ColumnType&>( + const_col_general->get_data_column()); + const auto& general_val = data_col_general.get_data()[0]; + Int32 input_scale = data_col_general.get_scale(); + auto col_res = + PrimitiveTypeTraits::ColumnType::create(input_rows_count, result_scale); + + for (size_t i = 0; i < input_rows_count; ++i) { + DecimalRoundingImpl::apply( + general_val, input_scale, col_res->get_element(i).value(), + col_scale_i32.get_data()[i]); + } + + for (size_t i = 0; i < input_rows_count; ++i) { + // For func(ColumnDecimal, ColumnInt32), we should always have same scale with source Decimal column + // So we need this check to make sure the result have correct digits count + // + // Case 0: scale_arg <= -(integer part digits count) + // do nothing, because result is 0 + // Case 1: scale_arg <= 0 && scale_arg > -(integer part digits count) + // decimal parts has been erased, so add them back by multiply 10^(scale_arg) + // Case 2: scale_arg > 0 && scale_arg < result_scale + // decimal part now has scale_arg digits, so multiply 10^(result_scale - scal_arg) + // Case 3: scale_arg >= input_scale + // do nothing + const Int32 scale_arg = col_scale_i32.get_data()[i]; + if (scale_arg <= 0) { + col_res->get_element(i) = DecimalV2Value(col_res->get_element(i).value() * + int_exp10(result_scale)); + } else if (scale_arg > 0 && scale_arg < result_scale) { + col_res->get_element(i) = DecimalV2Value(col_res->get_element(i).value() * + int_exp10(result_scale - scale_arg)); + } + } + + return col_res; + } else if constexpr (is_decimal(T)) { const typename PrimitiveTypeTraits::ColumnType& data_col_general = assert_cast::ColumnType&>( const_col_general->get_data_column()); diff --git a/be/src/vec/functions/uniform.cpp b/be/src/vec/functions/uniform.cpp index 56d85b26199045..a6124bae40026f 100644 --- a/be/src/vec/functions/uniform.cpp +++ b/be/src/vec/functions/uniform.cpp @@ -79,7 +79,7 @@ struct UniformIntImpl { for (int i = 0; i < input_rows_count; i++) { // Use gen value as seed for each row - auto seed = (*gen_column)[i].get(); + auto seed = (*gen_column)[i].get(); std::mt19937_64 generator(seed); std::uniform_int_distribution distribution(min, max); res_data[i] = distribution(generator); @@ -127,7 +127,7 @@ struct UniformDoubleImpl { for (int i = 0; i < input_rows_count; i++) { // Use gen value as seed for each row - auto seed = (*gen_column)[i].get(); + auto seed = (*gen_column)[i].get(); std::mt19937_64 generator(seed); std::uniform_real_distribution distribution(min, max); res_data[i] = distribution(generator); diff --git a/be/src/vec/io/io_helper.h b/be/src/vec/io/io_helper.h index fae49ffad5eb73..6e0cf2674b02c2 100644 --- a/be/src/vec/io/io_helper.h +++ b/be/src/vec/io/io_helper.h @@ -217,15 +217,16 @@ template StringParser::ParseResult read_decimal_text_impl(T& x, const StringRef& buf, UInt32 precision, UInt32 scale) { static_assert(IsDecimalNumber); - if constexpr (!std::is_same_v) { + if constexpr (!std::is_same_v) { StringParser::ParseResult result = StringParser::PARSE_SUCCESS; x.value = StringParser::string_to_decimal

(buf.data, (int)buf.size, precision, scale, &result); return result; } else { StringParser::ParseResult result = StringParser::PARSE_SUCCESS; - x.value = StringParser::string_to_decimal( - buf.data, (int)buf.size, DecimalV2Value::PRECISION, DecimalV2Value::SCALE, &result); + x = DecimalV2Value(StringParser::string_to_decimal( + buf.data, (int)buf.size, DecimalV2Value::PRECISION, DecimalV2Value::SCALE, + &result)); return result; } } diff --git a/be/src/vec/json/json_parser.cpp b/be/src/vec/json/json_parser.cpp index 00d023b6c7c261..e4ad2bfe7c560d 100644 --- a/be/src/vec/json/json_parser.cpp +++ b/be/src/vec/json/json_parser.cpp @@ -264,7 +264,7 @@ void JSONDataParser::handleExistingPath(std::pair(value).size(); + size_t array_size = value.get().size(); auto& current_nested_sizes = ctx.nested_sizes_by_key[nested_key]; if (current_nested_sizes.size() == ctx.current_size) { current_nested_sizes.push_back(array_size); @@ -293,7 +293,7 @@ void JSONDataParser::handleNewPath(UInt128 hash, const PathInData::P auto nested_key = getNameOfNested(path, value); if (!nested_key.empty()) { - size_t array_size = get(value).size(); + size_t array_size = value.get().size(); auto& current_nested_sizes = ctx.nested_sizes_by_key[nested_key]; if (current_nested_sizes.empty()) { current_nested_sizes.resize(ctx.current_size); diff --git a/be/src/vec/sink/vtablet_block_convertor.cpp b/be/src/vec/sink/vtablet_block_convertor.cpp index e9bff30dba927f..a006ebaf4903f2 100644 --- a/be/src/vec/sink/vtablet_block_convertor.cpp +++ b/be/src/vec/sink/vtablet_block_convertor.cpp @@ -365,7 +365,7 @@ Status OlapTableBlockConvertor::_internal_validate_column( if (dec_val.greater_than_scale(type->get_scale())) { auto code = dec_val.round(&dec_val, remove_nullable(type)->get_scale(), HALF_UP); - column_decimal->get_data()[j] = dec_val.value(); + column_decimal->get_data()[j] = dec_val; if (code != E_DEC_OK) { fmt::format_to(error_msg, "round one decimal failed.value={}; ", diff --git a/be/src/vec/sink/writer/iceberg/viceberg_table_writer.cpp b/be/src/vec/sink/writer/iceberg/viceberg_table_writer.cpp index 24b29df5cdb70b..6f4400418eb517 100644 --- a/be/src/vec/sink/writer/iceberg/viceberg_table_writer.cpp +++ b/be/src/vec/sink/writer/iceberg/viceberg_table_writer.cpp @@ -604,7 +604,7 @@ std::any VIcebergTableWriter::_get_iceberg_partition_value( case TYPE_BOOLEAN: { vectorized::Field field = vectorized::check_and_get_column(*col_ptr)->operator[](position); - return field.get(); + return field.get(); } case TYPE_TINYINT: { return *reinterpret_cast(item); diff --git a/be/src/vec/sink/writer/vhive_table_writer.cpp b/be/src/vec/sink/writer/vhive_table_writer.cpp index 6fb49419b045ad..d99fe86535c420 100644 --- a/be/src/vec/sink/writer/vhive_table_writer.cpp +++ b/be/src/vec/sink/writer/vhive_table_writer.cpp @@ -454,7 +454,7 @@ std::string VHiveTableWriter::_to_partition_value(const DataTypePtr& type_desc, case TYPE_BOOLEAN: { vectorized::Field field = vectorized::check_and_get_column(*column)->operator[](position); - return std::to_string(field.get()); + return std::to_string(field.get()); } case TYPE_TINYINT: { return std::to_string(*reinterpret_cast(item)); diff --git a/be/test/exec/schema_scanner/schema_cluster_snapshot_properties_scanner_test.cpp b/be/test/exec/schema_scanner/schema_cluster_snapshot_properties_scanner_test.cpp index be70016e285bd6..23c81d36e37fb0 100644 --- a/be/test/exec/schema_scanner/schema_cluster_snapshot_properties_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_cluster_snapshot_properties_scanner_test.cpp @@ -43,7 +43,7 @@ TEST_F(SchemaClusterSnapshotPropertiesScannerTest, test_get_next_block_internal) ASSERT_EQ(1, data_block->rows()); auto col = data_block->safe_get_by_position(2); - auto v = (*col.column)[0].get(); + auto v = (*col.column)[0].get(); EXPECT_EQ(v, 30); } diff --git a/be/test/exec/schema_scanner/schema_cluster_snapshots_scanner_test.cpp b/be/test/exec/schema_scanner/schema_cluster_snapshots_scanner_test.cpp index a831076efdcc76..77c1ac1f7c9459 100644 --- a/be/test/exec/schema_scanner/schema_cluster_snapshots_scanner_test.cpp +++ b/be/test/exec/schema_scanner/schema_cluster_snapshots_scanner_test.cpp @@ -60,7 +60,7 @@ TEST_F(SchemaClusterSnapshotsScannerTest, test_get_next_block_internal) { ASSERT_EQ(2, data_block->rows()); auto col = data_block->safe_get_by_position(0); - auto v = (*col.column)[1].get(); + auto v = (*col.column)[1].get(); EXPECT_EQ(v, "232ds"); } diff --git a/be/test/olap/rowset/segment_v2/inverted_index_query_param_test.cpp b/be/test/olap/rowset/segment_v2/inverted_index_query_param_test.cpp index 7334b2e761e7ea..36e9106f4fd87a 100644 --- a/be/test/olap/rowset/segment_v2/inverted_index_query_param_test.cpp +++ b/be/test/olap/rowset/segment_v2/inverted_index_query_param_test.cpp @@ -33,7 +33,7 @@ class InvertedIndexQueryParamTest : public testing::Test { // ==================== Integer Types Tests ==================== TEST_F(InvertedIndexQueryParamTest, TestBooleanWithField) { - auto field = vectorized::Field::create_field(static_cast(1)); + auto field = vectorized::Field::create_field(static_cast(1)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_BOOLEAN, &field, param); @@ -44,7 +44,7 @@ TEST_F(InvertedIndexQueryParamTest, TestBooleanWithField) { } TEST_F(InvertedIndexQueryParamTest, TestBooleanWithFieldFalse) { - auto field = vectorized::Field::create_field(static_cast(0)); + auto field = vectorized::Field::create_field(static_cast(0)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_BOOLEAN, &field, param); @@ -64,7 +64,7 @@ TEST_F(InvertedIndexQueryParamTest, TestBooleanTemplateWithNativeValue) { } TEST_F(InvertedIndexQueryParamTest, TestTinyIntWithField) { - auto field = vectorized::Field::create_field(static_cast(42)); + auto field = vectorized::Field::create_field(static_cast(42)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_TINYINT, &field, param); @@ -84,7 +84,8 @@ TEST_F(InvertedIndexQueryParamTest, TestTinyIntTemplateWithNativeValue) { } TEST_F(InvertedIndexQueryParamTest, TestSmallIntWithField) { - auto field = vectorized::Field::create_field(static_cast(1234)); + auto field = + vectorized::Field::create_field(static_cast(1234)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_SMALLINT, &field, param); @@ -104,8 +105,7 @@ TEST_F(InvertedIndexQueryParamTest, TestSmallIntTemplateWithNativeValue) { } TEST_F(InvertedIndexQueryParamTest, TestIntWithField) { - auto field = - vectorized::Field::create_field(static_cast(123456)); + auto field = vectorized::Field::create_field(static_cast(123456)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_INT, &field, param); @@ -305,7 +305,7 @@ TEST_F(InvertedIndexQueryParamTest, TestStringWithSpecialCharacters) { TEST_F(InvertedIndexQueryParamTest, TestDecimalV2WithField) { // DecimalV2 uses Int128 as underlying storage vectorized::Int128 dec_value = 123456789; - auto field = vectorized::Field::create_field(dec_value); + auto field = vectorized::Field::create_field(DecimalV2Value(dec_value)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_DECIMALV2, &field, param); @@ -316,7 +316,7 @@ TEST_F(InvertedIndexQueryParamTest, TestDecimalV2WithField) { TEST_F(InvertedIndexQueryParamTest, TestDecimal32WithField) { // Decimal32 uses Int64 for Field storage vectorized::Int64 dec_value = 12345; - auto field = vectorized::Field::create_field(dec_value); + auto field = vectorized::Field::create_field(dec_value); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_DECIMAL32, &field, param); @@ -327,7 +327,7 @@ TEST_F(InvertedIndexQueryParamTest, TestDecimal32WithField) { TEST_F(InvertedIndexQueryParamTest, TestDecimal64WithField) { // Decimal64 uses Int64 for Field storage vectorized::Int64 dec_value = 123456789012; - auto field = vectorized::Field::create_field(dec_value); + auto field = vectorized::Field::create_field(dec_value); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_DECIMAL64, &field, param); @@ -338,7 +338,7 @@ TEST_F(InvertedIndexQueryParamTest, TestDecimal64WithField) { TEST_F(InvertedIndexQueryParamTest, TestDecimal128IWithField) { // Decimal128I uses Int128 for Field storage vectorized::Int128 dec_value = 123456789012345LL; - auto field = vectorized::Field::create_field(dec_value); + auto field = vectorized::Field::create_field(dec_value); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value( PrimitiveType::TYPE_DECIMAL128I, &field, param); @@ -349,7 +349,8 @@ TEST_F(InvertedIndexQueryParamTest, TestDecimal128IWithField) { TEST_F(InvertedIndexQueryParamTest, TestDecimal256WithField) { // Decimal256 uses Int128 for Field storage vectorized::Int128 dec_value = 123456789012345LL; - auto field = vectorized::Field::create_field(dec_value); + auto field = vectorized::Field::create_field( + vectorized::Decimal(dec_value)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_DECIMAL256, &field, param); @@ -360,8 +361,9 @@ TEST_F(InvertedIndexQueryParamTest, TestDecimal256WithField) { // ==================== Date/Time Types Tests ==================== TEST_F(InvertedIndexQueryParamTest, TestDateWithField) { - auto field = - vectorized::Field::create_field(static_cast(20231205)); + VecDateTimeValue tmp; + tmp.from_date_int64(20231205); + auto field = vectorized::Field::create_field(tmp); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_DATE, &field, param); @@ -370,8 +372,9 @@ TEST_F(InvertedIndexQueryParamTest, TestDateWithField) { } TEST_F(InvertedIndexQueryParamTest, TestDateTimeWithField) { - auto field = vectorized::Field::create_field( - static_cast(20231205120000LL)); + VecDateTimeValue tmp; + tmp.create_from_olap_datetime(20231205120000LL); + auto field = vectorized::Field::create_field(tmp); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_DATETIME, &field, param); @@ -381,8 +384,9 @@ TEST_F(InvertedIndexQueryParamTest, TestDateTimeWithField) { TEST_F(InvertedIndexQueryParamTest, TestDateV2WithField) { vectorized::UInt64 v = 20231205; - auto field = vectorized::Field::create_field( - *(typename PrimitiveTypeTraits::CppType*)&v); + typename PrimitiveTypeTraits::CppType tmp; + tmp.from_date_int64(v); + auto field = vectorized::Field::create_field(tmp); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_DATEV2, &field, param); @@ -477,7 +481,7 @@ TEST_F(InvertedIndexQueryParamTest, TestIntegerBoundaryMin) { // Test minimum values { auto field = - vectorized::Field::create_field(static_cast(-128)); + vectorized::Field::create_field(static_cast(-128)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value( PrimitiveType::TYPE_TINYINT, &field, param); @@ -486,8 +490,8 @@ TEST_F(InvertedIndexQueryParamTest, TestIntegerBoundaryMin) { EXPECT_EQ(*value, -128); } { - auto field = vectorized::Field::create_field( - static_cast(-32768)); + auto field = vectorized::Field::create_field( + static_cast(-32768)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value( PrimitiveType::TYPE_SMALLINT, &field, param); @@ -501,7 +505,7 @@ TEST_F(InvertedIndexQueryParamTest, TestIntegerBoundaryMax) { // Test maximum values { auto field = - vectorized::Field::create_field(static_cast(127)); + vectorized::Field::create_field(static_cast(127)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value( PrimitiveType::TYPE_TINYINT, &field, param); @@ -510,8 +514,8 @@ TEST_F(InvertedIndexQueryParamTest, TestIntegerBoundaryMax) { EXPECT_EQ(*value, 127); } { - auto field = - vectorized::Field::create_field(static_cast(32767)); + auto field = vectorized::Field::create_field( + static_cast(32767)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value( PrimitiveType::TYPE_SMALLINT, &field, param); @@ -524,8 +528,7 @@ TEST_F(InvertedIndexQueryParamTest, TestIntegerBoundaryMax) { TEST_F(InvertedIndexQueryParamTest, TestZeroValues) { // Test zero values for different types { - auto field = - vectorized::Field::create_field(static_cast(0)); + auto field = vectorized::Field::create_field(static_cast(0)); std::unique_ptr param; auto status = InvertedIndexQueryParamFactory::create_query_value(PrimitiveType::TYPE_INT, &field, param); diff --git a/be/test/testutil/variant_util.h b/be/test/testutil/variant_util.h index 2e65a87c64f54b..76ebbd4d5bf46d 100644 --- a/be/test/testutil/variant_util.h +++ b/be/test/testutil/variant_util.h @@ -37,11 +37,11 @@ class VariantUtil { auto int_field = doris::vectorized::Field::create_field(20); auto str_field = doris::vectorized::Field::create_field(String("str", 3)); auto arr_int_field = doris::vectorized::Field::create_field(Array()); - auto& array1 = arr_int_field.get(); + auto& array1 = arr_int_field.get(); array1.emplace_back(int_field); array1.emplace_back(int_field); auto arr_str_field = doris::vectorized::Field::create_field(Array()); - auto& array2 = arr_str_field.get(); + auto& array2 = arr_str_field.get(); array2.emplace_back(str_field); array2.emplace_back(str_field); field_map["int"] = int_field; @@ -64,7 +64,7 @@ class VariantUtil { const std::vector>& key_and_values) { doris::vectorized::Field res = doris::vectorized::Field::create_field(VariantMap()); - auto& object = res.get(); + auto& object = res.get(); for (const auto& [k, v] : key_and_values) { PathInData path(k); object.try_emplace(path, FieldWithDataType {.field = v}); @@ -195,11 +195,11 @@ class VariantUtil { doris::vectorized::Field::create_field(Array()); auto variant_field = doris::vectorized::Field::create_field(VariantMap()); for (const auto& entry : data) { - auto& variant_map = variant_field.get(); + auto& variant_map = variant_field.get(); for (const auto& [k, v] : entry) { variant_map.try_emplace(PathInData(k), FieldWithDataType {.field = v}); } - array_field.get().emplace_back(std::move(variant_field)); + array_field.get().emplace_back(std::move(variant_field)); } return array_field; } diff --git a/be/test/vec/aggregate_functions/agg_group_array_intersect_test.cpp b/be/test/vec/aggregate_functions/agg_group_array_intersect_test.cpp index 5824f71f75ec56..6f645cd954b25c 100644 --- a/be/test/vec/aggregate_functions/agg_group_array_intersect_test.cpp +++ b/be/test/vec/aggregate_functions/agg_group_array_intersect_test.cpp @@ -44,8 +44,7 @@ void sort_numeric_array(Array& array) { if (a.is_null() || b.is_null()) { return a.is_null() && !b.is_null(); } - return doris::vectorized::get::ColumnItemType>(a) < - doris::vectorized::get::ColumnItemType>(b); + return a.get() < b.get(); }); } @@ -117,7 +116,7 @@ void validate_numeric_test(MutableColumnPtr& test_col_data) { agg_function->insert_result_into(place, ans); Field actual_field; ans.get(0, actual_field); - const auto& actual_result = doris::vectorized::get(actual_field); + const auto& actual_result = actual_field.get(); Array expected_result = { Field::create_field((typename PrimitiveTypeTraits::ColumnItemType)2), @@ -205,7 +204,7 @@ void validate_numeric_nullable_test(MutableColumnPtr& test_col_data) { Field actual_field; ans.get(0, actual_field); - const auto& actual_result = doris::vectorized::get(actual_field); + const auto& actual_result = actual_field.get(); Array expected_result = { vectorized::Field(), @@ -302,7 +301,7 @@ TEST(AggGroupArrayIntersectTest, string_test) { agg_function->insert_result_into(place, ans); Field actual_field; ans.get(0, actual_field); - const auto& actual_result = doris::vectorized::get(actual_field); + const auto& actual_result = actual_field.get(); Array expected_result = {vectorized::Field::create_field("b"), vectorized::Field::create_field("c")}; @@ -370,7 +369,7 @@ TEST(AggGroupArrayIntersectTest, string_nullable_test) { agg_function->insert_result_into(place, ans); Field actual_field; ans.get(0, actual_field); - const auto& actual_result = doris::vectorized::get(actual_field); + const auto& actual_result = actual_field.get(); Array expected_result = {vectorized::Field(), vectorized::Field::create_field("c")}; diff --git a/be/test/vec/aggregate_functions/agg_min_max_test.cpp b/be/test/vec/aggregate_functions/agg_min_max_test.cpp index c7cad0118c669e..54ac10cd705ca2 100644 --- a/be/test/vec/aggregate_functions/agg_min_max_test.cpp +++ b/be/test/vec/aggregate_functions/agg_min_max_test.cpp @@ -105,7 +105,7 @@ TEST_P(AggMinMaxTest, min_max_decimal_test) { // Check result. ColumnDecimal128V2 ans(0, 9); agg_function->insert_result_into(place, ans); - EXPECT_EQ(min_max_type == "min" ? 0 : agg_test_batch_size - 1, ans.get_element(0).value); + EXPECT_EQ(min_max_type == "min" ? 0 : agg_test_batch_size - 1, ans.get_element(0).value()); agg_function->destroy(place); auto dst = agg_function->create_serialize_column(); @@ -121,7 +121,7 @@ TEST_P(AggMinMaxTest, min_max_decimal_test) { } for (size_t i = 0; i != agg_test_batch_size; ++i) { - EXPECT_EQ(i, result.get_element(i).value); + EXPECT_EQ(i, result.get_element(i).value()); } } diff --git a/be/test/vec/aggregate_functions/agg_replace_test.cpp b/be/test/vec/aggregate_functions/agg_replace_test.cpp index 1ebcf7dd4ae6fe..3ead67ba2f2e89 100644 --- a/be/test/vec/aggregate_functions/agg_replace_test.cpp +++ b/be/test/vec/aggregate_functions/agg_replace_test.cpp @@ -90,6 +90,12 @@ class VAggReplaceTest : public testing::Test { const_cast(&hll)->update(static_cast(expect_num)); auto actual = hll.estimate_cardinality(); EXPECT_EQ(expect, actual); + } else if constexpr (std::is_same_v) { + EXPECT_EQ(expect_num, (*(int128_t*)unwrap_col->get_data_at(pos).data)); + } else if constexpr (IsDataTypeDecimal) { + EXPECT_EQ(expect_num, + (*(typename DataType::FieldType::NativeType*)unwrap_col->get_data_at(pos) + .data)); } else { EXPECT_EQ(expect_num, unwrap_col->get_int(pos)); } diff --git a/be/test/vec/columns/column_array_test.cpp b/be/test/vec/columns/column_array_test.cpp index 5b5bfc17c5d8f4..0e6db9df6dd05d 100644 --- a/be/test/vec/columns/column_array_test.cpp +++ b/be/test/vec/columns/column_array_test.cpp @@ -750,7 +750,7 @@ TEST_F(ColumnArrayTest, MaxArraySizeAsFieldTest) { auto check_type = remove_nullable(array_types[i]); Field a; column->get(column->size() - 1, a); - Array af = a.get(); + Array af = a.get(); if (af.size() > 0) { auto start_size = af.size(); Field ef = af[0]; @@ -789,12 +789,12 @@ TEST_F(ColumnArrayTest, IsDefaultAtTest) { // check field Array is empty Field f; column->get(j, f); - auto array = f.get(); + auto array = f.get(); EXPECT_EQ(array.size(), 0) << "array is not empty"; } else { Field f; column->get(j, f); - auto array = f.get(); + auto array = f.get(); EXPECT_GT(array.size(), 0) << "array is empty"; } } @@ -835,10 +835,10 @@ TEST_F(ColumnArrayTest, String64ArrayTest) { auto str64_array_column = ColumnArray::create(std::move(str64_column), std::move(off_column)); EXPECT_EQ(str64_array_column->size(), offs.size() - 1); for (size_t i = 0; i < str64_array_column->size(); ++i) { - auto v = get(str64_array_column->operator[](i)); + auto v = str64_array_column->operator[](i).get(); EXPECT_EQ(v.size(), offs[i + 1] - offs[i]); for (size_t j = 0; j < v.size(); ++j) { - EXPECT_EQ(vals[offs[i] + j], get(v[j])); + EXPECT_EQ(vals[offs[i] + j], v[j].get()); } } // test insert ColumnArray> into ColumnArray> @@ -852,18 +852,18 @@ TEST_F(ColumnArrayTest, String64ArrayTest) { indices.data() + indices.size()); EXPECT_EQ(str32_array_column->size(), 3); - auto v = get(str32_array_column->operator[](0)); + auto v = str32_array_column->operator[](0).get(); EXPECT_EQ(v.size(), 2); - EXPECT_EQ(get(v[0]), vals[0]); - EXPECT_EQ(get(v[1]), vals[1]); + EXPECT_EQ(v[0].get(), vals[0]); + EXPECT_EQ(v[1].get(), vals[1]); - v = get(str32_array_column->operator[](1)); + v = str32_array_column->operator[](1).get(); EXPECT_EQ(v.size(), 1); - EXPECT_EQ(get(v[0]), vals[2]); + EXPECT_EQ(v[0].get(), vals[2]); - v = get(str32_array_column->operator[](2)); + v = str32_array_column->operator[](2).get(); EXPECT_EQ(v.size(), 1); - EXPECT_EQ(get(v[0]), vals[3]); + EXPECT_EQ(v[0].get(), vals[3]); } TEST_F(ColumnArrayTest, IntArrayPermuteTest) { diff --git a/be/test/vec/columns/column_dictionary_test.cpp b/be/test/vec/columns/column_dictionary_test.cpp index 14b42c51819f79..c27dce59fa56a6 100644 --- a/be/test/vec/columns/column_dictionary_test.cpp +++ b/be/test/vec/columns/column_dictionary_test.cpp @@ -222,7 +222,7 @@ TEST_F(ColumnDictionaryTest, field) { for (size_t i = 0; i != count; ++i) { Field f; column_dict_char->get(i, f); - EXPECT_EQ(f.get(), codes_data[i]); + EXPECT_EQ(f.get(), codes_data[i]); } } TEST_F(ColumnDictionaryTest, serialize_value_into_arena) { diff --git a/be/test/vec/columns/column_string_test.cpp b/be/test/vec/columns/column_string_test.cpp index 2dd8ed8cb08770..de6b6e18b4de47 100644 --- a/be/test/vec/columns/column_string_test.cpp +++ b/be/test/vec/columns/column_string_test.cpp @@ -295,7 +295,8 @@ TEST_F(ColumnStringTest, field_test) { for (size_t i = 0; i != src_size; ++i) { Field f; assert_col->get(i, f); - ASSERT_EQ(f.get(), source_column->get_data_at(i)); + ASSERT_EQ(StringRef(f.get().data(), f.get().size()), + source_column->get_data_at(i)); } } { @@ -310,7 +311,7 @@ TEST_F(ColumnStringTest, field_test) { JsonbField jsonbf; Field f = Field::create_field((std::move(jsonbf))); assert_col->get(i, f); - const auto& real_field = vectorized::get(f); + const auto& real_field = f.get(); ASSERT_EQ(StringRef(real_field.get_value(), real_field.get_size()), source_column->get_data_at(i)); } diff --git a/be/test/vec/columns/column_varbinary_test.cpp b/be/test/vec/columns/column_varbinary_test.cpp index 249b31c29ca2b7..f00c16aa620d17 100644 --- a/be/test/vec/columns/column_varbinary_test.cpp +++ b/be/test/vec/columns/column_varbinary_test.cpp @@ -348,15 +348,13 @@ TEST_F(ColumnVarbinaryTest, FieldAccessOperatorAndGet) { for (size_t i = 0; i < vals.size(); ++i) { // operator[] Field f = (*col)[i]; - const auto& sv = - vectorized::get::CppType&>(f); + const auto& sv = f.get(); ASSERT_EQ(sv.size(), vals[i].size()); ASSERT_EQ(memcmp(sv.data(), vals[i].data(), sv.size()), 0); // get(size_t, Field&) Field f2; col->get(i, f2); - const auto& sv2 = - vectorized::get::CppType&>(f2); + const auto& sv2 = f2.get(); ASSERT_EQ(sv2.size(), vals[i].size()); ASSERT_EQ(memcmp(sv2.data(), vals[i].data(), sv2.size()), 0); } diff --git a/be/test/vec/columns/column_variant_test.cpp b/be/test/vec/columns/column_variant_test.cpp index 72ba9841c78abc..c0eaecea5b4c4d 100644 --- a/be/test/vec/columns/column_variant_test.cpp +++ b/be/test/vec/columns/column_variant_test.cpp @@ -195,17 +195,17 @@ TEST_F(ColumnVariantTest, basic_deserialize) { auto data = path->get_data_at(start); EXPECT_EQ(data, StringRef("v.b.d", 5)); auto pair = variant->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair.first.get(), 30); + EXPECT_EQ(pair.first.get(), 30); auto data2 = path->get_data_at(start); auto pair2 = variant->deserialize_from_sparse_column(value, start++); EXPECT_EQ(data2, StringRef("v.c.d", 5)); - EXPECT_EQ(pair2.first.get(), 30); + EXPECT_EQ(pair2.first.get(), 30); auto data3 = path->get_data_at(start); auto pair3 = variant->deserialize_from_sparse_column(value, start++); EXPECT_EQ(data3, StringRef("v.d.d", 5)); - EXPECT_EQ(pair3.first.get(), "50"); + EXPECT_EQ(pair3.first.get(), "50"); EXPECT_EQ(start, end); } } @@ -332,7 +332,7 @@ TEST_F(ColumnVariantTest, basic_inset_range_from) { EXPECT_TRUE(column->data.data[0]->is_null_at(row)); } for (size_t row = 5; row != 10; ++row) { - EXPECT_EQ((*column->data.data[0])[row].get(), 30); + EXPECT_EQ((*column->data.data[0])[row].get(), 30); } } } @@ -350,19 +350,19 @@ TEST_F(ColumnVariantTest, basic_inset_range_from) { EXPECT_EQ(data, StringRef("v.a", 3)); auto pair = dst->deserialize_from_sparse_column(value, start++); if (pair.first.get_type() == PrimitiveType::TYPE_BIGINT) { - EXPECT_EQ(pair.first.get(), 20) << pair.first.get_type_name(); + EXPECT_EQ(pair.first.get(), 20) << pair.first.get_type_name(); } else { - EXPECT_EQ(pair.first.get(), 20) << pair.first.get_type_name(); + EXPECT_EQ(pair.first.get(), 20) << pair.first.get_type_name(); } auto data2 = path->get_data_at(start); EXPECT_EQ(data2, StringRef("v.c", 3)); auto pair2 = dst->deserialize_from_sparse_column(value, start++); if (pair.first.get_type() == PrimitiveType::TYPE_BIGINT) { - EXPECT_EQ(pair2.first.get(), 20) - << pair2.first.get_type_name() << " " << pair2.first.get(); + EXPECT_EQ(pair2.first.get(), 20) + << pair2.first.get_type_name() << " " << pair2.first.get(); } else { - EXPECT_EQ(pair2.first.get(), 20); + EXPECT_EQ(pair2.first.get(), 20); } EXPECT_EQ(start, end); @@ -377,24 +377,24 @@ TEST_F(ColumnVariantTest, basic_inset_range_from) { EXPECT_EQ(data, StringRef("v.a", 3)); auto pair = dst->deserialize_from_sparse_column(value, start++); if (pair.first.get_type() == PrimitiveType::TYPE_BIGINT) { - EXPECT_EQ(pair.first.get(), 20) << pair.first.get_type_name(); + EXPECT_EQ(pair.first.get(), 20) << pair.first.get_type_name(); } else { - EXPECT_EQ(pair.first.get(), 20); + EXPECT_EQ(pair.first.get(), 20); } auto data2 = path->get_data_at(start); EXPECT_EQ(data2, StringRef("v.c", 3)); auto pair2 = dst->deserialize_from_sparse_column(value, start++); if (pair.first.get_type() == PrimitiveType::TYPE_BIGINT) { - EXPECT_EQ(pair2.first.get(), 20) << pair2.first.get_type_name(); + EXPECT_EQ(pair2.first.get(), 20) << pair2.first.get_type_name(); } else { - EXPECT_EQ(pair2.first.get(), 20); + EXPECT_EQ(pair2.first.get(), 20); } auto data3 = path->get_data_at(start); EXPECT_EQ(data3, StringRef("v.d.d", 5)); auto pair3 = dst->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair3.first.get(), "50"); + EXPECT_EQ(pair3.first.get(), "50"); EXPECT_EQ(start, end); } @@ -702,7 +702,7 @@ TEST_F(ColumnVariantTest, advanced_insert_range_from) { auto data = path->get_data_at(start); EXPECT_EQ(data, StringRef("v.a", 3)); auto pair = dst->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair.first.get(), 20); + EXPECT_EQ(pair.first.get(), 20); auto data2 = path->get_data_at(start); EXPECT_EQ(data2, StringRef("v.c", 3)); @@ -720,7 +720,7 @@ TEST_F(ColumnVariantTest, advanced_insert_range_from) { auto data = path->get_data_at(start); auto pair = dst->deserialize_from_sparse_column(value, start++); EXPECT_EQ(data, StringRef("v.a", 3)); - EXPECT_EQ(pair.first.get(), 20); + EXPECT_EQ(pair.first.get(), 20); auto data2 = path->get_data_at(start); auto pair2 = dst->deserialize_from_sparse_column(value, start++); @@ -744,7 +744,7 @@ TEST_F(ColumnVariantTest, advanced_insert_range_from) { auto data = path->get_data_at(start); auto pair = dst->deserialize_from_sparse_column(value, start++); EXPECT_EQ(data, StringRef("v.a", 3)); - EXPECT_EQ(pair.first.get(), 20); + EXPECT_EQ(pair.first.get(), 20); auto data2 = path->get_data_at(start); auto pair2 = dst->deserialize_from_sparse_column(value, start++); @@ -831,17 +831,17 @@ TEST_F(ColumnVariantTest, empty_inset_range_from) { auto data = path->get_data_at(start); EXPECT_EQ(data, StringRef("v.x", 3)); auto pair = dst->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair.first.get(), std::numeric_limits::max()); + EXPECT_EQ(pair.first.get(), std::numeric_limits::max()); auto data2 = path->get_data_at(start); EXPECT_EQ(data2, StringRef("v.y", 3)); auto pair2 = dst->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair2.first.get(), std::numeric_limits::max()); + EXPECT_EQ(pair2.first.get(), std::numeric_limits::max()); auto data3 = path->get_data_at(start); EXPECT_EQ(data3, StringRef("v.z", 3)); auto pair3 = dst->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair3.first.get(), + EXPECT_EQ(pair3.first.get(), Int64(static_cast(std::numeric_limits::max()) + 1)); EXPECT_EQ(start, end); @@ -883,17 +883,17 @@ TEST_F(ColumnVariantTest, empty_inset_range_from) { auto data = path->get_data_at(start); EXPECT_EQ(data, StringRef("v.x", 3)); auto pair = dst->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair.first.get(), std::numeric_limits::max()); + EXPECT_EQ(pair.first.get(), std::numeric_limits::max()); auto data2 = path->get_data_at(start); EXPECT_EQ(data2, StringRef("v.y", 3)); auto pair2 = dst->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair2.first.get(), std::numeric_limits::max()); + EXPECT_EQ(pair2.first.get(), std::numeric_limits::max()); auto data3 = path->get_data_at(start); EXPECT_EQ(data3, StringRef("v.z", 3)); auto pair3 = dst->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair3.first.get(), + EXPECT_EQ(pair3.first.get(), Int64(static_cast(std::numeric_limits::max()) + 1)); EXPECT_EQ(start, end); @@ -914,17 +914,17 @@ TEST_F(ColumnVariantTest, empty_inset_range_from) { auto data = path->get_data_at(start); EXPECT_EQ(data, StringRef("v.b.d", 5)); auto pair = dst->deserialize_from_sparse_column(value, start++); - EXPECT_EQ(pair.first.get(), 30); + EXPECT_EQ(pair.first.get(), 30); auto data2 = path->get_data_at(start); auto pair2 = dst->deserialize_from_sparse_column(value, start++); EXPECT_EQ(data2, StringRef("v.c.d", 5)); - EXPECT_EQ(pair2.first.get(), 30); + EXPECT_EQ(pair2.first.get(), 30); auto data3 = path->get_data_at(start); auto pair3 = dst->deserialize_from_sparse_column(value, start++); EXPECT_EQ(data3, StringRef("v.d.d", 5)); - EXPECT_EQ(pair3.first.get(), "50"); + EXPECT_EQ(pair3.first.get(), "50"); EXPECT_EQ(start, end); } } @@ -983,13 +983,13 @@ TEST_F(ColumnVariantTest, test_insert_indices_from) { Field result1; dst_column->get(0, result1); - const auto& fv = result1.get(); + const auto& fv = result1.get(); auto res = fv.at(PathInData()); - EXPECT_EQ(res.field.get(), 123); + EXPECT_EQ(res.field.get(), 123); Field result2; dst_column->get(1, result2); - EXPECT_EQ(result2.get().at(PathInData()).field.get(), 456); + EXPECT_EQ(result2.get().at(PathInData()).field.get(), 456); } // Test case 2: Insert from scalar variant source to non-empty destination of same type @@ -1023,9 +1023,9 @@ TEST_F(ColumnVariantTest, test_insert_indices_from) { dst_column->get(1, result2); dst_column->get(2, result3); - EXPECT_EQ(result1.get().at(PathInData()).field.get(), 789); - EXPECT_EQ(result2.get().at(PathInData()).field.get(), 456); - EXPECT_EQ(result3.get().at(PathInData()).field.get(), 123); + EXPECT_EQ(result1.get().at(PathInData()).field.get(), 789); + EXPECT_EQ(result2.get().at(PathInData()).field.get(), 456); + EXPECT_EQ(result3.get().at(PathInData()).field.get(), 123); } // Test case 3: Insert from non-scalar or different type source (fallback to try_insert) @@ -1035,7 +1035,7 @@ TEST_F(ColumnVariantTest, test_insert_indices_from) { // Create a map with {"a": 123} Field field_map = Field::create_field(VariantMap()); - auto& map1 = field_map.get(); + auto& map1 = field_map.get(); map1.insert_or_assign(PathInData("a"), FieldWithDataType {.field = Field::create_field(123), .base_scalar_type_id = PrimitiveType::TYPE_INT}); @@ -1043,7 +1043,7 @@ TEST_F(ColumnVariantTest, test_insert_indices_from) { // Create another map with {"b": "hello"} field_map = Field::create_field(VariantMap()); - auto& map2 = field_map.get(); + auto& map2 = field_map.get(); map2.insert_or_assign( PathInData("b"), FieldWithDataType {.field = Field::create_field(String("hello")), @@ -1073,11 +1073,11 @@ TEST_F(ColumnVariantTest, test_insert_indices_from) { EXPECT_TRUE(result1.get_type() == PrimitiveType::TYPE_VARIANT); EXPECT_TRUE(result2.get_type() == PrimitiveType::TYPE_VARIANT); - const auto& result1_map = result1.get(); - const auto& result2_map = result2.get(); + const auto& result1_map = result1.get(); + const auto& result2_map = result2.get(); - EXPECT_EQ(result1_map.at(PathInData("b")).field.get(), "hello"); - EXPECT_EQ(result2_map.at(PathInData("a")).field.get(), 123); + EXPECT_EQ(result1_map.at(PathInData("b")).field.get(), "hello"); + EXPECT_EQ(result2_map.at(PathInData("a")).field.get(), 123); } } @@ -2201,8 +2201,8 @@ doris::vectorized::Field get_field_v2(std::string_view type, size_t array_elemen doris::vectorized::Field str_field = Field::create_field(String("str", 3)); doris::vectorized::Field arr_int_field = Field::create_field(Array()); doris::vectorized::Field arr_str_field = Field::create_field(Array()); - auto& array1 = arr_int_field.get(); - auto& array2 = arr_str_field.get(); + auto& array1 = arr_int_field.get(); + auto& array2 = arr_str_field.get(); for (size_t i = 0; i < array_element_cnt; ++i) { array1.emplace_back(int_field); array2.emplace_back(str_field); @@ -2250,9 +2250,10 @@ TEST_F(ColumnVariantTest, array_field_operations) { array_type ->create_column(); // Nullable(Array(Nullable(Array(Nullable(TINYINT))))) Field array_field = vectorized::Field::create_field(Array()); - array_field.get().emplace_back(vectorized::Field::create_field(1)); + array_field.get().emplace_back( + vectorized::Field::create_field(1)); Field array_field_o = vectorized::Field::create_field(Array()); - array_field_o.get().emplace_back(array_field); + array_field_o.get().emplace_back(array_field); column->insert(array_field_o); obj->add_sub_column(path, std::move(column)); @@ -2279,9 +2280,9 @@ TEST_F(ColumnVariantTest, array_field_operations) { auto array_type = create_array(PrimitiveType::TYPE_TINYINT, 1); auto column = array_type->create_column(); Field array1 = vectorized::Field::create_field(Array()); - array1.get().emplace_back(vectorized::Field::create_field(1)); - array1.get().emplace_back(vectorized::Field::create_field(2)); - array1.get().emplace_back(vectorized::Field::create_field(3)); + array1.get().emplace_back(vectorized::Field::create_field(1)); + array1.get().emplace_back(vectorized::Field::create_field(2)); + array1.get().emplace_back(vectorized::Field::create_field(3)); column->insert(array1); obj->add_sub_column(path, std::move(column), array_type); @@ -2450,22 +2451,22 @@ TEST_F(ColumnVariantTest, try_insert_default_from_nested) { auto array_type = create_array(PrimitiveType::TYPE_STRING, 1); auto column = array_type->create_column(); Field array1 = vectorized::Field::create_field(Array()); - array1.get().emplace_back(vectorized::Field::create_field("amory")); - array1.get().emplace_back(vectorized::Field::create_field("commit")); + array1.get().emplace_back(vectorized::Field::create_field("amory")); + array1.get().emplace_back(vectorized::Field::create_field("commit")); Field array2 = vectorized::Field::create_field(Array()); - array2.get().emplace_back(vectorized::Field::create_field("amory")); - array2.get().emplace_back(vectorized::Field::create_field("doris")); + array2.get().emplace_back(vectorized::Field::create_field("amory")); + array2.get().emplace_back(vectorized::Field::create_field("doris")); column->insert(array1); column->insert(array2); auto array_type2 = create_array(PrimitiveType::TYPE_STRING, 2); auto column2 = array_type2->create_column(); Field array22 = vectorized::Field::create_field(Array()); - array22.get().emplace_back(array1); - array22.get().emplace_back(array2); + array22.get().emplace_back(array1); + array22.get().emplace_back(array2); Field array23 = vectorized::Field::create_field(Array()); - array23.get().emplace_back(array2); - array23.get().emplace_back(array1); + array23.get().emplace_back(array2); + array23.get().emplace_back(array1); column2->insert(array22); column2->insert(array23); @@ -2508,7 +2509,7 @@ TEST_F(ColumnVariantTest, unnest) { Field array2 = VariantUtil::create_nested_array_field( {{{"a", vectorized::Field::create_field("amory")}}, {{"b", vectorized::Field::create_field("doris")}}}); - std::cout << "array: " << array1.get().size() << std::endl; + std::cout << "array: " << array1.get().size() << std::endl; nested_col->insert(array1); nested_col->insert(array2); std::cout << nested_col->size() << std::endl; @@ -3098,8 +3099,8 @@ EXPECT_EQ(info.num_dimensions, 2); JsonbField field(value.value(), value.size()); Field array = Field::create_field(Array()); - array.get().push_back(Field::create_field(std::move(field))); - array.get().push_back(Field::create_field(JsonbField())); + array.get().push_back(Field::create_field(std::move(field))); + array.get().push_back(Field::create_field(JsonbField())); FieldInfo info; schema_util::get_field_info(array, &info); // which should support ??!! @@ -3120,15 +3121,15 @@ TEST_F(ColumnVariantTest, field_visitor) { Field replacement = Field::create_field(Int64(42)); Field result = apply_visitor(FieldVisitorReplaceScalars(replacement, 0), field); - EXPECT_EQ(result.get(), 42); + EXPECT_EQ(result.get(), 42); Field replacement1 = Field::create_field(Int64(42)); Field result1 = apply_visitor(FieldVisitorReplaceScalars(replacement, 1), field); - EXPECT_EQ(result1.get().size(), 3); - EXPECT_EQ(result1.get()[0].get(), 42); - EXPECT_EQ(result1.get()[1].get(), 42); - EXPECT_EQ(result1.get()[2].get(), 42); + EXPECT_EQ(result1.get().size(), 3); + EXPECT_EQ(result1.get()[0].get(), 42); + EXPECT_EQ(result1.get()[1].get(), 42); + EXPECT_EQ(result1.get()[2].get(), 42); } } @@ -3192,7 +3193,7 @@ TEST_F(ColumnVariantTest, subcolumn_operations_coverage) { // col_arr->insert(array1); // col_arr->insert(array2); Field an = Field::create_field(Array()); - an.get().push_back(Field::create_field(Int64(1))); + an.get().push_back(Field::create_field(Int64(1))); col_arr->insert(an); col_arr->insert(an); col_arr->insert(an); @@ -3236,7 +3237,7 @@ TEST_F(ColumnVariantTest, subcolumn_operations_coverage) { std::vector> data; Field an = Field::create_field(Array()); - an.get().push_back(Field::create_field(Null())); + an.get().push_back(Field::create_field(Null())); data.emplace_back("v.a", an); // 2. subcolumn path auto vf = VariantUtil::construct_variant_map(data); @@ -3510,7 +3511,7 @@ TEST_F(ColumnVariantTest, test_variant_deserialize_from_sparse_column) { { Field int_field = Field::create_field(123); Field array_field = Field::create_field(Array(1)); - array_field.get()[0] = int_field; + array_field.get()[0] = int_field; FieldInfo info = {PrimitiveType::TYPE_TINYINT, false, false, 1}; ColumnVariant::Subcolumn int_subcolumn(0, true, false); int_subcolumn.insert(array_field, info); @@ -3530,9 +3531,9 @@ TEST_F(ColumnVariantTest, test_variant_deserialize_from_sparse_column) { EXPECT_EQ(subcolumn.get_dimensions(), 1); EXPECT_EQ(subcolumn.get_least_common_base_type_id(), PrimitiveType::TYPE_TINYINT); auto v = subcolumn.get_last_field(); - auto& arr = v.get(); + auto& arr = v.get(); EXPECT_EQ(arr.size(), 1); - EXPECT_EQ(arr[0].get(), 123); + EXPECT_EQ(arr[0].get(), 123); subcolumn.deserialize_from_sparse_column(&value, 1); EXPECT_EQ(subcolumn.data.size(), 2); @@ -3541,9 +3542,9 @@ TEST_F(ColumnVariantTest, test_variant_deserialize_from_sparse_column) { EXPECT_EQ(subcolumn.get_dimensions(), 1); EXPECT_EQ(subcolumn.get_least_common_base_type_id(), PrimitiveType::TYPE_INT); auto v2 = subcolumn.get_last_field(); - auto& arr2 = v2.get(); + auto& arr2 = v2.get(); EXPECT_EQ(arr2.size(), 1); - EXPECT_EQ(arr2[0].get(), 123); + EXPECT_EQ(arr2[0].get(), 123); } column_map.clear(); @@ -3554,15 +3555,15 @@ TEST_F(ColumnVariantTest, test_variant_deserialize_from_sparse_column) { { Field int_field = Field::create_field(123); Field array_field = Field::create_field(Array(1)); - array_field.get()[0] = Field(); + array_field.get()[0] = Field(); FieldInfo info = {PrimitiveType::TYPE_NULL, false, false, 1}; ColumnVariant::Subcolumn int_subcolumn(0, true, false); int_subcolumn.insert(array_field, info); int_subcolumn.serialize_to_sparse_column(&key, "b", &value, 0); array_field = Field::create_field(Array(2)); - array_field.get()[0] = Field(); - array_field.get()[1] = int_field; + array_field.get()[0] = Field(); + array_field.get()[1] = int_field; info = {PrimitiveType::TYPE_INT, false, false, 1}; int_subcolumn.insert(array_field, info); int_subcolumn.serialize_to_sparse_column(&key, "b", &value, 1); @@ -3576,7 +3577,7 @@ TEST_F(ColumnVariantTest, test_variant_deserialize_from_sparse_column) { PrimitiveType::TYPE_ARRAY); EXPECT_EQ(subcolumn.get_dimensions(), 1); auto v = subcolumn.get_last_field(); - auto& arr = v.get(); + auto& arr = v.get(); EXPECT_EQ(arr.size(), 1); EXPECT_TRUE(arr[0].is_null()); @@ -3587,10 +3588,10 @@ TEST_F(ColumnVariantTest, test_variant_deserialize_from_sparse_column) { EXPECT_EQ(subcolumn.get_dimensions(), 1); EXPECT_EQ(subcolumn.get_least_common_base_type_id(), PrimitiveType::TYPE_INT); auto v2 = subcolumn.get_last_field(); - auto& arr2 = v2.get(); + auto& arr2 = v2.get(); EXPECT_EQ(arr2.size(), 2); EXPECT_TRUE(arr2[0].is_null()); - EXPECT_EQ(arr2[1].get(), 123); + EXPECT_EQ(arr2[1].get(), 123); } } diff --git a/be/test/vec/columns/common_column_test.h b/be/test/vec/columns/common_column_test.h index 9595b327f81493..efc57c9747ef9c 100644 --- a/be/test/vec/columns/common_column_test.h +++ b/be/test/vec/columns/common_column_test.h @@ -2576,7 +2576,9 @@ auto assert_column_vector_field_callback = [](auto x, const MutableColumnPtr& so for (size_t i = 0; i != src_size; ++i) { Field f; assert_col->get(i, f); - ASSERT_EQ(f.get(), col_vec_src->get_element(i)) << f.get_type_name(); + auto tmp = col_vec_src->get_element(i); + ASSERT_EQ(f.get(), *(typename PrimitiveTypeTraits::CppType*)&tmp) + << f.get_type_name(); } }; @@ -2928,6 +2930,8 @@ auto assert_column_vector_insert_default_callback = [](auto x, PType == PrimitiveType::TYPE_DATETIME) { EXPECT_EQ(col_vec_target->get_element(i), T(PrimitiveTypeTraits::CppType::DEFAULT_VALUE)); + } else if constexpr (PType == PrimitiveType::TYPE_DECIMALV2) { + EXPECT_EQ(col_vec_target->get_element(i), DecimalV2Value()); } else { EXPECT_EQ(col_vec_target->get_element(i), T {}); } @@ -2979,6 +2983,8 @@ auto assert_column_vector_insert_many_defaults_callback = PType == PrimitiveType::TYPE_DATETIME) { EXPECT_EQ(col_vec_target->get_element(i), T(PrimitiveTypeTraits::CppType::DEFAULT_VALUE)); + } else if constexpr (PType == PrimitiveType::TYPE_DECIMALV2) { + EXPECT_EQ(col_vec_target->get_element(i), DecimalV2Value()); } else { EXPECT_EQ(col_vec_target->get_element(i), T {}); } @@ -3010,9 +3016,7 @@ auto assert_column_vector_get_int64_callback = [](auto x, const MutableColumnPtr auto* col_vec_src = assert_cast(source_column.get()); const auto& data = col_vec_src->get_data(); for (size_t i = 0; i != src_size; ++i) { - if constexpr (IsDecimalNumber) { - EXPECT_EQ(col_vec_src->get_int(i), (Int64)(data[i].value * col_vec_src->get_scale())); - } else { + if constexpr (!IsDecimalNumber) { EXPECT_EQ(col_vec_src->get_int(i), (Int64)data[i]); } } @@ -3257,7 +3261,9 @@ auto assert_column_vector_replace_column_null_data_callback = [](auto x, const M target_column->replace_column_null_data(null_map.data()); for (size_t i = 0; i < src_size; ++i) { if (null_map[i] == 1) { - if constexpr (IsDecimalNumber) { + if constexpr (IsDecimal128V2) { + EXPECT_EQ(col_vec_target->get_element(i), DecimalV2Value {}); + } else if constexpr (IsDecimalNumber) { EXPECT_EQ(col_vec_target->get_element(i), T {}); } else { EXPECT_EQ(col_vec_target->get_element(i), ColumnVecType::default_value()); @@ -3358,6 +3364,8 @@ auto assert_column_vector_clone_resized_callback = [](auto x, for (; i < clone_count; ++i) { if constexpr (std::is_same_v || std::is_same_v) { EXPECT_EQ(col_vec_target->get_data_at(i).to_string(), ""); + } else if constexpr (IsDecimal128V2) { + EXPECT_EQ(col_vec_target->get_element(i), DecimalV2Value {}); } else if constexpr (IsDecimalNumber) { EXPECT_EQ(col_vec_target->get_element(i), T {}); } else { diff --git a/be/test/vec/core/column_array_test.cpp b/be/test/vec/core/column_array_test.cpp index f709d4931ec2f4..03afa94e69fb61 100644 --- a/be/test/vec/core/column_array_test.cpp +++ b/be/test/vec/core/column_array_test.cpp @@ -75,10 +75,10 @@ TEST(ColumnArrayOldTest, IntArrayTest) { ColumnArray array_column(std::move(data_column), std::move(off_column)); EXPECT_EQ(array_column.size(), offs.size() - 1); for (size_t i = 0; i < array_column.size(); ++i) { - auto v = get(array_column[i]); + auto v = array_column[i].get(); EXPECT_EQ(v.size(), offs[i + 1] - offs[i]); for (size_t j = 0; j < v.size(); ++j) { - EXPECT_EQ(vals[offs[i] + j], get(v[j])); + EXPECT_EQ(vals[offs[i] + j], v[j].get()); } } } @@ -100,10 +100,10 @@ TEST(ColumnArrayOldTest, StringArrayTest) { ColumnArray array_column(std::move(data_column), std::move(off_column)); EXPECT_EQ(array_column.size(), offs.size() - 1); for (size_t i = 0; i < array_column.size(); ++i) { - auto v = get(array_column[i]); + auto v = array_column[i].get(); EXPECT_EQ(v.size(), offs[i + 1] - offs[i]); for (size_t j = 0; j < v.size(); ++j) { - EXPECT_EQ(vals[offs[i] + j], get(v[j])); + EXPECT_EQ(vals[offs[i] + j], v[j].get()); } } } diff --git a/be/test/vec/core/column_complex_test.cpp b/be/test/vec/core/column_complex_test.cpp index a1167c68df5136..a6319b2b9fd039 100644 --- a/be/test/vec/core/column_complex_test.cpp +++ b/be/test/vec/core/column_complex_test.cpp @@ -608,7 +608,7 @@ TEST_F(ColumnBitmapTest, ColumnBitmapReadWrite) { Field field; column->get(0, field); - auto bitmap = field.get(); + auto bitmap = field.get(); EXPECT_TRUE(bitmap.contains(10)); EXPECT_TRUE(bitmap.contains(1000000)); } @@ -636,7 +636,7 @@ TEST_F(ColumnBitmapTest, OperatorValidate) { for (size_t i = 0; i != row_size; ++i) { auto field = bitmap_column[i]; ASSERT_EQ(field.get_type(), PrimitiveType::TYPE_BITMAP); - const auto& bitmap = vectorized::get(field); + const auto& bitmap = field.get(); ASSERT_EQ(bitmap.cardinality(), i + 1); for (size_t j = 0; j <= i; ++j) { diff --git a/be/test/vec/core/column_map_test.cpp b/be/test/vec/core/column_map_test.cpp index 37baee03c9ef87..4661511e891025 100644 --- a/be/test/vec/core/column_map_test.cpp +++ b/be/test/vec/core/column_map_test.cpp @@ -78,9 +78,9 @@ TEST(ColumnMapTest2, StringKeyTest) { indices.data() + indices.size()); EXPECT_EQ(col_map_str32.size(), 2); - auto map = get(col_map_str32[0]); - auto k = get(map[0]); - auto v = get(map[1]); + auto map = col_map_str32[0].get(); + auto k = map[0].get(); + auto v = map[1].get(); EXPECT_EQ(k.size(), 3); for (size_t i = 0; i < k.size(); ++i) { EXPECT_EQ(k[i], k1[i]); @@ -90,9 +90,9 @@ TEST(ColumnMapTest2, StringKeyTest) { EXPECT_EQ(v[i], v1[i]); } - map = get(col_map_str32[1]); - k = get(map[0]); - v = get(map[1]); + map = col_map_str32[1].get(); + k = map[0].get(); + v = map[1].get(); EXPECT_EQ(k.size(), 3); for (size_t i = 0; i < k.size(); ++i) { EXPECT_EQ(k[i], k3[i]); @@ -316,35 +316,35 @@ TEST(ColumnMapTest2, StringKeyTestDuplicatedKeysNestedMap) { ASSERT_EQ(string_keys.get_element(0), "a"); ASSERT_EQ(string_keys.get_element(1), "aa"); - auto map_value1 = get(map_values[0]); - auto map_value2 = get(map_values[1]); + auto map_value1 = map_values[0].get(); + auto map_value2 = map_values[1].get(); ASSERT_EQ(map_value1.size(), 2); ASSERT_EQ(map_value2.size(), 2); // keys - auto v1_keys = get(map_value1[0]); + auto v1_keys = map_value1[0].get(); ASSERT_EQ(v1_keys.size(), 3); - ASSERT_EQ(get(v1_keys[0]), "a"); - ASSERT_EQ(get(v1_keys[1]), "b"); - ASSERT_EQ(get(v1_keys[2]), "c"); + ASSERT_EQ(v1_keys[0].get(), "a"); + ASSERT_EQ(v1_keys[1].get(), "b"); + ASSERT_EQ(v1_keys[2].get(), "c"); - auto v2_keys = get(map_value2[0]); + auto v2_keys = map_value2[0].get(); ASSERT_EQ(v2_keys.size(), 2); - ASSERT_EQ(get(v2_keys[0]), "aa"); - ASSERT_EQ(get(v2_keys[1]), "cc"); + ASSERT_EQ(v2_keys[0].get(), "aa"); + ASSERT_EQ(v2_keys[1].get(), "cc"); // values - auto v1_values = get(map_value1[1]); + auto v1_values = map_value1[1].get(); ASSERT_EQ(v1_values.size(), 3); - ASSERT_EQ(get(v1_values[0]), 4); - ASSERT_EQ(get(v1_values[1]), 5); - ASSERT_EQ(get(v1_values[2]), 6); + ASSERT_EQ(v1_values[0].get(), 4); + ASSERT_EQ(v1_values[1].get(), 5); + ASSERT_EQ(v1_values[2].get(), 6); - auto v2_values = get(map_value2[1]); + auto v2_values = map_value2[1].get(); ASSERT_EQ(v2_values.size(), 2); - ASSERT_EQ(get(v2_values[0]), 11); - ASSERT_EQ(get(v2_values[1]), 333); + ASSERT_EQ(v2_values[0].get(), 11); + ASSERT_EQ(v2_values[1].get(), 333); }; TEST(ColumnMapTest2, StringValueTest) { @@ -391,9 +391,9 @@ TEST(ColumnMapTest2, StringValueTest) { indices.data() + indices.size()); EXPECT_EQ(col_map_str32.size(), 2); - auto map = get(col_map_str32[0]); - auto k = get(map[0]); - auto v = get(map[1]); + auto map = col_map_str32[0].get(); + auto k = map[0].get(); + auto v = map[1].get(); EXPECT_EQ(k.size(), 3); for (size_t i = 0; i < k.size(); ++i) { EXPECT_EQ(k[i], k1[i]); @@ -403,9 +403,9 @@ TEST(ColumnMapTest2, StringValueTest) { EXPECT_EQ(v[i], v1[i]); } - map = get(col_map_str32[1]); - k = get(map[0]); - v = get(map[1]); + map = col_map_str32[1].get(); + k = map[0].get(); + v = map[1].get(); EXPECT_EQ(k.size(), 3); for (size_t i = 0; i < k.size(); ++i) { EXPECT_EQ(k[i], k3[i]); diff --git a/be/test/vec/core/column_struct_test.cpp b/be/test/vec/core/column_struct_test.cpp index 41bc37b9272f80..5b0e725fee2765 100644 --- a/be/test/vec/core/column_struct_test.cpp +++ b/be/test/vec/core/column_struct_test.cpp @@ -62,17 +62,17 @@ TEST(ColumnStructTest2, StringTest) { ->insert_indices_from(*str64_struct_column, indices.data(), indices.data() + indices.size()); EXPECT_EQ(str32_struct_column->size(), indices.size()); - auto t = get(str32_struct_column->operator[](0)); + auto t = str32_struct_column->operator[](0).get(); EXPECT_EQ(t.size(), 2); EXPECT_EQ(t[0], Field::create_field("aaa")); EXPECT_EQ(t[1], Field::create_field(111)); - t = get(str32_struct_column->operator[](1)); + t = str32_struct_column->operator[](1).get(); EXPECT_EQ(t.size(), 2); EXPECT_EQ(t[0], Field::create_field("ccc")); EXPECT_EQ(t[1], Field::create_field(333)); - t = get(str32_struct_column->operator[](2)); + t = str32_struct_column->operator[](2).get(); EXPECT_EQ(t.size(), 2); EXPECT_EQ(t[0], Field::create_field("ddd")); EXPECT_EQ(t[1], Field::create_field(444)); diff --git a/be/test/vec/core/column_test.cpp b/be/test/vec/core/column_test.cpp index 7dc7f4e0088e49..42d48875df48c3 100644 --- a/be/test/vec/core/column_test.cpp +++ b/be/test/vec/core/column_test.cpp @@ -158,16 +158,16 @@ TEST_F(ColumnTest, ShrinkColumnArray) { EXPECT_EQ(shrunk_col->size(), 2); auto data_col = assert_cast(*shrunk_col).get_data_ptr(); EXPECT_EQ(data_col->size(), 3); - auto v = get(shrunk_col->operator[](0)); + auto v = shrunk_col->operator[](0).get(); EXPECT_EQ(v.size(), 3); - EXPECT_EQ(get(v[0]), 1); - EXPECT_EQ(get(v[1]), 2); - EXPECT_EQ(get(v[2]), 3); - v = get(shrunk_col->operator[](1)); + EXPECT_EQ(v[0].get(), 1); + EXPECT_EQ(v[1].get(), 2); + EXPECT_EQ(v[2].get(), 3); + v = shrunk_col->operator[](1).get(); EXPECT_EQ(v.size(), 0); - EXPECT_EQ(get(data_col->operator[](0)), 1); - EXPECT_EQ(get(data_col->operator[](1)), 2); - EXPECT_EQ(get(data_col->operator[](2)), 3); + EXPECT_EQ(data_col->operator[](0).get(), 1); + EXPECT_EQ(data_col->operator[](1).get(), 2); + EXPECT_EQ(data_col->operator[](2).get(), 3); // expand will not make data expand EXPECT_EQ(col_arr->size(), 2); @@ -175,14 +175,14 @@ TEST_F(ColumnTest, ShrinkColumnArray) { EXPECT_EQ(shrunk_col->size(), 10); data_col = assert_cast(*shrunk_col).get_data_ptr(); EXPECT_EQ(data_col->size(), 3); - v = get(shrunk_col->operator[](0)); + v = shrunk_col->operator[](0).get(); EXPECT_EQ(v.size(), 3); - EXPECT_EQ(get(v[0]), 1); - EXPECT_EQ(get(v[1]), 2); - EXPECT_EQ(get(v[2]), 3); - v = get(shrunk_col->operator[](1)); + EXPECT_EQ(v[0].get(), 1); + EXPECT_EQ(v[1].get(), 2); + EXPECT_EQ(v[2].get(), 3); + v = shrunk_col->operator[](1).get(); EXPECT_EQ(v.size(), 0); - v = get(shrunk_col->operator[](2)); + v = shrunk_col->operator[](2).get(); EXPECT_EQ(v.size(), 0); } @@ -193,21 +193,21 @@ TEST_F(ColumnTest, ShrinkColumnMap) { EXPECT_EQ(shrunk_col->size(), 2); auto data_col = assert_cast(*shrunk_col).get_values_ptr(); EXPECT_EQ(data_col->size(), 3); - auto v = get(shrunk_col->operator[](0)); + auto v = shrunk_col->operator[](0).get(); EXPECT_EQ(v.size(), 2); - EXPECT_EQ(get(v[0]), + EXPECT_EQ(v[0].get(), Array({Field::create_field("a"), Field::create_field("b"), Field::create_field("c")})); - EXPECT_EQ(get(v[1]), + EXPECT_EQ(v[1].get(), Array({Field::create_field(1), Field::create_field(2), Field::create_field(3)})); - v = get(shrunk_col->operator[](1)); + v = shrunk_col->operator[](1).get(); EXPECT_EQ(v.size(), 2); - EXPECT_EQ(get(v[0]), Array()); - EXPECT_EQ(get(v[1]), Array()); - EXPECT_EQ(get(data_col->operator[](0)), 1); - EXPECT_EQ(get(data_col->operator[](1)), 2); - EXPECT_EQ(get(data_col->operator[](2)), 3); + EXPECT_EQ(v[0].get(), Array()); + EXPECT_EQ(v[1].get(), Array()); + EXPECT_EQ(data_col->operator[](0).get(), 1); + EXPECT_EQ(data_col->operator[](1).get(), 2); + EXPECT_EQ(data_col->operator[](2).get(), 3); // expand will not make data expand EXPECT_EQ(col_map->size(), 2); @@ -215,22 +215,22 @@ TEST_F(ColumnTest, ShrinkColumnMap) { EXPECT_EQ(shrunk_col->size(), 10); data_col = assert_cast(*shrunk_col).get_values_ptr(); EXPECT_EQ(data_col->size(), 3); - v = get(shrunk_col->operator[](0)); + v = shrunk_col->operator[](0).get(); EXPECT_EQ(v.size(), 2); - EXPECT_EQ(get(v[0]), + EXPECT_EQ(v[0].get(), Array({Field::create_field("a"), Field::create_field("b"), Field::create_field("c")})); - EXPECT_EQ(get(v[1]), + EXPECT_EQ(v[1].get(), Array({Field::create_field(1), Field::create_field(2), Field::create_field(3)})); - v = get(shrunk_col->operator[](1)); + v = shrunk_col->operator[](1).get(); EXPECT_EQ(v.size(), 2); - EXPECT_EQ(get(v[0]), Array()); - EXPECT_EQ(get(v[1]), Array()); - v = get(shrunk_col->operator[](2)); + EXPECT_EQ(v[0].get(), Array()); + EXPECT_EQ(v[1].get(), Array()); + v = shrunk_col->operator[](2).get(); EXPECT_EQ(v.size(), 2); - EXPECT_EQ(get(v[0]), Array()); - EXPECT_EQ(get(v[1]), Array()); + EXPECT_EQ(v[0].get(), Array()); + EXPECT_EQ(v[1].get(), Array()); } } // namespace doris::vectorized diff --git a/be/test/vec/core/field_test.cpp b/be/test/vec/core/field_test.cpp index d40fac5fbf9db1..7a436c65505c20 100644 --- a/be/test/vec/core/field_test.cpp +++ b/be/test/vec/core/field_test.cpp @@ -36,27 +36,27 @@ TEST(VFieldTest, field_string) { Field f; f = Field::create_field(String {"Hello, world (1)"}); - ASSERT_EQ(f.get(), "Hello, world (1)"); + ASSERT_EQ(f.get(), "Hello, world (1)"); f = Field::create_field(String {"Hello, world (2)"}); - ASSERT_EQ(f.get(), "Hello, world (2)"); + ASSERT_EQ(f.get(), "Hello, world (2)"); f = Field::create_field( Array {Field ::create_field(String {"Hello, world (3)"})}); - ASSERT_EQ(f.get()[0].get(), "Hello, world (3)"); + ASSERT_EQ(f.get()[0].get(), "Hello, world (3)"); f = Field::create_field(String {"Hello, world (4)"}); - ASSERT_EQ(f.get(), "Hello, world (4)"); + ASSERT_EQ(f.get(), "Hello, world (4)"); f = Field::create_field( Array {Field::create_field(String {"Hello, world (5)"})}); - ASSERT_EQ(f.get()[0].get(), "Hello, world (5)"); + ASSERT_EQ(f.get()[0].get(), "Hello, world (5)"); f = Field::create_field( Array {Field::create_field(String {"Hello, world (6)"})}); - ASSERT_EQ(f.get()[0].get(), "Hello, world (6)"); + ASSERT_EQ(f.get()[0].get(), "Hello, world (6)"); } TEST(VFieldTest, field_timestamptz) { Field f; f = Field::create_field(*(TimestampTzValue*)&MIN_DATETIME_V2); ASSERT_EQ(f.get_type(), TYPE_TIMESTAMPTZ); - ASSERT_EQ(f.get(), MIN_DATETIME_V2); + ASSERT_EQ(f.get().to_date_int_val(), MIN_DATETIME_V2); } TEST(VFieldTest, jsonb_field_unique_ptr) { @@ -110,10 +110,10 @@ TEST(VFieldTest, jsonb_field_unique_ptr) { // Test JsonbField with Field Field field_jf = Field::create_field(jf1); ASSERT_EQ(field_jf.get_type(), TYPE_JSONB); - ASSERT_NE(field_jf.get().get_value(), nullptr); - ASSERT_EQ(field_jf.get().get_size(), test_size); - ASSERT_EQ(std::string(field_jf.get().get_value(), - field_jf.get().get_size()), + ASSERT_NE(field_jf.get().get_value(), nullptr); + ASSERT_EQ(field_jf.get().get_size(), test_size); + ASSERT_EQ(std::string(field_jf.get().get_value(), + field_jf.get().get_size()), std::string(test_data)); } @@ -184,9 +184,9 @@ TEST(VFieldTest, jsonb_field_io) { Field f2 = Field::create_field(jsonb_from_field); ASSERT_EQ(f2.get_type(), TYPE_JSONB); - ASSERT_NE(f2.get().get_value(), nullptr); + ASSERT_NE(f2.get().get_value(), nullptr); ASSERT_EQ( - std::string(f2.get().get_value(), f2.get().get_size()), + std::string(f2.get().get_value(), f2.get().get_size()), std::string(test_data)); } } diff --git a/be/test/vec/data_types/data_type_array_test.cpp b/be/test/vec/data_types/data_type_array_test.cpp index ad41cb2c6a3872..f054dc950886b9 100644 --- a/be/test/vec/data_types/data_type_array_test.cpp +++ b/be/test/vec/data_types/data_type_array_test.cpp @@ -538,7 +538,7 @@ TEST_F(DataTypeArrayTest, GetFieldWithDataTypeTest) { auto fdt = array_type->get_field_with_data_type(*column, 0); EXPECT_EQ(fdt.field.get_type(), TYPE_ARRAY); - EXPECT_EQ(fdt.field.get(), arr); + EXPECT_EQ(fdt.field.get(), arr); EXPECT_EQ(fdt.base_scalar_type_id, TYPE_INT); EXPECT_EQ(fdt.num_dimensions, 1); EXPECT_EQ(fdt.precision, -1); @@ -595,11 +595,11 @@ TEST_F(DataTypeArrayTest, GetFieldWithDataTypeTest) { EXPECT_EQ(fdt.field.get_type(), TYPE_ARRAY); EXPECT_EQ(fdt.base_scalar_type_id, TYPE_JSONB); EXPECT_EQ(fdt.num_dimensions, 1); - const auto& result_arr = fdt.field.get(); + const auto& result_arr = fdt.field.get(); EXPECT_EQ(result_arr.size(), 1); EXPECT_EQ(result_arr[0].get_type(), TYPE_JSONB); - EXPECT_EQ(std::string(result_arr[0].get().get_value(), - result_arr[0].get().get_size()), + EXPECT_EQ(std::string(result_arr[0].get().get_value(), + result_arr[0].get().get_size()), json_str); } diff --git a/be/test/vec/data_types/data_type_datetime_v1_test.cpp b/be/test/vec/data_types/data_type_datetime_v1_test.cpp index aa4fed9e00cb93..c6dd02dbd6f48f 100644 --- a/be/test/vec/data_types/data_type_datetime_v1_test.cpp +++ b/be/test/vec/data_types/data_type_datetime_v1_test.cpp @@ -164,8 +164,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "0000-01-01"; auto field = dt_date.get_field(expr_node); - auto int_value = field.get(); - auto date_value = binary_cast(int_value); + auto date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -176,8 +175,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { // should be OK expr_node.date_literal.value = "0000-01-01 00:00:00.000000"; field = dt_date.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -187,8 +185,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "9999-12-31 00:00:00.000000"; field = dt_date.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -198,8 +195,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "2021-01-01"; field = dt_date.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -209,8 +205,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "9999-12-31"; field = dt_date.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -221,8 +216,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { // it's OK to have time part for date expr_node.date_literal.value = "0000-01-01 23:59:59"; field = dt_date.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -232,8 +226,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59"; field = dt_date.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -245,8 +238,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { TExprNode expr_node; expr_node.date_literal.value = "0000-01-01 00:00:00"; auto field = dt_datetime.get_field(expr_node); - auto int_value = field.get(); - auto date_value = binary_cast(int_value); + auto date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -256,8 +248,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "2021-12-31 12:23:34"; field = dt_datetime.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -267,8 +258,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59"; field = dt_datetime.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -278,8 +268,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.00000"; field = dt_datetime.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -290,8 +279,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { // microsecond is discarded expr_node.date_literal.value = "0000-01-01 00:00:00.000001"; field = dt_datetime.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -301,8 +289,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.1"; field = dt_datetime.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -312,8 +299,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "2021-12-31 12:23:34.12345"; field = dt_datetime.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -323,8 +309,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59.999994"; field = dt_datetime.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -334,8 +319,7 @@ TEST_F(DataTypeDateTimeV1Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59.99999"; field = dt_datetime.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); diff --git a/be/test/vec/data_types/data_type_datetime_v2_test.cpp b/be/test/vec/data_types/data_type_datetime_v2_test.cpp index 3c2af1cc9e9285..c2f7ca0973ad7b 100644 --- a/be/test/vec/data_types/data_type_datetime_v2_test.cpp +++ b/be/test/vec/data_types/data_type_datetime_v2_test.cpp @@ -264,9 +264,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01"; auto field = dt_date_v2.get_field(expr_node); - auto int_value = field.get(); - DateV2Value date_value = - binary_cast>(int_value); + auto date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -278,8 +276,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { // should be OK expr_node.date_literal.value = "0000-01-01 00:00:00.000000"; field = dt_date_v2.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -290,8 +287,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "9999-12-31 00:00:00.000000"; field = dt_date_v2.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -302,16 +298,14 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "2021-01-01"; field = dt_date_v2.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); expr_node.date_literal.value = "9999-12-31"; field = dt_date_v2.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -319,8 +313,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { // it's OK to have time part for date expr_node.date_literal.value = "0000-01-01 23:59:59"; field = dt_date_v2.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -331,8 +324,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59"; field = dt_date_v2.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -346,9 +338,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00"; auto field = dt_datetime_v2_0.get_field(expr_node); - auto int_value = field.get(); - DateV2Value date_value = - binary_cast>(int_value); + auto date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -359,8 +349,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "2021-12-31 12:23:34"; field = dt_datetime_v2_0.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -371,8 +360,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59"; field = dt_datetime_v2_0.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -389,9 +377,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.00000"; auto field = dt_datetime_v2_5.get_field(expr_node); - auto int_value = field.get(); - DateV2Value date_value = - binary_cast>(int_value); + auto date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -403,8 +389,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { // microsecond is rounded expr_node.date_literal.value = "0000-01-01 00:00:00.000001"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -415,8 +400,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.000005"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -427,8 +411,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.000010"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -439,8 +422,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.1"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -451,8 +433,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "2021-12-31 12:23:34.12345"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -464,8 +445,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { // microsecond is rounded expr_node.date_literal.value = "2021-12-31 12:23:34.123454"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -476,8 +456,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "2021-12-31 12:23:34.123456"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -488,8 +467,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59.999994"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -500,8 +478,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59.999985"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -512,8 +489,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59.99999"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -530,9 +506,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.1"; auto field = dt_datetime_v2_6.get_field(expr_node); - auto int_value = field.get(); - DateV2Value date_value = - binary_cast>(int_value); + auto date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -543,8 +517,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.000000"; field = dt_datetime_v2_6.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -555,8 +528,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.000001"; field = dt_datetime_v2_6.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -567,8 +539,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.100000"; field = dt_datetime_v2_6.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -579,8 +550,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "0000-01-01 00:00:00.100001"; field = dt_datetime_v2_6.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 0); EXPECT_EQ(date_value.month(), 1); EXPECT_EQ(date_value.day(), 1); @@ -591,8 +561,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "2021-12-31 12:23:34.99999"; field = dt_datetime_v2_6.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -607,8 +576,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { // EXPECT_EQ(date_value.microsecond(), 999999); expr_node.date_literal.value = "2021-12-31 12:23:34.999999"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -619,8 +587,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:59.999999"; field = dt_datetime_v2_6.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -631,8 +598,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "2021-12-31 12:23:34.9999994"; field = dt_datetime_v2_5.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -643,8 +609,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "2021-12-31 12:23:34.9999985"; field = dt_datetime_v2_6.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -655,8 +620,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "2021-12-31 12:23:34.9999999"; field = dt_datetime_v2_6.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 2021); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); @@ -667,8 +631,7 @@ TEST_F(DataTypeDateTimeV2Test, get_field) { expr_node.date_literal.value = "9999-12-31 23:59:58.9999999"; field = dt_datetime_v2_6.get_field(expr_node); - int_value = field.get(); - date_value = binary_cast>(int_value); + date_value = field.get(); EXPECT_EQ(date_value.year(), 9999); EXPECT_EQ(date_value.month(), 12); EXPECT_EQ(date_value.day(), 31); diff --git a/be/test/vec/data_types/data_type_decimal_test.cpp b/be/test/vec/data_types/data_type_decimal_test.cpp index 87966758192af7..5c5692583fb353 100644 --- a/be/test/vec/data_types/data_type_decimal_test.cpp +++ b/be/test/vec/data_types/data_type_decimal_test.cpp @@ -465,7 +465,7 @@ TEST_F(DataTypeDecimalTest, get_default) { using DataType = decltype(dt); using ColumnType = typename DataType::ColumnType; auto default_field = dt.get_default(); - auto decimal_field = default_field.template get(); + auto decimal_field = default_field.template get(); EXPECT_EQ(decimal_field, typename ColumnType::value_type()); }; test_func(dt_decimal32_1); @@ -482,7 +482,6 @@ TEST_F(DataTypeDecimalTest, get_field) { std::string line; auto test_func = [&](auto dt, const std::string& input_data_file_name) { using DataType = decltype(dt); - using ColumnType = typename DataType::ColumnType; { expr_node.decimal_literal.value = "abc"; EXPECT_THROW(dt.get_field(expr_node), Exception); @@ -505,7 +504,7 @@ TEST_F(DataTypeDecimalTest, get_field) { } expr_node.decimal_literal.value = line; auto field = dt.get_field(expr_node); - auto decimal_field = field.template get(); + auto decimal_field = field.template get(); res.push_back(decimal_field.to_string(dt.get_scale())); } check_or_generate_res_file(output_file, {res}); diff --git a/be/test/vec/data_types/data_type_varbinary_test.cpp b/be/test/vec/data_types/data_type_varbinary_test.cpp index 9e6003a38eb6d7..e58b2cc406d93e 100644 --- a/be/test/vec/data_types/data_type_varbinary_test.cpp +++ b/be/test/vec/data_types/data_type_varbinary_test.cpp @@ -89,7 +89,7 @@ TEST_F(DataTypeVarbinaryTest, CreateColumnAndCheckColumn) { TEST_F(DataTypeVarbinaryTest, GetDefaultField) { DataTypeVarbinary dt; Field def = dt.get_default(); - const auto& sv = get(def); + const auto& sv = def.get(); EXPECT_EQ(sv.size(), 0U); } @@ -178,7 +178,7 @@ TEST_F(DataTypeVarbinaryTest, GetFieldWithDataType) { auto fwd = dt.get_field_with_data_type(*col, 0); EXPECT_EQ(fwd.base_scalar_type_id, PrimitiveType::TYPE_VARBINARY); - const auto& sv = get(fwd.field); + const auto& sv = fwd.field.get(); ASSERT_EQ(sv.size(), v.size()); ASSERT_EQ(memcmp(sv.data(), v.data(), sv.size()), 0); } @@ -191,7 +191,7 @@ TEST_F(DataTypeVarbinaryTest, GetFieldFromTExprNode) { node.__isset.varbinary_literal = true; Field f = dt.get_field(node); - const auto& sv = get(f); + const auto& sv = f.get(); ASSERT_EQ(sv.size(), 5U); ASSERT_EQ(memcmp(sv.data(), "hello", 5), 0); } @@ -278,7 +278,7 @@ TEST_F(DataTypeVarbinaryTest, GetFieldFromTExprNodeWithEmbeddedNull) { node.__isset.varbinary_literal = true; Field f = dt.get_field(node); - const auto& sv = get(f); + const auto& sv = f.get(); ASSERT_EQ(sv.size(), raw.size()); ASSERT_EQ(memcmp(sv.data(), raw.data(), sv.size()), 0); } @@ -301,7 +301,7 @@ TEST_F(DataTypeVarbinaryTest, GetFieldWithDataTypeNonInline) { auto fwd = dt.get_field_with_data_type(*col, 0); EXPECT_EQ(fwd.base_scalar_type_id, PrimitiveType::TYPE_VARBINARY); - const auto& sv = get(fwd.field); + const auto& sv = fwd.field.get(); ASSERT_EQ(sv.size(), big.size()); ASSERT_EQ(memcmp(sv.data(), big.data(), sv.size()), 0); } diff --git a/be/test/vec/data_types/serde/data_type_serde_test.cpp b/be/test/vec/data_types/serde/data_type_serde_test.cpp index 00324f4204608a..58fc1ec907edb3 100644 --- a/be/test/vec/data_types/serde/data_type_serde_test.cpp +++ b/be/test/vec/data_types/serde/data_type_serde_test.cpp @@ -429,12 +429,12 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_STRING); - EXPECT_EQ(subcolumn.get_last_field().get(), "123"); + EXPECT_EQ(subcolumn.get_last_field().get(), "123"); subcolumn.deserialize_from_sparse_column(&value, 0); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_STRING); - EXPECT_EQ(subcolumn.get_last_field().get(), "123"); + EXPECT_EQ(subcolumn.get_last_field().get(), "123"); } { @@ -442,11 +442,11 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { subcolumn.deserialize_from_sparse_column(&value, 1); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_INT); - EXPECT_EQ(subcolumn.get_last_field().get(), 123); + EXPECT_EQ(subcolumn.get_last_field().get(), 123); subcolumn.deserialize_from_sparse_column(&value, 1); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_INT); - EXPECT_EQ(subcolumn.get_last_field().get(), 123); + EXPECT_EQ(subcolumn.get_last_field().get(), 123); } { @@ -455,12 +455,12 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_LARGEINT); - EXPECT_EQ(subcolumn.get_last_field().get(), 123); + EXPECT_EQ(subcolumn.get_last_field().get(), 123); subcolumn.deserialize_from_sparse_column(&value, 2); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_LARGEINT); - EXPECT_EQ(subcolumn.get_last_field().get(), 123); + EXPECT_EQ(subcolumn.get_last_field().get(), 123); } { @@ -469,12 +469,12 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DOUBLE); - EXPECT_EQ(subcolumn.get_last_field().get(), 123.456); + EXPECT_EQ(subcolumn.get_last_field().get(), 123.456); subcolumn.deserialize_from_sparse_column(&value, 3); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DOUBLE); - EXPECT_EQ(subcolumn.get_last_field().get(), 123.456); + EXPECT_EQ(subcolumn.get_last_field().get(), 123.456); } { @@ -483,12 +483,12 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_BOOLEAN); - EXPECT_EQ(subcolumn.get_last_field().get(), true); + EXPECT_EQ(subcolumn.get_last_field().get(), true); subcolumn.deserialize_from_sparse_column(&value, 4); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_BOOLEAN); - EXPECT_EQ(subcolumn.get_last_field().get(), true); + EXPECT_EQ(subcolumn.get_last_field().get(), true); } { @@ -497,12 +497,12 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DATETIMEV2); - EXPECT_EQ(subcolumn.get_last_field().get(), 23232323); + EXPECT_EQ(subcolumn.get_last_field().get().to_date_int_val(), 23232323); subcolumn.deserialize_from_sparse_column(&value, 5); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DATETIMEV2); - EXPECT_EQ(subcolumn.get_last_field().get(), 23232323); + EXPECT_EQ(subcolumn.get_last_field().get().to_date_int_val(), 23232323); } { @@ -511,12 +511,12 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DATEV2); - EXPECT_EQ(subcolumn.get_last_field().get(), 154543245); + EXPECT_EQ(subcolumn.get_last_field().get().to_date_int_val(), 154543245); subcolumn.deserialize_from_sparse_column(&value, 6); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DATEV2); - EXPECT_EQ(subcolumn.get_last_field().get(), 154543245); + EXPECT_EQ(subcolumn.get_last_field().get().to_date_int_val(), 154543245); } { @@ -525,12 +525,12 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_IPV4); - EXPECT_EQ(subcolumn.get_last_field().get(), static_cast(367357)); + EXPECT_EQ(subcolumn.get_last_field().get(), static_cast(367357)); subcolumn.deserialize_from_sparse_column(&value, 7); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_IPV4); - EXPECT_EQ(subcolumn.get_last_field().get(), static_cast(367357)); + EXPECT_EQ(subcolumn.get_last_field().get(), static_cast(367357)); } { @@ -539,12 +539,12 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_IPV6); - EXPECT_EQ(subcolumn.get_last_field().get(), static_cast(36534645)); + EXPECT_EQ(subcolumn.get_last_field().get(), static_cast(36534645)); subcolumn.deserialize_from_sparse_column(&value, 8); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_IPV6); - EXPECT_EQ(subcolumn.get_last_field().get(), static_cast(36534645)); + EXPECT_EQ(subcolumn.get_last_field().get(), static_cast(36534645)); } { @@ -553,7 +553,7 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DECIMAL32); - auto v = subcolumn.get_last_field().get(); + auto v = subcolumn.get_last_field().get(); EXPECT_EQ(static_cast(v), static_cast(3456345634)); subcolumn.deserialize_from_sparse_column(&value, 9); EXPECT_EQ(subcolumn.data.size(), 1); @@ -567,13 +567,13 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DECIMAL64); - auto v = subcolumn.get_last_field().get(); + auto v = subcolumn.get_last_field().get(); EXPECT_EQ(static_cast(v), static_cast(13452435)); subcolumn.deserialize_from_sparse_column(&value, 10); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DECIMAL64); - v = subcolumn.get_last_field().get(); + v = subcolumn.get_last_field().get(); EXPECT_EQ(static_cast(v), static_cast(13452435)); } @@ -583,13 +583,13 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DECIMAL128I); - auto v = subcolumn.get_last_field().get(); + auto v = subcolumn.get_last_field().get(); EXPECT_EQ(static_cast(v), static_cast(2342345)); subcolumn.deserialize_from_sparse_column(&value, 11); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DECIMAL128I); - v = subcolumn.get_last_field().get(); + v = subcolumn.get_last_field().get(); EXPECT_EQ(static_cast(v), static_cast(2342345)); } @@ -599,13 +599,13 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DECIMAL256); - auto v = subcolumn.get_last_field().get(); + auto v = subcolumn.get_last_field().get(); EXPECT_TRUE(v == Decimal256(2345243)); subcolumn.deserialize_from_sparse_column(&value, 12); EXPECT_EQ(subcolumn.data.size(), 1); EXPECT_EQ(subcolumn.get_least_common_type()->get_primitive_type(), PrimitiveType::TYPE_DECIMAL256); - v = subcolumn.get_last_field().get(); + v = subcolumn.get_last_field().get(); EXPECT_TRUE(v == Decimal256(2345243)); } @@ -630,7 +630,7 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.get_dimensions(), 1); EXPECT_EQ(subcolumn.get_least_common_base_type_id(), PrimitiveType::TYPE_JSONB); auto v = subcolumn.get_last_field(); - auto& arr = v.get(); + auto& arr = v.get(); EXPECT_EQ(arr.size(), 3); EXPECT_FALSE(arr[0].is_null()); EXPECT_TRUE(arr[1].is_null()); @@ -643,7 +643,7 @@ TEST(DataTypeSerDeTest, DeserializeFromSparseColumnTest) { EXPECT_EQ(subcolumn.get_least_common_base_type_id(), PrimitiveType::TYPE_JSONB); v = subcolumn.get_last_field(); - arr = v.get(); + arr = v.get(); EXPECT_EQ(arr.size(), 3); EXPECT_FALSE(arr[0].is_null()); EXPECT_TRUE(arr[1].is_null()); diff --git a/be/test/vec/exec/format/parquet/parquet_expr_test.cpp b/be/test/vec/exec/format/parquet/parquet_expr_test.cpp index f7182b93a87475..54e7456feec312 100644 --- a/be/test/vec/exec/format/parquet/parquet_expr_test.cpp +++ b/be/test/vec/exec/format/parquet/parquet_expr_test.cpp @@ -667,8 +667,8 @@ TEST_F(ParquetExprTest, test_min_max_p) { auto col = ColumnHelper::create_column_with_name({1.1f, 3.1f}); - std::cout << "min_field = " << min_field.get() << "\n"; - std::cout << "max_field = " << max_field.get() << "\n"; + std::cout << "min_field = " << min_field.get() << "\n"; + std::cout << "max_field = " << max_field.get() << "\n"; Field ans_min = col.column->operator[](0); Field ans_max = col.column->operator[](1); diff --git a/be/test/vec/exec/vgeneric_iterators_test.cpp b/be/test/vec/exec/vgeneric_iterators_test.cpp index 62c2208c014600..4aaa91995fd04f 100644 --- a/be/test/vec/exec/vgeneric_iterators_test.cpp +++ b/be/test/vec/exec/vgeneric_iterators_test.cpp @@ -95,9 +95,9 @@ TEST(VGenericIteratorsTest, AutoIncrement) { int row_count = 0; size_t rows = block.rows(); for (size_t i = 0; i < rows; ++i) { - EXPECT_EQ(row_count, (*c0)[i].get()); - EXPECT_EQ(row_count + 1, (*c1)[i].get()); - EXPECT_EQ(row_count + 2, (*c2)[i].get()); + EXPECT_EQ(row_count, (*c0)[i].get()); + EXPECT_EQ(row_count + 1, (*c1)[i].get()); + EXPECT_EQ(row_count + 2, (*c2)[i].get()); row_count++; } } @@ -138,9 +138,9 @@ TEST(VGenericIteratorsTest, Union) { base_value -= 100; } - EXPECT_EQ(base_value, (*c0)[i].get()); - EXPECT_EQ(base_value + 1, (*c1)[i].get()); - EXPECT_EQ(base_value + 2, (*c2)[i].get()); + EXPECT_EQ(base_value, (*c0)[i].get()); + EXPECT_EQ(base_value + 1, (*c1)[i].get()); + EXPECT_EQ(base_value + 2, (*c2)[i].get()); row_count++; } } @@ -187,9 +187,9 @@ TEST(VGenericIteratorsTest, MergeAgg) { base_value = row_count - 300; } - EXPECT_EQ(base_value, (*c0)[i].get()); - EXPECT_EQ(base_value + 1, (*c1)[i].get()); - EXPECT_EQ(base_value + 2, (*c2)[i].get()); + EXPECT_EQ(base_value, (*c0)[i].get()); + EXPECT_EQ(base_value + 1, (*c1)[i].get()); + EXPECT_EQ(base_value + 2, (*c2)[i].get()); row_count++; } } @@ -228,9 +228,9 @@ TEST(VGenericIteratorsTest, MergeUnique) { for (size_t i = 0; i < block.rows(); ++i) { size_t base_value = row_count; - EXPECT_EQ(base_value, (*c0)[i].get()); - EXPECT_EQ(base_value + 1, (*c1)[i].get()); - EXPECT_EQ(base_value + 2, (*c2)[i].get()); + EXPECT_EQ(base_value, (*c0)[i].get()); + EXPECT_EQ(base_value + 1, (*c1)[i].get()); + EXPECT_EQ(base_value + 2, (*c2)[i].get()); row_count++; } } @@ -346,7 +346,7 @@ TEST(VGenericIteratorsTest, MergeWithSeqColumn) { auto col0 = block.get_by_position(0).column; auto col1 = block.get_by_position(1).column; auto seq_col = block.get_by_position(seq_column_id).column; - size_t actual_value = (*seq_col)[0].get(); + size_t actual_value = (*seq_col)[0].get(); EXPECT_EQ(seg_iter_num - 1, actual_value); } diff --git a/be/test/vec/exprs/vexpr_test.cpp b/be/test/vec/exprs/vexpr_test.cpp index a8b2315d3bd827..d3858e2d949eb7 100644 --- a/be/test/vec/exprs/vexpr_test.cpp +++ b/be/test/vec/exprs/vexpr_test.cpp @@ -422,7 +422,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); + auto v = (*ctn.column)[0].get(); EXPECT_EQ(v, true); EXPECT_EQ("1", literal.value()); @@ -437,7 +437,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); + auto v = (*ctn.column)[0].get(); EXPECT_EQ(v, 1024); EXPECT_EQ("1024", literal.value()); @@ -452,7 +452,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); + auto v = (*ctn.column)[0].get(); EXPECT_EQ(v, 1024); EXPECT_EQ("1024", literal.value()); @@ -467,7 +467,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); + auto v = (*ctn.column)[0].get(); EXPECT_EQ(v, 1024); EXPECT_EQ("1024", literal.value()); @@ -482,7 +482,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get<__int128_t>(); + auto v = (*ctn.column)[0].get(); EXPECT_EQ(v, 1024); EXPECT_EQ("1024", literal.value()); @@ -497,7 +497,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); + auto v = (*ctn.column)[0].get(); EXPECT_FLOAT_EQ(v, 1024.0f); EXPECT_EQ("1024", literal.value()); @@ -512,7 +512,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); + auto v = (*ctn.column)[0].get(); EXPECT_FLOAT_EQ(v, 1024.0) << ctn.column->get_name(); EXPECT_EQ("1024", literal.value()) << ctn.column->get_name(); @@ -526,15 +526,11 @@ TEST(TEST_VEXPR, LITERALTEST) { const char* date = "20210407000000"; data_time_value.from_date_str(date, strlen(date)); std::cout << data_time_value.type() << std::endl; - __int64_t dt; - memcpy(&dt, &data_time_value, sizeof(__int64_t)); VLiteral literal(create_literal(std::string(date))); Block block; int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get<__int64_t>(); - EXPECT_EQ(v, dt); EXPECT_EQ("2021-04-07 00:00:00", literal.value()); auto node = std::make_shared( @@ -613,8 +609,6 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get<__int64_t>(); - EXPECT_EQ(v, dt); EXPECT_EQ("2021-04-07", literal.value()); auto node = std::make_shared( @@ -633,7 +627,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); + auto v = (*ctn.column)[0].get(); EXPECT_EQ(v, dt); EXPECT_EQ("2021-04-07", literal.value()); @@ -684,7 +678,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); + auto v = (*ctn.column)[0].get(); EXPECT_EQ(v, s); EXPECT_EQ(s, literal.value()); @@ -699,8 +693,8 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; static_cast(literal.execute(nullptr, &block, &ret)); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); - EXPECT_FLOAT_EQ(((double)v) / (std::pow(10, 9)), 1234.56); + auto v = (*ctn.column)[0].get(); + EXPECT_FLOAT_EQ(((double)v.value()) / (std::pow(10, 9)), 1234.56); EXPECT_EQ("1234.560000000", literal.value()); auto node = std::make_shared( @@ -714,7 +708,7 @@ TEST(TEST_VEXPR, LITERALTEST) { int ret = -1; EXPECT_TRUE(literal.execute(nullptr, &block, &ret).ok()); auto ctn = block.safe_get_by_position(ret); - auto v = (*ctn.column)[0].get(); + auto v = (*ctn.column)[0].get(); EXPECT_FLOAT_EQ(v / 1000000, 12.1234); EXPECT_EQ("00:00:12.1234", literal.value()); diff --git a/be/test/vec/function/cast/cast_test.h b/be/test/vec/function/cast/cast_test.h index 6f094a4d6de759..df57dc98242040 100644 --- a/be/test/vec/function/cast/cast_test.h +++ b/be/test/vec/function/cast/cast_test.h @@ -63,6 +63,9 @@ inline auto get_decimal_ctor() { if constexpr (std::is_same_v) { return DECIMAL128V2; } + if constexpr (std::is_same_v) { + return DECIMALV2VALUE; + } if constexpr (std::is_same_v) { return DECIMAL128V3; } diff --git a/be/test/vec/function/cast/cast_to_boolean_test.cpp b/be/test/vec/function/cast/cast_to_boolean_test.cpp index b0056aff0f7b10..7f83510b3f70d1 100644 --- a/be/test/vec/function/cast/cast_to_boolean_test.cpp +++ b/be/test/vec/function/cast/cast_to_boolean_test.cpp @@ -340,10 +340,13 @@ TEST_F(FunctionCastTest, test_from_decimal_to_bool) { { InputTypeSet input_types = {PrimitiveType::TYPE_DECIMALV2}; DataSet data_set = { - {{Decimal128V2 {1}}, UInt8(1)}, {{Decimal128V2 {0}}, UInt8(0)}, - {{Decimal128V2 {+0}}, UInt8(0)}, {{Decimal128V2 {-0}}, UInt8(0)}, - {{Decimal128V2 {-1}}, UInt8(1)}, {{Decimal128V2 {0.5}}, UInt8(1)}, - {{Decimal128V2 {-0.5}}, UInt8(1)}, + {{DECIMALV2VALUEFROMDOUBLE(1)}, UInt8(1)}, + {{DECIMALV2VALUEFROMDOUBLE(0)}, UInt8(0)}, + {{DECIMALV2VALUEFROMDOUBLE(+0)}, UInt8(0)}, + {{DECIMALV2VALUEFROMDOUBLE(-0)}, UInt8(0)}, + {{DECIMALV2VALUEFROMDOUBLE(-1)}, UInt8(1)}, + {{DECIMALV2VALUEFROMDOUBLE(0.5)}, UInt8(1)}, + {{DECIMALV2VALUEFROMDOUBLE(-0.5)}, UInt8(1)}, }; check_function_for_cast(input_types, data_set); } @@ -396,10 +399,13 @@ TEST_F(FunctionCastTest, test_from_decimal_to_bool_strict_mode) { { InputTypeSet input_types = {PrimitiveType::TYPE_DECIMALV2}; DataSet data_set = { - {{Decimal128V2 {1}}, UInt8(1)}, {{Decimal128V2 {0}}, UInt8(0)}, - {{Decimal128V2 {+0}}, UInt8(0)}, {{Decimal128V2 {-0}}, UInt8(0)}, - {{Decimal128V2 {-1}}, UInt8(1)}, {{Decimal128V2 {0.5}}, UInt8(1)}, - {{Decimal128V2 {-0.5}}, UInt8(1)}, + {{DECIMALV2VALUEFROMDOUBLE(1)}, UInt8(1)}, + {{DECIMALV2VALUEFROMDOUBLE(0)}, UInt8(0)}, + {{DECIMALV2VALUEFROMDOUBLE(+0)}, UInt8(0)}, + {{DECIMALV2VALUEFROMDOUBLE(-0)}, UInt8(0)}, + {{DECIMALV2VALUEFROMDOUBLE(-1)}, UInt8(1)}, + {{DECIMALV2VALUEFROMDOUBLE(0.5)}, UInt8(1)}, + {{DECIMALV2VALUEFROMDOUBLE(-0.5)}, UInt8(1)}, }; check_function_for_cast_strict_mode(input_types, data_set); } diff --git a/be/test/vec/function/cast/cast_to_decimal.cpp b/be/test/vec/function/cast/cast_to_decimal.cpp index e5f1463a91a58b..b26dc3bc4f3638 100644 --- a/be/test/vec/function/cast/cast_to_decimal.cpp +++ b/be/test/vec/function/cast/cast_to_decimal.cpp @@ -100,10 +100,10 @@ TEST_F(FunctionCastToDecimalTest, test_from_bool) { from_bool_test_func(18, 9); from_bool_test_func(18, 17); - from_bool_test_func(27, 9); - // from_bool_test_func(); - // from_bool_test_func(); - // from_bool_test_func(); + from_bool_test_func(27, 9); + // from_bool_test_func(); + // from_bool_test_func(); + // from_bool_test_func(); from_bool_test_func(38, 0); from_bool_test_func(38, 1); @@ -119,7 +119,7 @@ TEST_F(FunctionCastToDecimalTest, test_from_bool) { TEST_F(FunctionCastToDecimalTest, test_from_bool_overflow) { from_bool_overflow_test_func(); from_bool_overflow_test_func(); - from_bool_overflow_test_func(); + from_bool_overflow_test_func(); from_bool_overflow_test_func(); from_bool_overflow_test_func(); } diff --git a/be/test/vec/function/cast/cast_to_decimal.h b/be/test/vec/function/cast/cast_to_decimal.h index dfdaef0bb2bf40..0cd35ec1d21da2 100644 --- a/be/test/vec/function/cast/cast_to_decimal.h +++ b/be/test/vec/function/cast/cast_to_decimal.h @@ -1959,7 +1959,7 @@ struct FunctionCastToDecimalTest : public FunctionCastTest { (*ofs_case) << " sql \"set enable_decimal256 = true;\"\n"; } } - if constexpr (std::is_same_v) { + if constexpr (IsDecimal128V2) { between_decimal_with_precision_and_scale_test_func( 1, 0, to_precision, to_scale, table_index++, test_data_index, ofs_case, ofs_expected_result, ofs_const_case, ofs_const_expected_result); @@ -2215,7 +2215,8 @@ struct FunctionCastToDecimalTest : public FunctionCastTest { ? BeConsts::MAX_DECIMAL128_PRECISION + 1 : 1))); static_assert(from_min_decimal_p == 1 || from_min_decimal_p > 9); - if constexpr (std::is_same_v) { + if constexpr (std::is_same_v || + std::is_same_v) { between_decimal_with_precision_and_scale_overflow_test_func( 1, 0, to_precision, to_scale, table_index++, test_data_index, ofs_case, ofs_expected_result, ofs_const_case, ofs_const_expected_result); diff --git a/be/test/vec/function/cast/cast_to_decimal128_from_decimal128.cpp b/be/test/vec/function/cast/cast_to_decimal128_from_decimal128.cpp index 856ba9fbc96799..47432d4065cfb4 100644 --- a/be/test/vec/function/cast/cast_to_decimal128_from_decimal128.cpp +++ b/be/test/vec/function/cast/cast_to_decimal128_from_decimal128.cpp @@ -22,6 +22,6 @@ TEST_F(FunctionCastToDecimalTest, test_to_decimal128_from_decimal128) { between_decimal_test_func(); } TEST_F(FunctionCastToDecimalTest, test_to_decimal128_from_decimalv2) { - between_decimal_test_func(); + between_decimal_test_func(); } } // namespace doris::vectorized \ No newline at end of file diff --git a/be/test/vec/function/cast/cast_to_decimal128_from_decimal128_overflow.cpp b/be/test/vec/function/cast/cast_to_decimal128_from_decimal128_overflow.cpp index a49a8c119e55c1..14e188444c888b 100644 --- a/be/test/vec/function/cast/cast_to_decimal128_from_decimal128_overflow.cpp +++ b/be/test/vec/function/cast/cast_to_decimal128_from_decimal128_overflow.cpp @@ -23,6 +23,6 @@ TEST_F(FunctionCastToDecimalTest, test_to_decimal128_from_decimal128_overflow) { between_decimal_overflow_test_func(); } TEST_F(FunctionCastToDecimalTest, test_to_decimal128_from_decimalv2_overflow) { - between_decimal_overflow_test_func(); + between_decimal_overflow_test_func(); } } // namespace doris::vectorized diff --git a/be/test/vec/function/cast/cast_to_decimal256_from_decimal128.cpp b/be/test/vec/function/cast/cast_to_decimal256_from_decimal128.cpp index 6273b710b0a905..548e7675a881cc 100644 --- a/be/test/vec/function/cast/cast_to_decimal256_from_decimal128.cpp +++ b/be/test/vec/function/cast/cast_to_decimal256_from_decimal128.cpp @@ -22,6 +22,6 @@ TEST_F(FunctionCastToDecimalTest, test_to_decimal256_from_decimal128) { between_decimal_test_func(); } TEST_F(FunctionCastToDecimalTest, test_to_decimal256_from_decimalv2) { - between_decimal_test_func(); + between_decimal_test_func(); } } // namespace doris::vectorized \ No newline at end of file diff --git a/be/test/vec/function/cast/cast_to_decimal256_from_decimal128_overflow.cpp b/be/test/vec/function/cast/cast_to_decimal256_from_decimal128_overflow.cpp index 03e6034fb252bc..472a64a126d09d 100644 --- a/be/test/vec/function/cast/cast_to_decimal256_from_decimal128_overflow.cpp +++ b/be/test/vec/function/cast/cast_to_decimal256_from_decimal128_overflow.cpp @@ -23,6 +23,6 @@ TEST_F(FunctionCastToDecimalTest, test_to_decimal256_from_decimal128_overflow) { between_decimal_overflow_test_func(); } TEST_F(FunctionCastToDecimalTest, test_to_decimal256_from_decimalv2_overflow) { - between_decimal_overflow_test_func(); + between_decimal_overflow_test_func(); } } // namespace doris::vectorized diff --git a/be/test/vec/function/cast/cast_to_decimal32_from_decimal128.cpp b/be/test/vec/function/cast/cast_to_decimal32_from_decimal128.cpp index 5374c5485b1194..825765e64def4b 100644 --- a/be/test/vec/function/cast/cast_to_decimal32_from_decimal128.cpp +++ b/be/test/vec/function/cast/cast_to_decimal32_from_decimal128.cpp @@ -23,6 +23,6 @@ TEST_F(FunctionCastToDecimalTest, test_to_decimal32_from_decimal128) { between_decimal_test_func(); } TEST_F(FunctionCastToDecimalTest, test_to_decimal32_from_decimalv2) { - between_decimal_test_func(); + between_decimal_test_func(); } } // namespace doris::vectorized diff --git a/be/test/vec/function/cast/cast_to_decimal32_from_decimal128_overflow.cpp b/be/test/vec/function/cast/cast_to_decimal32_from_decimal128_overflow.cpp index 883e5b045c0439..a21b2c1e369f1b 100644 --- a/be/test/vec/function/cast/cast_to_decimal32_from_decimal128_overflow.cpp +++ b/be/test/vec/function/cast/cast_to_decimal32_from_decimal128_overflow.cpp @@ -23,6 +23,6 @@ TEST_F(FunctionCastToDecimalTest, test_to_decimal32_from_decimal128_overflow) { between_decimal_overflow_test_func(); } TEST_F(FunctionCastToDecimalTest, test_to_decimal32_from_decimalv2_overflow) { - between_decimal_overflow_test_func(); + between_decimal_overflow_test_func(); } } // namespace doris::vectorized diff --git a/be/test/vec/function/cast/cast_to_decimal64_from_decimal128.cpp b/be/test/vec/function/cast/cast_to_decimal64_from_decimal128.cpp index 157d34cb31f070..f938826ad040a6 100644 --- a/be/test/vec/function/cast/cast_to_decimal64_from_decimal128.cpp +++ b/be/test/vec/function/cast/cast_to_decimal64_from_decimal128.cpp @@ -26,7 +26,7 @@ TEST_F(FunctionCastToDecimalTest, test_to_decimal64_from_decimal128) { between_decimal_test_func(); } TEST_F(FunctionCastToDecimalTest, test_to_decimal64_from_decimalv2) { - between_decimal_test_func(); + between_decimal_test_func(); } } // namespace doris::vectorized \ No newline at end of file diff --git a/be/test/vec/function/cast/cast_to_decimal64_from_decimal128_overflow.cpp b/be/test/vec/function/cast/cast_to_decimal64_from_decimal128_overflow.cpp index 1be32b2bdbb274..ccb0d145e640ad 100644 --- a/be/test/vec/function/cast/cast_to_decimal64_from_decimal128_overflow.cpp +++ b/be/test/vec/function/cast/cast_to_decimal64_from_decimal128_overflow.cpp @@ -26,6 +26,6 @@ TEST_F(FunctionCastToDecimalTest, test_to_decimal64_from_decimal128_overflow) { between_decimal_overflow_test_func(); } TEST_F(FunctionCastToDecimalTest, test_to_decimal64_from_decimalv2_overflow) { - between_decimal_overflow_test_func(); + between_decimal_overflow_test_func(); } } // namespace doris::vectorized diff --git a/be/test/vec/function/cast/cast_to_float_double.cpp b/be/test/vec/function/cast/cast_to_float_double.cpp index e719f2cf0f0491..7e9cf51b88b720 100644 --- a/be/test/vec/function/cast/cast_to_float_double.cpp +++ b/be/test/vec/function/cast/cast_to_float_double.cpp @@ -892,8 +892,14 @@ struct FunctionCastToFloatTest : public FunctionCastTest { auto decimal_num = decimal_ctor(i, 0, FromScale); auto num_str = dt_from.to_string(decimal_num); // auto float_v = static_cast(i); - FloatType float_v = static_cast(decimal_num.value) / - static_cast(scale_multiplier); + FloatType float_v; + if constexpr (IsDecimalV2) { + float_v = static_cast(decimal_num.value()) / + static_cast(scale_multiplier); + } else { + float_v = static_cast(decimal_num.value) / + static_cast(scale_multiplier); + } if (std::isinf(float_v)) { // std::cout << fmt::format("cast {}({}, {}) value {} to float_v result is inf\n", // type_to_string(FromT::PType), FromPrecision, FromScale, @@ -906,8 +912,13 @@ struct FunctionCastToFloatTest : public FunctionCastTest { decimal_num = decimal_ctor(-i, 0, FromScale); num_str = dt_from.to_string(decimal_num); - float_v = static_cast(decimal_num.value) / - static_cast(scale_multiplier); + if constexpr (IsDecimalV2) { + float_v = static_cast(decimal_num.value()) / + static_cast(scale_multiplier); + } else { + float_v = static_cast(decimal_num.value) / + static_cast(scale_multiplier); + } if (std::isinf(float_v)) { // std::cout << fmt::format("cast {}({}, {}) value {} to float_v result is inf\n", // type_to_string(FromT::PType), FromPrecision, FromScale, @@ -929,16 +940,27 @@ struct FunctionCastToFloatTest : public FunctionCastTest { for (const auto& f : fractional_part) { auto decimal_num = decimal_ctor(0, f, FromScale); auto num_str = dt_from.to_string(decimal_num); - FloatType float_v = static_cast(decimal_num.value) / - static_cast(scale_multiplier); + FloatType float_v; + if constexpr (IsDecimalV2) { + float_v = static_cast(decimal_num.value()) / + static_cast(scale_multiplier); + } else { + float_v = static_cast(decimal_num.value) / + static_cast(scale_multiplier); + } // dbg_str += fmt::format("({}, {})|", dt.to_string(decimal_num), float_v); data_set.push_back({{decimal_num}, float_v}); test_data_set.emplace_back(num_str, float_v); decimal_num = decimal_ctor(0, -f, FromScale); num_str = dt_from.to_string(decimal_num); - float_v = static_cast(decimal_num.value) / - static_cast(scale_multiplier); + if constexpr (IsDecimalV2) { + float_v = static_cast(decimal_num.value()) / + static_cast(scale_multiplier); + } else { + float_v = static_cast(decimal_num.value) / + static_cast(scale_multiplier); + } // dbg_str += fmt::format("({}, {})|", dt.to_string(decimal_num), float_v); data_set.push_back({{decimal_num}, float_v}); test_data_set.emplace_back(num_str, float_v); @@ -955,8 +977,14 @@ struct FunctionCastToFloatTest : public FunctionCastTest { for (const auto& f : fractional_part) { auto decimal_num = decimal_ctor(i, f, FromScale); auto num_str = dt_from.to_string(decimal_num); - FloatType float_v = static_cast(decimal_num.value) / - static_cast(scale_multiplier); + FloatType float_v; + if constexpr (IsDecimalV2) { + float_v = static_cast(decimal_num.value()) / + static_cast(scale_multiplier); + } else { + float_v = static_cast(decimal_num.value) / + static_cast(scale_multiplier); + } if (std::isinf(float_v)) { // std::cout << fmt::format("cast {}({}, {}) value {} to float_v result is inf\n", // type_to_string(FromT::PType), FromPrecision, FromScale, @@ -969,8 +997,13 @@ struct FunctionCastToFloatTest : public FunctionCastTest { decimal_num = decimal_ctor(-i, -f, FromScale); num_str = dt_from.to_string(decimal_num); - float_v = static_cast(decimal_num.value) / - static_cast(scale_multiplier); + if constexpr (IsDecimalV2) { + float_v = static_cast(decimal_num.value()) / + static_cast(scale_multiplier); + } else { + float_v = static_cast(decimal_num.value) / + static_cast(scale_multiplier); + } if (std::isinf(float_v)) { // std::cout << fmt::format("cast {}({}, {}) value {} to float_v result is inf\n", // type_to_string(FromT::PType), FromPrecision, FromScale, @@ -1659,14 +1692,14 @@ TEST_F(FunctionCastToFloatTest, test_from_decimal) { from_decimal_test_func(); from_decimal_test_func(); - from_decimal_test_func(); + from_decimal_test_func(); from_decimal_test_func(); from_decimal_test_func(); from_decimal_test_func(); from_decimal_test_func(); - from_decimal_test_func(); + from_decimal_test_func(); } TEST_F(FunctionCastToFloatTest, test_from_decimal_overflow) { from_decimal_overflow_test_func(); diff --git a/be/test/vec/function/cast/cast_to_integer.cpp b/be/test/vec/function/cast/cast_to_integer.cpp index 0bb88b2349ea13..82297e6da7e92e 100644 --- a/be/test/vec/function/cast/cast_to_integer.cpp +++ b/be/test/vec/function/cast/cast_to_integer.cpp @@ -1448,7 +1448,8 @@ struct FunctionCastToIntTest : public FunctionCastTest { : 1))); static_assert(min_decimal_pre == 1 || min_decimal_pre > 9); - if constexpr (std::is_same_v) { + if constexpr (std::is_same_v || + std::is_same_v) { from_decimal_with_p_s_no_overflow_test_func(1, 0); from_decimal_with_p_s_no_overflow_test_func(1, 1); from_decimal_with_p_s_no_overflow_test_func(27, 9); @@ -1671,7 +1672,8 @@ struct FunctionCastToIntTest : public FunctionCastTest { } } - if constexpr (std::is_same_v) { + if constexpr (std::is_same_v || + std::is_same_v) { from_decimal_with_p_s_overflow_test_func( 1, 0, regression_case_name, table_index++, ofs_case, ofs_expected_result, ofs_const_case, ofs_const_expected_result); @@ -2205,35 +2207,35 @@ TEST_F(FunctionCastToIntTest, test_from_decimal) { from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); - from_decimal_to_int_test_func(); + from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); - from_decimal_to_int_test_func(); + from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); - from_decimal_to_int_test_func(); + from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); - from_decimal_to_int_test_func(); + from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); from_decimal_to_int_test_func(); - from_decimal_to_int_test_func(); + from_decimal_to_int_test_func(); } TEST_F(FunctionCastToIntTest, DISABLE_test_from_decimal_overflow) { GTEST_SKIP(); @@ -2242,35 +2244,35 @@ TEST_F(FunctionCastToIntTest, DISABLE_test_from_decimal_overflow) { from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); - from_decimal_to_int_overflow_test_func(); + from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); - from_decimal_to_int_overflow_test_func(); + from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); - from_decimal_to_int_overflow_test_func(); + from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); - from_decimal_to_int_overflow_test_func(); + from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); from_decimal_to_int_overflow_test_func(); - from_decimal_to_int_overflow_test_func(); + from_decimal_to_int_overflow_test_func(); } TEST_F(FunctionCastToIntTest, test_from_date) { from_date_test_func(); diff --git a/be/test/vec/function/cast/function_variant_cast_test.cpp b/be/test/vec/function/cast/function_variant_cast_test.cpp index dc40e70f7d3b4b..203606c236dbd0 100644 --- a/be/test/vec/function/cast/function_variant_cast_test.cpp +++ b/be/test/vec/function/cast/function_variant_cast_test.cpp @@ -37,7 +37,7 @@ namespace doris::vectorized { static doris::vectorized::Field construct_variant_map( const std::vector>& key_and_values) { doris::vectorized::Field res = Field::create_field(VariantMap {}); - auto& object = res.get(); + auto& object = res.get(); for (const auto& [k, v] : key_and_values) { PathInData path(k); object.try_emplace(path, v); diff --git a/be/test/vec/function/function_array_element_test.cpp b/be/test/vec/function/function_array_element_test.cpp index f75d386016b0b5..f5d911e6950f1d 100644 --- a/be/test/vec/function/function_array_element_test.cpp +++ b/be/test/vec/function/function_array_element_test.cpp @@ -94,13 +94,14 @@ TEST(function_array_element_test, element_at) { InputTypeSet input_types = {PrimitiveType::TYPE_ARRAY, PrimitiveType::TYPE_DECIMALV2, PrimitiveType::TYPE_BIGINT}; - TestArray vec = {ut_type::DECIMALV2(17014116.67), ut_type::DECIMALV2(-17014116.67), - ut_type::DECIMALV2(0.0)}; + TestArray vec = {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(0.0)}; DataSet data_set = {{{vec, Int64(0)}, Null()}, - {{vec, Int64(1)}, ut_type::DECIMALV2(17014116.67)}, + {{vec, Int64(1)}, ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67)}, {{vec, Int64(4)}, Null()}, - {{vec, Int64(-1)}, ut_type::DECIMALV2(0.0)}, - {{vec, Int64(-2)}, ut_type::DECIMALV2(-17014116.67)}, + {{vec, Int64(-1)}, ut_type::DECIMALV2VALUEFROMDOUBLE(0.0)}, + {{vec, Int64(-2)}, ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67)}, {{vec, Int64(-4)}, Null()}, {{Null(), Int64(1)}, Null()}, {{empty_arr, Int64(0)}, Null()}, diff --git a/be/test/vec/function/function_array_index_test.cpp b/be/test/vec/function/function_array_index_test.cpp index 788fcea595dfe8..9056bebe2eda8c 100644 --- a/be/test/vec/function/function_array_index_test.cpp +++ b/be/test/vec/function/function_array_index_test.cpp @@ -116,12 +116,13 @@ TEST(function_array_index_test, array_contains) { InputTypeSet input_types = {PrimitiveType::TYPE_ARRAY, PrimitiveType::TYPE_DECIMALV2, PrimitiveType::TYPE_DECIMALV2}; - TestArray vec = {ut_type::DECIMALV2(17014116.67), ut_type::DECIMALV2(-17014116.67), - ut_type::DECIMALV2(0.0)}; - DataSet data_set = {{{vec, ut_type::DECIMALV2(-17014116.67)}, UInt8(1)}, - {{vec, ut_type::DECIMALV2(0)}, UInt8(1)}, - {{Null(), ut_type::DECIMALV2(0)}, Null()}, - {{empty_arr, ut_type::DECIMALV2(0)}, UInt8(0)}}; + TestArray vec = {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(0.0)}; + DataSet data_set = {{{vec, ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67)}, UInt8(1)}, + {{vec, ut_type::DECIMALV2VALUEFROMDOUBLE(0)}, UInt8(1)}, + {{Null(), ut_type::DECIMALV2VALUEFROMDOUBLE(0)}, Null()}, + {{empty_arr, ut_type::DECIMALV2VALUEFROMDOUBLE(0)}, UInt8(0)}}; static_cast(check_function(func_name, input_types, data_set)); } @@ -193,12 +194,13 @@ TEST(function_array_index_test, array_position) { InputTypeSet input_types = {PrimitiveType::TYPE_ARRAY, PrimitiveType::TYPE_DECIMALV2, PrimitiveType::TYPE_DECIMALV2}; - TestArray vec = {ut_type::DECIMALV2(17014116.67), ut_type::DECIMALV2(-17014116.67), - ut_type::DECIMALV2(0)}; - DataSet data_set = {{{vec, ut_type::DECIMALV2(-17014116.67)}, Int64(2)}, - {{vec, ut_type::DECIMALV2(0)}, Int64(3)}, - {{Null(), ut_type::DECIMALV2(0)}, Null()}, - {{empty_arr, ut_type::DECIMALV2(0)}, Int64(0)}}; + TestArray vec = {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(0)}; + DataSet data_set = {{{vec, ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67)}, Int64(2)}, + {{vec, ut_type::DECIMALV2VALUEFROMDOUBLE(0)}, Int64(3)}, + {{Null(), ut_type::DECIMALV2VALUEFROMDOUBLE(0)}, Null()}, + {{empty_arr, ut_type::DECIMALV2VALUEFROMDOUBLE(0)}, Int64(0)}}; static_cast(check_function(func_name, input_types, data_set)); } diff --git a/be/test/vec/function/function_arrays_overlap_test.cpp b/be/test/vec/function/function_arrays_overlap_test.cpp index dc353d53fb3bbe..5664cd42b52922 100644 --- a/be/test/vec/function/function_arrays_overlap_test.cpp +++ b/be/test/vec/function/function_arrays_overlap_test.cpp @@ -76,14 +76,15 @@ TEST(function_arrays_overlap_test, arrays_overlap) { InputTypeSet input_types = {PrimitiveType::TYPE_ARRAY, PrimitiveType::TYPE_DECIMALV2, PrimitiveType::TYPE_ARRAY, PrimitiveType::TYPE_DECIMALV2}; - TestArray vec1 = {ut_type::DECIMALV2(17014116.67), ut_type::DECIMALV2(-17014116.67), - ut_type::DECIMALV2(0.0)}; - TestArray vec2 = {ut_type::DECIMALV2(17014116.67)}; - - TestArray vec3 = {ut_type::DECIMALV2(17014116.67), ut_type::DECIMALV2(-17014116.67), - Null()}; - TestArray vec4 = {ut_type::DECIMALV2(-17014116.67)}; - TestArray vec5 = {ut_type::DECIMALV2(-17014116.68)}; + TestArray vec1 = {ut_type::DECIMALV2VALUE(17014116, 670000000, 9), + ut_type::DECIMALV2VALUE(-17014116, 670000000, 9), + ut_type::DECIMALV2VALUE(0, 0, 9)}; + TestArray vec2 = {ut_type::DECIMALV2VALUE(17014116, 670000000, 9)}; + + TestArray vec3 = {ut_type::DECIMALV2VALUE(17014116, 670000000, 9), + ut_type::DECIMALV2VALUE(-17014116, 670000000, 9), Null()}; + TestArray vec4 = {ut_type::DECIMALV2VALUE(-17014116, 670000000, 9)}; + TestArray vec5 = {ut_type::DECIMALV2VALUE(-17014116, 680000000, 9)}; DataSet data_set = {{{vec1, vec2}, UInt8(1)}, {{Null(), vec1}, Null()}, {{vec1, Null()}, Null()}, {{empty_arr, vec1}, UInt8(0)}, {{vec3, vec4}, UInt8(1)}, {{vec3, vec5}, UInt8(0)}, @@ -115,13 +116,15 @@ TEST(function_arrays_overlap_test, arrays_overlap) { InputTypeSet input_types = {PrimitiveType::TYPE_ARRAY, PrimitiveType::TYPE_DECIMALV2, PrimitiveType::TYPE_ARRAY, PrimitiveType::TYPE_DECIMALV2}; - TestArray vec1 = {ut_type::DECIMALV2(17014116.67), ut_type::DECIMALV2(-17014116.67), - ut_type::DECIMALV2(0.0)}; - TestArray vec2 = {ut_type::DECIMALV2(17014116.67)}; + TestArray vec1 = {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(0.0)}; + TestArray vec2 = {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67)}; - TestArray vec3 = {ut_type::DECIMALV2(17014116.67), ut_type::DECIMALV2(-17014116.67)}; - TestArray vec4 = {ut_type::DECIMALV2(-17014116.67)}; - TestArray vec5 = {ut_type::DECIMALV2(-17014116.68)}; + TestArray vec3 = {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67)}; + TestArray vec4 = {ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67)}; + TestArray vec5 = {ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.68)}; DataSet data_set = {{{vec1, vec2}, UInt8(1)}, {{empty_arr, vec1}, UInt8(0)}, {{vec3, vec4}, UInt8(1)}, {{vec3, vec5}, UInt8(0)}, {{vec4, vec3}, UInt8(1)}, {{vec5, vec3}, UInt8(0)}}; diff --git a/be/test/vec/function/function_math_test.cpp b/be/test/vec/function/function_math_test.cpp index f6fbc6df6e3c4f..3fdc3ab29e959b 100644 --- a/be/test/vec/function/function_math_test.cpp +++ b/be/test/vec/function/function_math_test.cpp @@ -609,8 +609,8 @@ TEST(MathFunctionTest, money_format_test) { { InputTypeSet input_types = {PrimitiveType::TYPE_DECIMALV2}; DataSet data_set = {{{Null()}, Null()}, - {{DECIMALV2(17014116.67)}, VARCHAR("17,014,116.67")}, - {{DECIMALV2(-17014116.67)}, VARCHAR("-17,014,116.67")}}; + {{DECIMALV2VALUEFROMDOUBLE(17014116.67)}, VARCHAR("17,014,116.67")}, + {{DECIMALV2VALUEFROMDOUBLE(-17014116.67)}, VARCHAR("-17,014,116.67")}}; static_cast(check_function(func_name, input_types, data_set)); } @@ -666,9 +666,10 @@ TEST(MathFunctionTest, format_round_test) { } { InputTypeSet input_types = {PrimitiveType::TYPE_DECIMALV2, PrimitiveType::TYPE_INT}; - DataSet data_set = {{{Null(), INT(2)}, Null()}, - {{DECIMALV2(17014116.67), INT(2)}, VARCHAR("17,014,116.67")}, - {{DECIMALV2(-17014116.67), INT(2)}, VARCHAR("-17,014,116.67")}}; + DataSet data_set = { + {{Null(), INT(2)}, Null()}, + {{DECIMALV2VALUEFROMDOUBLE(17014116.67), INT(2)}, VARCHAR("17,014,116.67")}, + {{DECIMALV2VALUEFROMDOUBLE(-17014116.67), INT(2)}, VARCHAR("-17,014,116.67")}}; static_cast(check_function(func_name, input_types, data_set)); } diff --git a/be/test/vec/function/function_money_format_test.cpp b/be/test/vec/function/function_money_format_test.cpp index a9d6a60b68049d..a924b92b28d610 100644 --- a/be/test/vec/function/function_money_format_test.cpp +++ b/be/test/vec/function/function_money_format_test.cpp @@ -71,7 +71,7 @@ TEST(function_money_format_test, money_format_with_decimalV2) { auto col_res_expected = ColumnString::create(); for (const auto& input_and_expected : input_dec_str_and_expected_str) { DecimalV2Value dec_v2_value(input_and_expected.first); - col_dec_v2->insert_value(Decimal128V2(dec_v2_value.value())); + col_dec_v2->insert_value(dec_v2_value); col_res_expected->insert_data(input_and_expected.second.c_str(), input_and_expected.second.size()); } diff --git a/be/test/vec/function/function_test_util.cpp b/be/test/vec/function/function_test_util.cpp index d67f36a6e69502..7a19df2efd1ba4 100644 --- a/be/test/vec/function/function_test_util.cpp +++ b/be/test/vec/function/function_test_util.cpp @@ -473,7 +473,7 @@ bool insert_cell(MutableColumnPtr& column, DataTypePtr type_ptr, const AnyType& break; } case PrimitiveType::TYPE_DECIMALV2: { - auto value = any_cast(cell); + auto value = any_cast(cell); column->insert_data(reinterpret_cast(&value), 0); break; } diff --git a/be/test/vec/function/function_test_util.h b/be/test/vec/function/function_test_util.h index 7e2799c9dd5704..ad34f4ded691ff 100644 --- a/be/test/vec/function/function_test_util.h +++ b/be/test/vec/function/function_test_util.h @@ -214,6 +214,14 @@ inline auto DECIMAL128V3 = [](int128_t x, int128_t y, int scale) { inline auto DECIMAL256 = [](wide::Int256 x, wide::Int256 y, int scale) { return Decimal256::from_int_frac(x, y, scale); }; +inline auto DECIMALV2VALUE = [](int128_t x, int128_t y, int scale) { + return DecimalV2Value(Decimal128V2::from_int_frac(x, y, 9).value); +}; +inline auto DECIMALV2VALUEFROMDOUBLE = [](double value) { + DecimalV2Value decimal_value; + decimal_value.assign_from_double(value); + return DecimalV2Value(binary_cast(decimal_value)); +}; using DATETIME = std::string; diff --git a/be/test/vec/function/function_time_test.cpp b/be/test/vec/function/function_time_test.cpp index 6c6bc58458fc81..6e3d12c22ae177 100644 --- a/be/test/vec/function/function_time_test.cpp +++ b/be/test/vec/function/function_time_test.cpp @@ -1765,7 +1765,7 @@ TEST(VTimestampFunctionsTest, curtime_test) { auto result_col = block.get_by_position(0).column; EXPECT_TRUE(result_col); if (const auto* const_col = check_and_get_column(result_col.get())) { - auto time_value = const_col->get_field().get(); + auto time_value = const_col->get_field().get(); EXPECT_GE(time_value, 0.0); EXPECT_LE(time_value, 24.0 * 3600 * 1000000); } @@ -1808,7 +1808,7 @@ TEST(VTimestampFunctionsTest, curtime_test) { auto result_col = block.get_by_position(1).column; EXPECT_TRUE(result_col); if (const auto* const_col = check_and_get_column(result_col.get())) { - auto time_value = const_col->get_field().get(); + auto time_value = const_col->get_field().get(); EXPECT_GE(time_value, 0.0); EXPECT_LE(time_value, 24.0 * 3600 * 1000000); } diff --git a/be/test/vec/function/table_function_test.cpp b/be/test/vec/function/table_function_test.cpp index ed81918ff524e3..64708135d2ba1d 100644 --- a/be/test/vec/function/table_function_test.cpp +++ b/be/test/vec/function/table_function_test.cpp @@ -107,14 +107,15 @@ TEST_F(TableFunctionTest, vexplode_outer) { // explode_outer(Array) { InputTypeSet input_types = {PrimitiveType::TYPE_ARRAY, PrimitiveType::TYPE_DECIMALV2}; - TestArray vec = {ut_type::DECIMALV2(17014116.67), ut_type::DECIMALV2(-17014116.67)}; + TestArray vec = {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67)}; InputDataSet input_set = {{Null()}, {AnyType {TestArray {}}}, {AnyType {vec}}}; InputTypeSet output_types = {PrimitiveType::TYPE_DECIMALV2}; InputDataSet output_set = {{Null()}, {Null()}, - {ut_type::DECIMALV2(17014116.67)}, - {ut_type::DECIMALV2(-17014116.67)}}; + {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67)}, + {ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67)}}; check_vec_table_function(&explode_outer, input_types, input_set, output_types, output_set); } @@ -157,15 +158,16 @@ TEST_F(TableFunctionTest, vexplode_outer_v2) { // // explode_outer(Array) { InputTypeSet input_types = {PrimitiveType::TYPE_ARRAY, PrimitiveType::TYPE_DECIMALV2}; - TestArray vec = {ut_type::DECIMALV2(17014116.67), ut_type::DECIMALV2(-17014116.67)}; + TestArray vec = {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67), + ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67)}; InputDataSet input_set = {{Null()}, {AnyType {TestArray {}}}, {AnyType {vec}}}; InputTypeSet output_types = {PrimitiveType::TYPE_DECIMALV2}; InputDataSet output_set = {{Null()}, {Null()}, - {ut_type::DECIMALV2(17014116.67)}, - {ut_type::DECIMALV2(-17014116.67)}}; + {ut_type::DECIMALV2VALUEFROMDOUBLE(17014116.67)}, + {ut_type::DECIMALV2VALUEFROMDOUBLE(-17014116.67)}}; check_vec_table_function(&explode_outer, input_types, input_set, output_types, output_set); } diff --git a/be/test/vec/jsonb/convert_field_to_type_test.cpp b/be/test/vec/jsonb/convert_field_to_type_test.cpp index fcc1fd9b26eecd..800c827df90aae 100644 --- a/be/test/vec/jsonb/convert_field_to_type_test.cpp +++ b/be/test/vec/jsonb/convert_field_to_type_test.cpp @@ -316,7 +316,7 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { ASSERT_EQ(result.get_type(), TYPE_JSONB); ASSERT_FALSE(result.is_null()); - const JsonbField& jsonb_result = result.get(); + const JsonbField& jsonb_result = result.get(); ASSERT_NE(jsonb_result.get_value(), nullptr); ASSERT_GT(jsonb_result.get_size(), 0); @@ -341,7 +341,7 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { ASSERT_EQ(result.get_type(), TYPE_JSONB); ASSERT_FALSE(result.is_null()); - const JsonbField& jsonb_result = result.get(); + const JsonbField& jsonb_result = result.get(); ASSERT_NE(jsonb_result.get_value(), nullptr); ASSERT_GT(jsonb_result.get_size(), 0); @@ -372,7 +372,7 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { ASSERT_EQ(result.get_type(), TYPE_JSONB); ASSERT_FALSE(result.is_null()); - const JsonbField& jsonb_result = result.get(); + const JsonbField& jsonb_result = result.get(); ASSERT_NE(jsonb_result.get_value(), nullptr); ASSERT_GT(jsonb_result.get_size(), 0); @@ -404,7 +404,7 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { ASSERT_EQ(result.get_type(), TYPE_JSONB); ASSERT_FALSE(result.is_null()); - const JsonbField& jsonb_result = result.get(); + const JsonbField& jsonb_result = result.get(); ASSERT_NE(jsonb_result.get_value(), nullptr); ASSERT_EQ(jsonb_result.get_size(), original_jsonb.get_size()); ASSERT_EQ(memcmp(jsonb_result.get_value(), original_jsonb.get_value(), @@ -439,7 +439,7 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToNullableJsonb) { ASSERT_EQ(result.get_type(), TYPE_JSONB); ASSERT_FALSE(result.is_null()); - const JsonbField& jsonb_result = result.get(); + const JsonbField& jsonb_result = result.get(); ASSERT_NE(jsonb_result.get_value(), nullptr); ASSERT_GT(jsonb_result.get_size(), 0); @@ -474,7 +474,7 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ArrayToJsonb) { ASSERT_EQ(result.get_type(), TYPE_ARRAY); ASSERT_FALSE(result.is_null()); - const Array& result_array = result.get(); + const Array& result_array = result.get(); ASSERT_EQ(result_array.size(), 3); // Verify each element is converted to JSONB @@ -482,7 +482,7 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ArrayToJsonb) { ASSERT_EQ(result_array[i].get_type(), TYPE_JSONB); ASSERT_FALSE(result_array[i].is_null()); - const auto& jsonb_element = result_array[i].get(); + const auto& jsonb_element = result_array[i].get(); ASSERT_NE(jsonb_element.get_value(), nullptr); ASSERT_GT(jsonb_element.get_size(), 0); diff --git a/be/test/vec/utils/arrow_column_to_doris_column_test.cpp b/be/test/vec/utils/arrow_column_to_doris_column_test.cpp index ef67c30fb06bbf..59a6636847efa7 100644 --- a/be/test/vec/utils/arrow_column_to_doris_column_test.cpp +++ b/be/test/vec/utils/arrow_column_to_doris_column_test.cpp @@ -633,7 +633,7 @@ void test_arrow_to_array_column(ColumnWithTypeAndName& column, auto& array_column = static_cast(*data_column); EXPECT_EQ(array_column.size() - old_size, vec_offsets.size() - 1); for (size_t i = 0; i < array_column.size() - old_size; ++i) { - auto v = get(array_column[old_size + i]); + auto v = array_column[old_size + i].get(); EXPECT_EQ(v.size(), vec_offsets[i + 1] - vec_offsets[i]); EXPECT_EQ(v.size(), array_column.get_offsets()[old_size + i] - array_column.get_offsets()[old_size + i - 1]); @@ -646,14 +646,14 @@ void test_arrow_to_array_column(ColumnWithTypeAndName& column, for (size_t j = 0; j < v.size(); ++j) { // in nested column, values like [null, xx, null, xx, ...] if ((vec_offsets[i] + j) % 2 != 0) { - EXPECT_EQ(value, get(v[j])); + EXPECT_EQ(value, v[j].get()); } } } } else { // check value for (size_t j = 0; j < v.size(); ++j) { - EXPECT_EQ(value, get(v[j])); + EXPECT_EQ(value, v[j].get()); } } }