From b5401134ecc6ea65ab6c8aefdc8c0c90d66085b2 Mon Sep 17 00:00:00 2001 From: amory Date: Fri, 11 Jul 2025 16:28:56 +0800 Subject: [PATCH 01/11] [fix](variant)fix variant type conflicts in nested types (#52696) 1. fix variant type conflicts with scalar and array 2. fix multi-level array can be parse into variant which should be report as error 3. fix convert_field_to_type convert_numric_type do not use PrimitiveType 4. add UT for function_cast :: FromVariant --- be/src/vec/columns/column_object.h | 8 + .../vec/data_types/convert_field_to_type.cpp | 2 +- be/src/vec/json/json_parser.cpp | 12 +- be/src/vec/json/json_parser.h | 2 + .../cast/function_variant_cast_test.cpp | 468 ++++++++++++++++ .../vec/jsonb/convert_field_to_type_test.cpp | 522 ++++++++++++++++++ be/test/vec/jsonb/json_parser_test.cpp | 169 ++++++ regression-test/data/variant_p0/desc.out | 6 +- regression-test/data/variant_p0/load.out | 8 +- regression-test/data/variant_p0/nested2.out | 337 +++++++++++ .../suites/variant_p0/nested2.groovy | 151 +++++ 11 files changed, 1678 insertions(+), 7 deletions(-) create mode 100644 be/test/vec/function/cast/function_variant_cast_test.cpp create mode 100644 be/test/vec/jsonb/convert_field_to_type_test.cpp create mode 100644 be/test/vec/jsonb/json_parser_test.cpp create mode 100644 regression-test/data/variant_p0/nested2.out create mode 100644 regression-test/suites/variant_p0/nested2.groovy diff --git a/be/src/vec/columns/column_object.h b/be/src/vec/columns/column_object.h index 971537c6155868..f36d1898d2991a 100644 --- a/be/src/vec/columns/column_object.h +++ b/be/src/vec/columns/column_object.h @@ -114,6 +114,7 @@ class ColumnObject final : public COWHelper { constexpr static TypeIndex MOST_COMMON_TYPE_ID = TypeIndex::JSONB; // Nullable(Array(Nullable(Object))) const static DataTypePtr NESTED_TYPE; + // Finlize mode for subcolumns, write mode will estimate which subcolumns are sparse columns(too many null values inside column), // merge and encode them into a shared column in root column. Only affects in flush block to segments. // Otherwise read mode should be as default mode. @@ -209,6 +210,7 @@ class ColumnObject final : public COWHelper { void add_new_column_part(DataTypePtr type); +<<<<<<< HEAD:be/src/vec/columns/column_object.h // Serialize the i-th row of the column into the sparse column. void serialize_to_sparse_column(ColumnString* key, std::string_view path, ColumnString* value, size_t row); @@ -220,6 +222,12 @@ class ColumnObject final : public COWHelper { bool is_empty_nested(size_t row) const; void resize(size_t n); +======= + /// Converts Array to Array for special case handling + static void convert_array_string_to_array_jsonb(Field& array_field); + + friend class ColumnVariant; +>>>>>>> 179627f735 ([fix](variant)fix variant type conflicts in nested types (#52696)):be/src/vec/columns/column_variant.h private: class LeastCommonType { 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 ca8984b313d5e6..5a50b446b9b95b 100644 --- a/be/src/vec/data_types/convert_field_to_type.cpp +++ b/be/src/vec/data_types/convert_field_to_type.cpp @@ -335,4 +335,4 @@ void convert_field_to_type(const Field& from_value, const IDataType& to_type, Fi return convert_field_to_typeImpl(from_value, to_type, from_type_hint, to); } } -} // namespace doris::vectorized \ No newline at end of file +} // namespace doris::vectorized diff --git a/be/src/vec/json/json_parser.cpp b/be/src/vec/json/json_parser.cpp index f6e8a65cc08c71..e031f168820156 100644 --- a/be/src/vec/json/json_parser.cpp +++ b/be/src/vec/json/json_parser.cpp @@ -59,8 +59,14 @@ void JSONDataParser::traverse(const Element& element, ParseContext& if (element.isObject()) { traverseObject(element.getObject(), ctx); } else if (element.isArray()) { + if (ctx.has_nested_in_flatten) { + throw doris::Exception(doris::ErrorCode::INVALID_ARGUMENT, + "Nesting of array in Nested array within variant subcolumns is " + "currently not supported."); + } has_nested = false; check_has_nested_object(element); + ctx.has_nested_in_flatten = has_nested && ctx.enable_flatten_nested; if (has_nested && !ctx.enable_flatten_nested) { // Parse nested arrays to JsonbField JsonbWriter writer; @@ -71,6 +77,8 @@ void JSONDataParser::traverse(const Element& element, ParseContext& } else { traverseArray(element.getArray(), ctx); } + // we should set has_nested_in_flatten to false when traverse array finished for next array otherwise it will be true for next array + ctx.has_nested_in_flatten = false; } else { ctx.paths.push_back(ctx.builder.get_parts()); ctx.values.push_back(getValueAsField(element)); @@ -137,6 +145,7 @@ template void JSONDataParser::traverseArray(const JSONArray& array, ParseContext& ctx) { /// Traverse elements of array and collect an array of fields by each path. ParseArrayContext array_ctx; + array_ctx.has_nested_in_flatten = ctx.has_nested_in_flatten; array_ctx.total_size = array.size(); for (auto it = array.begin(); it != array.end(); ++it) { traverseArrayElement(*it, array_ctx); @@ -162,8 +171,9 @@ template void JSONDataParser::traverseArrayElement(const Element& element, ParseArrayContext& ctx) { ParseContext element_ctx; + element_ctx.has_nested_in_flatten = ctx.has_nested_in_flatten; traverse(element, element_ctx); - auto& [_, paths, values, flatten_nested] = element_ctx; + auto& [_, paths, values, flatten_nested, has_nested] = element_ctx; size_t size = paths.size(); size_t keys_to_update = ctx.arrays_by_path.size(); for (size_t i = 0; i < size; ++i) { diff --git a/be/src/vec/json/json_parser.h b/be/src/vec/json/json_parser.h index 52336d455c0737..8d47e1936fdee8 100644 --- a/be/src/vec/json/json_parser.h +++ b/be/src/vec/json/json_parser.h @@ -145,6 +145,7 @@ class JSONDataParser { std::vector paths; std::vector values; bool enable_flatten_nested = false; + bool has_nested_in_flatten = false; }; using PathPartsWithArray = std::pair; using PathToArray = phmap::flat_hash_map; @@ -154,6 +155,7 @@ class JSONDataParser { size_t total_size = 0; PathToArray arrays_by_path; KeyToSizes nested_sizes_by_key; + bool has_nested_in_flatten = false; }; void traverse(const Element& element, ParseContext& ctx); void traverseObject(const JSONObject& object, ParseContext& ctx); diff --git a/be/test/vec/function/cast/function_variant_cast_test.cpp b/be/test/vec/function/cast/function_variant_cast_test.cpp new file mode 100644 index 00000000000000..db0ccc8144b51e --- /dev/null +++ b/be/test/vec/function/cast/function_variant_cast_test.cpp @@ -0,0 +1,468 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include + +#include "common/status.h" +#include "gtest/gtest_pred_impl.h" +#include "olap/field.h" +#include "runtime/define_primitive_type.h" +#include "runtime/primitive_type.h" +#include "runtime/runtime_state.h" +#include "vec/columns/column_array.h" +#include "vec/columns/column_variant.h" +#include "vec/core/field.h" +#include "vec/data_types/data_type_array.h" +#include "vec/data_types/data_type_nullable.h" +#include "vec/data_types/data_type_number.h" +#include "vec/data_types/data_type_string.h" +#include "vec/data_types/data_type_variant.h" +#include "vec/functions/simple_function_factory.h" + +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(); + for (const auto& [k, v] : key_and_values) { + PathInData path(k); + object.try_emplace(path, v); + } + return res; +} + +static auto construct_basic_varint_column() { + // 1. create an empty variant column + auto variant = ColumnVariant::create(5); + + std::vector> data; + + // 2. subcolumn path + data.emplace_back("v.a", Field::create_field(20)); + data.emplace_back("v.b", Field::create_field("20")); + data.emplace_back("v.c", Field::create_field(20)); + data.emplace_back("v.f", Field::create_field(20)); + data.emplace_back("v.e", Field::create_field("50")); + for (int i = 0; i < 5; ++i) { + auto field = construct_variant_map(data); + variant->try_insert(field); + } + + return variant; +} + +TEST(FunctionVariantCast, CastToVariant) { + // Test casting from basic types to variant + { + // Test Int32 to variant + auto int32_type = std::make_shared(); + auto variant_type = std::make_shared(); + auto int32_col = ColumnInt32::create(); + int32_col->insert(Field::create_field(42)); + int32_col->insert(Field::create_field(100)); + int32_col->insert(Field::create_field(-1)); + + ColumnsWithTypeAndName arguments {{int32_col->get_ptr(), int32_type, "int32_col"}, + {nullptr, variant_type, "variant_type"}}; + + auto function = + SimpleFunctionFactory::instance().get_function("CAST", arguments, variant_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, variant_type, "result"}); + + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 3).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + const auto* variant_col = assert_cast(result_col.get()); + ASSERT_EQ(variant_col->size(), 3); + } + + // Test casting from string to variant + { + auto string_type = std::make_shared(); + auto variant_type = std::make_shared(); + auto string_col = ColumnString::create(); + string_col->insert_data("hello", 5); + string_col->insert_data("world", 5); + + ColumnsWithTypeAndName arguments {{string_col->get_ptr(), string_type, "string_col"}, + {nullptr, variant_type, "variant_type"}}; + + auto function = SimpleFunctionFactory::instance().get_function("CAST", arguments, + make_nullable(variant_type)); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, variant_type, "result"}); + + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 2).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + const auto* variant_col = + assert_cast(remove_nullable(result_col).get()); + ASSERT_EQ(variant_col->size(), 2); + } + + // Test casting from array to variant + { + auto array_type = std::make_shared(std::make_shared()); + auto variant_type = std::make_shared(); + auto array_col = + ColumnArray::create(ColumnInt32::create(), ColumnArray::ColumnOffsets::create()); + auto& data = assert_cast(array_col->get_data()); + auto& offsets = array_col->get_offsets(); + + data.insert(Field::create_field(1)); + data.insert(Field::create_field(2)); + data.insert(Field::create_field(3)); + offsets.push_back(3); + + ColumnsWithTypeAndName arguments {{array_col->get_ptr(), array_type, "array_col"}, + {nullptr, variant_type, "variant_type"}}; + + auto function = + SimpleFunctionFactory::instance().get_function("CAST", arguments, variant_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, variant_type, "result"}); + + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 1).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + const auto* variant_col = + assert_cast(remove_nullable(result_col).get()); + ASSERT_EQ(variant_col->size(), 1); + } +} + +TEST(FunctionVariantCast, CastFromVariant) { + // Test casting from variant to basic types + { + auto variant_type = std::make_shared(); + auto int32_type = std::make_shared(); + auto variant_col = ColumnVariant::create(true); + + // Create a variant column with integer values + variant_col->create_root(int32_type, ColumnInt32::create()); + MutableColumnPtr data = variant_col->get_root(); + data->insert(Field::create_field(42)); + data->insert(Field::create_field(100)); + data->insert(Field::create_field(-1)); + + ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, + {nullptr, int32_type, "int32_type"}}; + + auto function = + SimpleFunctionFactory::instance().get_function("CAST", arguments, int32_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, int32_type, "result"}); + + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 3).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + // always nullable + const auto* int32_result = + assert_cast(remove_nullable(result_col).get()); + ASSERT_EQ(int32_result->size(), 3); + ASSERT_EQ(int32_result->get_element(0), 42); + ASSERT_EQ(int32_result->get_element(1), 100); + ASSERT_EQ(int32_result->get_element(2), -1); + } + + // Test casting from variant to string + { + auto variant_type = std::make_shared(); + auto string_type = std::make_shared(); + auto variant_col = ColumnVariant::create(true); + + // Create a variant column with string values + variant_col->create_root(string_type, ColumnString::create()); + MutableColumnPtr data = variant_col->get_root(); + data->insert_data("hello", 5); + data->insert_data("world", 5); + + ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, + {nullptr, string_type, "string_type"}}; + + auto function = + SimpleFunctionFactory::instance().get_function("CAST", arguments, string_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, string_type, "result"}); + + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 2).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + const auto* string_result = + assert_cast(remove_nullable(result_col).get()); + ASSERT_EQ(string_result->size(), 2); + ASSERT_EQ(string_result->get_data_at(0).to_string(), "hello"); + ASSERT_EQ(string_result->get_data_at(1).to_string(), "world"); + } + + // Test casting from variant to array + { + auto variant_type = std::make_shared(); + auto array_type = std::make_shared(std::make_shared()); + auto variant_col = ColumnVariant::create(true); + + // Create a variant column with array values + variant_col->create_root( + array_type, + ColumnArray::create(ColumnInt32::create(), ColumnArray::ColumnOffsets::create())); + MutableColumnPtr data = variant_col->get_root(); + + Field a = Field::create_field(Array {Field::create_field(1), + Field::create_field(2), + Field::create_field(3)}); + + data->insert(a); + + ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, + {nullptr, array_type, "array_type"}}; + + auto function = + SimpleFunctionFactory::instance().get_function("CAST", arguments, array_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, array_type, "result"}); + + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 1).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + const auto* array_result = + assert_cast(remove_nullable(result_col).get()); + ASSERT_EQ(array_result->size(), 1); + const auto& result_data = assert_cast(array_result->get_data()); + ASSERT_EQ(result_data.size(), 3); + ASSERT_EQ(result_data.get_element(0), 1); + ASSERT_EQ(result_data.get_element(1), 2); + ASSERT_EQ(result_data.get_element(2), 3); + } +} + +TEST(FunctionVariantCast, CastVariantWithNull) { + auto variant_type = std::make_shared(); + auto int32_type = std::make_shared(); + auto nullable_int32_type = std::make_shared(int32_type); + + // Create a variant column with nullable integer values + auto variant_col = ColumnVariant::create(true); + variant_col->create_root(nullable_int32_type, + ColumnNullable::create(ColumnInt32::create(), ColumnUInt8::create())); + MutableColumnPtr data = variant_col->get_root(); + + data->insert(Field::create_field(42)); + data->insert(Field::create_field(Null())); + data->insert(Field::create_field(100)); + + ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, + {nullptr, nullable_int32_type, "nullable_int32_type"}}; + + variant_col->finalize(); + auto function = + SimpleFunctionFactory::instance().get_function("CAST", arguments, nullable_int32_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, nullable_int32_type, "result"}); + + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 3).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + const auto* nullable_result = assert_cast(result_col.get()); + ASSERT_EQ(nullable_result->size(), 3); + + const auto& result_data = assert_cast(nullable_result->get_nested_column()); + const auto& result_null_map = nullable_result->get_null_map_data(); + + ASSERT_EQ(result_data.get_element(0), 42); + ASSERT_EQ(result_null_map[0], 0); + ASSERT_EQ(result_null_map[1], 1); + ASSERT_EQ(result_data.get_element(2), 100); +} + +TEST(FunctionVariantCast, CastFromVariantWithEmptyRoot) { + // Test case 1: variant.empty() branch + { + auto variant_type = std::make_shared(); + auto int32_type = std::make_shared(); + MutableColumnPtr root = ColumnInt32::create(); + root->insert(Field::create_field(42)); + vectorized::ColumnVariant::Subcolumns dynamic_subcolumns; + dynamic_subcolumns.add( + vectorized::PathInData(ColumnVariant::COLUMN_NAME_DUMMY), + vectorized::ColumnVariant::Subcolumn {root->get_ptr(), int32_type, true, true}); + auto variant_col = ColumnVariant::create(std::move(dynamic_subcolumns), true); + + variant_col->finalize(); + ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, + {nullptr, int32_type, "int32_type"}}; + + auto function = + SimpleFunctionFactory::instance().get_function("CAST", arguments, int32_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, int32_type, "result"}); + + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 1).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + // always nullable + const auto* int32_result = + assert_cast(remove_nullable(result_col).get()); + ASSERT_EQ(int32_result->size(), 1); + // because of variant.empty() we insert_default with data_type_to + ASSERT_EQ(int32_result->get_element(0), 0); + } + + // Test case 2: !data_type_to->is_nullable() && !WhichDataType(data_type_to).is_string() branch + { + // object has sparse column + auto int32_type = std::make_shared(); + auto variant_col = construct_basic_varint_column(); + auto variant_type = std::make_shared(); + + ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, + {nullptr, int32_type, "int32_type"}}; + + variant_col->finalize(); + auto function = + SimpleFunctionFactory::instance().get_function("CAST", arguments, int32_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, int32_type, "result"}); + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 1).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + const auto* nullable_result = assert_cast(result_col.get()); + ASSERT_EQ(nullable_result->size(), 1); + ASSERT_TRUE(nullable_result->is_null_at(0)); + } + + // Test case 3: WhichDataType(data_type_to).is_string() branch + { + // variant has sparse column + auto int32_type = std::make_shared(); + auto variant_col = construct_basic_varint_column(); + + auto string_type = std::make_shared(); + auto variant_type = std::make_shared(); + + ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, + {nullptr, string_type, "string_type"}}; + + variant_col->finalize(); + auto function = + SimpleFunctionFactory::instance().get_function("CAST", arguments, string_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, string_type, "result"}); + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 1).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + const auto* string_result = assert_cast(result_col.get()); + // just call ConvertImplGenericToString which will insert all source column data to ColumnString + ASSERT_EQ(string_result->size(), variant_col->size()); + ASSERT_EQ(string_result->get_data_at(0).to_string(), + "{\"v\":{\"a\":20,\"b\":\"20\",\"c\":20,\"e\":\"50\",\"f\":20}}"); + } + + // Test case 4: else branch (nullable type) + { + auto variant_col = construct_basic_varint_column(); + variant_col->finalize(); + auto nullable_variant_col = make_nullable(variant_col->get_ptr()); + + auto nullable_string_type = make_nullable(std::make_shared()); + auto variant_type = std::make_shared(); + auto nullable_variant_type = make_nullable(variant_type); + + ColumnsWithTypeAndName arguments { + {nullable_variant_col->get_ptr(), nullable_variant_type, "variant_col"}, + {nullptr, nullable_string_type, "nullable_string_type"}}; + + auto function = SimpleFunctionFactory::instance().get_function("CAST", arguments, + nullable_string_type); + ASSERT_NE(function, nullptr); + + Block block {arguments}; + size_t result_column = block.columns(); + block.insert({nullptr, nullable_string_type, "result"}); + RuntimeState state; + auto ctx = FunctionContext::create_context(&state, {}, {}); + ASSERT_TRUE(function->execute(ctx.get(), block, {0}, result_column, 1).ok()); + + auto result_col = block.get_by_position(result_column).column; + ASSERT_NE(result_col.get(), nullptr); + const auto* nullable_result = assert_cast(result_col.get()); + ASSERT_EQ(nullable_result->size(), 1); + ASSERT_TRUE(nullable_result->is_null_at(1)); + } +} + +} // namespace doris::vectorized \ No newline at end of file diff --git a/be/test/vec/jsonb/convert_field_to_type_test.cpp b/be/test/vec/jsonb/convert_field_to_type_test.cpp new file mode 100644 index 00000000000000..a848f7165ab99d --- /dev/null +++ b/be/test/vec/jsonb/convert_field_to_type_test.cpp @@ -0,0 +1,522 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "vec/data_types/convert_field_to_type.cpp" + +#include + +#include +#include + +#include "runtime/jsonb_value.h" +#include "util/jsonb_document.h" +#include "util/jsonb_writer.h" +#include "vec/core/field.h" +#include "vec/core/types.h" +#include "vec/data_types/data_type.h" +#include "vec/data_types/data_type_array.h" +#include "vec/data_types/data_type_jsonb.h" +#include "vec/data_types/data_type_nullable.h" + +namespace doris::vectorized { + +class ConvertFieldToTypeTest : public ::testing::Test { +protected: + void SetUp() override {} +}; + +// Test FieldVisitorToJsonb with different field types using the same pattern as convert_field_to_typeImpl +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Null) { + JsonbWriter writer; + + // Test null field using Field::dispatch pattern + Field null_field; + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + null_field); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's a null value + ASSERT_TRUE(doc->getValue()->isNull()); +} + +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Int64) { + JsonbWriter writer; + + // Test Int64 field using Field::dispatch pattern + Int64 test_value = 12345; + Field int_field = Field::create_field(test_value); + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + int_field); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's an integer value + ASSERT_TRUE(doc->getValue()->isInt64()); + ASSERT_EQ(doc->getValue()->int_val(), test_value); +} + +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_UInt64) { + JsonbWriter writer; + + // Test UInt64 field using Field::dispatch pattern + UInt64 test_value = 12345; + Field uint_field = Field::create_field(test_value); + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + uint_field); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's an integer value + ASSERT_TRUE(doc->getValue()->isInt64()); + ASSERT_EQ(doc->getValue()->int_val(), static_cast(test_value)); +} + +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Float64) { + JsonbWriter writer; + + // Test Float64 field using Field::dispatch pattern + Float64 test_value = 123.456; + Field double_field = Field::create_field(test_value); + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + double_field); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's a double value + ASSERT_TRUE(doc->getValue()->isDouble()); + ASSERT_DOUBLE_EQ(doc->getValue()->unpack()->val(), test_value); +} + +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_String) { + JsonbWriter writer; + + // Test String field using Field::dispatch pattern + String test_value = "hello world"; + Field string_field = Field::create_field(test_value); + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + string_field); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's a string value + ASSERT_TRUE(doc->getValue()->isString()); + const auto* string_val = doc->getValue()->unpack(); + std::string real_string(string_val->getBlob(), string_val->getBlobLen()); + ASSERT_EQ(real_string, test_value); +} + +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_JsonbField) { + JsonbWriter writer; + JsonBinaryValue jsonb_value; + std::string test_data = R"({"a": ["1", "2"]})"; + THROW_IF_ERROR(jsonb_value.from_json_string(test_data)); + Field jsonb_field_obj = + Field::create_field(JsonbField(jsonb_value.value(), jsonb_value.size())); + + // Test JsonbField using Field::dispatch pattern + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + jsonb_field_obj); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's an object value + ASSERT_TRUE(doc->getValue()->isObject()); +} + +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Array) { + JsonbWriter writer; + + // Create an array with mixed types + Array array_field; + array_field.push_back(Field::create_field(123)); + array_field.push_back(Field::create_field("hello")); + array_field.push_back(Field::create_field(456.789)); + + Field array_obj = Field::create_field(array_field); + + // Test Array using Field::dispatch pattern + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + array_obj); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's an array value + ASSERT_TRUE(doc->getValue()->isArray()); + ASSERT_EQ(doc->getValue()->numElements(), 3); +} + +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_NestedArray) { + JsonbWriter writer; + + // Create a nested array + Array inner_array; + inner_array.push_back(Field::create_field(1)); + inner_array.push_back(Field::create_field(2)); + + Array outer_array; + outer_array.push_back(Field::create_field(inner_array)); + outer_array.push_back(Field::create_field("nested")); + + Field nested_array_obj = Field::create_field(outer_array); + + // Test nested Array using Field::dispatch pattern + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + nested_array_obj); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's an array value + ASSERT_TRUE(doc->getValue()->isArray()); + ASSERT_EQ(doc->getValue()->numElements(), 2); +} + +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_LargeInt) { + JsonbWriter writer; + + // Test Int128 field using Field::dispatch pattern + Int128 test_value = 1234567890123456789; + Field largeint_field = Field::create_field(test_value); + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + largeint_field); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's an int128 value + ASSERT_TRUE(doc->getValue()->isInt128()); + ASSERT_EQ(doc->getValue()->int_val(), test_value); +} + +TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_UInt128) { + JsonbWriter writer; + + // Test UInt128 field using Field::dispatch pattern + UInt128 test_value = 1234567890123456789; + Field uint128_field = Field::create_field(test_value); + Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, + uint128_field); + + auto* output = writer.getOutput(); + ASSERT_NE(output, nullptr); + ASSERT_GT(output->getSize(), 0); + + // Verify the output is valid JSONB + JsonbDocument* doc = nullptr; + auto status = + JsonbDocument::checkAndCreateDocument(output->getBuffer(), output->getSize(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + + // Verify it's an int128 value + ASSERT_TRUE(doc->getValue()->isInt128()); + ASSERT_EQ(doc->getValue()->int_val(), static_cast(test_value)); +} + +// Test convert_field_to_type function with JSONB type (similar to convert_field_to_typeImpl) +TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { + DataTypeJsonb jsonb_type; + + // Test converting Int64 to JSONB + { + Int64 test_value = 12345; + Field int_field = Field::create_field(test_value); + Field result; + + convert_field_to_type(int_field, jsonb_type, &result); + + ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_FALSE(result.is_null()); + + const JsonbField& jsonb_result = result.get(); + ASSERT_NE(jsonb_result.get_value(), nullptr); + ASSERT_GT(jsonb_result.get_size(), 0); + + // Verify the JSONB content + JsonbDocument* doc = nullptr; + auto status = JsonbDocument::checkAndCreateDocument(jsonb_result.get_value(), + jsonb_result.get_size(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + ASSERT_TRUE(doc->getValue()->isInt64()); + ASSERT_EQ(doc->getValue()->int_val(), test_value); + } + + // Test converting String to JSONB + { + String test_value = "hello world"; + Field string_field = Field::create_field(test_value); + Field result; + + convert_field_to_type(string_field, jsonb_type, &result); + + ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_FALSE(result.is_null()); + + const JsonbField& jsonb_result = result.get(); + ASSERT_NE(jsonb_result.get_value(), nullptr); + ASSERT_GT(jsonb_result.get_size(), 0); + + // Verify the JSONB content + JsonbDocument* doc = nullptr; + auto status = JsonbDocument::checkAndCreateDocument(jsonb_result.get_value(), + jsonb_result.get_size(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + ASSERT_TRUE(doc->getValue()->isString()); + const auto* string_val = doc->getValue()->unpack(); + std::string real_string(string_val->getBlob(), string_val->getBlobLen()); + ASSERT_EQ(real_string, test_value); + } + + // Test converting Array to JSONB + { + Array array_field; + array_field.push_back(Field::create_field(1)); + array_field.push_back(Field::create_field("test")); + array_field.push_back(Field::create_field(3.14)); + + Field array_obj = Field::create_field(array_field); + Field result; + + convert_field_to_type(array_obj, jsonb_type, &result); + + ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_FALSE(result.is_null()); + + const JsonbField& jsonb_result = result.get(); + ASSERT_NE(jsonb_result.get_value(), nullptr); + ASSERT_GT(jsonb_result.get_size(), 0); + + // Verify the JSONB content + JsonbDocument* doc = nullptr; + auto status = JsonbDocument::checkAndCreateDocument(jsonb_result.get_value(), + jsonb_result.get_size(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + ASSERT_TRUE(doc->getValue()->isArray()); + ASSERT_EQ(doc->getValue()->numElements(), 3); + } + + // Test converting JSONB to JSONB (should be no-op) + { + JsonbWriter test_writer; + test_writer.writeStartObject(); + test_writer.writeKey("key"); + test_writer.writeString("value"); + test_writer.writeEndObject(); + + auto* test_output = test_writer.getOutput(); + JsonbField original_jsonb(test_output->getBuffer(), test_output->getSize()); + Field jsonb_field = Field::create_field(original_jsonb); + Field result; + + convert_field_to_type(jsonb_field, jsonb_type, &result); + + ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_FALSE(result.is_null()); + + 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(), + original_jsonb.get_size()), + 0); + } +} + +// Test convert_field_to_type with nullable JSONB type +TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToNullableJsonb) { + auto nullable_jsonb_type = + std::make_shared(std::make_shared()); + + // Test converting null field + { + Field null_field; + Field result; + + convert_field_to_type(null_field, *nullable_jsonb_type, &result); + + ASSERT_TRUE(result.is_null()); + } + + // Test converting non-null field + { + String test_value = "test string"; + Field string_field = Field::create_field(test_value); + Field result; + + convert_field_to_type(string_field, *nullable_jsonb_type, &result); + + ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_FALSE(result.is_null()); + + const JsonbField& jsonb_result = result.get(); + ASSERT_NE(jsonb_result.get_value(), nullptr); + ASSERT_GT(jsonb_result.get_size(), 0); + + // Verify the JSONB content + JsonbDocument* doc = nullptr; + auto status = JsonbDocument::checkAndCreateDocument(jsonb_result.get_value(), + jsonb_result.get_size(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); + ASSERT_NE(doc, nullptr); + ASSERT_TRUE(doc->getValue()->isString()); + const auto* string_val = doc->getValue()->unpack(); + std::string real_string(string_val->getBlob(), string_val->getBlobLen()); + ASSERT_EQ(real_string, test_value); + } +} + +// Test convert_field_to_type with array of JSONB +TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ArrayToJsonb) { + auto array_jsonb_type = std::make_shared(std::make_shared()); + + // Create an array with mixed types that will be converted to JSONB + Array array_field; + array_field.push_back(Field::create_field(123)); + array_field.push_back(Field::create_field("hello")); + array_field.push_back(Field::create_field(456.789)); + + Field array_obj = Field::create_field(array_field); + Field result; + + convert_field_to_type(array_obj, *array_jsonb_type, &result); + + ASSERT_EQ(result.get_type(), TYPE_ARRAY); + ASSERT_FALSE(result.is_null()); + + const Array& result_array = result.get(); + ASSERT_EQ(result_array.size(), 3); + + // Verify each element is converted to JSONB + for (size_t i = 0; i < result_array.size(); ++i) { + ASSERT_EQ(result_array[i].get_type(), TYPE_JSONB); + ASSERT_FALSE(result_array[i].is_null()); + + const auto& jsonb_element = result_array[i].get(); + ASSERT_NE(jsonb_element.get_value(), nullptr); + ASSERT_GT(jsonb_element.get_size(), 0); + + // Verify the JSONB content + JsonbDocument* doc = nullptr; + auto status = JsonbDocument::checkAndCreateDocument(jsonb_element.get_value(), + jsonb_element.get_size(), &doc); + ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument for element " << i << ": " + << status.to_string(); + ASSERT_NE(doc, nullptr); + } +} + +// Test error cases +TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ErrorCases) { + DataTypeJsonb jsonb_type; + + // Test with unsupported types (should throw exception) + { + Field tuple_field = Field::create_field(Tuple()); + + EXPECT_THROW( + { + Field result; + convert_field_to_type(tuple_field, jsonb_type, &result); + }, + doris::Exception); + } +} + +} // namespace doris::vectorized \ No newline at end of file diff --git a/be/test/vec/jsonb/json_parser_test.cpp b/be/test/vec/jsonb/json_parser_test.cpp new file mode 100644 index 00000000000000..6d248a73cd0d91 --- /dev/null +++ b/be/test/vec/jsonb/json_parser_test.cpp @@ -0,0 +1,169 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +#include "vec/json/json_parser.h" + +#include + +#include + +using doris::vectorized::JSONDataParser; +using doris::vectorized::SimdJSONParser; +using doris::vectorized::ParseConfig; + +TEST(JsonParserTest, ParseSimpleTypes) { + JSONDataParser parser; + ParseConfig config; + + // int + auto result = parser.parse("123", 3, config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 1); + + // double + result = parser.parse("1.23", 4, config); + ASSERT_TRUE(result.has_value()); + + // bool + result = parser.parse("true", 4, config); + ASSERT_TRUE(result.has_value()); + + // null + result = parser.parse("null", 4, config); + ASSERT_TRUE(result.has_value()); + + // string + result = parser.parse("\"abc\"", 5, config); + ASSERT_TRUE(result.has_value()); +} + +TEST(JsonParserTest, ParseObjectAndArray) { + JSONDataParser parser; + ParseConfig config; + + // Object + auto result = parser.parse(R"({"a":1,"b":2})", 13, config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 2); + + // Array + result = parser.parse("[1,2,3]", 7, config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 1); +} + +TEST(JsonParserTest, ParseMultiLevelNestedArray) { + JSONDataParser parser; + ParseConfig config; + + auto result = parser.parse("[[1,2],[3,4]]", 13, config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 1); + EXPECT_EQ(result->paths.size(), 1); + EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_ARRAY); + + result = parser.parse("[[[1],[2]],[[3],[4]]]", 21, config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 1); + EXPECT_EQ(result->paths.size(), 1); + EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_ARRAY); + + result = parser.parse("[[1,2],[3],[4,5,6]]", 19, config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 1); + EXPECT_EQ(result->paths.size(), 1); + + // Test complex nested structure + config.enable_flatten_nested = false; + std::string json1 = R"({"a":[[1,2],[3],[4,5,6]]})"; + // multi level nested array in object + result = parser.parse(json1.c_str(), json1.size(), config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 1); + EXPECT_EQ(result->paths.size(), 1); + EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_ARRAY); + + std::string json = R"({"nested": [{"a": [1,2,3]}]})"; + // result should be jsonbField + result = parser.parse(json.c_str(), json.size(), config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 1); + EXPECT_EQ(result->paths.size(), 1); + EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_JSONB); + + // multi level nested array in nested array object + std::string json2 = R"({"a":[{"b":[[1,2,3]]}]})"; + result = parser.parse(json2.c_str(), json2.size(), config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 1); + EXPECT_EQ(result->paths.size(), 1); + EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_JSONB); + + // test flatten nested + config.enable_flatten_nested = true; + EXPECT_ANY_THROW(parser.parse(json.c_str(), json.size(), config)); + // test flatten nested with multi level nested array + // no throw because it is not nested object array + result = parser.parse(json1.c_str(), json1.size(), config); + ASSERT_TRUE(result.has_value()); + EXPECT_EQ(result->values.size(), 1); + EXPECT_EQ(result->paths.size(), 1); + EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_ARRAY); + + EXPECT_ANY_THROW(parser.parse(json2.c_str(), json2.size(), config)); +} + +TEST(JsonParserTest, ParseNestedAndFlatten) { + JSONDataParser parser; + ParseConfig config; + config.enable_flatten_nested = true; + + std::string json = R"({"a":[{"b":1},{"b":2}]})"; + auto result = parser.parse(json.c_str(), json.size(), config); + ASSERT_TRUE(result.has_value()); + EXPECT_GT(result->values.size(), 0); + + config.enable_flatten_nested = false; + std::string json2 = R"({"a":[{"b":1},{"b":2}]})"; + result = parser.parse(json2.c_str(), json2.size(), config); + ASSERT_TRUE(result.has_value()); +} + +TEST(JsonParserTest, ParseInvalidJson) { + JSONDataParser parser; + ParseConfig config; + + auto result = parser.parse("{a:1}", 5, config); + ASSERT_FALSE(result.has_value()); + + result = parser.parse("", 0, config); + ASSERT_FALSE(result.has_value()); +} + +TEST(JsonParserTest, ParseCornerCases) { + JSONDataParser parser; + ParseConfig config; + + auto result = parser.parse("{}", 2, config); + ASSERT_TRUE(result.has_value()); + + result = parser.parse("[]", 2, config); + ASSERT_TRUE(result.has_value()); + + result = parser.parse(R"({"a":"\n\t"})", 12, config); + ASSERT_TRUE(result.has_value()); +} diff --git a/regression-test/data/variant_p0/desc.out b/regression-test/data/variant_p0/desc.out index 1eff52e44842f3..71f804cc25c5bb 100644 --- a/regression-test/data/variant_p0/desc.out +++ b/regression-test/data/variant_p0/desc.out @@ -16,7 +16,7 @@ v.b json Yes false \N NONE v.c.c smallint Yes false \N NONE v.c.e double Yes false \N NONE v.ddd.aaa tinyint Yes false \N NONE -v.ddd.mxmxm json Yes false \N NONE +v.ddd.mxmxm array Yes false \N NONE v.oooo.xxxx.xxx tinyint Yes false \N NONE v.xxxx text Yes false \N NONE @@ -37,7 +37,7 @@ v.b json Yes false \N NONE v.c.c smallint Yes false \N NONE v.c.e double Yes false \N NONE v.ddd.aaa tinyint Yes false \N NONE -v.ddd.mxmxm json Yes false \N NONE +v.ddd.mxmxm array Yes false \N NONE v.oooo.xxxx.xxx tinyint Yes false \N NONE v.xxxx text Yes false \N NONE @@ -66,7 +66,7 @@ v.b json Yes false \N NONE v.c.c smallint Yes false \N NONE v.c.e double Yes false \N NONE v.ddd.aaa tinyint Yes false \N NONE -v.ddd.mxmxm json Yes false \N NONE +v.ddd.mxmxm array Yes false \N NONE v.oooo.xxxx.xxx tinyint Yes false \N NONE v.xxxx text Yes false \N NONE diff --git a/regression-test/data/variant_p0/load.out b/regression-test/data/variant_p0/load.out index f25280c3feac81..555764b22b9b3c 100644 --- a/regression-test/data/variant_p0/load.out +++ b/regression-test/data/variant_p0/load.out @@ -224,7 +224,11 @@ [123] -- !sql_25 -- +<<<<<<< HEAD 50000 55000.00000000863 6150000 +======= +50000 55000.000000007036 6150000 +>>>>>>> 179627f735 ([fix](variant)fix variant type conflicts in nested types (#52696)) -- !sql_26 -- 5000 @@ -246,8 +250,8 @@ ["123",123,[123]] 123 123456 -[123,"123",1.11111] -[123,1.11,"123"] +[123, "123", 1.11111] +[123, 1.11, "123"] [123,{"xx":1}] [123,{"a":1}] [{"a":1},123] diff --git a/regression-test/data/variant_p0/nested2.out b/regression-test/data/variant_p0/nested2.out new file mode 100644 index 00000000000000..c7790a107de3da --- /dev/null +++ b/regression-test/data/variant_p0/nested2.out @@ -0,0 +1,337 @@ +-- This file is automatically generated. You should know what you did if you want to edit this +-- !sql_desc_1 -- +k bigint Yes true \N +v variant Yes false \N NONE +v.nested.a array Yes false \N NONE +v.nested.b array Yes false \N NONE +v.nested.c array Yes false \N NONE + +-- !sql_0 -- +1 {"nested":[{"a":1,"c":1.1},{"b":"1"}]} + +-- !sql_1 -- +[1, null] + +-- !sql_2 -- +[null, "1"] + +-- !sql_3 -- +[1.1, null] + +-- !sql_4 -- +[{"a":1,"c":1.1}, {"b":"1"}] + +-- !sql_8 -- +[1, null] 2 + +-- !sql_9 -- +[null, 1] 2 + +-- !sql_10 -- +[1, null] 2 + +-- !sql_11 -- +["1", null] 2 + +-- !sql_12 -- +[null, "1"] 2 + +-- !sql_13 -- +["1.1", null] 2 + +-- !sql_14 -- +[1, null] 2 + +-- !sql_15 -- +[null, 1] 2 + +-- !sql_16 -- +[1.1, null] 2 + +-- !sql_desc_2 -- +k bigint Yes true \N +v variant Yes false \N NONE +v.nested.a array Yes false \N NONE +v.nested.b array Yes false \N NONE +v.nested.c array Yes false \N NONE + +-- !sql_0 -- +1 {"nested":[{"a":1.0,"c":1.1},{"b":"1"}]} +2 {"nested":[{"a":2.5,"b":123.1}]} + +-- !sql_1 -- +[1, null] +[2.5] + +-- !sql_2 -- +[null, ""1""] +["123.1"] + +-- !sql_3 -- +[1.1, null] +\N + +-- !sql_4 -- +[{"a":1.0,"c":1.1}, {"b":"1"}] +[{"a":2.5,"b":123.1}] + +-- !sql_8 -- +[1, null] 2 +[2] 1 + +-- !sql_9 -- +[null, 1] 2 +[123] 1 + +-- !sql_10 -- +[1, null] 2 +\N \N + +-- !sql_11 -- +["1", null] 2 +["2.5"] 1 + +-- !sql_12 -- +[null, "1"] 2 +["123.1"] 1 + +-- !sql_13 -- +["1.1", null] 2 +\N \N + +-- !sql_14 -- +[1, null] 2 +[2.5] 1 + +-- !sql_15 -- +[null, 1] 2 +[123.1] 1 + +-- !sql_16 -- +[1.1, null] 2 +\N \N + +-- !sql_0 -- +1 {"nested":[{"a":1.0,"c":1.1},{"b":"1"}]} +2 {"nested":[{"a":2.5,"b":123.1}]} + +-- !sql_1 -- +[1, null] +[2.5] + +-- !sql_2 -- +[null, ""1""] +["123.1"] + +-- !sql_3 -- +[1.1, null] +[null] + +-- !sql_4 -- +[{"a":1.0,"c":1.1}, {"b":"1"}] +[{"a":2.5,"b":123.1}] + +-- !sql_8 -- +[1, null] 2 +[2] 1 + +-- !sql_9 -- +[null, 1] 2 +[123] 1 + +-- !sql_10 -- +[1, null] 2 +[null] 1 + +-- !sql_11 -- +["1", null] 2 +["2.5"] 1 + +-- !sql_12 -- +[null, "1"] 2 +["123.1"] 1 + +-- !sql_13 -- +["1.1", null] 2 +[null] 1 + +-- !sql_14 -- +[1, null] 2 +[2.5] 1 + +-- !sql_15 -- +[null, 1] 2 +[123.1] 1 + +-- !sql_16 -- +[1.1, null] 2 +[null] 1 + +-- !sql_desc_4 -- +k bigint Yes true \N +v variant Yes false \N NONE +v.nested.a array Yes false \N NONE +v.nested.b array Yes false \N NONE +v.nested.c array Yes false \N NONE + +-- !sql_0 -- +1 {"nested":[{"a":1,"b":1.1},{"a":"1","b":"1","c":"1"}]} + +-- !sql_1 -- +["1", ""1""] + +-- !sql_2 -- +["1.1", ""1""] + +-- !sql_3 -- +[null, "1"] + +-- !sql_4 -- +[{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}] + +-- !sql_8 -- +[1, 1] 2 + +-- !sql_9 -- +[1, 1] 2 + +-- !sql_10 -- +[null, 1] 2 + +-- !sql_11 -- +["1", "1"] 2 + +-- !sql_12 -- +["1.1", "1"] 2 + +-- !sql_13 -- +[null, "1"] 2 + +-- !sql_14 -- +[1, 1] 2 + +-- !sql_15 -- +[1.1, 1] 2 + +-- !sql_16 -- +[null, 1] 2 + +-- !sql_desc_5 -- +k bigint Yes true \N +v variant Yes false \N NONE +v.nested.a array Yes false \N NONE +v.nested.b array Yes false \N NONE +v.nested.c array Yes false \N NONE + +-- !sql_0 -- +1 {"nested":[{"a":1,"b":1.1},{"a":"1","b":"1","c":"1"}]} +2 {"nested":[{"a":1,"c":1.1}]} + +-- !sql_1 -- +["1", ""1""] +["1"] + +-- !sql_2 -- +["1.1", ""1""] +\N + +-- !sql_3 -- +[null, ""1""] +["1.1"] + +-- !sql_4 -- +[{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}] +[{"a":1,"c":1.1}] + +-- !sql_8 -- +[1, 1] 2 +[1] 1 + +-- !sql_9 -- +[1, 1] 2 +\N \N + +-- !sql_10 -- +[null, 1] 2 +[1] 1 + +-- !sql_11 -- +["1", "1"] 2 +["1"] 1 + +-- !sql_12 -- +["1.1", "1"] 2 +\N \N + +-- !sql_13 -- +[null, "1"] 2 +["1.1"] 1 + +-- !sql_14 -- +[1, 1] 2 +[1] 1 + +-- !sql_15 -- +[1.1, 1] 2 +\N \N + +-- !sql_16 -- +[null, 1] 2 +[1.1] 1 + +-- !sql_0 -- +1 {"nested":[{"a":1,"b":1.1},{"a":"1","b":"1","c":"1"}]} +2 {"nested":[{"a":1,"c":1.1}]} + +-- !sql_1 -- +["1", ""1""] +["1"] + +-- !sql_2 -- +["1.1", ""1""] +[null] + +-- !sql_3 -- +[null, ""1""] +["1.1"] + +-- !sql_4 -- +[{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}] +[{"a":1,"c":1.1}] + +-- !sql_8 -- +[1, 1] 2 +[1] 1 + +-- !sql_9 -- +[1, 1] 2 +[null] 1 + +-- !sql_10 -- +[null, 1] 2 +[1] 1 + +-- !sql_11 -- +["1", "1"] 2 +["1"] 1 + +-- !sql_12 -- +["1.1", "1"] 2 +[null] 1 + +-- !sql_13 -- +[null, "1"] 2 +["1.1"] 1 + +-- !sql_14 -- +[1, 1] 2 +[1] 1 + +-- !sql_15 -- +[1.1, 1] 2 +[null] 1 + +-- !sql_16 -- +[null, 1] 2 +[1.1] 1 + diff --git a/regression-test/suites/variant_p0/nested2.groovy b/regression-test/suites/variant_p0/nested2.groovy new file mode 100644 index 00000000000000..8d48fcfce9b1c0 --- /dev/null +++ b/regression-test/suites/variant_p0/nested2.groovy @@ -0,0 +1,151 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +// this test is used to test the type conflict of nested array +suite("variant_nested_type_conflict", "p0"){ + + try { + + def table_name = "var_nested_type_conflict" + sql "DROP TABLE IF EXISTS ${table_name}" + sql """set describe_extend_variant_column = true""" + + sql """ + CREATE TABLE IF NOT EXISTS ${table_name} ( + k bigint, + v variant + ) + DUPLICATE KEY(`k`) + DISTRIBUTED BY HASH(k) BUCKETS 1 -- 1 bucket make really compaction in conflict case + properties("replication_num" = "1", "disable_auto_compaction" = "false", "variant_enable_flatten_nested" = "true"); + """ + def sql_select_batch = { + qt_sql_0 """select * from ${table_name} order by k""" + + qt_sql_1 """select v['nested']['a'] from ${table_name} order by k""" + qt_sql_2 """select v['nested']['b'] from ${table_name} order by k""" + qt_sql_3 """select v['nested']['c'] from ${table_name} order by k""" + + qt_sql_4 """select v['nested'] from ${table_name} order by k""" + } + + def sql_test_cast_to_array = { + // test cast to array + qt_sql_8 """select cast(v['nested']['a'] as array), size(cast(v['nested']['a'] as array)) from ${table_name} order by k""" + qt_sql_9 """select cast(v['nested']['b'] as array), size(cast(v['nested']['b'] as array)) from ${table_name} order by k""" + qt_sql_10 """select cast(v['nested']['c'] as array), size(cast(v['nested']['c'] as array)) from ${table_name} order by k""" + + // test cast to array + qt_sql_11 """select cast(v['nested']['a'] as array), size(cast(v['nested']['a'] as array)) from ${table_name} order by k""" + qt_sql_12 """select cast(v['nested']['b'] as array), size(cast(v['nested']['b'] as array)) from ${table_name} order by k""" + qt_sql_13 """select cast(v['nested']['c'] as array), size(cast(v['nested']['c'] as array)) from ${table_name} order by k""" + + // test cast to array + qt_sql_14 """select cast(v['nested']['a'] as array), size(cast(v['nested']['a'] as array)) from ${table_name} order by k""" + qt_sql_15 """select cast(v['nested']['b'] as array), size(cast(v['nested']['b'] as array)) from ${table_name} order by k""" + qt_sql_16 """select cast(v['nested']['c'] as array), size(cast(v['nested']['c'] as array)) from ${table_name} order by k""" + + } + // insert Nested array in Nested array which is not supported + test { + sql """ + insert into ${table_name} values (1, '{"nested": [{"a": [1,2,3]}]}'); + """ + exception "Nesting of array in Nested array within variant subcolumns is currently not supported." + } + /// insert a array of object for a, b, c + // insert type conflict in multiple rows + sql """ + insert into ${table_name} values (1, '{"nested": [{"a": 1, "c": 1.1}, {"b": "1"}]}'); + """ + + // for cloud we should select first and then desc for syncing rowset to get latest schema + sql """ + select * from ${table_name} order by k limit 1; + """ + qt_sql_desc_1 """ + desc ${table_name}; + """ + // now select for a, b, c + sql_select_batch() + sql_test_cast_to_array() + /// insert a, b type changed to double + sql """ + insert into ${table_name} values (2, '{"nested": [{"a": 2.5, "b": 123.1}]}'); + """ + // for cloud we should select first and then desc for syncing rowset to get latest schema + sql """ + select * from ${table_name} order by k limit 1; + """ + qt_sql_desc_2 """ + desc ${table_name}; + """ + // now select for a, b, c + sql_select_batch() + sql_test_cast_to_array() + + // trigger and wait compaction + trigger_and_wait_compaction("${table_name}", "full") + + // now select for a, b, c + sql_select_batch() + sql_test_cast_to_array() + + sql """ truncate table ${table_name} """ + + + // insert type conflict in one row + sql """ + insert into ${table_name} values (1, '{"nested": [{"a": 1, "b": 1.1}, {"a": "1", "b": "1", "c": "1"}]}'); + """ + // for cloud we should select first and then desc for syncing rowset to get latest schema + sql """ + select * from ${table_name} order by k limit 1; + """ + qt_sql_desc_4 """ + desc ${table_name}; + """ + // now select for a, b, c + sql_select_batch() + sql_test_cast_to_array() + + // insert c type changed to double + sql """ + insert into ${table_name} values (2, '{"nested": [{"a": 1, "c": 1.1}]}'); + """ + // for cloud we should select first and then desc for syncing rowset to get latest schema + sql """ + select * from ${table_name} order by k limit 1; + """ + qt_sql_desc_5 """ + desc ${table_name}; + """ + // now select for a, b, c + sql_select_batch() + sql_test_cast_to_array() + + // trigger and wait compaction + trigger_and_wait_compaction("${table_name}", "full") + + // now select for a, b, c + sql_select_batch() + sql_test_cast_to_array() + + } finally { + } + +} From 22978e6c663a997de3a214ba86d6ec274c04b637 Mon Sep 17 00:00:00 2001 From: amorynan Date: Fri, 11 Jul 2025 16:53:13 +0800 Subject: [PATCH 02/11] fixed --- be/src/vec/columns/column_object.cpp | 6 ------ be/src/vec/columns/column_object.h | 7 ------- 2 files changed, 13 deletions(-) diff --git a/be/src/vec/columns/column_object.cpp b/be/src/vec/columns/column_object.cpp index 8f876c14241d98..c4a4c0494ceb58 100644 --- a/be/src/vec/columns/column_object.cpp +++ b/be/src/vec/columns/column_object.cpp @@ -87,12 +87,6 @@ DataTypePtr create_array_of_type(TypeIndex type, size_t num_dimensions, bool is_ if (type == TypeIndex::Nothing) { return std::make_shared(); } - if (type == ColumnObject::MOST_COMMON_TYPE_ID) { - // JSONB type MUST NOT wrapped in ARRAY column, it should be top level. - // So we ignored num_dimensions. - return is_nullable ? make_nullable(std::make_shared()) - : std::make_shared(); - } DataTypePtr result = DataTypeFactory::instance().create_data_type(type, is_nullable, precision, scale); for (size_t i = 0; i < num_dimensions; ++i) { diff --git a/be/src/vec/columns/column_object.h b/be/src/vec/columns/column_object.h index f36d1898d2991a..319e5569e958a0 100644 --- a/be/src/vec/columns/column_object.h +++ b/be/src/vec/columns/column_object.h @@ -210,7 +210,6 @@ class ColumnObject final : public COWHelper { void add_new_column_part(DataTypePtr type); -<<<<<<< HEAD:be/src/vec/columns/column_object.h // Serialize the i-th row of the column into the sparse column. void serialize_to_sparse_column(ColumnString* key, std::string_view path, ColumnString* value, size_t row); @@ -222,12 +221,6 @@ class ColumnObject final : public COWHelper { bool is_empty_nested(size_t row) const; void resize(size_t n); -======= - /// Converts Array to Array for special case handling - static void convert_array_string_to_array_jsonb(Field& array_field); - - friend class ColumnVariant; ->>>>>>> 179627f735 ([fix](variant)fix variant type conflicts in nested types (#52696)):be/src/vec/columns/column_variant.h private: class LeastCommonType { From ad8aeb80b0185577a3d49ab0a900d1834109ee19 Mon Sep 17 00:00:00 2001 From: amorynan Date: Mon, 21 Jul 2025 15:10:39 +0800 Subject: [PATCH 03/11] fix out file --- regression-test/data/variant_p0/load.out | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/regression-test/data/variant_p0/load.out b/regression-test/data/variant_p0/load.out index 2ffecb087f97b5..fefa6a3dc7aeb4 100644 --- a/regression-test/data/variant_p0/load.out +++ b/regression-test/data/variant_p0/load.out @@ -224,7 +224,7 @@ [123] -- !sql_25 -- -50000 55000.00000000543 6150000 +50000 55000.00000000863 6150000 -- !sql_26 -- 5000 @@ -246,8 +246,8 @@ ["123",123,[123]] 123 123456 -[123, "123", 1.11111] -[123, 1.11, "123"] +[123,"123",1.11111] +[123,1.11,"123"] [123,{"xx":1}] [123,{"a":1}] [{"a":1},123] @@ -269,15 +269,15 @@ -- !sql_31 -- {"a":1123,"b":[123,{"xx":1}],"c":{"c":456,"e":7.111},"oooo":{"xxxx":{"xxx":123}}} -{"a":1234,"ddd":{"aaa":123,"mxmxm":[456,"789"]},"xxxx":"kaana"} -{"a":1234,"ddd":{"aaa":123,"mxmxm":[456,"789"]},"xxxx":"kaana"} -{"a":1234,"ddd":{"aaa":123,"mxmxm":[456,"789"]},"xxxx":"kaana"} -{"a":1234,"ddd":{"aaa":123,"mxmxm":[456,"789"]},"xxxx":"kaana"} -{"a":1234,"ddd":{"aaa":123,"mxmxm":[456,"789"]},"xxxx":"kaana"} -{"a":1234,"ddd":{"aaa":123,"mxmxm":[456,"789"]},"xxxx":"kaana"} -{"a":1234,"ddd":{"aaa":123,"mxmxm":[456,"789"]},"xxxx":"kaana"} -{"a":1234,"ddd":{"aaa":123,"mxmxm":[456,"789"]},"xxxx":"kaana"} -{"a":1234,"ddd":{"aaa":123,"mxmxm":[456,"789"]},"xxxx":"kaana"} +{"a":1234,"ddd":{"aaa":123,"mxmxm":[456, "789"]},"xxxx":"kaana"} +{"a":1234,"ddd":{"aaa":123,"mxmxm":[456, "789"]},"xxxx":"kaana"} +{"a":1234,"ddd":{"aaa":123,"mxmxm":[456, "789"]},"xxxx":"kaana"} +{"a":1234,"ddd":{"aaa":123,"mxmxm":[456, "789"]},"xxxx":"kaana"} +{"a":1234,"ddd":{"aaa":123,"mxmxm":[456, "789"]},"xxxx":"kaana"} +{"a":1234,"ddd":{"aaa":123,"mxmxm":[456, "789"]},"xxxx":"kaana"} +{"a":1234,"ddd":{"aaa":123,"mxmxm":[456, "789"]},"xxxx":"kaana"} +{"a":1234,"ddd":{"aaa":123,"mxmxm":[456, "789"]},"xxxx":"kaana"} +{"a":1234,"ddd":{"aaa":123,"mxmxm":[456, "789"]},"xxxx":"kaana"} -- !sql_36_1 -- 1 \N \N From cb60efbe79858f3140a36cc09cc4aa90dcaf6492 Mon Sep 17 00:00:00 2001 From: amorynan Date: Tue, 22 Jul 2025 22:35:26 +0800 Subject: [PATCH 04/11] fix ut code --- be/test/vec/exec/column_type_convert_test.cpp | 491 +++++++++--------- .../cast/function_variant_cast_test.cpp | 94 ++-- .../vec/jsonb/convert_field_to_type_test.cpp | 111 ++-- 3 files changed, 347 insertions(+), 349 deletions(-) diff --git a/be/test/vec/exec/column_type_convert_test.cpp b/be/test/vec/exec/column_type_convert_test.cpp index bbc5a5b947c17c..edc7819129393a 100644 --- a/be/test/vec/exec/column_type_convert_test.cpp +++ b/be/test/vec/exec/column_type_convert_test.cpp @@ -656,256 +656,257 @@ TEST_F(ColumnTypeConverterTest, TestDecimalConversions) { // Test string type conversions TEST_F(ColumnTypeConverterTest, TestStringConversions) { // Test numeric to string conversions - {// INT -> STRING - {TypeDescriptor src_type(TYPE_INT); - auto dst_type = std::make_shared(); - - auto converter = - converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnInt32::create(); - auto& src_data = src_col->get_data(); - src_data.push_back(std::numeric_limits::max()); - src_data.push_back(std::numeric_limits::min()); - src_data.push_back(0); - - auto dst_col = dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(3, string_col.size()); - EXPECT_EQ(std::to_string(std::numeric_limits::max()), - string_col.get_data_at(0).to_string()); - EXPECT_EQ(std::to_string(std::numeric_limits::min()), - string_col.get_data_at(1).to_string()); - EXPECT_EQ("0", string_col.get_data_at(2).to_string()); -} + { // INT -> STRING + { + TypeDescriptor src_type(TYPE_INT); + auto dst_type = std::make_shared(); + + auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, + converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnInt32::create(); + auto& src_data = src_col->get_data(); + src_data.push_back(std::numeric_limits::max()); + src_data.push_back(std::numeric_limits::min()); + src_data.push_back(0); + + auto dst_col = dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(3, string_col.size()); + EXPECT_EQ(std::to_string(std::numeric_limits::max()), + string_col.get_data_at(0).to_string()); + EXPECT_EQ(std::to_string(std::numeric_limits::min()), + string_col.get_data_at(1).to_string()); + EXPECT_EQ("0", string_col.get_data_at(2).to_string()); + } -// DOUBLE -> STRING -{ - TypeDescriptor src_type(TYPE_DOUBLE); - auto dst_type = std::make_shared(); - - auto converter = - converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnFloat64::create(); - auto& src_data = src_col->get_data(); - src_data.push_back(3.14159265359); - src_data.push_back(-2.71828182846); - src_data.push_back(std::numeric_limits::infinity()); - src_data.push_back(std::numeric_limits::quiet_NaN()); - - auto dst_col = dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(4, string_col.size()); - // Note: Exact string representation may vary by platform - EXPECT_TRUE(string_col.get_data_at(0).to_string().find("3.14159") == 0); - EXPECT_TRUE(string_col.get_data_at(1).to_string().find("-2.71828") == 0); - EXPECT_TRUE(string_col.get_data_at(2).to_string().find("inf") != std::string::npos); - EXPECT_TRUE(string_col.get_data_at(3).to_string().find("nan") != std::string::npos); -} -} // namespace doris::vectorized - -// Test string to numeric conversions with invalid input -{ - TypeDescriptor src_type(TYPE_STRING); - auto dst_type = std::make_shared(); - auto nullable_dst_type = std::make_shared(dst_type); - - auto converter = converter::ColumnTypeConverter::get_converter(src_type, nullable_dst_type, - converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnString::create(); - src_col->resize(0); - src_col->insert_data("42", 2); - src_col->insert_data("not a number", 11); - src_col->insert_data("2147483648", 10); // Greater than INT32_MAX - - auto dst_col = nullable_dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); - auto& nullable_col = static_cast(*mutable_dst); - auto& nested_col = static_cast(nullable_col.get_nested_column()); - auto& null_map = nullable_col.get_null_map_data(); - null_map.resize_fill(src_col->size(), 0); - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - ASSERT_EQ(3, nested_col.size()); - EXPECT_EQ(42, nested_col.get_data()[0]); - EXPECT_EQ(1, null_map[1]); // Invalid format - EXPECT_EQ(1, null_map[2]); // Out of range - EXPECT_EQ(0, null_map[0]); -} -// TEST DECIMAL -> STRING -{ - TypeDescriptor src_type(TYPE_DECIMAL32); - src_type.precision = 9; - src_type.scale = 2; - - auto dst_type = std::make_shared(); - - auto converter = - converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnDecimal::create(9, 2); - auto& src_data = src_col->get_data(); - // Add test values - src_data.resize(0); - src_data.push_back(Decimal32(12345)); // 123.45 - src_data.push_back(Decimal32(-67890)); // -678.90 - src_data.push_back(Decimal32(0)); // Zero - - auto dst_col = dst_type->create_column(); - dst_col->resize(0); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(3, string_col.size()); - EXPECT_EQ("123.45", string_col.get_data_at(0).to_string()); // 123.45 - EXPECT_EQ("-678.90", string_col.get_data_at(1).to_string()); // -678.90 - EXPECT_EQ("0.00", string_col.get_data_at(2).to_string()); // Zero value -} + // DOUBLE -> STRING + { + TypeDescriptor src_type(TYPE_DOUBLE); + auto dst_type = std::make_shared(); + + auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, + converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnFloat64::create(); + auto& src_data = src_col->get_data(); + src_data.push_back(3.14159265359); + src_data.push_back(-2.71828182846); + src_data.push_back(std::numeric_limits::infinity()); + src_data.push_back(std::numeric_limits::quiet_NaN()); + + auto dst_col = dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(4, string_col.size()); + // Note: Exact string representation may vary by platform + EXPECT_TRUE(string_col.get_data_at(0).to_string().find("3.14159") == 0); + EXPECT_TRUE(string_col.get_data_at(1).to_string().find("-2.71828") == 0); + EXPECT_TRUE(string_col.get_data_at(2).to_string().find("inf") != std::string::npos); + EXPECT_TRUE(string_col.get_data_at(3).to_string().find("nan") != std::string::npos); + } + } // namespace doris::vectorized -// TEST DATE/TIMESTAMP -> STRING -{ - TypeDescriptor src_type(TYPE_DATEV2); - auto dst_type = std::make_shared(); - - auto converter = - converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnDateV2::create(); - auto& src_data = src_col->get_data(); - // Add test date values - src_data.resize(0); - DateV2Value value; - value.unchecked_set_time(2021, 1, 1, 0, 0, 0); - src_data.push_back( - *reinterpret_cast(&value)); // "2021-01-01" in days format - value.unchecked_set_time(1970, 1, 1, 0, 0, 0); - src_data.push_back(*reinterpret_cast( - &value)); // "1970-01-01" in days format (epoch start) - value.unchecked_set_time(2070, 1, 1, 0, 0, 0); - src_data.push_back( - *reinterpret_cast(&value)); // "2070-01-01" in days format - - auto dst_col = dst_type->create_column(); - dst_col->resize(0); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(3, string_col.size()); - EXPECT_EQ("2021-01-01", string_col.get_data_at(0).to_string()); - EXPECT_EQ("1970-01-01", string_col.get_data_at(1).to_string()); - EXPECT_EQ("2070-01-01", string_col.get_data_at(2).to_string()); -} + // Test string to numeric conversions with invalid input + { + TypeDescriptor src_type(TYPE_STRING); + auto dst_type = std::make_shared(); + auto nullable_dst_type = std::make_shared(dst_type); -// TEST BOOLEAN -> STRING -{ - TypeDescriptor src_type(TYPE_BOOLEAN); - auto dst_type = std::make_shared(); - - auto converter = - converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnUInt8::create(); - auto& src_data = src_col->get_data(); - src_data.resize(0); - // Add boolean values - src_data.push_back(1); // true - src_data.push_back(0); // false - src_data.push_back(1); // true - src_data.push_back(0); // false - - auto dst_col = dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(4, string_col.size()); - EXPECT_EQ("TRUE", string_col.get_data_at(0).to_string()); // true - EXPECT_EQ("FALSE", string_col.get_data_at(1).to_string()); // false - EXPECT_EQ("TRUE", string_col.get_data_at(2).to_string()); // true - EXPECT_EQ("FALSE", string_col.get_data_at(3).to_string()); // false -} + auto converter = converter::ColumnTypeConverter::get_converter(src_type, nullable_dst_type, + converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); -// TEST STRING -> BOOLEAN (for ORC file format, Apache Hive behavior) -{ - TypeDescriptor src_type(TYPE_STRING); - auto dst_type = std::make_shared(); // BOOLEAN represented as UInt8 - auto nullable_dst_type = std::make_shared(dst_type); - - auto converter = converter::ColumnTypeConverter::get_converter(src_type, nullable_dst_type, - converter::ORC); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnString::create(); - // Add test strings - src_col->resize(0); - src_col->insert_data("0", 1); // Hive: false - src_col->insert_data("123", 3); // Hive: true - src_col->insert_data("-1", 2); // Hive: true - src_col->insert_data(" ", 1); // Hive: null - src_col->insert_data("not_a_number", 13); // Hive: null - src_col->insert_data("1.5", 3); // Hive: null (not an integer) - src_col->insert_data("", 0); // Hive: null - - auto dst_col = nullable_dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); - - auto& nullable_col = static_cast(*mutable_dst); - auto& nested_col = static_cast( - nullable_col.get_nested_column()); // Boolean as UInt8 (0 or 1) - auto& null_map = nullable_col.get_null_map_data(); - null_map.resize_fill(src_col->size(), 0); - - // Perform conversion - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - ASSERT_EQ(7, nested_col.size()); - EXPECT_EQ(0, nested_col.get_data()[0]); // "0" -> false (0) - EXPECT_EQ(1, nested_col.get_data()[1]); // "123" -> true (1) - EXPECT_EQ(1, nested_col.get_data()[2]); // "-1" -> true (1) - EXPECT_EQ(1, null_map[3]); // " " -> null - EXPECT_EQ(1, null_map[4]); // "not_a_number" -> null - EXPECT_EQ(1, null_map[5]); // "1.5" -> null - EXPECT_EQ(1, null_map[6]); // "" -> null - - for (int i = 0; i < 3; i++) { - EXPECT_EQ(0, null_map[i]); + auto src_col = ColumnString::create(); + src_col->resize(0); + src_col->insert_data("42", 2); + src_col->insert_data("not a number", 11); + src_col->insert_data("2147483648", 10); // Greater than INT32_MAX + + auto dst_col = nullable_dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + auto& nullable_col = static_cast(*mutable_dst); + auto& nested_col = static_cast(nullable_col.get_nested_column()); + auto& null_map = nullable_col.get_null_map_data(); + null_map.resize_fill(src_col->size(), 0); + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + ASSERT_EQ(3, nested_col.size()); + EXPECT_EQ(42, nested_col.get_data()[0]); + EXPECT_EQ(1, null_map[1]); // Invalid format + EXPECT_EQ(1, null_map[2]); // Out of range + EXPECT_EQ(0, null_map[0]); + } + // TEST DECIMAL -> STRING + { + TypeDescriptor src_type(TYPE_DECIMAL32); + src_type.precision = 9; + src_type.scale = 2; + + auto dst_type = std::make_shared(); + + auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, + converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnDecimal::create(9, 2); + auto& src_data = src_col->get_data(); + // Add test values + src_data.resize(0); + src_data.push_back(Decimal32(12345)); // 123.45 + src_data.push_back(Decimal32(-67890)); // -678.90 + src_data.push_back(Decimal32(0)); // Zero + + auto dst_col = dst_type->create_column(); + dst_col->resize(0); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(3, string_col.size()); + EXPECT_EQ("123.45", string_col.get_data_at(0).to_string()); // 123.45 + EXPECT_EQ("-678.90", string_col.get_data_at(1).to_string()); // -678.90 + EXPECT_EQ("0.00", string_col.get_data_at(2).to_string()); // Zero value + } + + // TEST DATE/TIMESTAMP -> STRING + { + TypeDescriptor src_type(TYPE_DATEV2); + auto dst_type = std::make_shared(); + + auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, + converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnDateV2::create(); + auto& src_data = src_col->get_data(); + // Add test date values + src_data.resize(0); + DateV2Value value; + value.unchecked_set_time(2021, 1, 1, 0, 0, 0); + src_data.push_back( + *reinterpret_cast(&value)); // "2021-01-01" in days format + value.unchecked_set_time(1970, 1, 1, 0, 0, 0); + src_data.push_back(*reinterpret_cast( + &value)); // "1970-01-01" in days format (epoch start) + value.unchecked_set_time(2070, 1, 1, 0, 0, 0); + src_data.push_back( + *reinterpret_cast(&value)); // "2070-01-01" in days format + + auto dst_col = dst_type->create_column(); + dst_col->resize(0); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(3, string_col.size()); + EXPECT_EQ("2021-01-01", string_col.get_data_at(0).to_string()); + EXPECT_EQ("1970-01-01", string_col.get_data_at(1).to_string()); + EXPECT_EQ("2070-01-01", string_col.get_data_at(2).to_string()); + } + + // TEST BOOLEAN -> STRING + { + TypeDescriptor src_type(TYPE_BOOLEAN); + auto dst_type = std::make_shared(); + + auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, + converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnUInt8::create(); + auto& src_data = src_col->get_data(); + src_data.resize(0); + // Add boolean values + src_data.push_back(1); // true + src_data.push_back(0); // false + src_data.push_back(1); // true + src_data.push_back(0); // false + + auto dst_col = dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(4, string_col.size()); + EXPECT_EQ("TRUE", string_col.get_data_at(0).to_string()); // true + EXPECT_EQ("FALSE", string_col.get_data_at(1).to_string()); // false + EXPECT_EQ("TRUE", string_col.get_data_at(2).to_string()); // true + EXPECT_EQ("FALSE", string_col.get_data_at(3).to_string()); // false + } + + // TEST STRING -> BOOLEAN (for ORC file format, Apache Hive behavior) + { + TypeDescriptor src_type(TYPE_STRING); + auto dst_type = std::make_shared(); // BOOLEAN represented as UInt8 + auto nullable_dst_type = std::make_shared(dst_type); + + auto converter = converter::ColumnTypeConverter::get_converter(src_type, nullable_dst_type, + converter::ORC); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnString::create(); + // Add test strings + src_col->resize(0); + src_col->insert_data("0", 1); // Hive: false + src_col->insert_data("123", 3); // Hive: true + src_col->insert_data("-1", 2); // Hive: true + src_col->insert_data(" ", 1); // Hive: null + src_col->insert_data("not_a_number", 13); // Hive: null + src_col->insert_data("1.5", 3); // Hive: null (not an integer) + src_col->insert_data("", 0); // Hive: null + + auto dst_col = nullable_dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + + auto& nullable_col = static_cast(*mutable_dst); + auto& nested_col = static_cast( + nullable_col.get_nested_column()); // Boolean as UInt8 (0 or 1) + auto& null_map = nullable_col.get_null_map_data(); + null_map.resize_fill(src_col->size(), 0); + + // Perform conversion + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + ASSERT_EQ(7, nested_col.size()); + EXPECT_EQ(0, nested_col.get_data()[0]); // "0" -> false (0) + EXPECT_EQ(1, nested_col.get_data()[1]); // "123" -> true (1) + EXPECT_EQ(1, nested_col.get_data()[2]); // "-1" -> true (1) + EXPECT_EQ(1, null_map[3]); // " " -> null + EXPECT_EQ(1, null_map[4]); // "not_a_number" -> null + EXPECT_EQ(1, null_map[5]); // "1.5" -> null + EXPECT_EQ(1, null_map[6]); // "" -> null + + for (int i = 0; i < 3; i++) { + EXPECT_EQ(0, null_map[i]); + } } -} } TEST_F(ColumnTypeConverterTest, TestUnsupportedConversions) { 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 db0ccc8144b51e..aa026d4a1557df 100644 --- a/be/test/vec/function/cast/function_variant_cast_test.cpp +++ b/be/test/vec/function/cast/function_variant_cast_test.cpp @@ -24,19 +24,19 @@ #include "runtime/primitive_type.h" #include "runtime/runtime_state.h" #include "vec/columns/column_array.h" -#include "vec/columns/column_variant.h" +#include "vec/columns/column_object.h" #include "vec/core/field.h" #include "vec/data_types/data_type_array.h" #include "vec/data_types/data_type_nullable.h" #include "vec/data_types/data_type_number.h" +#include "vec/data_types/data_type_object.h" #include "vec/data_types/data_type_string.h" -#include "vec/data_types/data_type_variant.h" #include "vec/functions/simple_function_factory.h" namespace doris::vectorized { static doris::vectorized::Field construct_variant_map( const std::vector>& key_and_values) { - doris::vectorized::Field res = Field::create_field(VariantMap {}); + doris::vectorized::Field res = VariantMap(); auto& object = res.get(); for (const auto& [k, v] : key_and_values) { PathInData path(k); @@ -47,16 +47,16 @@ static doris::vectorized::Field construct_variant_map( static auto construct_basic_varint_column() { // 1. create an empty variant column - auto variant = ColumnVariant::create(5); + auto variant = ColumnObject::create(5); std::vector> data; // 2. subcolumn path - data.emplace_back("v.a", Field::create_field(20)); - data.emplace_back("v.b", Field::create_field("20")); - data.emplace_back("v.c", Field::create_field(20)); - data.emplace_back("v.f", Field::create_field(20)); - data.emplace_back("v.e", Field::create_field("50")); + data.emplace_back("v.a", 20); + data.emplace_back("v.b", "20"); + data.emplace_back("v.c", 20); + data.emplace_back("v.f", 20); + data.emplace_back("v.e", "50"); for (int i = 0; i < 5; ++i) { auto field = construct_variant_map(data); variant->try_insert(field); @@ -70,11 +70,11 @@ TEST(FunctionVariantCast, CastToVariant) { { // Test Int32 to variant auto int32_type = std::make_shared(); - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); auto int32_col = ColumnInt32::create(); - int32_col->insert(Field::create_field(42)); - int32_col->insert(Field::create_field(100)); - int32_col->insert(Field::create_field(-1)); + int32_col->insert(42); + int32_col->insert(100); + int32_col->insert(-1); ColumnsWithTypeAndName arguments {{int32_col->get_ptr(), int32_type, "int32_col"}, {nullptr, variant_type, "variant_type"}}; @@ -93,14 +93,14 @@ TEST(FunctionVariantCast, CastToVariant) { auto result_col = block.get_by_position(result_column).column; ASSERT_NE(result_col.get(), nullptr); - const auto* variant_col = assert_cast(result_col.get()); + const auto* variant_col = assert_cast(result_col.get()); ASSERT_EQ(variant_col->size(), 3); } // Test casting from string to variant { auto string_type = std::make_shared(); - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); auto string_col = ColumnString::create(); string_col->insert_data("hello", 5); string_col->insert_data("world", 5); @@ -123,22 +123,22 @@ TEST(FunctionVariantCast, CastToVariant) { auto result_col = block.get_by_position(result_column).column; ASSERT_NE(result_col.get(), nullptr); const auto* variant_col = - assert_cast(remove_nullable(result_col).get()); + assert_cast(remove_nullable(result_col).get()); ASSERT_EQ(variant_col->size(), 2); } // Test casting from array to variant { auto array_type = std::make_shared(std::make_shared()); - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); auto array_col = ColumnArray::create(ColumnInt32::create(), ColumnArray::ColumnOffsets::create()); auto& data = assert_cast(array_col->get_data()); auto& offsets = array_col->get_offsets(); - data.insert(Field::create_field(1)); - data.insert(Field::create_field(2)); - data.insert(Field::create_field(3)); + data.insert(1); + data.insert(2); + data.insert(3); offsets.push_back(3); ColumnsWithTypeAndName arguments {{array_col->get_ptr(), array_type, "array_col"}, @@ -159,7 +159,7 @@ TEST(FunctionVariantCast, CastToVariant) { auto result_col = block.get_by_position(result_column).column; ASSERT_NE(result_col.get(), nullptr); const auto* variant_col = - assert_cast(remove_nullable(result_col).get()); + assert_cast(remove_nullable(result_col).get()); ASSERT_EQ(variant_col->size(), 1); } } @@ -167,16 +167,16 @@ TEST(FunctionVariantCast, CastToVariant) { TEST(FunctionVariantCast, CastFromVariant) { // Test casting from variant to basic types { - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); auto int32_type = std::make_shared(); - auto variant_col = ColumnVariant::create(true); + auto variant_col = ColumnObject::create(true); // Create a variant column with integer values variant_col->create_root(int32_type, ColumnInt32::create()); MutableColumnPtr data = variant_col->get_root(); - data->insert(Field::create_field(42)); - data->insert(Field::create_field(100)); - data->insert(Field::create_field(-1)); + data->insert(42); + data->insert(100); + data->insert(-1); ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, {nullptr, int32_type, "int32_type"}}; @@ -206,9 +206,9 @@ TEST(FunctionVariantCast, CastFromVariant) { // Test casting from variant to string { - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); auto string_type = std::make_shared(); - auto variant_col = ColumnVariant::create(true); + auto variant_col = ColumnObject::create(true); // Create a variant column with string values variant_col->create_root(string_type, ColumnString::create()); @@ -242,9 +242,9 @@ TEST(FunctionVariantCast, CastFromVariant) { // Test casting from variant to array { - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); auto array_type = std::make_shared(std::make_shared()); - auto variant_col = ColumnVariant::create(true); + auto variant_col = ColumnObject::create(true); // Create a variant column with array values variant_col->create_root( @@ -252,9 +252,7 @@ TEST(FunctionVariantCast, CastFromVariant) { ColumnArray::create(ColumnInt32::create(), ColumnArray::ColumnOffsets::create())); MutableColumnPtr data = variant_col->get_root(); - Field a = Field::create_field(Array {Field::create_field(1), - Field::create_field(2), - Field::create_field(3)}); + Field a = Array {1, 2, 3}; data->insert(a); @@ -287,19 +285,19 @@ TEST(FunctionVariantCast, CastFromVariant) { } TEST(FunctionVariantCast, CastVariantWithNull) { - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); auto int32_type = std::make_shared(); auto nullable_int32_type = std::make_shared(int32_type); // Create a variant column with nullable integer values - auto variant_col = ColumnVariant::create(true); + auto variant_col = ColumnObject::create(true); variant_col->create_root(nullable_int32_type, ColumnNullable::create(ColumnInt32::create(), ColumnUInt8::create())); MutableColumnPtr data = variant_col->get_root(); - data->insert(Field::create_field(42)); - data->insert(Field::create_field(Null())); - data->insert(Field::create_field(100)); + data->insert(42); + data->insert(Null()); + data->insert(100); ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, {nullptr, nullable_int32_type, "nullable_int32_type"}}; @@ -334,15 +332,15 @@ TEST(FunctionVariantCast, CastVariantWithNull) { TEST(FunctionVariantCast, CastFromVariantWithEmptyRoot) { // Test case 1: variant.empty() branch { - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); auto int32_type = std::make_shared(); MutableColumnPtr root = ColumnInt32::create(); - root->insert(Field::create_field(42)); - vectorized::ColumnVariant::Subcolumns dynamic_subcolumns; + root->insert(42); + vectorized::ColumnObject::Subcolumns dynamic_subcolumns; dynamic_subcolumns.add( - vectorized::PathInData(ColumnVariant::COLUMN_NAME_DUMMY), - vectorized::ColumnVariant::Subcolumn {root->get_ptr(), int32_type, true, true}); - auto variant_col = ColumnVariant::create(std::move(dynamic_subcolumns), true); + vectorized::PathInData(ColumnObject::COLUMN_NAME_DUMMY), + vectorized::ColumnObject::Subcolumn {root->get_ptr(), int32_type, true, true}); + auto variant_col = ColumnObject::create(0, std::move(dynamic_subcolumns)); variant_col->finalize(); ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, @@ -375,7 +373,7 @@ TEST(FunctionVariantCast, CastFromVariantWithEmptyRoot) { // object has sparse column auto int32_type = std::make_shared(); auto variant_col = construct_basic_varint_column(); - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, {nullptr, int32_type, "int32_type"}}; @@ -406,7 +404,7 @@ TEST(FunctionVariantCast, CastFromVariantWithEmptyRoot) { auto variant_col = construct_basic_varint_column(); auto string_type = std::make_shared(); - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); ColumnsWithTypeAndName arguments {{variant_col->get_ptr(), variant_type, "variant_col"}, {nullptr, string_type, "string_type"}}; @@ -439,7 +437,7 @@ TEST(FunctionVariantCast, CastFromVariantWithEmptyRoot) { auto nullable_variant_col = make_nullable(variant_col->get_ptr()); auto nullable_string_type = make_nullable(std::make_shared()); - auto variant_type = std::make_shared(); + auto variant_type = std::make_shared(); auto nullable_variant_type = make_nullable(variant_type); ColumnsWithTypeAndName arguments { @@ -465,4 +463,4 @@ TEST(FunctionVariantCast, CastFromVariantWithEmptyRoot) { } } -} // namespace doris::vectorized \ No newline at end of file +} // namespace doris::vectorized 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 a848f7165ab99d..065d86c039cc11 100644 --- a/be/test/vec/jsonb/convert_field_to_type_test.cpp +++ b/be/test/vec/jsonb/convert_field_to_type_test.cpp @@ -68,7 +68,7 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Int64) { // Test Int64 field using Field::dispatch pattern Int64 test_value = 12345; - Field int_field = Field::create_field(test_value); + Field int_field = test_value; Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, int_field); @@ -85,7 +85,7 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Int64) { // Verify it's an integer value ASSERT_TRUE(doc->getValue()->isInt64()); - ASSERT_EQ(doc->getValue()->int_val(), test_value); + ASSERT_EQ(((const JsonbIntVal*)doc->getValue())->val(), test_value); } TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_UInt64) { @@ -93,7 +93,7 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_UInt64) { // Test UInt64 field using Field::dispatch pattern UInt64 test_value = 12345; - Field uint_field = Field::create_field(test_value); + Field uint_field = test_value; Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, uint_field); @@ -110,7 +110,7 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_UInt64) { // Verify it's an integer value ASSERT_TRUE(doc->getValue()->isInt64()); - ASSERT_EQ(doc->getValue()->int_val(), static_cast(test_value)); + ASSERT_EQ(((const JsonbIntVal*)doc->getValue())->val(), static_cast(test_value)); } TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Float64) { @@ -118,7 +118,7 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Float64) { // Test Float64 field using Field::dispatch pattern Float64 test_value = 123.456; - Field double_field = Field::create_field(test_value); + Field double_field = test_value; Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, double_field); @@ -135,15 +135,14 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Float64) { // Verify it's a double value ASSERT_TRUE(doc->getValue()->isDouble()); - ASSERT_DOUBLE_EQ(doc->getValue()->unpack()->val(), test_value); + ASSERT_DOUBLE_EQ(((const JsonbDoubleVal*)doc->getValue())->val(), test_value); } TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_String) { JsonbWriter writer; // Test String field using Field::dispatch pattern - String test_value = "hello world"; - Field string_field = Field::create_field(test_value); + Field string_field = "hello world"; Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, string_field); @@ -160,18 +159,17 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_String) { // Verify it's a string value ASSERT_TRUE(doc->getValue()->isString()); - const auto* string_val = doc->getValue()->unpack(); + const auto* string_val = static_cast(doc->getValue()); std::string real_string(string_val->getBlob(), string_val->getBlobLen()); - ASSERT_EQ(real_string, test_value); + ASSERT_EQ(real_string, string_field.get()); } TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_JsonbField) { JsonbWriter writer; JsonBinaryValue jsonb_value; std::string test_data = R"({"a": ["1", "2"]})"; - THROW_IF_ERROR(jsonb_value.from_json_string(test_data)); - Field jsonb_field_obj = - Field::create_field(JsonbField(jsonb_value.value(), jsonb_value.size())); + THROW_IF_ERROR(jsonb_value.from_json_string(test_data.data(), test_data.size())); + Field jsonb_field_obj = JsonbField(jsonb_value.value(), jsonb_value.size()); // Test JsonbField using Field::dispatch pattern Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, @@ -197,11 +195,11 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Array) { // Create an array with mixed types Array array_field; - array_field.push_back(Field::create_field(123)); - array_field.push_back(Field::create_field("hello")); - array_field.push_back(Field::create_field(456.789)); + array_field.push_back(123); + array_field.push_back("hello"); + array_field.push_back(456.789); - Field array_obj = Field::create_field(array_field); + Field array_obj = array_field; // Test Array using Field::dispatch pattern Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, @@ -220,7 +218,8 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_Array) { // Verify it's an array value ASSERT_TRUE(doc->getValue()->isArray()); - ASSERT_EQ(doc->getValue()->numElements(), 3); + const ArrayVal& array = static_cast(*doc->getValue()); + ASSERT_EQ(array.numElem(), 3); } TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_NestedArray) { @@ -228,14 +227,14 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_NestedArray) { // Create a nested array Array inner_array; - inner_array.push_back(Field::create_field(1)); - inner_array.push_back(Field::create_field(2)); + inner_array.push_back(1); + inner_array.push_back(2); Array outer_array; - outer_array.push_back(Field::create_field(inner_array)); - outer_array.push_back(Field::create_field("nested")); + outer_array.push_back(inner_array); + outer_array.push_back("nested"); - Field nested_array_obj = Field::create_field(outer_array); + Field nested_array_obj = outer_array; // Test nested Array using Field::dispatch pattern Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, @@ -254,7 +253,8 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_NestedArray) { // Verify it's an array value ASSERT_TRUE(doc->getValue()->isArray()); - ASSERT_EQ(doc->getValue()->numElements(), 2); + const ArrayVal& array = static_cast(*doc->getValue()); + ASSERT_EQ(array.numElem(), 2); } TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_LargeInt) { @@ -262,7 +262,7 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_LargeInt) { // Test Int128 field using Field::dispatch pattern Int128 test_value = 1234567890123456789; - Field largeint_field = Field::create_field(test_value); + Field largeint_field = test_value; Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, largeint_field); @@ -279,7 +279,7 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_LargeInt) { // Verify it's an int128 value ASSERT_TRUE(doc->getValue()->isInt128()); - ASSERT_EQ(doc->getValue()->int_val(), test_value); + ASSERT_EQ(((const JsonbIntVal*)doc->getValue())->val(), test_value); } TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_UInt128) { @@ -287,7 +287,7 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_UInt128) { // Test UInt128 field using Field::dispatch pattern UInt128 test_value = 1234567890123456789; - Field uint128_field = Field::create_field(test_value); + Field uint128_field = test_value; Field::dispatch([&writer](const auto& value) { FieldVisitorToJsonb()(value, &writer); }, uint128_field); @@ -304,7 +304,7 @@ TEST_F(ConvertFieldToTypeTest, FieldVisitorToJsonb_UInt128) { // Verify it's an int128 value ASSERT_TRUE(doc->getValue()->isInt128()); - ASSERT_EQ(doc->getValue()->int_val(), static_cast(test_value)); + ASSERT_EQ(((const JsonbIntVal*)doc->getValue())->val(), static_cast(test_value)); } // Test convert_field_to_type function with JSONB type (similar to convert_field_to_typeImpl) @@ -314,12 +314,12 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { // Test converting Int64 to JSONB { Int64 test_value = 12345; - Field int_field = Field::create_field(test_value); + Field int_field = test_value; Field result; convert_field_to_type(int_field, jsonb_type, &result); - ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_EQ(result.get_type(), Field::Types::JSONB); ASSERT_FALSE(result.is_null()); const JsonbField& jsonb_result = result.get(); @@ -333,18 +333,17 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); ASSERT_NE(doc, nullptr); ASSERT_TRUE(doc->getValue()->isInt64()); - ASSERT_EQ(doc->getValue()->int_val(), test_value); + ASSERT_EQ(((const JsonbIntVal*)doc->getValue())->val(), test_value); } // Test converting String to JSONB { - String test_value = "hello world"; - Field string_field = Field::create_field(test_value); + Field string_field = "hello world"; Field result; convert_field_to_type(string_field, jsonb_type, &result); - ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_EQ(result.get_type(), Field::Types::JSONB); ASSERT_FALSE(result.is_null()); const JsonbField& jsonb_result = result.get(); @@ -358,24 +357,24 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); ASSERT_NE(doc, nullptr); ASSERT_TRUE(doc->getValue()->isString()); - const auto* string_val = doc->getValue()->unpack(); + const auto* string_val = static_cast(doc->getValue()); std::string real_string(string_val->getBlob(), string_val->getBlobLen()); - ASSERT_EQ(real_string, test_value); + ASSERT_EQ(real_string, string_field.get()); } // Test converting Array to JSONB { Array array_field; - array_field.push_back(Field::create_field(1)); - array_field.push_back(Field::create_field("test")); - array_field.push_back(Field::create_field(3.14)); + array_field.push_back(1); + array_field.push_back("test"); + array_field.push_back(3.14); - Field array_obj = Field::create_field(array_field); + Field array_obj = array_field; Field result; convert_field_to_type(array_obj, jsonb_type, &result); - ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_EQ(result.get_type(), Field::Types::JSONB); ASSERT_FALSE(result.is_null()); const JsonbField& jsonb_result = result.get(); @@ -389,7 +388,8 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); ASSERT_NE(doc, nullptr); ASSERT_TRUE(doc->getValue()->isArray()); - ASSERT_EQ(doc->getValue()->numElements(), 3); + const ArrayVal& array = static_cast(*doc->getValue()); + ASSERT_EQ(array.numElem(), 3); } // Test converting JSONB to JSONB (should be no-op) @@ -402,12 +402,12 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToJsonb) { auto* test_output = test_writer.getOutput(); JsonbField original_jsonb(test_output->getBuffer(), test_output->getSize()); - Field jsonb_field = Field::create_field(original_jsonb); + Field jsonb_field = original_jsonb; Field result; convert_field_to_type(jsonb_field, jsonb_type, &result); - ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_EQ(result.get_type(), Field::Types::JSONB); ASSERT_FALSE(result.is_null()); const JsonbField& jsonb_result = result.get(); @@ -436,13 +436,12 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToNullableJsonb) { // Test converting non-null field { - String test_value = "test string"; - Field string_field = Field::create_field(test_value); + Field string_field = "test string"; Field result; convert_field_to_type(string_field, *nullable_jsonb_type, &result); - ASSERT_EQ(result.get_type(), TYPE_JSONB); + ASSERT_EQ(result.get_type(), Field::Types::JSONB); ASSERT_FALSE(result.is_null()); const JsonbField& jsonb_result = result.get(); @@ -456,9 +455,9 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ToNullableJsonb) { ASSERT_TRUE(status.ok()) << "Failed to create JsonbDocument: " << status.to_string(); ASSERT_NE(doc, nullptr); ASSERT_TRUE(doc->getValue()->isString()); - const auto* string_val = doc->getValue()->unpack(); + const auto* string_val = static_cast(doc->getValue()); std::string real_string(string_val->getBlob(), string_val->getBlobLen()); - ASSERT_EQ(real_string, test_value); + ASSERT_EQ(real_string, string_field.get()); } } @@ -468,16 +467,16 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ArrayToJsonb) { // Create an array with mixed types that will be converted to JSONB Array array_field; - array_field.push_back(Field::create_field(123)); - array_field.push_back(Field::create_field("hello")); - array_field.push_back(Field::create_field(456.789)); + array_field.push_back(123); + array_field.push_back("hello"); + array_field.push_back(456.789); - Field array_obj = Field::create_field(array_field); + Field array_obj = array_field; Field result; convert_field_to_type(array_obj, *array_jsonb_type, &result); - ASSERT_EQ(result.get_type(), TYPE_ARRAY); + ASSERT_EQ(result.get_type(), Field::Types::Array); ASSERT_FALSE(result.is_null()); const Array& result_array = result.get(); @@ -485,7 +484,7 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ArrayToJsonb) { // Verify each element is converted to JSONB for (size_t i = 0; i < result_array.size(); ++i) { - ASSERT_EQ(result_array[i].get_type(), TYPE_JSONB); + ASSERT_EQ(result_array[i].get_type(), Field::Types::JSONB); ASSERT_FALSE(result_array[i].is_null()); const auto& jsonb_element = result_array[i].get(); @@ -508,7 +507,7 @@ TEST_F(ConvertFieldToTypeTest, ConvertFieldToType_ErrorCases) { // Test with unsupported types (should throw exception) { - Field tuple_field = Field::create_field(Tuple()); + Field tuple_field = Tuple(); EXPECT_THROW( { From 64cc626d0fc8e9b6c987ee57a07a5dc2be8d955d Mon Sep 17 00:00:00 2001 From: amorynan Date: Thu, 24 Jul 2025 14:42:18 +0800 Subject: [PATCH 05/11] fix ut cases and regress case out --- .../column_variant_allocated_bytes.out | 4 +- .../vec/columns/column_variant_byte_size.out | 4 +- .../column_variant_update_crc_with_value.out | 2 +- ...ant_update_crc_with_value_with_nullmap.out | 2 +- .../column_variant_update_crcs_with_value.out | 2 +- ...nt_update_crcs_with_value_with_nullmap.out | 2 +- ...olumn_variant_update_hashes_with_value.out | 2 +- ..._update_hashes_with_value_with_nullmap.out | 2 +- ...olumn_variant_update_xxHash_with_value.out | 2 +- ..._update_xxHash_with_value_with_nullmap.out | 2 +- be/test/vec/columns/column_object_test.cpp | 15 +- be/test/vec/columns/column_variant_test.cpp | 485 ++++++++---------- be/test/vec/jsonb/json_parser_test.cpp | 12 +- regression-test/data/variant_p0/nested2.out | 56 +- 14 files changed, 282 insertions(+), 310 deletions(-) diff --git a/be/test/expected_result/vec/columns/column_variant_allocated_bytes.out b/be/test/expected_result/vec/columns/column_variant_allocated_bytes.out index 346c07705acb6b..3aec885b6b837a 100644 --- a/be/test/expected_result/vec/columns/column_variant_allocated_bytes.out +++ b/be/test/expected_result/vec/columns/column_variant_allocated_bytes.out @@ -1,2 +1,2 @@ -column: variant with allocate size: 40073536 -40073536 \ No newline at end of file +column: variant with allocate size: 180480 +180480 \ No newline at end of file diff --git a/be/test/expected_result/vec/columns/column_variant_byte_size.out b/be/test/expected_result/vec/columns/column_variant_byte_size.out index 54e7a490f26b72..85e0a0b6fb5c85 100644 --- a/be/test/expected_result/vec/columns/column_variant_byte_size.out +++ b/be/test/expected_result/vec/columns/column_variant_byte_size.out @@ -1,2 +1,2 @@ -column: variant with byte_size: 21849217 -21849217 \ No newline at end of file +column: variant with byte_size: 1610 +1610 \ No newline at end of file diff --git a/be/test/expected_result/vec/columns/column_variant_update_crc_with_value.out b/be/test/expected_result/vec/columns/column_variant_update_crc_with_value.out index b2e93e82ac0454..26218ea29a0596 100644 --- a/be/test/expected_result/vec/columns/column_variant_update_crc_with_value.out +++ b/be/test/expected_result/vec/columns/column_variant_update_crc_with_value.out @@ -1 +1 @@ -column: variant with hashes: 589097515 with ptr: 2023 \ No newline at end of file +column: variant with hashes: 1798947085 with ptr: 15 \ No newline at end of file diff --git a/be/test/expected_result/vec/columns/column_variant_update_crc_with_value_with_nullmap.out b/be/test/expected_result/vec/columns/column_variant_update_crc_with_value_with_nullmap.out index b2e93e82ac0454..26218ea29a0596 100644 --- a/be/test/expected_result/vec/columns/column_variant_update_crc_with_value_with_nullmap.out +++ b/be/test/expected_result/vec/columns/column_variant_update_crc_with_value_with_nullmap.out @@ -1 +1 @@ -column: variant with hashes: 589097515 with ptr: 2023 \ No newline at end of file +column: variant with hashes: 1798947085 with ptr: 15 \ No newline at end of file diff --git a/be/test/expected_result/vec/columns/column_variant_update_crcs_with_value.out b/be/test/expected_result/vec/columns/column_variant_update_crcs_with_value.out index 6a347c4861a3be..18beb2922b85a3 100644 --- a/be/test/expected_result/vec/columns/column_variant_update_crcs_with_value.out +++ b/be/test/expected_result/vec/columns/column_variant_update_crcs_with_value.out @@ -1 +1 @@ -column: variant with hashes: [2554212050,875308879,875308879,531770243,2554212050,292727423,531770243,56215268,531770243,3870712440,2800491184,2110884430,875308879,2800491184,292727423,2110884430,292727423,2110884430,2800491184,292727423,875308879,531770243,3151753056,228149016,2554212050,228149016,531770243,3151753056,2800491184,531770243,292727423,2554212050,3151753056,2110884430,531770243,56215268,2554212050,56215268,875308879,2554212050,2110884430,875308879,292727423,3151753056,875308879,875308879,228149016,2800491184,56215268,3151753056,3870712440,228149016,875308879,531770243,875308879,228149016,56215268,2554212050,875308879,3151753056,2110884430,228149016,2800491184,2554212050,875308879,2554212050,2800491184,3870712440,2800491184,2554212050,3151753056,228149016,3870712440,3151753056,2110884430,531770243,2554212050,292727423,875308879,2800491184,56215268,56215268,3151753056,292727423,2110884430,3151753056,2554212050,875308879,875308879,2110884430,292727423,875308879,3151753056,875308879,56215268,56215268,228149016,531770243,2110884430,875308879,206457449,3056345527,206457449,945595961,3056345527,3757992959,945595961,2319820929,2319820929,2319820929,206457449,2298353109,945595961,2319820929,3757992959,2319820929,3757992959,945595961,206457449,328859107,3056345527,206457449,328859107,3757992959,3757992959,328859107,328859107,2319820929,3757992959,2319820929,2319820929,206457449,206457449,945595961,3757992959,2319820929,206457449,328859107,3757992959,2319820929,945595961,3056345527,328859107,3757992959,945595961,328859107,2319820929,3757992959,206457449,945595961,2298353109,3757992959,206457449,3757992959,3757992959,3757992959,3056345527,206457449,2319820929,328859107,2298353109,2319820929,3757992959,206457449,3757992959,945595961,945595961,2319820929,328859107,945595961,328859107,3757992959,3056345527,206457449,328859107,2319820929,2298353109,3757992959,2298353109,3757992959,206457449,206457449,945595961,945595961,328859107,2298353109,2319820929,3056345527,945595961,945595961,206457449,2298353109,3056345527,328859107,328859107,2298353109,945595961,3757992959,206457449,3056345527,2319820929,206457449,4021403194,3791554254,3163854069,2426113412,3791554254,875308879,1127013187,3791554254,3619212951,3490322757,3163854069,277161457,1127013187,2095449094,2675109342,875308879,3619212951,2675109342,2675109342,875308879,875308879,1127013187,3619212951,3791554254,2426113412,1127013187,3163854069,3490322757,4021403194,875308879,277161457,3490322757,3791554254,1127013187,3490322757,2675109342,1127013187,875308879,875308879,2675109342,875308879,2623587766,1412097454,3619212951,3163854069,277161457,277161457,2623587766,2675109342,1412097454,2426113412,1412097454,3619212951,4021403194,277161457,3791554254,277161457,2623587766,875308879,2623587766,875308879,1412097454,2095449094,4021403194,3791554254,2426113412,277161457,1412097454,2623587766,3791554254,875308879,2426113412,1127013187,2095449094,2426113412,3619212951,3791554254,875308879,3490322757,875308879,3619212951,3163854069,2675109342,1127013187,277161457,3163854069,2675109342,875308879,2426113412,3619212951,3619212951,2623587766,277161457,3619212951,4021403194,3163854069,875308879,2095449094,3791554254,875308879,206457449,2319820929,3713701357,2319820929,245036776,2319820929,1279925963,2319820929,245036776,245036776,2319820929,1009539744,2883643870,742946069,1730305250,2319820929,2319820929,1300901992,2319820929,1678724484,2319820929,214945855,245036776,245036776,245036776,245036776,841678387,1670232249,2319820929,2319820929,547614921,3487609301,2319820929,245036776,245036776,245036776,245036776,2319820929,267474682,322797428,1635050326,4093602497,245036776,406505130,3169709373,2319820929,2319820929,4122837106,3257513932,245036776,3845098914,431758952,2319820929,2319820929,1303248467,712118488,2319820929,245036776,3783471398,245036776,1459105707,2319820929,2750536968,3598211802,2690294081,2319820929,2319820929,4022517944,2319820929,3156540036,245036776,1529051518,580212272,2319820929,1406629871,3868366140,2061314429,1486118375,2319820929,245036776,245036776,3105009972,245036776,482959489,2319820929,2319820929,3497234092,2319820929,776725489,2319820929,2319820929,2319820929,2702811293,2067250681,3225084378,245036776,2319820929,2319820929,2559451111,245036776,245036776,206457449,67249588,1374168901,278858376,493873076,4084673981,510117270,41895437,3994559385,2555127593,3250213105,928455593,3358289013,3766879468,311209869,489673661,2473358398,702604066,3483693693,3992365999,995231258,2355745514,124854608,603212044,1374767497,2077502108,2435894610,2098772170,346519683,1033170558,331850287,1800229191,2850473336,2581242235,3660862272,1906913917,444858004,747394550,3386800584,1630132099,315928327,441132445,1792024794,2023003965,3620867491,2551513008,459508459,139336638,1942701061,362634791,328939274,145554324,1753982408,2271294770,1936003737,89298621,4179412613,1740696274,1824856044,3680855085,53713029,3703756410,3037548457,2069434675,1672208283,1417672719,3706234437,3058970945,175116829,1930213060,2314492291,2790068948,533083882,1031164277,2967055841,2141023153,930413770,3680357096,2226799062,26645633,4218756057,3914801163,1727687163,1296088894,1530836448,3821249527,3245532611,990818111,3876141276,1220614408,2054227140,4241979408,4291785431,4166164792,51196893,2585268663,1779998830,2354863292,2249433733,826731613,2463896152,206457449,2748280675,2867180464,2082937181,4149061331,2099880093,1032205427,1407175194,2070838713,2956635482,775450823,1764346396,464873018,4197248635,3066494737,305703413,4122580484,2976410684,448194140,577223695,398579960,542052957,492960350,3828594757,2994885838,1041219030,3851524682,3584388331,742373584,2776564824,3811826576,2445896331,723554865,2151830432,3843821359,1856264448,2953999226,1062978595,1191821944,3645680821,4277896305,3967840170,487070360,2144162949,3666809638,2727438070,4091024743,627340099,3782695377,1433204595,2097054820,4206074941,3696785896,610751379,1946573589,258060547,1040224730,4070965387,219516606,1883164268,1480815107,3226098148,3832624963,3566399922,2252829153,4294209566,478849194,406806657,115301336,2466060304,388832831,2488449901,1835453450,573857157,4078818841,450039442,2582822604,1582363514,4282480438,376220919,2338592051,2443548964,1351323832,1527886681,2165079909,540325740,1596611261,3020329245,492966275,2891506631,1090090457,1741256643,2304226637,2517016051,1665171572,1388868895,2708270850,4037423082,4161684819,2945360105,4158062928,206457449,1345573618,3294698430,378146796,3185691525,1423314999,1183050335,480857483,1408866085,1493282984,3431121339,3214119743,1368028177,3096074533,2517522693,1428011979,876438143,1179497848,2896669809,3682592894,91860740,2538141008,1510397830,3558318554,258448067,3373588885,860042355,26591778,13119206,101986143,526354237,311602139,3898387972,3758964934,2259930920,1182835455,2678094366,1432991366,613027639,659293075,1762314514,870611657,87229789,3909108025,2229049529,3346369163,325316551,4040989397,2373436217,2014520177,3081986421,382312077,1529995627,407359062,1254877325,3621778471,1379689530,1878459704,796144100,3710114079,1310142038,167357536,3609738832,2110590438,558286277,2778379400,552088448,4274230435,1886171114,60500785,420070033,508639587,920507012,1822591205,1607557072,3598461969,2989081635,2143711504,3362061505,49120483,469268260,1094200285,2716641541,3926729610,3500875291,2070218613,994264319,3003013923,2737165219,2820669757,3264030361,3841849258,3828978277,2000173223,1047337437,4115826722,2834181023,2704725137,2617232942,647298667,3460677237,206457449,1414685303,2813937614,2901078141,1532729846,2859905828,2200012577,3272290859,2444743282,1554730084,4094558761,133111019,2291197489,2179555965,320692009,423841797,504820025,3739686110,1178819725,2064719274,910189826,3110076068,2208769826,1825010326,189240667,1030690039,307014201,2391842575,2705582881,4252622119,286338150,4256089001,627119804,1912458957,914594658,1202723850,2884624326,2953656934,2356643939,1316258088,3292616938,2291516901,2039140483,3361174774,1334785676,938622134,3304121425,492435535,3097850075,691428779,1722151639,2854640227,2180729195,453565981,1323383568,1585593336,2994120931,3958335651,1591776982,3288501029,2346149589,4259089829,1864734593,3871605789,1960989965,963226321,3945165668,342197097,1343697553,2280403218,2198020726,1285884102,1364846818,1403304002,3004101998,3323310895,370144009,3517501029,1574875705,996916007,2742452765,1447055554,932546527,3572722038,1523493791,3248309364,3057170206,2264295711,1219832710,3308569139,3875254499,4221306161,944437261,1997306780,3819854753,4155030316,1951560538,3562695020,3833379694,2398248102,859400795,206457449,586273093,2780652753,2680113714,1773758786,4008527109,76693294,3445470153,2230128116,610023151,2254289049,3516495266,3638535591,1640147303,2611385124,1474143607,4277898838,2544574348,2920531045,1651627666,3096906132,1109418414,1272607332,3558276441,4001251850,1853667602,3153067471,3376826283,833655042,649890420,1381779966,2762932088,4118442646,2229401252,2056880485,1367429367,460965382,3669515733,1895403420,4142214177,2149040443,2026163865,621350301,2237464843,3370456853,3554534417,4125643904,496300840,1724670675,2060169664,1473730961,3336443673,2148399092,142054238,2934782596,1976905911,929272261,35319753,151664381,3488982785,1964740070,2254583586,2995133683,2985698643,3635372961,2038537299,2794178320,3934346811,1489348399,289197795,472840993,972088917,3034283066,2002616865,2050904600,3675181228,2359665738,807778350,1446174511,397502410,4170831501,2838025206,2135226869,3385752098,2650410162,2408989388,4249125116,3082097533,3160863422,2806925465,2047480711,1976351517,1502221440,4192483547,148295083,859667339,2304012676,559644530,2094781430,4284054802,877483186,206457449,1543479607,1623852772,1200339416,3452768322,4101954484,1891005294,832522794,2490725772,1516869969,741082233,3525252428,648595206,787608786,367660334,3232946092,2365489049,3520069691,3067396810,1380813486,3902100686,1583117055,3255888701,332586483,1722357400,1025234648,1917840703,4208477937,2503059493,4196592508,123072718,1779146460,336534863,3833374748,1258294211,3037352014,902375425,2699728898,1107960807,2960235333,686841250,1253670241,3611398425,300003307,3275723956,1722329870,4016563383,2393364765,20619610,1821607923,3768975201,2588586243,1941085989,2583249593,1688029982,1311518897,2237137881,3178278715,248288265,4252844413,3492370864,570015702,2342178781,2277986712,1056589020,2850675174,4206010791,2397297016,2437959081,2300302384,78388062,1909002967,2560110849,3461394646,3262026191,4148906538,2860512422,1642349388,1136092621,416007853,1857488008,2879205135,3520515329,1493291595,2536071434,4058199183,2027958178,2471385042,653320474,3179477944,2405562929,3503632665,2981318173,4092901441,2958068435,808052333,2234092015,3201315011,719105991,2758923429,1607093053,206457449,2504253262,3221731621,4138116967,4047978730,1981936204,2662622614,4250300161,532107163,4139604717,2845626768,2634574568,2118457233,2461513648,136121454,2466636660,1235331192,328616453,379137167,2178098163,333131000,77216278,1022169511,483168068,2513190500,2118741853,2067071349,2993184276,3088846864,1017085015,3092714149,3799184350,1505169366,4148622906,782699919,913888614,1105380460,520648220,77735972,668758974,2797500659,3661418919,1178033045,769249798,2943619758,4262721481,841965513,3517970171,2881341813,102057303,516122003,2886784766,1645896517,2417037267,558213430,2490018740,2536907375,2237649961,4233230969,1569200720,1737142861,3974101780,501726567,3361714925,2031258140,2289594218,2628270799,2216751055,4136030199,680387854,2645589857,658640767,1652217574,4243589284,1866550853,2857890100,1902208495,74441735,1298355828,4143343238,3517694781,2401012792,2622452926,3615674763,306687041,321250262,2519774351,842188974,3636159160,2178903250,1996758042,1384287304,2682994673,366624830,508166510,2112134979,927452354,2463572392,3402553678,4189472030,1337503874,206457449,3032063267,3180023468,1330670630,752164716,3721034069,1020707302,450403796,2791439709,4074087820,1886419370,3374557386,1004591396,4223068477,3504826099,3604870005,4067963457,3191465714,887647332,4206345917,3984969219,2518590073,2513076239,813553514,2173354413,210805432,132504387,2449236133,3445577680,885220620,1277731609,3466004452,1219295719,1456997661,2671664644,589161099,4175291491,3103048275,3559574932,2010162063,1288062381,2255004426,1327782019,3332002552,1636029333,2198817937,3220362662,720670463,2301560229,1891004091,987589065,1211735278,1925736029,1906344575,4055043644,3487650772,957243158,388910951,2538008042,3936262936,1437838506,504456778,951680078,1637856878,550986028,4220980273,1951268071,1153860947,789908551,4265692009,1055497872,1200034959,2913792944,3984531739,2650759913,1968432145,2503976839,593782125,126694130,3363965637,2562837473,1749355939,2513972350,4036937795,476393019,100785358,1940512063,379791877,817979114,3583149009,2131504573,1114091412,3353324513,3285811021,2884745593,105752092,559005301,920034199,3734712174,499053010,2137642994,206457449,2826719869,2902727516,1353774415,2909899152,2635280248,2125995537,2263332483,496574273,1452562650,147166725,2095966466,3824591196,877147297,2841334749,3650797078,1161532474,3462379257,791892796,3166482806,2669390317,971645909,113320512,1691056601,525518058,4248529866,4040006658,318098151,47311495,144136574,659670992,2628932269,4100724232,3971335876,2333752421,3607930785,1695159085,2439371481,3656075645,3931217103,2541279706,134574241,2986916429,694765959,343809494,513531178,1212950893,1485542661,3045785941,3390037998,2765011567,2184410254,3807865614,2386318531,469410773,2676559786,50328130,1022148800,1302681424,3581391476,1502490664,4023807872,2823088750,2535351889,2669608004,292548278,2579784934,2951049635,2693974051,4205324354,1735288325,560846941,3768744133,3942289663,3764113566,1440832283,1922919402,2810220835,1419767515,1025461365,1763597085,3544673147,21291497,198194479,1808737022,3146635070,2090194209,3927963304,3756335770,3776902050,1514861710,3456076285,1755737810,3572729260,519644623,174203428,1212253972,827443957,2015547805,990131342,4018910035,206457449,1129589072,2405141982,3976825593,502258043,1684147899,985241115,3627755204,1391658953,2697428081,3445515327,2909062841,2186080306,820321405,1182522163,1083615597,3059869413,4012655931,2419829086,346675351,2073448371,960543535,2373731667,160497703,2324207050,2991319902,721186577,51203289,1411207634,3944862321,4147819689,1080845277,3499051655,2579860710,1168675663,3488205518,3272551614,2828339759,142143685,202000959,1277263562,1836973773,1402894277,602941350,3846224758,854664663,157671949,593108945,3896636281,1660527604,2634387200,1774623183,3563922671,1861945939,2108722837,3001577736,3228368517,1649416669,488415365,2421238948,3276369529,3870114877,1052870429,1964376054,4001658974,223637186,236065860,3728709979,824841293,3282684254,2135402296,3181310287,224156543,4047097881,1921638069,1245909538,2545495839,4201577132,927479840,21808745,2375964203,1855530961,663654798,2327522375,3436559643,3972476363,1796038791,3412292640,665920389,4084102783,1978864640,1028074236,3570542100,680755905,1720735767,3440130210,2160560022,4178334004,3439992401,1002513365,4106626746,206457449,570959513,1845891023,1082206857,2292420689,3015589199,1586590940,252307581,3995642832,4056608193,3532549782,3785202773,2994120081,3385931907,2594836086,978384718,2288229392,3484735508,613938396,1935047887,3167922379,3383879321,884815608,2591950692,2420562279,664849709,1482930065,2452025110,3916121625,2533686980,3874848372,1839960482,864802052,2585765133,2509710336,2949023734,4041555081,614764712,357827858,494250421,1188690926,4142823156,1630008603,3400322008,944621441,2226831594,2167042389,2383038264,890705592,1661484375,1190285329,94851063,838486941,3370514968,4180526679,1034105614,3745702667,4177870618,748153924,374844961,3589498025,2574261783,1537640624,2622723396,1023370039,6493352,47842930,3211819738,2137755945,3395749632,1631753976,188320975,1594081719,2636523635,510136952,569361861,1545520159,1970116388,451765803,2001850641,554993480,2482692526,3635468988,1452927069,262116055,2722031037,3765110402,1499077412,1371107481,3470938935,2076146184,3976227470,3758898342,1447386958,2017176531,2310978965,855527705,681899184,2335731603,3000518325,2802367611,206457449,3021264169,2295023062,3838403096,938000149,3363150311,1554413877,1061818400,2333585828,125569476,2018186247,2247190766,2378639145,2921473878,4195640378,4084579436,1803083737,3816856583,2869739251,3925857438,1608947136,3628193229,1843400121,3794811046,1029301525,2173834746,3539051550,3533088751,3291536648,1979246517,3264079265,3630276139,3989210326,3531004169,2600101248,4067365153,2870914831,83721768,1636306841,3443345416,1768866748,1951379984,1186926211,3546241343,245311504,2802048760,3811321184,4078211185,3835590560,1327794254,3200644169,558293665,2074508198,2562698699,2247291833,3308987037,707693197,596583966,2641991082,680241824,3396293828,907056801,2918140953,235845036,2823653998,2815955782,3364624074,3581922704,3929280403,2299126203,441713172,172055577,1047883644,3215331856,17023473,171518934,963302819,1984579778,1209123557,1024689190,491092592,3004427155,435837519,1081926906,907764457,4269328547,1956493656,3657928477,1810175987,823435541,2604246256,4215412858,3462733195,2878461239,587037609,2186655728,3423176780,1850140462,2786128140,492724128,819017142,206457449,3840582516,1726336082,796275036,1656814955,1278252296,3532948312,3047746900,1912773744,2265528748,2383537969,1970064039,994709720,775827299,4238301744,2427859654,3521858632,717693859,1341310026,948657049,2434716452,3820374817,3830169193,4223621165,3835814084,2129306260,3823189164,3774406987,1270114338,1149392844,810421500,1190018960,645472477,812581690,2502781279,2333056774,187546263,3721081497,2533237797,4111336540,3082363818,2976621809,1975185597,2302372191,2944259131,1555021835,3966341202,3317050781,4031926936,1522198478,10140956,2186759424,735192325,2721177514,1793377375,979226602,444306099,3083593470,1117910115,179103027,4232700009,578970919,3532875650,2434036489,2028506151,156774632,1738905878,2109868196,3084516400,273672247,3559694832,3945358933,3546002343,1219301393,3255570744,103015186,544112669,2383100041,2928491285,691418679,2672276637,3800893488,905181382,1083407191,466398245,3309358590,137776317,928599029,1948485208,2276692469,3982284320,4123832281,4273421340,1469726456,2371969769,1144262467,2800837570,3736573449,1559780489,2850528971,4087826563,206457449,3286617731,3315904549,3504038238,2725194855,2919636469,2569261728,702645068,1915709852,2820671384,4194993065,1102211073,682094338,1156055943,344937906,755867173,2359503506,2706926051,197034170,3283147392,3586712310,2243014692,2477552430,1954173349,1509530906,2367184696,665209419,466979892,4118130364,2340116782,3242808821,1441322912,3775594217,3796230751,1217472085,2627937741,864022282,3701143642,367380892,2052437450,2593127739,1525753682,4139714735,3054998187,3140308115,3391194463,1611873134,3039866697,1708458571,1103796577,3023149539,2215912659,37802407,3350081975,2120645554,1670446160,1168489623,3490248816,2883212862,1446943054,3927845059,3087005062,990756133,2298508580,1152806520,3448986801,2566858668,1339880832,2371304710,1532931056,3785564218,299238820,364447274,3616979377,1524081259,2312401713,2627709959,1405876789,983254786,1281915258,1857303741,2141402630,733432787,461621176,1850655169,2112453159,236747234,3532192758,3142860129,3396679610,2824663257,10535378,2054646724,3277425368,3669633561,2012938901,2901346029,3435997522,4043345446,2533485309,369961474,206457449,2487822315,925319305,26271320,3394442418,492437815,1618134347,2914572416,54300775,1701291028,2760879152,183861836,3051646161,3456232777,92250378,1568308348,1621032850,1086907225,93119257,757790626,2160747866,65138674,2060022439,1208212549,218110360,970384459,4030784540,1704022876,1712554165,2603408210,1474168756,3459700896,2693341688,599786471,1887595420,3337371899,1402094845,1543905172,3808612093,565559513,1359857941,3837892266,3791143668,4136352293,3257718525,643842770,3397011783,3380592465,3332371411,1665795395,3017242150,2507637823,3930086996,1824176537,3285110893,2135260629,541614863,1815454524,3744520770,717051235,4263050656,3029216293,3874979871,1386896974,2696612159,3173897028,2974099401,3904641079,1881270347,2179480591,3783564256,666793191,3130257659,3190258560,3699854386,2110117912,3463754417,2920040274,406752582,3695690411,3113513260,558558841,688773616,3951374647,334085688,2065273351,3314681355,3570176103,2098913835,248467573,264044995,1920431865,1324517942,2348556741,2893416182,3992145933,1511831152,3299534113,2604105144,1215990666,2188144004,206457449,206457449,2427203324,2086843597,1885146884,1802050502,1802050502,2691621139,359523162,206457449,3309756800,2691621139,622711149,3854977387,1802050502,2295212953,206457449,2528944420,1540564141,672750835,1496104690,2965134651,610986707,3772477729,1802050502,2416798067,2997411081,206457449,2915360655,2359238647,3257110270,1979167548,1561512230,2615438422,2691621139,4152978262,1214009647,2426944005,2356524632,4012152653,2789527903,3755526275,3959912765,1510552865,881469330,3376442226,598649648,1412818241,2877185557,3615020741,3194181018,538765210,3065469854,4112728136,206457449,2474042631,143640946,671164977,3450502787,1787375796,707365176,8869712,3519166804,528924031,2535809062,2691621139,2721025795,2099986723,1694463263,529367024,394222788,2321287545,2939906446,4178483068,1177707551,1802050502,3761044270,2691621139,1417998721,1504078074,839637312,10857459,1306693788,1802050502,2072393547,2427009607,3647056391,3482051343,206457449,2691621139,2691505154,1441928267,403168972,3094669022,3061896921,3766052999,2790876178,1916938811,3744186645,1879149857,1068786317,1819868121,478742297,2099986723,206457449] \ No newline at end of file +column: variant with hashes: [1609492067,1609492067,1609492067,1609492067,1609492067,3450695186,3450695186,3450695186,3450695186,3450695186,1212465068,1212465068,1212465068,1212465068,1212465068] \ No newline at end of file diff --git a/be/test/expected_result/vec/columns/column_variant_update_crcs_with_value_with_nullmap.out b/be/test/expected_result/vec/columns/column_variant_update_crcs_with_value_with_nullmap.out index 6a347c4861a3be..18beb2922b85a3 100644 --- a/be/test/expected_result/vec/columns/column_variant_update_crcs_with_value_with_nullmap.out +++ b/be/test/expected_result/vec/columns/column_variant_update_crcs_with_value_with_nullmap.out @@ -1 +1 @@ -column: variant with hashes: [2554212050,875308879,875308879,531770243,2554212050,292727423,531770243,56215268,531770243,3870712440,2800491184,2110884430,875308879,2800491184,292727423,2110884430,292727423,2110884430,2800491184,292727423,875308879,531770243,3151753056,228149016,2554212050,228149016,531770243,3151753056,2800491184,531770243,292727423,2554212050,3151753056,2110884430,531770243,56215268,2554212050,56215268,875308879,2554212050,2110884430,875308879,292727423,3151753056,875308879,875308879,228149016,2800491184,56215268,3151753056,3870712440,228149016,875308879,531770243,875308879,228149016,56215268,2554212050,875308879,3151753056,2110884430,228149016,2800491184,2554212050,875308879,2554212050,2800491184,3870712440,2800491184,2554212050,3151753056,228149016,3870712440,3151753056,2110884430,531770243,2554212050,292727423,875308879,2800491184,56215268,56215268,3151753056,292727423,2110884430,3151753056,2554212050,875308879,875308879,2110884430,292727423,875308879,3151753056,875308879,56215268,56215268,228149016,531770243,2110884430,875308879,206457449,3056345527,206457449,945595961,3056345527,3757992959,945595961,2319820929,2319820929,2319820929,206457449,2298353109,945595961,2319820929,3757992959,2319820929,3757992959,945595961,206457449,328859107,3056345527,206457449,328859107,3757992959,3757992959,328859107,328859107,2319820929,3757992959,2319820929,2319820929,206457449,206457449,945595961,3757992959,2319820929,206457449,328859107,3757992959,2319820929,945595961,3056345527,328859107,3757992959,945595961,328859107,2319820929,3757992959,206457449,945595961,2298353109,3757992959,206457449,3757992959,3757992959,3757992959,3056345527,206457449,2319820929,328859107,2298353109,2319820929,3757992959,206457449,3757992959,945595961,945595961,2319820929,328859107,945595961,328859107,3757992959,3056345527,206457449,328859107,2319820929,2298353109,3757992959,2298353109,3757992959,206457449,206457449,945595961,945595961,328859107,2298353109,2319820929,3056345527,945595961,945595961,206457449,2298353109,3056345527,328859107,328859107,2298353109,945595961,3757992959,206457449,3056345527,2319820929,206457449,4021403194,3791554254,3163854069,2426113412,3791554254,875308879,1127013187,3791554254,3619212951,3490322757,3163854069,277161457,1127013187,2095449094,2675109342,875308879,3619212951,2675109342,2675109342,875308879,875308879,1127013187,3619212951,3791554254,2426113412,1127013187,3163854069,3490322757,4021403194,875308879,277161457,3490322757,3791554254,1127013187,3490322757,2675109342,1127013187,875308879,875308879,2675109342,875308879,2623587766,1412097454,3619212951,3163854069,277161457,277161457,2623587766,2675109342,1412097454,2426113412,1412097454,3619212951,4021403194,277161457,3791554254,277161457,2623587766,875308879,2623587766,875308879,1412097454,2095449094,4021403194,3791554254,2426113412,277161457,1412097454,2623587766,3791554254,875308879,2426113412,1127013187,2095449094,2426113412,3619212951,3791554254,875308879,3490322757,875308879,3619212951,3163854069,2675109342,1127013187,277161457,3163854069,2675109342,875308879,2426113412,3619212951,3619212951,2623587766,277161457,3619212951,4021403194,3163854069,875308879,2095449094,3791554254,875308879,206457449,2319820929,3713701357,2319820929,245036776,2319820929,1279925963,2319820929,245036776,245036776,2319820929,1009539744,2883643870,742946069,1730305250,2319820929,2319820929,1300901992,2319820929,1678724484,2319820929,214945855,245036776,245036776,245036776,245036776,841678387,1670232249,2319820929,2319820929,547614921,3487609301,2319820929,245036776,245036776,245036776,245036776,2319820929,267474682,322797428,1635050326,4093602497,245036776,406505130,3169709373,2319820929,2319820929,4122837106,3257513932,245036776,3845098914,431758952,2319820929,2319820929,1303248467,712118488,2319820929,245036776,3783471398,245036776,1459105707,2319820929,2750536968,3598211802,2690294081,2319820929,2319820929,4022517944,2319820929,3156540036,245036776,1529051518,580212272,2319820929,1406629871,3868366140,2061314429,1486118375,2319820929,245036776,245036776,3105009972,245036776,482959489,2319820929,2319820929,3497234092,2319820929,776725489,2319820929,2319820929,2319820929,2702811293,2067250681,3225084378,245036776,2319820929,2319820929,2559451111,245036776,245036776,206457449,67249588,1374168901,278858376,493873076,4084673981,510117270,41895437,3994559385,2555127593,3250213105,928455593,3358289013,3766879468,311209869,489673661,2473358398,702604066,3483693693,3992365999,995231258,2355745514,124854608,603212044,1374767497,2077502108,2435894610,2098772170,346519683,1033170558,331850287,1800229191,2850473336,2581242235,3660862272,1906913917,444858004,747394550,3386800584,1630132099,315928327,441132445,1792024794,2023003965,3620867491,2551513008,459508459,139336638,1942701061,362634791,328939274,145554324,1753982408,2271294770,1936003737,89298621,4179412613,1740696274,1824856044,3680855085,53713029,3703756410,3037548457,2069434675,1672208283,1417672719,3706234437,3058970945,175116829,1930213060,2314492291,2790068948,533083882,1031164277,2967055841,2141023153,930413770,3680357096,2226799062,26645633,4218756057,3914801163,1727687163,1296088894,1530836448,3821249527,3245532611,990818111,3876141276,1220614408,2054227140,4241979408,4291785431,4166164792,51196893,2585268663,1779998830,2354863292,2249433733,826731613,2463896152,206457449,2748280675,2867180464,2082937181,4149061331,2099880093,1032205427,1407175194,2070838713,2956635482,775450823,1764346396,464873018,4197248635,3066494737,305703413,4122580484,2976410684,448194140,577223695,398579960,542052957,492960350,3828594757,2994885838,1041219030,3851524682,3584388331,742373584,2776564824,3811826576,2445896331,723554865,2151830432,3843821359,1856264448,2953999226,1062978595,1191821944,3645680821,4277896305,3967840170,487070360,2144162949,3666809638,2727438070,4091024743,627340099,3782695377,1433204595,2097054820,4206074941,3696785896,610751379,1946573589,258060547,1040224730,4070965387,219516606,1883164268,1480815107,3226098148,3832624963,3566399922,2252829153,4294209566,478849194,406806657,115301336,2466060304,388832831,2488449901,1835453450,573857157,4078818841,450039442,2582822604,1582363514,4282480438,376220919,2338592051,2443548964,1351323832,1527886681,2165079909,540325740,1596611261,3020329245,492966275,2891506631,1090090457,1741256643,2304226637,2517016051,1665171572,1388868895,2708270850,4037423082,4161684819,2945360105,4158062928,206457449,1345573618,3294698430,378146796,3185691525,1423314999,1183050335,480857483,1408866085,1493282984,3431121339,3214119743,1368028177,3096074533,2517522693,1428011979,876438143,1179497848,2896669809,3682592894,91860740,2538141008,1510397830,3558318554,258448067,3373588885,860042355,26591778,13119206,101986143,526354237,311602139,3898387972,3758964934,2259930920,1182835455,2678094366,1432991366,613027639,659293075,1762314514,870611657,87229789,3909108025,2229049529,3346369163,325316551,4040989397,2373436217,2014520177,3081986421,382312077,1529995627,407359062,1254877325,3621778471,1379689530,1878459704,796144100,3710114079,1310142038,167357536,3609738832,2110590438,558286277,2778379400,552088448,4274230435,1886171114,60500785,420070033,508639587,920507012,1822591205,1607557072,3598461969,2989081635,2143711504,3362061505,49120483,469268260,1094200285,2716641541,3926729610,3500875291,2070218613,994264319,3003013923,2737165219,2820669757,3264030361,3841849258,3828978277,2000173223,1047337437,4115826722,2834181023,2704725137,2617232942,647298667,3460677237,206457449,1414685303,2813937614,2901078141,1532729846,2859905828,2200012577,3272290859,2444743282,1554730084,4094558761,133111019,2291197489,2179555965,320692009,423841797,504820025,3739686110,1178819725,2064719274,910189826,3110076068,2208769826,1825010326,189240667,1030690039,307014201,2391842575,2705582881,4252622119,286338150,4256089001,627119804,1912458957,914594658,1202723850,2884624326,2953656934,2356643939,1316258088,3292616938,2291516901,2039140483,3361174774,1334785676,938622134,3304121425,492435535,3097850075,691428779,1722151639,2854640227,2180729195,453565981,1323383568,1585593336,2994120931,3958335651,1591776982,3288501029,2346149589,4259089829,1864734593,3871605789,1960989965,963226321,3945165668,342197097,1343697553,2280403218,2198020726,1285884102,1364846818,1403304002,3004101998,3323310895,370144009,3517501029,1574875705,996916007,2742452765,1447055554,932546527,3572722038,1523493791,3248309364,3057170206,2264295711,1219832710,3308569139,3875254499,4221306161,944437261,1997306780,3819854753,4155030316,1951560538,3562695020,3833379694,2398248102,859400795,206457449,586273093,2780652753,2680113714,1773758786,4008527109,76693294,3445470153,2230128116,610023151,2254289049,3516495266,3638535591,1640147303,2611385124,1474143607,4277898838,2544574348,2920531045,1651627666,3096906132,1109418414,1272607332,3558276441,4001251850,1853667602,3153067471,3376826283,833655042,649890420,1381779966,2762932088,4118442646,2229401252,2056880485,1367429367,460965382,3669515733,1895403420,4142214177,2149040443,2026163865,621350301,2237464843,3370456853,3554534417,4125643904,496300840,1724670675,2060169664,1473730961,3336443673,2148399092,142054238,2934782596,1976905911,929272261,35319753,151664381,3488982785,1964740070,2254583586,2995133683,2985698643,3635372961,2038537299,2794178320,3934346811,1489348399,289197795,472840993,972088917,3034283066,2002616865,2050904600,3675181228,2359665738,807778350,1446174511,397502410,4170831501,2838025206,2135226869,3385752098,2650410162,2408989388,4249125116,3082097533,3160863422,2806925465,2047480711,1976351517,1502221440,4192483547,148295083,859667339,2304012676,559644530,2094781430,4284054802,877483186,206457449,1543479607,1623852772,1200339416,3452768322,4101954484,1891005294,832522794,2490725772,1516869969,741082233,3525252428,648595206,787608786,367660334,3232946092,2365489049,3520069691,3067396810,1380813486,3902100686,1583117055,3255888701,332586483,1722357400,1025234648,1917840703,4208477937,2503059493,4196592508,123072718,1779146460,336534863,3833374748,1258294211,3037352014,902375425,2699728898,1107960807,2960235333,686841250,1253670241,3611398425,300003307,3275723956,1722329870,4016563383,2393364765,20619610,1821607923,3768975201,2588586243,1941085989,2583249593,1688029982,1311518897,2237137881,3178278715,248288265,4252844413,3492370864,570015702,2342178781,2277986712,1056589020,2850675174,4206010791,2397297016,2437959081,2300302384,78388062,1909002967,2560110849,3461394646,3262026191,4148906538,2860512422,1642349388,1136092621,416007853,1857488008,2879205135,3520515329,1493291595,2536071434,4058199183,2027958178,2471385042,653320474,3179477944,2405562929,3503632665,2981318173,4092901441,2958068435,808052333,2234092015,3201315011,719105991,2758923429,1607093053,206457449,2504253262,3221731621,4138116967,4047978730,1981936204,2662622614,4250300161,532107163,4139604717,2845626768,2634574568,2118457233,2461513648,136121454,2466636660,1235331192,328616453,379137167,2178098163,333131000,77216278,1022169511,483168068,2513190500,2118741853,2067071349,2993184276,3088846864,1017085015,3092714149,3799184350,1505169366,4148622906,782699919,913888614,1105380460,520648220,77735972,668758974,2797500659,3661418919,1178033045,769249798,2943619758,4262721481,841965513,3517970171,2881341813,102057303,516122003,2886784766,1645896517,2417037267,558213430,2490018740,2536907375,2237649961,4233230969,1569200720,1737142861,3974101780,501726567,3361714925,2031258140,2289594218,2628270799,2216751055,4136030199,680387854,2645589857,658640767,1652217574,4243589284,1866550853,2857890100,1902208495,74441735,1298355828,4143343238,3517694781,2401012792,2622452926,3615674763,306687041,321250262,2519774351,842188974,3636159160,2178903250,1996758042,1384287304,2682994673,366624830,508166510,2112134979,927452354,2463572392,3402553678,4189472030,1337503874,206457449,3032063267,3180023468,1330670630,752164716,3721034069,1020707302,450403796,2791439709,4074087820,1886419370,3374557386,1004591396,4223068477,3504826099,3604870005,4067963457,3191465714,887647332,4206345917,3984969219,2518590073,2513076239,813553514,2173354413,210805432,132504387,2449236133,3445577680,885220620,1277731609,3466004452,1219295719,1456997661,2671664644,589161099,4175291491,3103048275,3559574932,2010162063,1288062381,2255004426,1327782019,3332002552,1636029333,2198817937,3220362662,720670463,2301560229,1891004091,987589065,1211735278,1925736029,1906344575,4055043644,3487650772,957243158,388910951,2538008042,3936262936,1437838506,504456778,951680078,1637856878,550986028,4220980273,1951268071,1153860947,789908551,4265692009,1055497872,1200034959,2913792944,3984531739,2650759913,1968432145,2503976839,593782125,126694130,3363965637,2562837473,1749355939,2513972350,4036937795,476393019,100785358,1940512063,379791877,817979114,3583149009,2131504573,1114091412,3353324513,3285811021,2884745593,105752092,559005301,920034199,3734712174,499053010,2137642994,206457449,2826719869,2902727516,1353774415,2909899152,2635280248,2125995537,2263332483,496574273,1452562650,147166725,2095966466,3824591196,877147297,2841334749,3650797078,1161532474,3462379257,791892796,3166482806,2669390317,971645909,113320512,1691056601,525518058,4248529866,4040006658,318098151,47311495,144136574,659670992,2628932269,4100724232,3971335876,2333752421,3607930785,1695159085,2439371481,3656075645,3931217103,2541279706,134574241,2986916429,694765959,343809494,513531178,1212950893,1485542661,3045785941,3390037998,2765011567,2184410254,3807865614,2386318531,469410773,2676559786,50328130,1022148800,1302681424,3581391476,1502490664,4023807872,2823088750,2535351889,2669608004,292548278,2579784934,2951049635,2693974051,4205324354,1735288325,560846941,3768744133,3942289663,3764113566,1440832283,1922919402,2810220835,1419767515,1025461365,1763597085,3544673147,21291497,198194479,1808737022,3146635070,2090194209,3927963304,3756335770,3776902050,1514861710,3456076285,1755737810,3572729260,519644623,174203428,1212253972,827443957,2015547805,990131342,4018910035,206457449,1129589072,2405141982,3976825593,502258043,1684147899,985241115,3627755204,1391658953,2697428081,3445515327,2909062841,2186080306,820321405,1182522163,1083615597,3059869413,4012655931,2419829086,346675351,2073448371,960543535,2373731667,160497703,2324207050,2991319902,721186577,51203289,1411207634,3944862321,4147819689,1080845277,3499051655,2579860710,1168675663,3488205518,3272551614,2828339759,142143685,202000959,1277263562,1836973773,1402894277,602941350,3846224758,854664663,157671949,593108945,3896636281,1660527604,2634387200,1774623183,3563922671,1861945939,2108722837,3001577736,3228368517,1649416669,488415365,2421238948,3276369529,3870114877,1052870429,1964376054,4001658974,223637186,236065860,3728709979,824841293,3282684254,2135402296,3181310287,224156543,4047097881,1921638069,1245909538,2545495839,4201577132,927479840,21808745,2375964203,1855530961,663654798,2327522375,3436559643,3972476363,1796038791,3412292640,665920389,4084102783,1978864640,1028074236,3570542100,680755905,1720735767,3440130210,2160560022,4178334004,3439992401,1002513365,4106626746,206457449,570959513,1845891023,1082206857,2292420689,3015589199,1586590940,252307581,3995642832,4056608193,3532549782,3785202773,2994120081,3385931907,2594836086,978384718,2288229392,3484735508,613938396,1935047887,3167922379,3383879321,884815608,2591950692,2420562279,664849709,1482930065,2452025110,3916121625,2533686980,3874848372,1839960482,864802052,2585765133,2509710336,2949023734,4041555081,614764712,357827858,494250421,1188690926,4142823156,1630008603,3400322008,944621441,2226831594,2167042389,2383038264,890705592,1661484375,1190285329,94851063,838486941,3370514968,4180526679,1034105614,3745702667,4177870618,748153924,374844961,3589498025,2574261783,1537640624,2622723396,1023370039,6493352,47842930,3211819738,2137755945,3395749632,1631753976,188320975,1594081719,2636523635,510136952,569361861,1545520159,1970116388,451765803,2001850641,554993480,2482692526,3635468988,1452927069,262116055,2722031037,3765110402,1499077412,1371107481,3470938935,2076146184,3976227470,3758898342,1447386958,2017176531,2310978965,855527705,681899184,2335731603,3000518325,2802367611,206457449,3021264169,2295023062,3838403096,938000149,3363150311,1554413877,1061818400,2333585828,125569476,2018186247,2247190766,2378639145,2921473878,4195640378,4084579436,1803083737,3816856583,2869739251,3925857438,1608947136,3628193229,1843400121,3794811046,1029301525,2173834746,3539051550,3533088751,3291536648,1979246517,3264079265,3630276139,3989210326,3531004169,2600101248,4067365153,2870914831,83721768,1636306841,3443345416,1768866748,1951379984,1186926211,3546241343,245311504,2802048760,3811321184,4078211185,3835590560,1327794254,3200644169,558293665,2074508198,2562698699,2247291833,3308987037,707693197,596583966,2641991082,680241824,3396293828,907056801,2918140953,235845036,2823653998,2815955782,3364624074,3581922704,3929280403,2299126203,441713172,172055577,1047883644,3215331856,17023473,171518934,963302819,1984579778,1209123557,1024689190,491092592,3004427155,435837519,1081926906,907764457,4269328547,1956493656,3657928477,1810175987,823435541,2604246256,4215412858,3462733195,2878461239,587037609,2186655728,3423176780,1850140462,2786128140,492724128,819017142,206457449,3840582516,1726336082,796275036,1656814955,1278252296,3532948312,3047746900,1912773744,2265528748,2383537969,1970064039,994709720,775827299,4238301744,2427859654,3521858632,717693859,1341310026,948657049,2434716452,3820374817,3830169193,4223621165,3835814084,2129306260,3823189164,3774406987,1270114338,1149392844,810421500,1190018960,645472477,812581690,2502781279,2333056774,187546263,3721081497,2533237797,4111336540,3082363818,2976621809,1975185597,2302372191,2944259131,1555021835,3966341202,3317050781,4031926936,1522198478,10140956,2186759424,735192325,2721177514,1793377375,979226602,444306099,3083593470,1117910115,179103027,4232700009,578970919,3532875650,2434036489,2028506151,156774632,1738905878,2109868196,3084516400,273672247,3559694832,3945358933,3546002343,1219301393,3255570744,103015186,544112669,2383100041,2928491285,691418679,2672276637,3800893488,905181382,1083407191,466398245,3309358590,137776317,928599029,1948485208,2276692469,3982284320,4123832281,4273421340,1469726456,2371969769,1144262467,2800837570,3736573449,1559780489,2850528971,4087826563,206457449,3286617731,3315904549,3504038238,2725194855,2919636469,2569261728,702645068,1915709852,2820671384,4194993065,1102211073,682094338,1156055943,344937906,755867173,2359503506,2706926051,197034170,3283147392,3586712310,2243014692,2477552430,1954173349,1509530906,2367184696,665209419,466979892,4118130364,2340116782,3242808821,1441322912,3775594217,3796230751,1217472085,2627937741,864022282,3701143642,367380892,2052437450,2593127739,1525753682,4139714735,3054998187,3140308115,3391194463,1611873134,3039866697,1708458571,1103796577,3023149539,2215912659,37802407,3350081975,2120645554,1670446160,1168489623,3490248816,2883212862,1446943054,3927845059,3087005062,990756133,2298508580,1152806520,3448986801,2566858668,1339880832,2371304710,1532931056,3785564218,299238820,364447274,3616979377,1524081259,2312401713,2627709959,1405876789,983254786,1281915258,1857303741,2141402630,733432787,461621176,1850655169,2112453159,236747234,3532192758,3142860129,3396679610,2824663257,10535378,2054646724,3277425368,3669633561,2012938901,2901346029,3435997522,4043345446,2533485309,369961474,206457449,2487822315,925319305,26271320,3394442418,492437815,1618134347,2914572416,54300775,1701291028,2760879152,183861836,3051646161,3456232777,92250378,1568308348,1621032850,1086907225,93119257,757790626,2160747866,65138674,2060022439,1208212549,218110360,970384459,4030784540,1704022876,1712554165,2603408210,1474168756,3459700896,2693341688,599786471,1887595420,3337371899,1402094845,1543905172,3808612093,565559513,1359857941,3837892266,3791143668,4136352293,3257718525,643842770,3397011783,3380592465,3332371411,1665795395,3017242150,2507637823,3930086996,1824176537,3285110893,2135260629,541614863,1815454524,3744520770,717051235,4263050656,3029216293,3874979871,1386896974,2696612159,3173897028,2974099401,3904641079,1881270347,2179480591,3783564256,666793191,3130257659,3190258560,3699854386,2110117912,3463754417,2920040274,406752582,3695690411,3113513260,558558841,688773616,3951374647,334085688,2065273351,3314681355,3570176103,2098913835,248467573,264044995,1920431865,1324517942,2348556741,2893416182,3992145933,1511831152,3299534113,2604105144,1215990666,2188144004,206457449,206457449,2427203324,2086843597,1885146884,1802050502,1802050502,2691621139,359523162,206457449,3309756800,2691621139,622711149,3854977387,1802050502,2295212953,206457449,2528944420,1540564141,672750835,1496104690,2965134651,610986707,3772477729,1802050502,2416798067,2997411081,206457449,2915360655,2359238647,3257110270,1979167548,1561512230,2615438422,2691621139,4152978262,1214009647,2426944005,2356524632,4012152653,2789527903,3755526275,3959912765,1510552865,881469330,3376442226,598649648,1412818241,2877185557,3615020741,3194181018,538765210,3065469854,4112728136,206457449,2474042631,143640946,671164977,3450502787,1787375796,707365176,8869712,3519166804,528924031,2535809062,2691621139,2721025795,2099986723,1694463263,529367024,394222788,2321287545,2939906446,4178483068,1177707551,1802050502,3761044270,2691621139,1417998721,1504078074,839637312,10857459,1306693788,1802050502,2072393547,2427009607,3647056391,3482051343,206457449,2691621139,2691505154,1441928267,403168972,3094669022,3061896921,3766052999,2790876178,1916938811,3744186645,1879149857,1068786317,1819868121,478742297,2099986723,206457449] \ No newline at end of file +column: variant with hashes: [1609492067,1609492067,1609492067,1609492067,1609492067,3450695186,3450695186,3450695186,3450695186,3450695186,1212465068,1212465068,1212465068,1212465068,1212465068] \ No newline at end of file diff --git a/be/test/expected_result/vec/columns/column_variant_update_hashes_with_value.out b/be/test/expected_result/vec/columns/column_variant_update_hashes_with_value.out index 94ed6fb2fd6e11..1675df9272eef9 100644 --- a/be/test/expected_result/vec/columns/column_variant_update_hashes_with_value.out +++ b/be/test/expected_result/vec/columns/column_variant_update_hashes_with_value.out @@ -1 +1 @@ -column: variant with hashes: [15051269310814893253,9207780176212329026,9207780176212329026,8769178907691657826,15051269310814893253,14523939085247816014,8769178907691657826,9403745004122609994,8769178907691657826,3326292242930667833,18294539114392923310,5059852396507440228,9207780176212329026,18294539114392923310,14523939085247816014,5059852396507440228,14523939085247816014,5059852396507440228,18294539114392923310,14523939085247816014,9207780176212329026,8769178907691657826,15998705484298151365,13025324953589402512,15051269310814893253,13025324953589402512,8769178907691657826,15998705484298151365,18294539114392923310,8769178907691657826,14523939085247816014,15051269310814893253,15998705484298151365,5059852396507440228,8769178907691657826,9403745004122609994,15051269310814893253,9403745004122609994,9207780176212329026,15051269310814893253,5059852396507440228,9207780176212329026,14523939085247816014,15998705484298151365,9207780176212329026,9207780176212329026,13025324953589402512,18294539114392923310,9403745004122609994,15998705484298151365,3326292242930667833,13025324953589402512,9207780176212329026,8769178907691657826,9207780176212329026,13025324953589402512,9403745004122609994,15051269310814893253,9207780176212329026,15998705484298151365,5059852396507440228,13025324953589402512,18294539114392923310,15051269310814893253,9207780176212329026,15051269310814893253,18294539114392923310,3326292242930667833,18294539114392923310,15051269310814893253,15998705484298151365,13025324953589402512,3326292242930667833,15998705484298151365,5059852396507440228,8769178907691657826,15051269310814893253,14523939085247816014,9207780176212329026,18294539114392923310,9403745004122609994,9403745004122609994,15998705484298151365,14523939085247816014,5059852396507440228,15998705484298151365,15051269310814893253,9207780176212329026,9207780176212329026,5059852396507440228,14523939085247816014,9207780176212329026,15998705484298151365,9207780176212329026,9403745004122609994,9403745004122609994,13025324953589402512,8769178907691657826,5059852396507440228,9207780176212329026,2747456810774424190,2115431628531621721,2747456810774424190,11108521448820104871,2115431628531621721,11658524710109995065,11108521448820104871,3680165156051276080,3680165156051276080,3680165156051276080,2747456810774424190,1114834042821335278,11108521448820104871,3680165156051276080,11658524710109995065,3680165156051276080,11658524710109995065,11108521448820104871,2747456810774424190,2242029725979635803,2115431628531621721,2747456810774424190,2242029725979635803,11658524710109995065,11658524710109995065,2242029725979635803,2242029725979635803,3680165156051276080,11658524710109995065,3680165156051276080,3680165156051276080,2747456810774424190,2747456810774424190,11108521448820104871,11658524710109995065,3680165156051276080,2747456810774424190,2242029725979635803,11658524710109995065,3680165156051276080,11108521448820104871,2115431628531621721,2242029725979635803,11658524710109995065,11108521448820104871,2242029725979635803,3680165156051276080,11658524710109995065,2747456810774424190,11108521448820104871,1114834042821335278,11658524710109995065,2747456810774424190,11658524710109995065,11658524710109995065,11658524710109995065,2115431628531621721,2747456810774424190,3680165156051276080,2242029725979635803,1114834042821335278,3680165156051276080,11658524710109995065,2747456810774424190,11658524710109995065,11108521448820104871,11108521448820104871,3680165156051276080,2242029725979635803,11108521448820104871,2242029725979635803,11658524710109995065,2115431628531621721,2747456810774424190,2242029725979635803,3680165156051276080,1114834042821335278,11658524710109995065,1114834042821335278,11658524710109995065,2747456810774424190,2747456810774424190,11108521448820104871,11108521448820104871,2242029725979635803,1114834042821335278,3680165156051276080,2115431628531621721,11108521448820104871,11108521448820104871,2747456810774424190,1114834042821335278,2115431628531621721,2242029725979635803,2242029725979635803,1114834042821335278,11108521448820104871,11658524710109995065,2747456810774424190,2115431628531621721,3680165156051276080,2747456810774424190,315613505956165789,2498112105820668958,6430204341299993250,11658880051228531410,2498112105820668958,9207780176212329026,4293843473711652263,2498112105820668958,5195856583498624548,16072724907715392575,6430204341299993250,3019116424532021809,4293843473711652263,9428088470960784672,3769343651968330256,9207780176212329026,5195856583498624548,3769343651968330256,3769343651968330256,9207780176212329026,9207780176212329026,4293843473711652263,5195856583498624548,2498112105820668958,11658880051228531410,4293843473711652263,6430204341299993250,16072724907715392575,315613505956165789,9207780176212329026,3019116424532021809,16072724907715392575,2498112105820668958,4293843473711652263,16072724907715392575,3769343651968330256,4293843473711652263,9207780176212329026,9207780176212329026,3769343651968330256,9207780176212329026,16644173885145963938,6285095068699370974,5195856583498624548,6430204341299993250,3019116424532021809,3019116424532021809,16644173885145963938,3769343651968330256,6285095068699370974,11658880051228531410,6285095068699370974,5195856583498624548,315613505956165789,3019116424532021809,2498112105820668958,3019116424532021809,16644173885145963938,9207780176212329026,16644173885145963938,9207780176212329026,6285095068699370974,9428088470960784672,315613505956165789,2498112105820668958,11658880051228531410,3019116424532021809,6285095068699370974,16644173885145963938,2498112105820668958,9207780176212329026,11658880051228531410,4293843473711652263,9428088470960784672,11658880051228531410,5195856583498624548,2498112105820668958,9207780176212329026,16072724907715392575,9207780176212329026,5195856583498624548,6430204341299993250,3769343651968330256,4293843473711652263,3019116424532021809,6430204341299993250,3769343651968330256,9207780176212329026,11658880051228531410,5195856583498624548,5195856583498624548,16644173885145963938,3019116424532021809,5195856583498624548,315613505956165789,6430204341299993250,9207780176212329026,9428088470960784672,2498112105820668958,9207780176212329026,2747456810774424190,3680165156051276080,9662470069863771691,3680165156051276080,13417612768935391199,3680165156051276080,9775403817335265173,3680165156051276080,13417612768935391199,13417612768935391199,3680165156051276080,2239490168756777951,7933297322072625096,4189408517164827345,924275407506982548,3680165156051276080,3680165156051276080,1014026476850412098,3680165156051276080,10916669483681532167,3680165156051276080,14834823011772737566,13417612768935391199,13417612768935391199,13417612768935391199,13417612768935391199,13174304167164506414,8346417635551536666,3680165156051276080,3680165156051276080,16106764367986511239,1747584442168232839,3680165156051276080,13417612768935391199,13417612768935391199,13417612768935391199,13417612768935391199,3680165156051276080,11099227435165797951,2607768470936414409,6672200189936620831,14855182594294522993,13417612768935391199,14759931287837011636,9033969725445768814,3680165156051276080,3680165156051276080,8213231143279534884,8684002893636410897,13417612768935391199,4029504466682066637,17978029283153647359,3680165156051276080,3680165156051276080,15360917473556977433,4294777512217396962,3680165156051276080,13417612768935391199,788775961423308088,13417612768935391199,12105104382138590367,3680165156051276080,9475745456774183551,17396668767050500192,4846746646370783057,3680165156051276080,3680165156051276080,13157281198703191941,3680165156051276080,5780592024621710131,13417612768935391199,18117014467115655538,15888407934548548016,3680165156051276080,6392059424527865082,17017400238663460429,15517435284409358143,16507739734631199009,3680165156051276080,13417612768935391199,13417612768935391199,4609314416006987188,13417612768935391199,1164313058346468605,3680165156051276080,3680165156051276080,7998067570217731083,3680165156051276080,16425447590975122036,3680165156051276080,3680165156051276080,3680165156051276080,5339617027717778319,5784262543917375916,982417070543811544,13417612768935391199,3680165156051276080,3680165156051276080,6949252644890793919,13417612768935391199,13417612768935391199,2747456810774424190,9841301704698446135,10742826364513797149,10938789742217367213,11828893679885595428,10110312675173581490,14888339402334771711,16968268506798126923,2184543490982071305,9480535704910462869,16952061899607333538,5722652767689118591,9222607523752026538,5761768707219907890,8976989862990496965,7202550597607108579,10997967509068479351,13257341186072981554,8291076750927015988,8677752044912609064,410515423800780147,14767184749201891034,892439147819538476,15166224533055616000,11758734116370891247,13738908795904806358,13716147179759594047,9754614192578565490,13566539847384817817,7428140461161282510,8046827033703790631,3427083657064866253,6689760577042222923,6955091820951139238,5200792748914130896,9446306484910423218,2353189165082816665,12269269603161756904,3634502645003341942,10100580510828473582,5265284275118206546,3627272625974044729,13833099296070076676,956650805525868292,7623800348402716165,3895208379865564857,11571411338481955661,2104016482898648288,16650553022668288408,1620857503767636571,3660167861732666697,8426806604602712232,1197805561889970680,18211717490468252525,10983005916583150622,16011452755140149058,8402016228563459307,16848573004401087964,5588162170866801082,5824947751422200047,13615514179621968267,13781767781228034014,14423422440059170642,4640354925879941661,8531583094239604610,3594266973649170541,11090449916454954961,5326923029705029655,1581335795679095261,17492371962559321113,1493392441690405438,2489592115412947516,12213533684989750447,5235860512241406149,1351923774884905944,15216141354232652141,16410329723721407395,6936124585426483851,12052080952434340474,15386361126214053258,17947917755510698585,8947846274069777874,5173032272494754420,14915812527886642538,8422924929494860962,14508912594747889086,5234319020029729230,3895091415083253511,702956857078529013,15003631243243990121,9148607054985526935,16888533590828269789,18412946120335945764,8092272529530028511,11465887032779490825,4575426738585512281,596133695499078891,11174558671047420501,6413470944729610712,7071725610767747912,8612669403407323119,2747456810774424190,18307605670063672847,15542983068504793860,13617147752052882980,17449779932237945944,361048085625915893,13949331863158446677,183205232455367428,9552416451672108477,11621120455720731945,3696999716426306200,17464623932249909801,13086925836175178185,675558012984476630,6351760953987014645,5042416241311924935,4441796860992933084,6150869374297499405,3779151262362459964,8247486771419665317,4946435607890870763,10175919850279848737,12228070893419008750,1040221689818688025,8782712530767676979,2471289196785042591,18015025985997600127,15753726540964255780,1904619538364727953,15001033169211692540,11019910338922671566,16659285940542355834,5654612658783591977,5539121617588282677,15832110466645423587,16073303419439300508,13896063928322732450,13737495779485462326,2139448577707913920,10990951234776377257,11822990033163534338,10214828777098758176,12780253586485868942,10959341402762148649,8097517431389540568,3579318737381359113,15203465725378367944,6475189041349688125,17583366957286575376,13786225935411234818,5627862574133346327,10687771757967575636,5428590748793773709,5605769682131888960,3098784905417578613,2521569044944428058,1109743006783783855,17798570472355409954,9740901200130067225,15552858128026996306,8096879481799462925,4499009401138534805,1488023888074053892,10720698241529741773,5306595936080176851,1723160093001737476,3313209945472343757,7352385621883264833,6591778030837885679,5961246303986050021,2054864314689337469,12279021957130435587,5158298631312873612,10258125727677186580,13946050407540646040,8907268586639725171,2284627768742538581,268760016228044423,12657682937280356871,7236143611661867535,7153493787930767032,15004626074231388579,15248147394052017445,15798457933279940839,12118339059207899460,740058309228133259,13499837521577277550,14414776098334861282,10978183840644767903,4442200482821689162,16653325249510641303,12594728469405603992,14803466150464812253,13544933844100505912,4092432764438652690,14608010978843001836,6859737055444880558,845118408627393200,14212804167574099787,4028758949368518670,12557041466594791328,2747456810774424190,17613331925478434264,4298495728994266532,14324097389444759822,4497250945495657052,16898196782707402812,2645830935622857146,7188606887937218434,11142474153313643722,9160552800018573440,5355734434831862642,17077582438320173986,6733031482846278197,10944305074493703516,772381186302046155,5956834376542349758,13219376239720109488,7152970795785000798,3532881827121440249,1490972260495550316,1580080210475436866,10458303851688712297,13549127333671732974,1472577544316448296,5348032008720413660,17997004660873501787,3666408794060349688,12151803445619616041,9308145560790278747,14657788168610162188,14567498919215412817,5180089724464668063,8836646187231100431,6733428790536959726,11063179280053239876,11163045789239979579,7249338646869494353,9539774900656196587,3146025727546447536,6962994075689384323,6225237367001960532,6265535826283864357,12464409598248783517,5701900589632194520,7821877596493126564,9698849625630977221,8468207659130468959,8592769204853745780,2560401561778060715,16110419091199082512,3548551876923534715,3191397550769510763,9356309514678985273,15461049155365146886,849141116438617612,17986300783788290313,11351860838401912547,4466850359968083665,17305856671713103846,12215671140581532246,7411303974111698092,1652498657537565281,13642680698468361738,3696638521048332733,9932763333520430973,1823536904168819188,9569123205563783070,7440973743612580723,14200591742665401092,18035377893452503918,16705333742392897378,1287078300157576430,949357972905331266,12913259348890523573,3855837142052632896,11883340650315066770,6271701450748319637,88922730680640319,15615297678122524065,14867896218141858710,12108175939291258547,5448335882923733436,386920597663747245,12780593783951827305,197423435556629822,11936537570946384715,6323840715354850164,17444105902216753143,12496341919754627916,17980561514905888786,65733309261215142,11202568213913235954,2412298314723315154,9108944695971584949,6239873934287370958,9849174412707034242,8908199128904778769,3588131515172091238,9021214721479479776,13250780938938057803,9297305607756737664,2747456810774424190,1808859805078019075,7618316316210616801,12215485669480966912,15429232069159932833,17229158444178454673,14106407237846645310,3106454456885766557,7731337911860333666,5331334585924034852,2083577722075073326,2287256194216169869,6270075565391186471,18028104341038154833,12634834509021955782,8613089217945014636,17773339189616251990,11350327666813949263,18140695107072618348,15281219379168027294,8978258268070614433,12540592517015773432,12431569109375357455,18418366110849632455,1831200803529777978,9335221536275256623,9602303318177040012,762002788316733331,16069643106717422136,7661884330085750748,7244417723769557846,17918133060711189607,15745591524471708685,9055439669625044354,5375850683043323111,4272764885907097689,6827164500899090634,11834832056038087030,5268108291063574770,2295687227243197992,9737821641871987709,11701693548778092052,2582379894515837276,4501153169400492897,13922424473775924125,4775391112116889731,7058682694812604414,5124650078325966997,5789484675460841018,4647900664205873997,6106248999797049093,3512812787507516860,18195130814727118322,1283041059589660954,5982640017580768890,11859621125261702311,16697860088806244127,13807742353857655607,5564602511196173749,9493202458841936611,11170116711038254487,14162600533985902410,78735094193786953,2956105308695312520,2308166261076583163,12467858897646511570,1935787131291873473,7740479482722802466,13732564706101006238,6134668068812174419,7938849479747137362,4981568008423252084,10408624575496594926,14609259385616770385,14257147088462197370,8182692156043940741,15472173181275853473,666298798650652188,5789887262584193518,3310442637074843102,2674626684214483775,18232849995488262965,3575726681561010632,6118480533485732037,13476656638458600287,2831254715132024830,6462254973907635097,13400800478237933566,14620935161940485430,2301643142193468515,15150551382723713405,14201273771588332317,6856066388685878919,9961319436884478796,7522289756890744724,14195711868278985112,14945867192866341473,13179056244966471899,5195005749984973034,7745105124372790929,3137812723921261427,2747456810774424190,14775427279083762338,7130655759219704242,3229130788721194281,8437374700216137204,12686099444432147334,16504206196097719159,1612261727533381215,2506416729915054177,2249975069604960137,9522042966476060971,14419475961259190697,5883548448237364515,14711248360092934187,2378079170792468348,307733942647063220,16070731595162441281,10213346231816908499,3924340623001655601,11948678465500444582,12925092868601492788,13302846191386337542,7166374619126548443,7329595547218601354,15183470653955845718,9683451374266391455,7921537379775566354,11178858228873533958,3859680149921018625,9594028132309021424,15831391060417539140,12396162139567626412,6678035818224129452,4226750629902568865,16754969507700644560,14169390946425982065,12772009183730222821,15449933717018976062,15606924722343103627,18199617330506675498,1785680722354987232,9054244052850135191,15306174722512402679,8882617938106388280,7533714105273133013,7480578381404617424,2030294516481617939,6946788936202235497,14819474548627018605,17321565826848038945,4966856066027168528,6430417963098676182,17569532873441754673,10993977078309543078,356546511725343984,2751712378771735711,11195328150356434180,6703196203525694331,16963077185010604076,3796061487937736794,9424881020069210577,9177443334249169473,4350917860043193128,13285854093073098545,9120543190624795604,641314390767936094,16883425110144900325,7670011673809934272,1815631643788417528,14173915919419492979,7304152789070090525,2499661662340297746,3507436728264011101,12008010396222598314,5701752076340584450,10710238860405584475,10187540203149054817,13245499313095691885,7072945911747355572,8878172791484372183,1386427279272451963,17185618877128973039,930382557135416632,8679291740020853301,3420475105185566459,4039410492201735706,16742526208893362794,6642879462346768663,4055187193914829989,13159365642148467323,5719135520104319373,6903712371859236905,2275956545360194321,14965983225764881709,1215041652023857535,6547591528413952581,4048008648670127345,13154615102152164321,2663250353023082271,14989611283801179035,2278721292300687327,2747456810774424190,16621804365264701290,15902902662797136389,3101254812284012024,12853375344110115987,17375960163585608888,6090752951116290345,15120738562652897506,292801200476768760,4858118587637213416,10363363028115492610,13499977208496694253,4340233131031863222,5034163834751435655,16180563488713165495,17761982013216654674,7746680096671885374,3799473289694482568,1600165660340595696,6296445769136783415,9287157131842972859,15320920019762070628,1523551886092456327,12951705257544083863,7032982369829797337,17972179168386959849,6486659592281883085,13418157807796680588,10641825513238789024,10987875206157296492,15329605795045246831,9714877993845163400,13160595876675818502,16578541844218547703,14551134548262802035,2369288310461955396,8616868295677485276,1883268625184607614,11153484061366741421,2029829267318514983,13320441084614711063,8179331388435213151,17272111569257227840,2256203974688584893,11414693033569701749,9317934712959125257,11657468661967719081,11850602997565048516,5053851349103422791,18152460281864471832,12883160333481805571,7336742905795695925,18304188026814628946,16038792422085358345,2727990645330754391,8586492337773451185,5753398122074171323,478725971348445084,5467063790313737495,1957158545739026284,868710565842286536,11491141749672857810,13814187597966113998,10805601231478495206,10011203716530849996,13592295037664709457,17510006404502252906,9810978798686251290,2533975984442425082,12628380787658329994,9253931975578131413,9272686582026085969,16885022496336395061,4411694523316838779,3742703674428791932,18361719631814538690,4430602852702566020,4953463398406790236,8047801819606254702,2666120740922446540,83189746008155417,13233747015807244007,14067094507155685099,14629509395258667458,17011584498906019331,17693659742533089337,14636628172879674286,13860441468588335269,11505499875575846223,10282663500323488558,7706068157257665902,4012951190874158923,5054859521836313142,146746973379565777,5082734709179172685,763987474940717775,357515281717046914,8522024621266274102,15043203336997734021,6584141311568584969,6137536912141007472,2747456810774424190,15102966532251805036,6429080070215424838,4465544746323381297,6428026334017520502,7165940222687148765,18068292086862363030,16724153948290905720,5102449326825672066,9796021655015119282,583315463691995859,8425104169375848537,18021104118226498985,13707209844217452207,3602209688479402477,3065643000248227296,12970109206296154111,6081053113068356284,806763431497437981,7074454182156022544,4666790624043123570,7410339373505206757,17359687780128095308,12851478050519680347,5516407615204137454,11446900172771659714,5916375000327169499,9911022437089857917,4559629905267559674,2711069799292097679,460127445148259076,15734760268044063346,14993064060874446192,14463515522847858248,2981297413925575659,14318791863243780990,15312559363386084129,12138899764542634628,4276517862872049004,13988620722158980547,579122199196489147,5227203990303085378,14607860961107443134,9214232629122779132,10864493353130512931,15089061042647629954,13044570535757212909,7939148601160055495,3670606081579267271,7440203961223868466,3886156371034526478,7758453967276438704,17045846166721202368,17160751084314184243,11295552755490174483,13965328619820493700,16324539300689717128,9959200077225735594,8434369755785586988,10849723992542493067,12479700721710284327,3889601221498794470,17827970792177339504,2058067949648511089,8288194933805088189,8388739812154100259,3792078995109442081,17544724949476670232,1359821750485975182,13953547571836785122,6585360761428174380,17779373243574698896,9653878935811138410,5443589691763360915,15020127836796732052,4080329516728078414,4156769456815703867,5570253396215292257,3420078179242338437,13969866225732030428,15765818829245109266,16882980983230708841,5685882884374678602,10800131966472828999,13530972475510641108,2276345503187439046,8690881788322600112,6894108265922379558,3138017842788634533,11120048404760289561,12436556872343541071,2050788898498501239,8364013059234141054,1588934512473191892,7704128580925167218,13080594395242551857,1611893070133014061,15039127767883081634,6121563523111709025,733571574987450770,18297892758592655378,2747456810774424190,14387809927948558926,8770241247735555976,4324459756888429511,10736658159964176636,13847490221490668755,18289582318770946046,8768548517459160234,895265414396184278,15577384544297380799,7928801336249356610,10121729696790866702,4483559212622004395,13949423053761648497,10377308702396498635,15596021558046983103,8496253237400745022,4530833959973030973,11651897080899414714,3996385525727596414,14921441450939101379,17721857401317611567,633766464612552037,14323755194059829102,15112801232247624766,3524648010089539838,11292953383903168119,9357798491967400315,13527879779752284948,9442318253412536641,12246663326973925447,3499316649647963000,2615546357121531837,11337899065977847560,4775871159094608466,14543296342812536498,17955308061934559067,937198032107063202,6361407636085093667,16259026920411008636,3684325193994504327,13674254695280344745,17457155831569656558,8057948849911987753,3435320404075875040,16198597322686810668,8678942346614976278,13321274484105779875,9799445146434483325,5905329027165043363,3194158099866910128,14619002343215163317,6858830643846868737,4518116530915013529,11437825744568536338,16029076187287089951,4850616439351031734,12527822655784759962,8521936281741730160,642951336755329417,6141205331179420106,11270378228125845070,8628790571367723148,17694212334968682745,14195346780780474350,10217451856885275427,1932657290464200639,11516039164635968816,17127105613579598297,10737508120317143688,5866917393414150097,18294155126709300230,17638762815113708052,8142146198250150220,653492565616522443,4324316300150191025,11564718929588318290,17124752949195138190,17911718032189319991,4365132741485088049,8533367691238810281,13726077062503587503,6407890411221977468,15906626131262520617,9763132957218287753,4452619230582950767,8187164160026993869,2556185280915457937,13695121886502979087,12603855654987660488,5901060035570367073,9696357027886418373,9545282955955462433,7907967183285249641,10181057333674243528,14436569595351905119,12209619398477797003,7914952334722130399,13071757550830989151,13988936523064590117,2554166070220680394,2747456810774424190,13125546717451195116,7306456991081513019,9846360906616894931,13220441011537783121,13100165614143437854,1701360359357786522,12102218390879837676,4219228081946746150,1759475019619445227,10478016171413265724,13539515649813581778,17263171621042747867,9384135737682073321,17579650890743909081,7346604961360219196,5726854952235317863,9982713697669166937,10045942416169379670,16238016827863118988,17175753997983420380,2418634050400401879,14854107235481306058,9107220194571152698,14749358319631591564,15903420634938633213,4934388589570505072,5143846174983891060,11750163304141382979,8414002870898119510,12304069005558784720,13150751639677238876,6052718926350200926,4714251373884861630,6827342445064031011,2794439854191621921,14080131268941296733,17139626252045792342,16632708085467570137,84846697803781479,11286332327868958787,11428476694482131507,16487504461896954168,3547031647968268356,10681949299305693089,7463536224716193922,6591054980031929947,18136527178700896050,10761462309072661885,12426612075527313722,15351163991000728940,1124261605507430052,18440987012265937692,8095376254636106349,268487093247448166,10165230921371934579,2750005451061022485,11555058913299477471,9593505339734736708,18198202330321620864,3684396886366908317,6219492064098681452,719616562681070296,18308697975129859081,15499968160539886255,5898159374413618915,16942747935601460047,8701270605819099624,5972826912130842343,4144108579132667324,14492507720787745071,17257218294676319423,16910455036144986010,2919142701579355956,16902325429829085464,9621431494568780278,4843444918757747272,9536661557800618091,2498536808213594990,7328921585882247967,10096396354225951615,4692349155739338723,10101509171953287029,16456639768814890725,6736462063993390581,6012337393879189857,15930600395627076128,15595597759655435910,3668656656259785701,15860462456483621088,6352906055035432414,18356591796340015529,18036620635586511199,738928898689831830,13608605474013927804,9297783379073707438,17577382139344547959,2458963103647828269,7050770040218581176,8752091947170817759,17674624086712424082,2747456810774424190,11555749646885719807,12116763064601741944,10567308901205178433,15529623473310298877,3408487166038051143,3299691911388697072,3007495253489859490,10496379407017684971,10921095959894677672,10747053957042806201,5922920368256990174,4865700896031264660,1494146159870300796,15400912649774187633,11790380509661360413,894172619449494912,708986011615594059,13084449327941144658,1980729287162237738,945441460517488753,17305717616155058936,16284128014728299305,9161514048285553620,11853431252965721205,5368432656998280858,2795090292331613013,10967838865488161901,15735200480163882753,5158223648103461311,6051648982968880701,11689479004871523756,3217669570277044559,10606831850116759515,9715747156014377186,18423999345965481749,4224201686351535120,339562711127758263,4677562806285871662,2885938008714223364,17025847637313772081,9751424822652100790,8206472029988837499,13084547581466155508,4673676758906991019,14357055841885816873,9311617830104427266,10527535604609520567,18079525323232024974,14391549501677989718,17874948713735849046,1211169217144133375,4444171717571261899,9765899672558335655,14085813373429891491,8702012242773776158,17581698449300422050,3009848376670280347,1768513850757379391,11623132648495443561,6237731819345738265,12626601586805298249,633563102135765382,14917673805653287905,1304794861467430259,16014970220190939903,3301458530114024351,4763014148475197704,8536290350722744923,6674035952628652976,755987141721232324,10926445840860737269,15671592438685450019,5426369528790794000,11340968513434723332,3412834661309524903,14194312184414296145,7847477839331903703,980852479292538796,15292241415088184952,2196376686750879561,11386122647427019028,1392513930575682439,6511857671357512926,11666360504546171290,5718414367728714120,5923308080819399001,1167925770341310090,4634873932318635300,15135360402785744508,299174593335815606,8011527786725642259,16794447954816060666,13328563096530432696,4759896671878702407,4469948309521050292,2355832378125511421,7434533940576439087,5417759640953740012,2050723930901812560,7967762072122793109,2747456810774424190,15215739492221836593,2939737414421008587,6446322337747242467,21879946997825028,16456744398202204204,18295218551162638518,8158908338174936417,13446400257091164857,220331706423524745,13427285653447062947,14382196284078857078,5815188426403973820,17423817905832311377,11411824183612384130,5136514163287864776,5886576321933455684,3430584075417323558,9550889669014775735,6764826286728993817,2491840306744362258,15569327863325553971,1227514367732923588,9261144418180514520,2877605420182337680,14530347792957097227,211120556348753812,180211266087734040,872030821950963801,6247867881464049771,561999773871244650,16323495281832214868,11550839271891864527,4840645149987348766,13584491543360279192,531388204428937193,6590603190974549861,11134780394186822266,11299897774604142373,17912539815821663503,1095389960277673879,822514535029923056,3373425241105388691,4538078977248546918,5284003875335687661,5423423931785843152,935980625559297296,7544610797386297639,14688226521000838471,8483323643139171152,4103717927424471323,4784381283435481128,15609216088410193672,3991530689890929439,12662351520794232092,1568586520432684384,11764458104392847530,7293360749002256926,8862235685349453644,7746332830365819458,16412174726860440148,3462369598354966446,7515166945125429388,1818431452475061550,3829226521739178995,16445676765621850304,16475533379276126178,10337110997946099516,14755048197048953598,512169291693695313,16570422323408510361,12894858585901719580,9550679794799461572,18223809618019314883,5895583719443585823,13381617720740874770,9756388659844787253,419738737307584738,18305552180524040754,5904318866972741777,12641333573692908227,1644526271859512355,3629447390907463586,17213299020346435390,16406770376413771386,8561004467872516120,10882604023926601344,3371130989875576864,17277704117980441185,17055638810172868564,12250508605635289061,603272600795030613,10039996983808845995,1392021940259437234,7841658334925181165,2449917642828789828,7174384079118295921,14669168217878290276,7275645175319000903,16307902379849141003,16085006571373086535,2747456810774424190,5312697365286710545,1740166779544288440,1410056285058756111,15817546918477350263,10151668847944565469,15159402886235814030,5033948193661944896,2591635590725229245,250686191087942067,7952127945327341357,3270829502575491541,17706449341067178858,9672319028124486940,1741021621597939880,11459618515389506333,8752195682842467268,3025154848861910700,2986031004386152895,16453109592400650221,11134977376016121417,9677437700516916874,5475293772232829476,3733547023425185260,4390720167520812824,13175180991323880227,5680692857533090388,7131593566154585348,11448628461490744810,13208934100820977741,9285347812840273863,18029902067079059693,12122197649851598054,14778413959234750864,15550763099151567132,8910454195154940405,8707053704556786606,6285581344654204839,8324133507545465650,5500894387997662216,8489664789639744431,9813928466098899941,5814886129118926015,3716322209540298206,721930923936206647,14020615196491120312,5685495581706607709,4536543441100890247,13404110290024159007,8422309035845502439,4191075949773967953,8022506990577338400,3297803077698124229,9474122607342812385,2982974729709294932,8231901544164035100,17486457074433062939,4267091432831359897,18272641381805259111,16734168661868892030,13439283326074175932,16551699014054517379,523501702831051860,4782343249559698686,12151490002552070968,14147845889432908254,3068343995265367000,4090920144216588412,16908373714560695917,10205849469396384168,11530006112201450378,13256719575063801059,3694345079005932433,9451849725119337944,16562872014519516374,821957973045587279,17199052942826077838,11508861300292313681,7728745407902180402,11669194556081728885,14040160659090605129,15719114838900192095,261759909113769595,12371537250465060710,9335147802761347227,12448451766442643292,32760251176925269,12235425466395757469,2895143681307225928,6998832851001927451,7902709533156292603,8630317393763233450,16040699018946836643,4623861050360009870,14774601773507972837,6314097322088512529,12196471877316529857,13942610066951357513,13415446477535295243,17743453302488002369,3623120111299528658,2747456810774424190,14595808620618687619,4956624804163774025,10656501183823267228,8849163952102915217,3138189349877052944,11530849654803217896,15488045464387636435,462785906338347129,18428583358724458096,16002374481474707002,7813319777006818056,4547848917229435544,10319184139605315085,14257753988721557153,17326832564852865589,9977808105255575831,4138654113831019152,13342252583251029074,4832987575703523473,17038368386734067367,13325476877660450518,15916076448991609125,650204809009071699,13311322087938885789,12487636955063767680,17749313884229196743,7739819495184799927,17665318410828985671,9357380208103742001,7449501557616207875,15401369468313462425,6298841206971684967,2720415548287537837,6180829419379263079,8813827796786860844,16565612163532543128,17576872201307100612,12988136280421159630,7419493739954003224,1239154947791898685,18328776810353762005,14127727191643426149,7522426658358247743,284248106642626262,6015370072918229149,6759286345675678201,6503153785566431627,2130590512237382565,13713681979709282284,3861115422075281024,15665509538094241790,3268370936874435595,16810599334707509346,7230332412311052630,341220364193304589,4506343564185899430,2223437258868092947,17310026048976423705,7177295684265033073,3170944774816704253,10840644724650732873,3505284018082570827,10807426339023324483,14228219714152014008,17940612152010186748,17864272401818339247,13298868465294372758,4696766452172033047,8984545129636103024,15863647052886151657,663466048893451929,7538032366704797499,14750823149604170380,16821204421550259760,3212505049775451619,14295827625109816754,7071509178390764980,4522779049726418525,11778096599773234508,12763159589860035029,11517082119247385196,17346386261809430352,10186626482181371910,2242754838155830328,13730219905690051075,2562273756836449587,15331844401894459854,13141379319778639934,3408091314783207134,12038615765724666917,12124722204327477911,15548358195506005328,305514341134888130,8131142972437071110,11241080752989051335,1388047851268764277,1463239939413659572,2442678508474621204,4764687213110323987,11811926331877380736,2747456810774424190,11804832672058772177,5416814813222112360,15318616015783400424,13146052196334931446,895314013413428192,3699926598523063110,1786283536485213523,9489273941345161049,197111473330969198,9258700865191119629,514814160493232256,8882991954412572977,12717983279337023009,8707749243990872022,144140367770456297,2548565895922299598,10017771767521390704,2731516236868404269,486869797513621151,15313765423393507474,11040576165402856805,5928267603353590275,7085257617036394798,10495259560541762321,771868630067242274,4370637210893188451,18421364970575659642,12896919294110048435,15379373565193937475,4285063239002784044,1579014214063754249,2254155318960492092,7747665101062924363,16037149715197777302,1436364582401536441,14081643704345895015,10142882219392597503,5335382528671444917,14664933223818162490,4457639790978789549,17980944840133163965,4734485656264389974,2033108280049670837,12252505567929828013,267918069978536456,1976649558713789642,13485380129386066773,16644623782723708322,2637039915468136453,2661164787984938336,11670643642640585266,993196678284675158,204049494997000124,10190448701385846923,14990251613835524670,12478822870582516571,6107079827667859532,11829613217632720809,15359780755177192180,11573596537580142323,5169078635615892338,18266606341996575186,2051986517696198951,845999985416759873,10151805952480116058,7794759227472031973,7537281011333248728,10870678420555194944,8691023734581929363,11874460935800541371,15476364317309159165,5612407957813901293,137265988838392142,13798404879420564474,1798243854586989982,2412319203330922218,11302984355706778562,10930948811027209190,2374783042052894700,11172324471295787809,7082158698875154205,4571188640887398373,8357765229140391944,11482721217668758261,787044158165436134,17219361910257947164,12667482951121281262,5119917683550612866,18016065455671263023,16232353477083432622,4588734689279667639,17770452497385106967,2806583258386187406,4912253300241512839,15725101648606891122,5179251196414626290,13924971101041130746,14938141821989220166,10938487644931976521,3391080579573309611,2747456810774424190,550730678662635920,11036628707514824652,4310318720615217021,1290205098408715201,6264558837644137918,12847006613575330122,15135292061264501735,16320315729588219787,17896005883118052760,12528277484559943881,6444442547425652792,17452717949140236982,205167876157182209,680380454771185902,16187223133013406591,6032215790601635672,18159044812658596037,5704926885593172543,14208206378725337354,6548252369914238241,3310358487353872676,3295782293031524242,17353208937723569468,16334781880569569397,4257229679437853894,4382719844844746756,3906582950789321267,1380415694590213979,2017645381825601323,15671697519037349169,1299750014135085107,13077403654508523094,10346268192273571696,12057834117451179089,11125374098111183241,4912093933493437775,3806084728362814968,106116865111680255,11728312865556942992,6404494904055656576,10273648685448235184,16704731077904575534,3280840515092627579,710427001284846868,3176378275371581514,3112930305053300736,4919789933321046236,17413859238510263619,15186741389303502255,8870979905688237564,9124997771185622777,17626959527798598370,1800937260032137458,15522944318096243839,17615944922366027880,1693948625784799116,6050020484110667468,15529909190626568653,10172943341797462317,10763798209202272821,2022574610319283297,6034945558009391380,5193048029285479862,10125446274268912450,12889116335562896526,10497009470721590206,477066961866875368,15984582274491438094,9722667657775291138,11804557708276012931,16565478294117314090,8145202875969792200,9847381942539233539,3922070584116135863,17697179581250724816,14868281881086723048,15687833403285411709,3210204939189278412,8096381068011122331,329045997944838234,17595722184255088523,7076827261487462985,12307171428969918018,1720188676063219932,16531344413910296647,2132537261052229448,3389815603095185509,6084651750998446871,9266735319237119529,2376736704956305060,18068330744426371869,2040890284409898241,2903142209538341437,3908213407201662157,4134579092144072316,14816037371660737620,4537388167918834717,9451064955450533365,16344102616860424472,10586177359116292645,2747456810774424190,2747456810774424190,8775533841765596026,8598661800576736657,859841143680829306,16832985826374125741,13576731593875001812,4047841883330530799,14468563807140312397,2747456810774424190,13706148461458866192,11888548015111673208,6279942607549426632,10560869903210027619,6840985564253972831,1629453574346666212,2747456810774424190,9404875290705216725,8047859747597739615,11279260331770449166,14738201029419054882,12802894158610641270,5007097775891892768,5985540232752165520,10905343657178759437,4738054991864250763,4412308128172281928,2747456810774424190,7950668948320098156,15510566813356266251,14491349918463444174,4597552876615663029,10909385503459286175,726434258702578570,2792808412003773828,4957294112396037910,15464224686106443715,12040753679692366823,11435780342100430117,6187810377673739302,5684209509184674602,2087130481686428051,10012013606835808902,16681498477444963490,2486485061016482748,7880053827155513992,226779149997741814,15941191421616117245,10354795925236520689,6148406478066548248,3066784816848150324,11418737338249817341,627687876342142576,6104753573815091241,2747456810774424190,7449913734407788309,12676920847387855545,1271126938699804827,2247521836253438921,3701119872973709075,14241482217434519499,10924457614931717714,14600386132130357546,8596772114579809763,1133135749005771946,15629511012870432565,562167134678708956,1785891314908345482,6590557618060320123,12239494261891275021,653937424729092947,3966532319148332951,14911875796528160662,1569656670076060091,10857513694953462041,14070300686498181161,7866092980731901009,3724790337117408985,16820170213536912102,14413787497956362302,16240642892274239867,14899256773044067082,7607469942913496757,11117746547951996750,17389863984625652218,15611338375046335567,17303681440514163259,18437921368343601590,2747456810774424190,6918890766581257847,4804063966554483719,9264444576494688449,16909508569334085447,16847923286055043403,13982001572869537842,12111499050594848849,3496838060884252484,17180373786659622650,18016199340872739497,18106969400714499324,13414017669024524692,5029772737520410873,6983887670055767099,6762037258984942787,2747456810774424190] \ No newline at end of file +column: variant with hashes: [5538722551051340495,5538722551051340495,5538722551051340495,5538722551051340495,5538722551051340495,7371345925615203687,7371345925615203687,7371345925615203687,7371345925615203687,7371345925615203687,1653038164052872993,1653038164052872993,1653038164052872993,1653038164052872993,1653038164052872993] \ No newline at end of file diff --git a/be/test/expected_result/vec/columns/column_variant_update_hashes_with_value_with_nullmap.out b/be/test/expected_result/vec/columns/column_variant_update_hashes_with_value_with_nullmap.out index 94ed6fb2fd6e11..1675df9272eef9 100644 --- a/be/test/expected_result/vec/columns/column_variant_update_hashes_with_value_with_nullmap.out +++ b/be/test/expected_result/vec/columns/column_variant_update_hashes_with_value_with_nullmap.out @@ -1 +1 @@ -column: variant with hashes: [15051269310814893253,9207780176212329026,9207780176212329026,8769178907691657826,15051269310814893253,14523939085247816014,8769178907691657826,9403745004122609994,8769178907691657826,3326292242930667833,18294539114392923310,5059852396507440228,9207780176212329026,18294539114392923310,14523939085247816014,5059852396507440228,14523939085247816014,5059852396507440228,18294539114392923310,14523939085247816014,9207780176212329026,8769178907691657826,15998705484298151365,13025324953589402512,15051269310814893253,13025324953589402512,8769178907691657826,15998705484298151365,18294539114392923310,8769178907691657826,14523939085247816014,15051269310814893253,15998705484298151365,5059852396507440228,8769178907691657826,9403745004122609994,15051269310814893253,9403745004122609994,9207780176212329026,15051269310814893253,5059852396507440228,9207780176212329026,14523939085247816014,15998705484298151365,9207780176212329026,9207780176212329026,13025324953589402512,18294539114392923310,9403745004122609994,15998705484298151365,3326292242930667833,13025324953589402512,9207780176212329026,8769178907691657826,9207780176212329026,13025324953589402512,9403745004122609994,15051269310814893253,9207780176212329026,15998705484298151365,5059852396507440228,13025324953589402512,18294539114392923310,15051269310814893253,9207780176212329026,15051269310814893253,18294539114392923310,3326292242930667833,18294539114392923310,15051269310814893253,15998705484298151365,13025324953589402512,3326292242930667833,15998705484298151365,5059852396507440228,8769178907691657826,15051269310814893253,14523939085247816014,9207780176212329026,18294539114392923310,9403745004122609994,9403745004122609994,15998705484298151365,14523939085247816014,5059852396507440228,15998705484298151365,15051269310814893253,9207780176212329026,9207780176212329026,5059852396507440228,14523939085247816014,9207780176212329026,15998705484298151365,9207780176212329026,9403745004122609994,9403745004122609994,13025324953589402512,8769178907691657826,5059852396507440228,9207780176212329026,2747456810774424190,2115431628531621721,2747456810774424190,11108521448820104871,2115431628531621721,11658524710109995065,11108521448820104871,3680165156051276080,3680165156051276080,3680165156051276080,2747456810774424190,1114834042821335278,11108521448820104871,3680165156051276080,11658524710109995065,3680165156051276080,11658524710109995065,11108521448820104871,2747456810774424190,2242029725979635803,2115431628531621721,2747456810774424190,2242029725979635803,11658524710109995065,11658524710109995065,2242029725979635803,2242029725979635803,3680165156051276080,11658524710109995065,3680165156051276080,3680165156051276080,2747456810774424190,2747456810774424190,11108521448820104871,11658524710109995065,3680165156051276080,2747456810774424190,2242029725979635803,11658524710109995065,3680165156051276080,11108521448820104871,2115431628531621721,2242029725979635803,11658524710109995065,11108521448820104871,2242029725979635803,3680165156051276080,11658524710109995065,2747456810774424190,11108521448820104871,1114834042821335278,11658524710109995065,2747456810774424190,11658524710109995065,11658524710109995065,11658524710109995065,2115431628531621721,2747456810774424190,3680165156051276080,2242029725979635803,1114834042821335278,3680165156051276080,11658524710109995065,2747456810774424190,11658524710109995065,11108521448820104871,11108521448820104871,3680165156051276080,2242029725979635803,11108521448820104871,2242029725979635803,11658524710109995065,2115431628531621721,2747456810774424190,2242029725979635803,3680165156051276080,1114834042821335278,11658524710109995065,1114834042821335278,11658524710109995065,2747456810774424190,2747456810774424190,11108521448820104871,11108521448820104871,2242029725979635803,1114834042821335278,3680165156051276080,2115431628531621721,11108521448820104871,11108521448820104871,2747456810774424190,1114834042821335278,2115431628531621721,2242029725979635803,2242029725979635803,1114834042821335278,11108521448820104871,11658524710109995065,2747456810774424190,2115431628531621721,3680165156051276080,2747456810774424190,315613505956165789,2498112105820668958,6430204341299993250,11658880051228531410,2498112105820668958,9207780176212329026,4293843473711652263,2498112105820668958,5195856583498624548,16072724907715392575,6430204341299993250,3019116424532021809,4293843473711652263,9428088470960784672,3769343651968330256,9207780176212329026,5195856583498624548,3769343651968330256,3769343651968330256,9207780176212329026,9207780176212329026,4293843473711652263,5195856583498624548,2498112105820668958,11658880051228531410,4293843473711652263,6430204341299993250,16072724907715392575,315613505956165789,9207780176212329026,3019116424532021809,16072724907715392575,2498112105820668958,4293843473711652263,16072724907715392575,3769343651968330256,4293843473711652263,9207780176212329026,9207780176212329026,3769343651968330256,9207780176212329026,16644173885145963938,6285095068699370974,5195856583498624548,6430204341299993250,3019116424532021809,3019116424532021809,16644173885145963938,3769343651968330256,6285095068699370974,11658880051228531410,6285095068699370974,5195856583498624548,315613505956165789,3019116424532021809,2498112105820668958,3019116424532021809,16644173885145963938,9207780176212329026,16644173885145963938,9207780176212329026,6285095068699370974,9428088470960784672,315613505956165789,2498112105820668958,11658880051228531410,3019116424532021809,6285095068699370974,16644173885145963938,2498112105820668958,9207780176212329026,11658880051228531410,4293843473711652263,9428088470960784672,11658880051228531410,5195856583498624548,2498112105820668958,9207780176212329026,16072724907715392575,9207780176212329026,5195856583498624548,6430204341299993250,3769343651968330256,4293843473711652263,3019116424532021809,6430204341299993250,3769343651968330256,9207780176212329026,11658880051228531410,5195856583498624548,5195856583498624548,16644173885145963938,3019116424532021809,5195856583498624548,315613505956165789,6430204341299993250,9207780176212329026,9428088470960784672,2498112105820668958,9207780176212329026,2747456810774424190,3680165156051276080,9662470069863771691,3680165156051276080,13417612768935391199,3680165156051276080,9775403817335265173,3680165156051276080,13417612768935391199,13417612768935391199,3680165156051276080,2239490168756777951,7933297322072625096,4189408517164827345,924275407506982548,3680165156051276080,3680165156051276080,1014026476850412098,3680165156051276080,10916669483681532167,3680165156051276080,14834823011772737566,13417612768935391199,13417612768935391199,13417612768935391199,13417612768935391199,13174304167164506414,8346417635551536666,3680165156051276080,3680165156051276080,16106764367986511239,1747584442168232839,3680165156051276080,13417612768935391199,13417612768935391199,13417612768935391199,13417612768935391199,3680165156051276080,11099227435165797951,2607768470936414409,6672200189936620831,14855182594294522993,13417612768935391199,14759931287837011636,9033969725445768814,3680165156051276080,3680165156051276080,8213231143279534884,8684002893636410897,13417612768935391199,4029504466682066637,17978029283153647359,3680165156051276080,3680165156051276080,15360917473556977433,4294777512217396962,3680165156051276080,13417612768935391199,788775961423308088,13417612768935391199,12105104382138590367,3680165156051276080,9475745456774183551,17396668767050500192,4846746646370783057,3680165156051276080,3680165156051276080,13157281198703191941,3680165156051276080,5780592024621710131,13417612768935391199,18117014467115655538,15888407934548548016,3680165156051276080,6392059424527865082,17017400238663460429,15517435284409358143,16507739734631199009,3680165156051276080,13417612768935391199,13417612768935391199,4609314416006987188,13417612768935391199,1164313058346468605,3680165156051276080,3680165156051276080,7998067570217731083,3680165156051276080,16425447590975122036,3680165156051276080,3680165156051276080,3680165156051276080,5339617027717778319,5784262543917375916,982417070543811544,13417612768935391199,3680165156051276080,3680165156051276080,6949252644890793919,13417612768935391199,13417612768935391199,2747456810774424190,9841301704698446135,10742826364513797149,10938789742217367213,11828893679885595428,10110312675173581490,14888339402334771711,16968268506798126923,2184543490982071305,9480535704910462869,16952061899607333538,5722652767689118591,9222607523752026538,5761768707219907890,8976989862990496965,7202550597607108579,10997967509068479351,13257341186072981554,8291076750927015988,8677752044912609064,410515423800780147,14767184749201891034,892439147819538476,15166224533055616000,11758734116370891247,13738908795904806358,13716147179759594047,9754614192578565490,13566539847384817817,7428140461161282510,8046827033703790631,3427083657064866253,6689760577042222923,6955091820951139238,5200792748914130896,9446306484910423218,2353189165082816665,12269269603161756904,3634502645003341942,10100580510828473582,5265284275118206546,3627272625974044729,13833099296070076676,956650805525868292,7623800348402716165,3895208379865564857,11571411338481955661,2104016482898648288,16650553022668288408,1620857503767636571,3660167861732666697,8426806604602712232,1197805561889970680,18211717490468252525,10983005916583150622,16011452755140149058,8402016228563459307,16848573004401087964,5588162170866801082,5824947751422200047,13615514179621968267,13781767781228034014,14423422440059170642,4640354925879941661,8531583094239604610,3594266973649170541,11090449916454954961,5326923029705029655,1581335795679095261,17492371962559321113,1493392441690405438,2489592115412947516,12213533684989750447,5235860512241406149,1351923774884905944,15216141354232652141,16410329723721407395,6936124585426483851,12052080952434340474,15386361126214053258,17947917755510698585,8947846274069777874,5173032272494754420,14915812527886642538,8422924929494860962,14508912594747889086,5234319020029729230,3895091415083253511,702956857078529013,15003631243243990121,9148607054985526935,16888533590828269789,18412946120335945764,8092272529530028511,11465887032779490825,4575426738585512281,596133695499078891,11174558671047420501,6413470944729610712,7071725610767747912,8612669403407323119,2747456810774424190,18307605670063672847,15542983068504793860,13617147752052882980,17449779932237945944,361048085625915893,13949331863158446677,183205232455367428,9552416451672108477,11621120455720731945,3696999716426306200,17464623932249909801,13086925836175178185,675558012984476630,6351760953987014645,5042416241311924935,4441796860992933084,6150869374297499405,3779151262362459964,8247486771419665317,4946435607890870763,10175919850279848737,12228070893419008750,1040221689818688025,8782712530767676979,2471289196785042591,18015025985997600127,15753726540964255780,1904619538364727953,15001033169211692540,11019910338922671566,16659285940542355834,5654612658783591977,5539121617588282677,15832110466645423587,16073303419439300508,13896063928322732450,13737495779485462326,2139448577707913920,10990951234776377257,11822990033163534338,10214828777098758176,12780253586485868942,10959341402762148649,8097517431389540568,3579318737381359113,15203465725378367944,6475189041349688125,17583366957286575376,13786225935411234818,5627862574133346327,10687771757967575636,5428590748793773709,5605769682131888960,3098784905417578613,2521569044944428058,1109743006783783855,17798570472355409954,9740901200130067225,15552858128026996306,8096879481799462925,4499009401138534805,1488023888074053892,10720698241529741773,5306595936080176851,1723160093001737476,3313209945472343757,7352385621883264833,6591778030837885679,5961246303986050021,2054864314689337469,12279021957130435587,5158298631312873612,10258125727677186580,13946050407540646040,8907268586639725171,2284627768742538581,268760016228044423,12657682937280356871,7236143611661867535,7153493787930767032,15004626074231388579,15248147394052017445,15798457933279940839,12118339059207899460,740058309228133259,13499837521577277550,14414776098334861282,10978183840644767903,4442200482821689162,16653325249510641303,12594728469405603992,14803466150464812253,13544933844100505912,4092432764438652690,14608010978843001836,6859737055444880558,845118408627393200,14212804167574099787,4028758949368518670,12557041466594791328,2747456810774424190,17613331925478434264,4298495728994266532,14324097389444759822,4497250945495657052,16898196782707402812,2645830935622857146,7188606887937218434,11142474153313643722,9160552800018573440,5355734434831862642,17077582438320173986,6733031482846278197,10944305074493703516,772381186302046155,5956834376542349758,13219376239720109488,7152970795785000798,3532881827121440249,1490972260495550316,1580080210475436866,10458303851688712297,13549127333671732974,1472577544316448296,5348032008720413660,17997004660873501787,3666408794060349688,12151803445619616041,9308145560790278747,14657788168610162188,14567498919215412817,5180089724464668063,8836646187231100431,6733428790536959726,11063179280053239876,11163045789239979579,7249338646869494353,9539774900656196587,3146025727546447536,6962994075689384323,6225237367001960532,6265535826283864357,12464409598248783517,5701900589632194520,7821877596493126564,9698849625630977221,8468207659130468959,8592769204853745780,2560401561778060715,16110419091199082512,3548551876923534715,3191397550769510763,9356309514678985273,15461049155365146886,849141116438617612,17986300783788290313,11351860838401912547,4466850359968083665,17305856671713103846,12215671140581532246,7411303974111698092,1652498657537565281,13642680698468361738,3696638521048332733,9932763333520430973,1823536904168819188,9569123205563783070,7440973743612580723,14200591742665401092,18035377893452503918,16705333742392897378,1287078300157576430,949357972905331266,12913259348890523573,3855837142052632896,11883340650315066770,6271701450748319637,88922730680640319,15615297678122524065,14867896218141858710,12108175939291258547,5448335882923733436,386920597663747245,12780593783951827305,197423435556629822,11936537570946384715,6323840715354850164,17444105902216753143,12496341919754627916,17980561514905888786,65733309261215142,11202568213913235954,2412298314723315154,9108944695971584949,6239873934287370958,9849174412707034242,8908199128904778769,3588131515172091238,9021214721479479776,13250780938938057803,9297305607756737664,2747456810774424190,1808859805078019075,7618316316210616801,12215485669480966912,15429232069159932833,17229158444178454673,14106407237846645310,3106454456885766557,7731337911860333666,5331334585924034852,2083577722075073326,2287256194216169869,6270075565391186471,18028104341038154833,12634834509021955782,8613089217945014636,17773339189616251990,11350327666813949263,18140695107072618348,15281219379168027294,8978258268070614433,12540592517015773432,12431569109375357455,18418366110849632455,1831200803529777978,9335221536275256623,9602303318177040012,762002788316733331,16069643106717422136,7661884330085750748,7244417723769557846,17918133060711189607,15745591524471708685,9055439669625044354,5375850683043323111,4272764885907097689,6827164500899090634,11834832056038087030,5268108291063574770,2295687227243197992,9737821641871987709,11701693548778092052,2582379894515837276,4501153169400492897,13922424473775924125,4775391112116889731,7058682694812604414,5124650078325966997,5789484675460841018,4647900664205873997,6106248999797049093,3512812787507516860,18195130814727118322,1283041059589660954,5982640017580768890,11859621125261702311,16697860088806244127,13807742353857655607,5564602511196173749,9493202458841936611,11170116711038254487,14162600533985902410,78735094193786953,2956105308695312520,2308166261076583163,12467858897646511570,1935787131291873473,7740479482722802466,13732564706101006238,6134668068812174419,7938849479747137362,4981568008423252084,10408624575496594926,14609259385616770385,14257147088462197370,8182692156043940741,15472173181275853473,666298798650652188,5789887262584193518,3310442637074843102,2674626684214483775,18232849995488262965,3575726681561010632,6118480533485732037,13476656638458600287,2831254715132024830,6462254973907635097,13400800478237933566,14620935161940485430,2301643142193468515,15150551382723713405,14201273771588332317,6856066388685878919,9961319436884478796,7522289756890744724,14195711868278985112,14945867192866341473,13179056244966471899,5195005749984973034,7745105124372790929,3137812723921261427,2747456810774424190,14775427279083762338,7130655759219704242,3229130788721194281,8437374700216137204,12686099444432147334,16504206196097719159,1612261727533381215,2506416729915054177,2249975069604960137,9522042966476060971,14419475961259190697,5883548448237364515,14711248360092934187,2378079170792468348,307733942647063220,16070731595162441281,10213346231816908499,3924340623001655601,11948678465500444582,12925092868601492788,13302846191386337542,7166374619126548443,7329595547218601354,15183470653955845718,9683451374266391455,7921537379775566354,11178858228873533958,3859680149921018625,9594028132309021424,15831391060417539140,12396162139567626412,6678035818224129452,4226750629902568865,16754969507700644560,14169390946425982065,12772009183730222821,15449933717018976062,15606924722343103627,18199617330506675498,1785680722354987232,9054244052850135191,15306174722512402679,8882617938106388280,7533714105273133013,7480578381404617424,2030294516481617939,6946788936202235497,14819474548627018605,17321565826848038945,4966856066027168528,6430417963098676182,17569532873441754673,10993977078309543078,356546511725343984,2751712378771735711,11195328150356434180,6703196203525694331,16963077185010604076,3796061487937736794,9424881020069210577,9177443334249169473,4350917860043193128,13285854093073098545,9120543190624795604,641314390767936094,16883425110144900325,7670011673809934272,1815631643788417528,14173915919419492979,7304152789070090525,2499661662340297746,3507436728264011101,12008010396222598314,5701752076340584450,10710238860405584475,10187540203149054817,13245499313095691885,7072945911747355572,8878172791484372183,1386427279272451963,17185618877128973039,930382557135416632,8679291740020853301,3420475105185566459,4039410492201735706,16742526208893362794,6642879462346768663,4055187193914829989,13159365642148467323,5719135520104319373,6903712371859236905,2275956545360194321,14965983225764881709,1215041652023857535,6547591528413952581,4048008648670127345,13154615102152164321,2663250353023082271,14989611283801179035,2278721292300687327,2747456810774424190,16621804365264701290,15902902662797136389,3101254812284012024,12853375344110115987,17375960163585608888,6090752951116290345,15120738562652897506,292801200476768760,4858118587637213416,10363363028115492610,13499977208496694253,4340233131031863222,5034163834751435655,16180563488713165495,17761982013216654674,7746680096671885374,3799473289694482568,1600165660340595696,6296445769136783415,9287157131842972859,15320920019762070628,1523551886092456327,12951705257544083863,7032982369829797337,17972179168386959849,6486659592281883085,13418157807796680588,10641825513238789024,10987875206157296492,15329605795045246831,9714877993845163400,13160595876675818502,16578541844218547703,14551134548262802035,2369288310461955396,8616868295677485276,1883268625184607614,11153484061366741421,2029829267318514983,13320441084614711063,8179331388435213151,17272111569257227840,2256203974688584893,11414693033569701749,9317934712959125257,11657468661967719081,11850602997565048516,5053851349103422791,18152460281864471832,12883160333481805571,7336742905795695925,18304188026814628946,16038792422085358345,2727990645330754391,8586492337773451185,5753398122074171323,478725971348445084,5467063790313737495,1957158545739026284,868710565842286536,11491141749672857810,13814187597966113998,10805601231478495206,10011203716530849996,13592295037664709457,17510006404502252906,9810978798686251290,2533975984442425082,12628380787658329994,9253931975578131413,9272686582026085969,16885022496336395061,4411694523316838779,3742703674428791932,18361719631814538690,4430602852702566020,4953463398406790236,8047801819606254702,2666120740922446540,83189746008155417,13233747015807244007,14067094507155685099,14629509395258667458,17011584498906019331,17693659742533089337,14636628172879674286,13860441468588335269,11505499875575846223,10282663500323488558,7706068157257665902,4012951190874158923,5054859521836313142,146746973379565777,5082734709179172685,763987474940717775,357515281717046914,8522024621266274102,15043203336997734021,6584141311568584969,6137536912141007472,2747456810774424190,15102966532251805036,6429080070215424838,4465544746323381297,6428026334017520502,7165940222687148765,18068292086862363030,16724153948290905720,5102449326825672066,9796021655015119282,583315463691995859,8425104169375848537,18021104118226498985,13707209844217452207,3602209688479402477,3065643000248227296,12970109206296154111,6081053113068356284,806763431497437981,7074454182156022544,4666790624043123570,7410339373505206757,17359687780128095308,12851478050519680347,5516407615204137454,11446900172771659714,5916375000327169499,9911022437089857917,4559629905267559674,2711069799292097679,460127445148259076,15734760268044063346,14993064060874446192,14463515522847858248,2981297413925575659,14318791863243780990,15312559363386084129,12138899764542634628,4276517862872049004,13988620722158980547,579122199196489147,5227203990303085378,14607860961107443134,9214232629122779132,10864493353130512931,15089061042647629954,13044570535757212909,7939148601160055495,3670606081579267271,7440203961223868466,3886156371034526478,7758453967276438704,17045846166721202368,17160751084314184243,11295552755490174483,13965328619820493700,16324539300689717128,9959200077225735594,8434369755785586988,10849723992542493067,12479700721710284327,3889601221498794470,17827970792177339504,2058067949648511089,8288194933805088189,8388739812154100259,3792078995109442081,17544724949476670232,1359821750485975182,13953547571836785122,6585360761428174380,17779373243574698896,9653878935811138410,5443589691763360915,15020127836796732052,4080329516728078414,4156769456815703867,5570253396215292257,3420078179242338437,13969866225732030428,15765818829245109266,16882980983230708841,5685882884374678602,10800131966472828999,13530972475510641108,2276345503187439046,8690881788322600112,6894108265922379558,3138017842788634533,11120048404760289561,12436556872343541071,2050788898498501239,8364013059234141054,1588934512473191892,7704128580925167218,13080594395242551857,1611893070133014061,15039127767883081634,6121563523111709025,733571574987450770,18297892758592655378,2747456810774424190,14387809927948558926,8770241247735555976,4324459756888429511,10736658159964176636,13847490221490668755,18289582318770946046,8768548517459160234,895265414396184278,15577384544297380799,7928801336249356610,10121729696790866702,4483559212622004395,13949423053761648497,10377308702396498635,15596021558046983103,8496253237400745022,4530833959973030973,11651897080899414714,3996385525727596414,14921441450939101379,17721857401317611567,633766464612552037,14323755194059829102,15112801232247624766,3524648010089539838,11292953383903168119,9357798491967400315,13527879779752284948,9442318253412536641,12246663326973925447,3499316649647963000,2615546357121531837,11337899065977847560,4775871159094608466,14543296342812536498,17955308061934559067,937198032107063202,6361407636085093667,16259026920411008636,3684325193994504327,13674254695280344745,17457155831569656558,8057948849911987753,3435320404075875040,16198597322686810668,8678942346614976278,13321274484105779875,9799445146434483325,5905329027165043363,3194158099866910128,14619002343215163317,6858830643846868737,4518116530915013529,11437825744568536338,16029076187287089951,4850616439351031734,12527822655784759962,8521936281741730160,642951336755329417,6141205331179420106,11270378228125845070,8628790571367723148,17694212334968682745,14195346780780474350,10217451856885275427,1932657290464200639,11516039164635968816,17127105613579598297,10737508120317143688,5866917393414150097,18294155126709300230,17638762815113708052,8142146198250150220,653492565616522443,4324316300150191025,11564718929588318290,17124752949195138190,17911718032189319991,4365132741485088049,8533367691238810281,13726077062503587503,6407890411221977468,15906626131262520617,9763132957218287753,4452619230582950767,8187164160026993869,2556185280915457937,13695121886502979087,12603855654987660488,5901060035570367073,9696357027886418373,9545282955955462433,7907967183285249641,10181057333674243528,14436569595351905119,12209619398477797003,7914952334722130399,13071757550830989151,13988936523064590117,2554166070220680394,2747456810774424190,13125546717451195116,7306456991081513019,9846360906616894931,13220441011537783121,13100165614143437854,1701360359357786522,12102218390879837676,4219228081946746150,1759475019619445227,10478016171413265724,13539515649813581778,17263171621042747867,9384135737682073321,17579650890743909081,7346604961360219196,5726854952235317863,9982713697669166937,10045942416169379670,16238016827863118988,17175753997983420380,2418634050400401879,14854107235481306058,9107220194571152698,14749358319631591564,15903420634938633213,4934388589570505072,5143846174983891060,11750163304141382979,8414002870898119510,12304069005558784720,13150751639677238876,6052718926350200926,4714251373884861630,6827342445064031011,2794439854191621921,14080131268941296733,17139626252045792342,16632708085467570137,84846697803781479,11286332327868958787,11428476694482131507,16487504461896954168,3547031647968268356,10681949299305693089,7463536224716193922,6591054980031929947,18136527178700896050,10761462309072661885,12426612075527313722,15351163991000728940,1124261605507430052,18440987012265937692,8095376254636106349,268487093247448166,10165230921371934579,2750005451061022485,11555058913299477471,9593505339734736708,18198202330321620864,3684396886366908317,6219492064098681452,719616562681070296,18308697975129859081,15499968160539886255,5898159374413618915,16942747935601460047,8701270605819099624,5972826912130842343,4144108579132667324,14492507720787745071,17257218294676319423,16910455036144986010,2919142701579355956,16902325429829085464,9621431494568780278,4843444918757747272,9536661557800618091,2498536808213594990,7328921585882247967,10096396354225951615,4692349155739338723,10101509171953287029,16456639768814890725,6736462063993390581,6012337393879189857,15930600395627076128,15595597759655435910,3668656656259785701,15860462456483621088,6352906055035432414,18356591796340015529,18036620635586511199,738928898689831830,13608605474013927804,9297783379073707438,17577382139344547959,2458963103647828269,7050770040218581176,8752091947170817759,17674624086712424082,2747456810774424190,11555749646885719807,12116763064601741944,10567308901205178433,15529623473310298877,3408487166038051143,3299691911388697072,3007495253489859490,10496379407017684971,10921095959894677672,10747053957042806201,5922920368256990174,4865700896031264660,1494146159870300796,15400912649774187633,11790380509661360413,894172619449494912,708986011615594059,13084449327941144658,1980729287162237738,945441460517488753,17305717616155058936,16284128014728299305,9161514048285553620,11853431252965721205,5368432656998280858,2795090292331613013,10967838865488161901,15735200480163882753,5158223648103461311,6051648982968880701,11689479004871523756,3217669570277044559,10606831850116759515,9715747156014377186,18423999345965481749,4224201686351535120,339562711127758263,4677562806285871662,2885938008714223364,17025847637313772081,9751424822652100790,8206472029988837499,13084547581466155508,4673676758906991019,14357055841885816873,9311617830104427266,10527535604609520567,18079525323232024974,14391549501677989718,17874948713735849046,1211169217144133375,4444171717571261899,9765899672558335655,14085813373429891491,8702012242773776158,17581698449300422050,3009848376670280347,1768513850757379391,11623132648495443561,6237731819345738265,12626601586805298249,633563102135765382,14917673805653287905,1304794861467430259,16014970220190939903,3301458530114024351,4763014148475197704,8536290350722744923,6674035952628652976,755987141721232324,10926445840860737269,15671592438685450019,5426369528790794000,11340968513434723332,3412834661309524903,14194312184414296145,7847477839331903703,980852479292538796,15292241415088184952,2196376686750879561,11386122647427019028,1392513930575682439,6511857671357512926,11666360504546171290,5718414367728714120,5923308080819399001,1167925770341310090,4634873932318635300,15135360402785744508,299174593335815606,8011527786725642259,16794447954816060666,13328563096530432696,4759896671878702407,4469948309521050292,2355832378125511421,7434533940576439087,5417759640953740012,2050723930901812560,7967762072122793109,2747456810774424190,15215739492221836593,2939737414421008587,6446322337747242467,21879946997825028,16456744398202204204,18295218551162638518,8158908338174936417,13446400257091164857,220331706423524745,13427285653447062947,14382196284078857078,5815188426403973820,17423817905832311377,11411824183612384130,5136514163287864776,5886576321933455684,3430584075417323558,9550889669014775735,6764826286728993817,2491840306744362258,15569327863325553971,1227514367732923588,9261144418180514520,2877605420182337680,14530347792957097227,211120556348753812,180211266087734040,872030821950963801,6247867881464049771,561999773871244650,16323495281832214868,11550839271891864527,4840645149987348766,13584491543360279192,531388204428937193,6590603190974549861,11134780394186822266,11299897774604142373,17912539815821663503,1095389960277673879,822514535029923056,3373425241105388691,4538078977248546918,5284003875335687661,5423423931785843152,935980625559297296,7544610797386297639,14688226521000838471,8483323643139171152,4103717927424471323,4784381283435481128,15609216088410193672,3991530689890929439,12662351520794232092,1568586520432684384,11764458104392847530,7293360749002256926,8862235685349453644,7746332830365819458,16412174726860440148,3462369598354966446,7515166945125429388,1818431452475061550,3829226521739178995,16445676765621850304,16475533379276126178,10337110997946099516,14755048197048953598,512169291693695313,16570422323408510361,12894858585901719580,9550679794799461572,18223809618019314883,5895583719443585823,13381617720740874770,9756388659844787253,419738737307584738,18305552180524040754,5904318866972741777,12641333573692908227,1644526271859512355,3629447390907463586,17213299020346435390,16406770376413771386,8561004467872516120,10882604023926601344,3371130989875576864,17277704117980441185,17055638810172868564,12250508605635289061,603272600795030613,10039996983808845995,1392021940259437234,7841658334925181165,2449917642828789828,7174384079118295921,14669168217878290276,7275645175319000903,16307902379849141003,16085006571373086535,2747456810774424190,5312697365286710545,1740166779544288440,1410056285058756111,15817546918477350263,10151668847944565469,15159402886235814030,5033948193661944896,2591635590725229245,250686191087942067,7952127945327341357,3270829502575491541,17706449341067178858,9672319028124486940,1741021621597939880,11459618515389506333,8752195682842467268,3025154848861910700,2986031004386152895,16453109592400650221,11134977376016121417,9677437700516916874,5475293772232829476,3733547023425185260,4390720167520812824,13175180991323880227,5680692857533090388,7131593566154585348,11448628461490744810,13208934100820977741,9285347812840273863,18029902067079059693,12122197649851598054,14778413959234750864,15550763099151567132,8910454195154940405,8707053704556786606,6285581344654204839,8324133507545465650,5500894387997662216,8489664789639744431,9813928466098899941,5814886129118926015,3716322209540298206,721930923936206647,14020615196491120312,5685495581706607709,4536543441100890247,13404110290024159007,8422309035845502439,4191075949773967953,8022506990577338400,3297803077698124229,9474122607342812385,2982974729709294932,8231901544164035100,17486457074433062939,4267091432831359897,18272641381805259111,16734168661868892030,13439283326074175932,16551699014054517379,523501702831051860,4782343249559698686,12151490002552070968,14147845889432908254,3068343995265367000,4090920144216588412,16908373714560695917,10205849469396384168,11530006112201450378,13256719575063801059,3694345079005932433,9451849725119337944,16562872014519516374,821957973045587279,17199052942826077838,11508861300292313681,7728745407902180402,11669194556081728885,14040160659090605129,15719114838900192095,261759909113769595,12371537250465060710,9335147802761347227,12448451766442643292,32760251176925269,12235425466395757469,2895143681307225928,6998832851001927451,7902709533156292603,8630317393763233450,16040699018946836643,4623861050360009870,14774601773507972837,6314097322088512529,12196471877316529857,13942610066951357513,13415446477535295243,17743453302488002369,3623120111299528658,2747456810774424190,14595808620618687619,4956624804163774025,10656501183823267228,8849163952102915217,3138189349877052944,11530849654803217896,15488045464387636435,462785906338347129,18428583358724458096,16002374481474707002,7813319777006818056,4547848917229435544,10319184139605315085,14257753988721557153,17326832564852865589,9977808105255575831,4138654113831019152,13342252583251029074,4832987575703523473,17038368386734067367,13325476877660450518,15916076448991609125,650204809009071699,13311322087938885789,12487636955063767680,17749313884229196743,7739819495184799927,17665318410828985671,9357380208103742001,7449501557616207875,15401369468313462425,6298841206971684967,2720415548287537837,6180829419379263079,8813827796786860844,16565612163532543128,17576872201307100612,12988136280421159630,7419493739954003224,1239154947791898685,18328776810353762005,14127727191643426149,7522426658358247743,284248106642626262,6015370072918229149,6759286345675678201,6503153785566431627,2130590512237382565,13713681979709282284,3861115422075281024,15665509538094241790,3268370936874435595,16810599334707509346,7230332412311052630,341220364193304589,4506343564185899430,2223437258868092947,17310026048976423705,7177295684265033073,3170944774816704253,10840644724650732873,3505284018082570827,10807426339023324483,14228219714152014008,17940612152010186748,17864272401818339247,13298868465294372758,4696766452172033047,8984545129636103024,15863647052886151657,663466048893451929,7538032366704797499,14750823149604170380,16821204421550259760,3212505049775451619,14295827625109816754,7071509178390764980,4522779049726418525,11778096599773234508,12763159589860035029,11517082119247385196,17346386261809430352,10186626482181371910,2242754838155830328,13730219905690051075,2562273756836449587,15331844401894459854,13141379319778639934,3408091314783207134,12038615765724666917,12124722204327477911,15548358195506005328,305514341134888130,8131142972437071110,11241080752989051335,1388047851268764277,1463239939413659572,2442678508474621204,4764687213110323987,11811926331877380736,2747456810774424190,11804832672058772177,5416814813222112360,15318616015783400424,13146052196334931446,895314013413428192,3699926598523063110,1786283536485213523,9489273941345161049,197111473330969198,9258700865191119629,514814160493232256,8882991954412572977,12717983279337023009,8707749243990872022,144140367770456297,2548565895922299598,10017771767521390704,2731516236868404269,486869797513621151,15313765423393507474,11040576165402856805,5928267603353590275,7085257617036394798,10495259560541762321,771868630067242274,4370637210893188451,18421364970575659642,12896919294110048435,15379373565193937475,4285063239002784044,1579014214063754249,2254155318960492092,7747665101062924363,16037149715197777302,1436364582401536441,14081643704345895015,10142882219392597503,5335382528671444917,14664933223818162490,4457639790978789549,17980944840133163965,4734485656264389974,2033108280049670837,12252505567929828013,267918069978536456,1976649558713789642,13485380129386066773,16644623782723708322,2637039915468136453,2661164787984938336,11670643642640585266,993196678284675158,204049494997000124,10190448701385846923,14990251613835524670,12478822870582516571,6107079827667859532,11829613217632720809,15359780755177192180,11573596537580142323,5169078635615892338,18266606341996575186,2051986517696198951,845999985416759873,10151805952480116058,7794759227472031973,7537281011333248728,10870678420555194944,8691023734581929363,11874460935800541371,15476364317309159165,5612407957813901293,137265988838392142,13798404879420564474,1798243854586989982,2412319203330922218,11302984355706778562,10930948811027209190,2374783042052894700,11172324471295787809,7082158698875154205,4571188640887398373,8357765229140391944,11482721217668758261,787044158165436134,17219361910257947164,12667482951121281262,5119917683550612866,18016065455671263023,16232353477083432622,4588734689279667639,17770452497385106967,2806583258386187406,4912253300241512839,15725101648606891122,5179251196414626290,13924971101041130746,14938141821989220166,10938487644931976521,3391080579573309611,2747456810774424190,550730678662635920,11036628707514824652,4310318720615217021,1290205098408715201,6264558837644137918,12847006613575330122,15135292061264501735,16320315729588219787,17896005883118052760,12528277484559943881,6444442547425652792,17452717949140236982,205167876157182209,680380454771185902,16187223133013406591,6032215790601635672,18159044812658596037,5704926885593172543,14208206378725337354,6548252369914238241,3310358487353872676,3295782293031524242,17353208937723569468,16334781880569569397,4257229679437853894,4382719844844746756,3906582950789321267,1380415694590213979,2017645381825601323,15671697519037349169,1299750014135085107,13077403654508523094,10346268192273571696,12057834117451179089,11125374098111183241,4912093933493437775,3806084728362814968,106116865111680255,11728312865556942992,6404494904055656576,10273648685448235184,16704731077904575534,3280840515092627579,710427001284846868,3176378275371581514,3112930305053300736,4919789933321046236,17413859238510263619,15186741389303502255,8870979905688237564,9124997771185622777,17626959527798598370,1800937260032137458,15522944318096243839,17615944922366027880,1693948625784799116,6050020484110667468,15529909190626568653,10172943341797462317,10763798209202272821,2022574610319283297,6034945558009391380,5193048029285479862,10125446274268912450,12889116335562896526,10497009470721590206,477066961866875368,15984582274491438094,9722667657775291138,11804557708276012931,16565478294117314090,8145202875969792200,9847381942539233539,3922070584116135863,17697179581250724816,14868281881086723048,15687833403285411709,3210204939189278412,8096381068011122331,329045997944838234,17595722184255088523,7076827261487462985,12307171428969918018,1720188676063219932,16531344413910296647,2132537261052229448,3389815603095185509,6084651750998446871,9266735319237119529,2376736704956305060,18068330744426371869,2040890284409898241,2903142209538341437,3908213407201662157,4134579092144072316,14816037371660737620,4537388167918834717,9451064955450533365,16344102616860424472,10586177359116292645,2747456810774424190,2747456810774424190,8775533841765596026,8598661800576736657,859841143680829306,16832985826374125741,13576731593875001812,4047841883330530799,14468563807140312397,2747456810774424190,13706148461458866192,11888548015111673208,6279942607549426632,10560869903210027619,6840985564253972831,1629453574346666212,2747456810774424190,9404875290705216725,8047859747597739615,11279260331770449166,14738201029419054882,12802894158610641270,5007097775891892768,5985540232752165520,10905343657178759437,4738054991864250763,4412308128172281928,2747456810774424190,7950668948320098156,15510566813356266251,14491349918463444174,4597552876615663029,10909385503459286175,726434258702578570,2792808412003773828,4957294112396037910,15464224686106443715,12040753679692366823,11435780342100430117,6187810377673739302,5684209509184674602,2087130481686428051,10012013606835808902,16681498477444963490,2486485061016482748,7880053827155513992,226779149997741814,15941191421616117245,10354795925236520689,6148406478066548248,3066784816848150324,11418737338249817341,627687876342142576,6104753573815091241,2747456810774424190,7449913734407788309,12676920847387855545,1271126938699804827,2247521836253438921,3701119872973709075,14241482217434519499,10924457614931717714,14600386132130357546,8596772114579809763,1133135749005771946,15629511012870432565,562167134678708956,1785891314908345482,6590557618060320123,12239494261891275021,653937424729092947,3966532319148332951,14911875796528160662,1569656670076060091,10857513694953462041,14070300686498181161,7866092980731901009,3724790337117408985,16820170213536912102,14413787497956362302,16240642892274239867,14899256773044067082,7607469942913496757,11117746547951996750,17389863984625652218,15611338375046335567,17303681440514163259,18437921368343601590,2747456810774424190,6918890766581257847,4804063966554483719,9264444576494688449,16909508569334085447,16847923286055043403,13982001572869537842,12111499050594848849,3496838060884252484,17180373786659622650,18016199340872739497,18106969400714499324,13414017669024524692,5029772737520410873,6983887670055767099,6762037258984942787,2747456810774424190] \ No newline at end of file +column: variant with hashes: [5538722551051340495,5538722551051340495,5538722551051340495,5538722551051340495,5538722551051340495,7371345925615203687,7371345925615203687,7371345925615203687,7371345925615203687,7371345925615203687,1653038164052872993,1653038164052872993,1653038164052872993,1653038164052872993,1653038164052872993] \ No newline at end of file diff --git a/be/test/expected_result/vec/columns/column_variant_update_xxHash_with_value.out b/be/test/expected_result/vec/columns/column_variant_update_xxHash_with_value.out index 80c79e48777067..a47b1bf29815e0 100644 --- a/be/test/expected_result/vec/columns/column_variant_update_xxHash_with_value.out +++ b/be/test/expected_result/vec/columns/column_variant_update_xxHash_with_value.out @@ -1 +1 @@ -column: variant with hashes: 1417894694298673530 with ptr: 2023 \ No newline at end of file +column: variant with hashes: 11329750091889114476 with ptr: 15 \ No newline at end of file diff --git a/be/test/expected_result/vec/columns/column_variant_update_xxHash_with_value_with_nullmap.out b/be/test/expected_result/vec/columns/column_variant_update_xxHash_with_value_with_nullmap.out index 80c79e48777067..a47b1bf29815e0 100644 --- a/be/test/expected_result/vec/columns/column_variant_update_xxHash_with_value_with_nullmap.out +++ b/be/test/expected_result/vec/columns/column_variant_update_xxHash_with_value_with_nullmap.out @@ -1 +1 @@ -column: variant with hashes: 1417894694298673530 with ptr: 2023 \ No newline at end of file +column: variant with hashes: 11329750091889114476 with ptr: 15 \ No newline at end of file diff --git a/be/test/vec/columns/column_object_test.cpp b/be/test/vec/columns/column_object_test.cpp index 7d10b5e77ef813..25a41722f95423 100644 --- a/be/test/vec/columns/column_object_test.cpp +++ b/be/test/vec/columns/column_object_test.cpp @@ -634,10 +634,17 @@ TEST(ColumnVariantTest, advanced_insert_range_from) { } } else if (column->path.get_path().size() == 5) { EXPECT_EQ(column->data.get_non_null_value_size(), 10); - EXPECT_EQ(assert_cast(column->data.data_types[0].get()) - ->get_nested_type() - ->get_type_id(), - TypeIndex::JSONB); + if (column->path.get_path() == "v.d.d") { + EXPECT_EQ(assert_cast(column->data.data_types[0].get()) + ->get_nested_type() + ->get_type_id(), + TypeIndex::Array); + } else if (column->path.get_path() == "v.c.d") { + EXPECT_EQ(assert_cast(column->data.data_types[0].get()) + ->get_nested_type() + ->get_type_id(), + TypeIndex::JSONB); + } for (size_t row = 0; row < 5; ++row) { EXPECT_TRUE(column->data.data[0]->is_null_at(row)); } diff --git a/be/test/vec/columns/column_variant_test.cpp b/be/test/vec/columns/column_variant_test.cpp index a7fba428b377ea..132513c469ec15 100644 --- a/be/test/vec/columns/column_variant_test.cpp +++ b/be/test/vec/columns/column_variant_test.cpp @@ -49,15 +49,13 @@ static ColumnObject::MutablePtr column_variant; class ColumnObjectTest : public CommonColumnTest { protected: static void SetUpTestSuite() { - root_dir = std::string(getenv("ROOT")); + column_variant = VariantUtil::construct_advanced_varint_column(); + std::cout << column_variant->get_name() << std::endl; + root_dir = std::string(getenv("DORIS_HOME")); std::cout << "root_dir: " << root_dir << std::endl; test_data_dir = root_dir + "/be/test/data/vec/columns"; test_result_dir = root_dir + "/be/test/expected_result/vec/columns"; - - column_variant = ColumnObject::create(true); - std::cout << dt_variant->get_name() << std::endl; - - load_json_columns_data(); + //load_json_columns_data(); } static void load_json_columns_data() { @@ -220,11 +218,7 @@ TEST_F(ColumnObjectTest, field_test) { } }; ColumnObject::MutablePtr obj; - obj = ColumnObject::create(1); - MutableColumns cols; - cols.push_back(obj->get_ptr()); - const auto& json_file_obj = test_data_dir_json + "json_variant/object_boundary.jsonl"; - load_columns_data_from_file(cols, serde, '\n', {0}, json_file_obj); + obj = VariantUtil::construct_advanced_varint_column(); EXPECT_TRUE(!obj->empty()); test_func(obj); } @@ -750,11 +744,7 @@ TEST_F(ColumnObjectTest, get_subcolumn) { TEST_F(ColumnObjectTest, ensure_root_node_type) { ColumnObject::MutablePtr obj; - obj = ColumnObject::create(1); - MutableColumns cols; - cols.push_back(obj->get_ptr()); - const auto& json_file_obj = test_data_dir_json + "json_variant/object_boundary.jsonl"; - load_columns_data_from_file(cols, serde, '\n', {0}, json_file_obj); + obj = VariantUtil::construct_advanced_varint_column(); EXPECT_TRUE(!obj->empty()); // Store original root type auto root = obj->get_subcolumns().get_root(); @@ -1188,11 +1178,7 @@ TEST_F(ColumnObjectTest, find_path_lower_bound_in_sparse_data) { } }; ColumnObject::MutablePtr obj; - obj = ColumnObject::create(1); - MutableColumns cols; - cols.push_back(obj->get_ptr()); - const auto& json_file_obj = test_data_dir_json + "json_variant/object_boundary.jsonl"; - load_columns_data_from_file(cols, serde, '\n', {0}, json_file_obj); + obj = VariantUtil::construct_advanced_varint_column(); EXPECT_TRUE(!obj->empty()); std::cout << "column variant size: " << obj->size() << std::endl; test_func(obj); @@ -1201,11 +1187,7 @@ TEST_F(ColumnObjectTest, find_path_lower_bound_in_sparse_data) { // used in SparseColumnExtractIterator::_fill_path_column TEST_F(ColumnObjectTest, fill_path_column_from_sparse_data) { ColumnObject::MutablePtr obj; - obj = ColumnObject::create(1); - MutableColumns cols; - cols.push_back(obj->get_ptr()); - const auto& json_file_obj = test_data_dir_json + "json_variant/object_boundary.jsonl"; - load_columns_data_from_file(cols, serde, '\n', {0}, json_file_obj); + obj = VariantUtil::construct_advanced_varint_column(); EXPECT_TRUE(!obj->empty()); auto sparse_col = obj->get_sparse_column(); auto cloned_sparse = sparse_col->clone_empty(); @@ -1226,27 +1208,6 @@ TEST_F(ColumnObjectTest, fill_path_column_from_sparse_data) { EXPECT_ANY_THROW(obj->check_consistency()); } -TEST_F(ColumnObjectTest, not_finalized) { - ColumnObject::MutablePtr obj; - obj = ColumnObject::create(1); - MutableColumns cols; - cols.push_back(obj->get_ptr()); - const auto& json_file_obj = test_data_dir_json + "json_variant/object_boundary.jsonl"; - load_columns_data_from_file(cols, serde, '\n', {0}, json_file_obj); - const auto& json_file_arr = test_data_dir_json + "json_variant/array_object_boundary.jsonl"; - load_columns_data_from_file(cols, serde, '\n', {0}, json_file_arr); - EXPECT_TRUE(obj->size() == 200); - EXPECT_FALSE(obj->is_finalized()); - // test get_finalized_column_ptr/ get_finalized_column for subColumn - auto subcolumns = obj->get_subcolumns(); - for (const auto& subcolumn : subcolumns) { - EXPECT_TRUE(subcolumn != nullptr); - EXPECT_FALSE(subcolumn->data.is_finalized()); - EXPECT_ANY_THROW(subcolumn->data.get_finalized_column_ptr()); - EXPECT_ANY_THROW(subcolumn->data.get_finalized_column()); - } -} - doris::vectorized::Field get_field_v2(std::string_view type, size_t array_element_cnt = 0) { static std::unordered_map field_map; if (field_map.empty()) { @@ -1903,220 +1864,224 @@ TEST_F(ColumnObjectTest, get_field_info_all_types) { } // Test nested Array with Int64 in different ranges - {// Test nested Array with Int64 <= Int8::max() - {Array inner_array; - inner_array.push_back(Int64(std::numeric_limits::max())); - inner_array.push_back(Int64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int8); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); -} - -// Test nested Array with Int64 <= Int16::max() -{ - Array inner_array; - inner_array.push_back(Int64(std::numeric_limits::max())); - inner_array.push_back(Int64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int16); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); -} - -// Test nested Array with Int64 <= Int32::max() -{ - Array inner_array; - inner_array.push_back(Int64(std::numeric_limits::max())); - inner_array.push_back(Int64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int32); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); -} - -// Test nested Array with Int64 > Int32::max() -{ - Array inner_array; - inner_array.push_back(Int64(static_cast(std::numeric_limits::max()) + 1)); - inner_array.push_back(Int64(static_cast(std::numeric_limits::max()) + 1)); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); -} -} // namespace doris::vectorized + { // Test nested Array with Int64 <= Int8::max() + { + Array inner_array; + inner_array.push_back(Int64(std::numeric_limits::max())); + inner_array.push_back(Int64(std::numeric_limits::max())); -// Test nested Array with UInt64 in different ranges -{// Test nested Array with UInt64 <= UInt8::max() - {Array inner_array; -inner_array.push_back(UInt64(std::numeric_limits::max())); -inner_array.push_back(UInt64(std::numeric_limits::max())); - -Array outer_array; -outer_array.push_back(inner_array); -outer_array.push_back(inner_array); - -Field field(outer_array); -FieldInfo info; -schema_util::get_field_info(field, &info); -EXPECT_EQ(info.scalar_type_id, TypeIndex::Int16); -EXPECT_FALSE(info.have_nulls); -EXPECT_FALSE(info.need_convert); -EXPECT_EQ(info.num_dimensions, 2); -} - -// Test nested Array with UInt64 <= UInt16::max() -{ - Array inner_array; - inner_array.push_back(UInt64(std::numeric_limits::max())); - inner_array.push_back(UInt64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int32); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); -} - -// Test nested Array with UInt64 <= UInt32::max() -{ - Array inner_array; - inner_array.push_back(UInt64(std::numeric_limits::max())); - inner_array.push_back(UInt64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); -} - -// Test nested Array with UInt64 > UInt32::max() -{ - Array inner_array; - inner_array.push_back(UInt64(static_cast(std::numeric_limits::max()) + 1)); - inner_array.push_back(UInt64(static_cast(std::numeric_limits::max()) + 1)); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); -} -} - -// Test nested Array with mixed Int64 and UInt64 -{ - Array inner_array1; - inner_array1.push_back(Int64(std::numeric_limits::max())); - inner_array1.push_back(Int64(std::numeric_limits::max())); - - Array inner_array2; - inner_array2.push_back(UInt64(std::numeric_limits::max())); - inner_array2.push_back(UInt64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array1); - outer_array.push_back(inner_array2); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); - EXPECT_FALSE(info.have_nulls); - EXPECT_TRUE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); -} - -// Test nested Array with nulls -{ - Array inner_array1; - inner_array1.push_back(Int64(1)); - inner_array1.push_back(Int64(2)); - - Array inner_array2; - inner_array2.push_back(Int64(3)); - inner_array2.push_back(Null()); - - Array outer_array; - outer_array.push_back(inner_array1); - outer_array.push_back(inner_array2); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int8); - EXPECT_TRUE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); -} - -// Test Array with JsonbField -{ - Slice slice("\"amory is cute\""); - JsonBinaryValue value; - Status st = value.from_json_string(slice.data, slice.size); - EXPECT_TRUE(st.ok()) << st.to_string(); - JsonbField field(value.value(), value.size()); - - Array array; - array.push_back(field); - array.push_back(field); - FieldInfo info; - schema_util::get_field_info(array, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::JSONB); -} + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int8); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + + // Test nested Array with Int64 <= Int16::max() + { + Array inner_array; + inner_array.push_back(Int64(std::numeric_limits::max())); + inner_array.push_back(Int64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int16); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + + // Test nested Array with Int64 <= Int32::max() + { + Array inner_array; + inner_array.push_back(Int64(std::numeric_limits::max())); + inner_array.push_back(Int64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int32); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + + // Test nested Array with Int64 > Int32::max() + { + Array inner_array; + inner_array.push_back(Int64(static_cast(std::numeric_limits::max()) + 1)); + inner_array.push_back(Int64(static_cast(std::numeric_limits::max()) + 1)); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + } // namespace doris::vectorized + + // Test nested Array with UInt64 in different ranges + { // Test nested Array with UInt64 <= UInt8::max() + { + Array inner_array; + inner_array.push_back(UInt64(std::numeric_limits::max())); + inner_array.push_back(UInt64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int16); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + + // Test nested Array with UInt64 <= UInt16::max() + { + Array inner_array; + inner_array.push_back(UInt64(std::numeric_limits::max())); + inner_array.push_back(UInt64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int32); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + + // Test nested Array with UInt64 <= UInt32::max() + { + Array inner_array; + inner_array.push_back(UInt64(std::numeric_limits::max())); + inner_array.push_back(UInt64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + + // Test nested Array with UInt64 > UInt32::max() + { + Array inner_array; + inner_array.push_back( + UInt64(static_cast(std::numeric_limits::max()) + 1)); + inner_array.push_back( + UInt64(static_cast(std::numeric_limits::max()) + 1)); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + } + + // Test nested Array with mixed Int64 and UInt64 + { + Array inner_array1; + inner_array1.push_back(Int64(std::numeric_limits::max())); + inner_array1.push_back(Int64(std::numeric_limits::max())); + + Array inner_array2; + inner_array2.push_back(UInt64(std::numeric_limits::max())); + inner_array2.push_back(UInt64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array1); + outer_array.push_back(inner_array2); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); + EXPECT_FALSE(info.have_nulls); + EXPECT_TRUE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + + // Test nested Array with nulls + { + Array inner_array1; + inner_array1.push_back(Int64(1)); + inner_array1.push_back(Int64(2)); + + Array inner_array2; + inner_array2.push_back(Int64(3)); + inner_array2.push_back(Null()); + + Array outer_array; + outer_array.push_back(inner_array1); + outer_array.push_back(inner_array2); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int8); + EXPECT_TRUE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); + } + + // Test Array with JsonbField + { + Slice slice("\"amory is cute\""); + JsonBinaryValue value; + Status st = value.from_json_string(slice.data, slice.size); + EXPECT_TRUE(st.ok()) << st.to_string(); + JsonbField field(value.value(), value.size()); + + Array array; + array.push_back(field); + array.push_back(field); + FieldInfo info; + schema_util::get_field_info(array, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::JSONB); + } } TEST_F(ColumnObjectTest, field_visitor) { diff --git a/be/test/vec/jsonb/json_parser_test.cpp b/be/test/vec/jsonb/json_parser_test.cpp index 6d248a73cd0d91..257a7c370c762c 100644 --- a/be/test/vec/jsonb/json_parser_test.cpp +++ b/be/test/vec/jsonb/json_parser_test.cpp @@ -74,13 +74,13 @@ TEST(JsonParserTest, ParseMultiLevelNestedArray) { ASSERT_TRUE(result.has_value()); EXPECT_EQ(result->values.size(), 1); EXPECT_EQ(result->paths.size(), 1); - EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_ARRAY); + EXPECT_EQ(result->values[0].get_type(), doris::vectorized::Field::Types::Array); result = parser.parse("[[[1],[2]],[[3],[4]]]", 21, config); ASSERT_TRUE(result.has_value()); EXPECT_EQ(result->values.size(), 1); EXPECT_EQ(result->paths.size(), 1); - EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_ARRAY); + EXPECT_EQ(result->values[0].get_type(), doris::vectorized::Field::Types::Array); result = parser.parse("[[1,2],[3],[4,5,6]]", 19, config); ASSERT_TRUE(result.has_value()); @@ -95,7 +95,7 @@ TEST(JsonParserTest, ParseMultiLevelNestedArray) { ASSERT_TRUE(result.has_value()); EXPECT_EQ(result->values.size(), 1); EXPECT_EQ(result->paths.size(), 1); - EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_ARRAY); + EXPECT_EQ(result->values[0].get_type(), doris::vectorized::Field::Types::Array); std::string json = R"({"nested": [{"a": [1,2,3]}]})"; // result should be jsonbField @@ -103,7 +103,7 @@ TEST(JsonParserTest, ParseMultiLevelNestedArray) { ASSERT_TRUE(result.has_value()); EXPECT_EQ(result->values.size(), 1); EXPECT_EQ(result->paths.size(), 1); - EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_JSONB); + EXPECT_EQ(result->values[0].get_type(), doris::vectorized::Field::Types::JSONB); // multi level nested array in nested array object std::string json2 = R"({"a":[{"b":[[1,2,3]]}]})"; @@ -111,7 +111,7 @@ TEST(JsonParserTest, ParseMultiLevelNestedArray) { ASSERT_TRUE(result.has_value()); EXPECT_EQ(result->values.size(), 1); EXPECT_EQ(result->paths.size(), 1); - EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_JSONB); + EXPECT_EQ(result->values[0].get_type(), doris::vectorized::Field::Types::JSONB); // test flatten nested config.enable_flatten_nested = true; @@ -122,7 +122,7 @@ TEST(JsonParserTest, ParseMultiLevelNestedArray) { ASSERT_TRUE(result.has_value()); EXPECT_EQ(result->values.size(), 1); EXPECT_EQ(result->paths.size(), 1); - EXPECT_EQ(result->values[0].get_type(), doris::PrimitiveType::TYPE_ARRAY); + EXPECT_EQ(result->values[0].get_type(), doris::vectorized::Field::Types::Array); EXPECT_ANY_THROW(parser.parse(json2.c_str(), json2.size(), config)); } diff --git a/regression-test/data/variant_p0/nested2.out b/regression-test/data/variant_p0/nested2.out index c7790a107de3da..472abecb63672f 100644 --- a/regression-test/data/variant_p0/nested2.out +++ b/regression-test/data/variant_p0/nested2.out @@ -1,13 +1,13 @@ -- This file is automatically generated. You should know what you did if you want to edit this -- !sql_desc_1 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE -- !sql_0 -- -1 {"nested":[{"a":1,"c":1.1},{"b":"1"}]} +1 {"nested":[{"a":1,"c":1.1}, {"b":"1"}]} -- !sql_1 -- [1, null] @@ -50,13 +50,13 @@ v.nested.c array Yes false \N NONE -- !sql_desc_2 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE -- !sql_0 -- -1 {"nested":[{"a":1.0,"c":1.1},{"b":"1"}]} +1 {"nested":[{"a":1,"c":1.1}, {"b":"1"}]} 2 {"nested":[{"a":2.5,"b":123.1}]} -- !sql_1 -- @@ -64,15 +64,15 @@ v.nested.c array Yes false \N NONE [2.5] -- !sql_2 -- -[null, ""1""] -["123.1"] +[null, "1"] +[123.1] -- !sql_3 -- [1.1, null] \N -- !sql_4 -- -[{"a":1.0,"c":1.1}, {"b":"1"}] +[{"a":1,"c":1.1}, {"b":"1"}] [{"a":2.5,"b":123.1}] -- !sql_8 -- @@ -112,7 +112,7 @@ v.nested.c array Yes false \N NONE \N \N -- !sql_0 -- -1 {"nested":[{"a":1.0,"c":1.1},{"b":"1"}]} +1 {"nested":[{"a":1,"c":1.1}, {"b":"1"}]} 2 {"nested":[{"a":2.5,"b":123.1}]} -- !sql_1 -- @@ -120,15 +120,15 @@ v.nested.c array Yes false \N NONE [2.5] -- !sql_2 -- -[null, ""1""] -["123.1"] +[null, "1"] +[123.1] -- !sql_3 -- [1.1, null] [null] -- !sql_4 -- -[{"a":1.0,"c":1.1}, {"b":"1"}] +[{"a":1,"c":1.1}, {"b":"1"}] [{"a":2.5,"b":123.1}] -- !sql_8 -- @@ -169,19 +169,19 @@ v.nested.c array Yes false \N NONE -- !sql_desc_4 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE -- !sql_0 -- -1 {"nested":[{"a":1,"b":1.1},{"a":"1","b":"1","c":"1"}]} +1 {"nested":[{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}]} -- !sql_1 -- -["1", ""1""] +[1, "1"] -- !sql_2 -- -["1.1", ""1""] +[1.1, "1"] -- !sql_3 -- [null, "1"] @@ -218,26 +218,26 @@ v.nested.c array Yes false \N NONE -- !sql_desc_5 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE -- !sql_0 -- -1 {"nested":[{"a":1,"b":1.1},{"a":"1","b":"1","c":"1"}]} +1 {"nested":[{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}]} 2 {"nested":[{"a":1,"c":1.1}]} -- !sql_1 -- -["1", ""1""] -["1"] +[1, "1"] +[1] -- !sql_2 -- -["1.1", ""1""] +[1.1, "1"] \N -- !sql_3 -- -[null, ""1""] -["1.1"] +[null, "1"] +[1.1] -- !sql_4 -- [{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}] @@ -280,20 +280,20 @@ v.nested.c array Yes false \N NONE [1.1] 1 -- !sql_0 -- -1 {"nested":[{"a":1,"b":1.1},{"a":"1","b":"1","c":"1"}]} +1 {"nested":[{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}]} 2 {"nested":[{"a":1,"c":1.1}]} -- !sql_1 -- -["1", ""1""] -["1"] +[1, "1"] +[1] -- !sql_2 -- -["1.1", ""1""] +[1.1, "1"] [null] -- !sql_3 -- -[null, ""1""] -["1.1"] +[null, "1"] +[1.1] -- !sql_4 -- [{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}] From 7c7005227edf43508a7e8b38f205de5ef692679d Mon Sep 17 00:00:00 2001 From: amorynan Date: Thu, 24 Jul 2025 14:51:35 +0800 Subject: [PATCH 06/11] format code --- be/test/vec/columns/column_variant_test.cpp | 430 ++++++++------- be/test/vec/exec/column_type_convert_test.cpp | 491 +++++++++--------- 2 files changed, 458 insertions(+), 463 deletions(-) diff --git a/be/test/vec/columns/column_variant_test.cpp b/be/test/vec/columns/column_variant_test.cpp index 132513c469ec15..57d9544b9abf67 100644 --- a/be/test/vec/columns/column_variant_test.cpp +++ b/be/test/vec/columns/column_variant_test.cpp @@ -1864,224 +1864,220 @@ TEST_F(ColumnObjectTest, get_field_info_all_types) { } // Test nested Array with Int64 in different ranges - { // Test nested Array with Int64 <= Int8::max() - { - Array inner_array; - inner_array.push_back(Int64(std::numeric_limits::max())); - inner_array.push_back(Int64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int8); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - - // Test nested Array with Int64 <= Int16::max() - { - Array inner_array; - inner_array.push_back(Int64(std::numeric_limits::max())); - inner_array.push_back(Int64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int16); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - - // Test nested Array with Int64 <= Int32::max() - { - Array inner_array; - inner_array.push_back(Int64(std::numeric_limits::max())); - inner_array.push_back(Int64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int32); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - - // Test nested Array with Int64 > Int32::max() - { - Array inner_array; - inner_array.push_back(Int64(static_cast(std::numeric_limits::max()) + 1)); - inner_array.push_back(Int64(static_cast(std::numeric_limits::max()) + 1)); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - } // namespace doris::vectorized - - // Test nested Array with UInt64 in different ranges - { // Test nested Array with UInt64 <= UInt8::max() - { - Array inner_array; - inner_array.push_back(UInt64(std::numeric_limits::max())); - inner_array.push_back(UInt64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int16); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - - // Test nested Array with UInt64 <= UInt16::max() - { - Array inner_array; - inner_array.push_back(UInt64(std::numeric_limits::max())); - inner_array.push_back(UInt64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int32); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - - // Test nested Array with UInt64 <= UInt32::max() - { - Array inner_array; - inner_array.push_back(UInt64(std::numeric_limits::max())); - inner_array.push_back(UInt64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - - // Test nested Array with UInt64 > UInt32::max() - { - Array inner_array; - inner_array.push_back( - UInt64(static_cast(std::numeric_limits::max()) + 1)); - inner_array.push_back( - UInt64(static_cast(std::numeric_limits::max()) + 1)); - - Array outer_array; - outer_array.push_back(inner_array); - outer_array.push_back(inner_array); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); - EXPECT_FALSE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - } - - // Test nested Array with mixed Int64 and UInt64 - { - Array inner_array1; - inner_array1.push_back(Int64(std::numeric_limits::max())); - inner_array1.push_back(Int64(std::numeric_limits::max())); - - Array inner_array2; - inner_array2.push_back(UInt64(std::numeric_limits::max())); - inner_array2.push_back(UInt64(std::numeric_limits::max())); - - Array outer_array; - outer_array.push_back(inner_array1); - outer_array.push_back(inner_array2); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); - EXPECT_FALSE(info.have_nulls); - EXPECT_TRUE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - - // Test nested Array with nulls - { - Array inner_array1; - inner_array1.push_back(Int64(1)); - inner_array1.push_back(Int64(2)); - - Array inner_array2; - inner_array2.push_back(Int64(3)); - inner_array2.push_back(Null()); - - Array outer_array; - outer_array.push_back(inner_array1); - outer_array.push_back(inner_array2); - - Field field(outer_array); - FieldInfo info; - schema_util::get_field_info(field, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::Int8); - EXPECT_TRUE(info.have_nulls); - EXPECT_FALSE(info.need_convert); - EXPECT_EQ(info.num_dimensions, 2); - } - - // Test Array with JsonbField - { - Slice slice("\"amory is cute\""); - JsonBinaryValue value; - Status st = value.from_json_string(slice.data, slice.size); - EXPECT_TRUE(st.ok()) << st.to_string(); - JsonbField field(value.value(), value.size()); + {// Test nested Array with Int64 <= Int8::max() + {Array inner_array; + inner_array.push_back(Int64(std::numeric_limits::max())); + inner_array.push_back(Int64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int8); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); +} + +// Test nested Array with Int64 <= Int16::max() +{ + Array inner_array; + inner_array.push_back(Int64(std::numeric_limits::max())); + inner_array.push_back(Int64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int16); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); +} + +// Test nested Array with Int64 <= Int32::max() +{ + Array inner_array; + inner_array.push_back(Int64(std::numeric_limits::max())); + inner_array.push_back(Int64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int32); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); +} + +// Test nested Array with Int64 > Int32::max() +{ + Array inner_array; + inner_array.push_back(Int64(static_cast(std::numeric_limits::max()) + 1)); + inner_array.push_back(Int64(static_cast(std::numeric_limits::max()) + 1)); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); +} +} // namespace doris::vectorized - Array array; - array.push_back(field); - array.push_back(field); - FieldInfo info; - schema_util::get_field_info(array, &info); - EXPECT_EQ(info.scalar_type_id, TypeIndex::JSONB); - } +// Test nested Array with UInt64 in different ranges +{// Test nested Array with UInt64 <= UInt8::max() + {Array inner_array; +inner_array.push_back(UInt64(std::numeric_limits::max())); +inner_array.push_back(UInt64(std::numeric_limits::max())); + +Array outer_array; +outer_array.push_back(inner_array); +outer_array.push_back(inner_array); + +Field field(outer_array); +FieldInfo info; +schema_util::get_field_info(field, &info); +EXPECT_EQ(info.scalar_type_id, TypeIndex::Int16); +EXPECT_FALSE(info.have_nulls); +EXPECT_FALSE(info.need_convert); +EXPECT_EQ(info.num_dimensions, 2); +} + +// Test nested Array with UInt64 <= UInt16::max() +{ + Array inner_array; + inner_array.push_back(UInt64(std::numeric_limits::max())); + inner_array.push_back(UInt64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int32); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); +} + +// Test nested Array with UInt64 <= UInt32::max() +{ + Array inner_array; + inner_array.push_back(UInt64(std::numeric_limits::max())); + inner_array.push_back(UInt64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); +} + +// Test nested Array with UInt64 > UInt32::max() +{ + Array inner_array; + inner_array.push_back(UInt64(static_cast(std::numeric_limits::max()) + 1)); + inner_array.push_back(UInt64(static_cast(std::numeric_limits::max()) + 1)); + + Array outer_array; + outer_array.push_back(inner_array); + outer_array.push_back(inner_array); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); + EXPECT_FALSE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); +} +} + +// Test nested Array with mixed Int64 and UInt64 +{ + Array inner_array1; + inner_array1.push_back(Int64(std::numeric_limits::max())); + inner_array1.push_back(Int64(std::numeric_limits::max())); + + Array inner_array2; + inner_array2.push_back(UInt64(std::numeric_limits::max())); + inner_array2.push_back(UInt64(std::numeric_limits::max())); + + Array outer_array; + outer_array.push_back(inner_array1); + outer_array.push_back(inner_array2); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int64); + EXPECT_FALSE(info.have_nulls); + EXPECT_TRUE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); +} + +// Test nested Array with nulls +{ + Array inner_array1; + inner_array1.push_back(Int64(1)); + inner_array1.push_back(Int64(2)); + + Array inner_array2; + inner_array2.push_back(Int64(3)); + inner_array2.push_back(Null()); + + Array outer_array; + outer_array.push_back(inner_array1); + outer_array.push_back(inner_array2); + + Field field(outer_array); + FieldInfo info; + schema_util::get_field_info(field, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::Int8); + EXPECT_TRUE(info.have_nulls); + EXPECT_FALSE(info.need_convert); + EXPECT_EQ(info.num_dimensions, 2); +} + +// Test Array with JsonbField +{ + Slice slice("\"amory is cute\""); + JsonBinaryValue value; + Status st = value.from_json_string(slice.data, slice.size); + EXPECT_TRUE(st.ok()) << st.to_string(); + JsonbField field(value.value(), value.size()); + + Array array; + array.push_back(field); + array.push_back(field); + FieldInfo info; + schema_util::get_field_info(array, &info); + EXPECT_EQ(info.scalar_type_id, TypeIndex::JSONB); +} } TEST_F(ColumnObjectTest, field_visitor) { diff --git a/be/test/vec/exec/column_type_convert_test.cpp b/be/test/vec/exec/column_type_convert_test.cpp index edc7819129393a..bbc5a5b947c17c 100644 --- a/be/test/vec/exec/column_type_convert_test.cpp +++ b/be/test/vec/exec/column_type_convert_test.cpp @@ -656,258 +656,257 @@ TEST_F(ColumnTypeConverterTest, TestDecimalConversions) { // Test string type conversions TEST_F(ColumnTypeConverterTest, TestStringConversions) { // Test numeric to string conversions - { // INT -> STRING - { - TypeDescriptor src_type(TYPE_INT); - auto dst_type = std::make_shared(); - - auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, - converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnInt32::create(); - auto& src_data = src_col->get_data(); - src_data.push_back(std::numeric_limits::max()); - src_data.push_back(std::numeric_limits::min()); - src_data.push_back(0); - - auto dst_col = dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(3, string_col.size()); - EXPECT_EQ(std::to_string(std::numeric_limits::max()), - string_col.get_data_at(0).to_string()); - EXPECT_EQ(std::to_string(std::numeric_limits::min()), - string_col.get_data_at(1).to_string()); - EXPECT_EQ("0", string_col.get_data_at(2).to_string()); - } - - // DOUBLE -> STRING - { - TypeDescriptor src_type(TYPE_DOUBLE); - auto dst_type = std::make_shared(); - - auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, - converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnFloat64::create(); - auto& src_data = src_col->get_data(); - src_data.push_back(3.14159265359); - src_data.push_back(-2.71828182846); - src_data.push_back(std::numeric_limits::infinity()); - src_data.push_back(std::numeric_limits::quiet_NaN()); - - auto dst_col = dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(4, string_col.size()); - // Note: Exact string representation may vary by platform - EXPECT_TRUE(string_col.get_data_at(0).to_string().find("3.14159") == 0); - EXPECT_TRUE(string_col.get_data_at(1).to_string().find("-2.71828") == 0); - EXPECT_TRUE(string_col.get_data_at(2).to_string().find("inf") != std::string::npos); - EXPECT_TRUE(string_col.get_data_at(3).to_string().find("nan") != std::string::npos); - } - } // namespace doris::vectorized - - // Test string to numeric conversions with invalid input - { - TypeDescriptor src_type(TYPE_STRING); - auto dst_type = std::make_shared(); - auto nullable_dst_type = std::make_shared(dst_type); - - auto converter = converter::ColumnTypeConverter::get_converter(src_type, nullable_dst_type, - converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnString::create(); - src_col->resize(0); - src_col->insert_data("42", 2); - src_col->insert_data("not a number", 11); - src_col->insert_data("2147483648", 10); // Greater than INT32_MAX - - auto dst_col = nullable_dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); - auto& nullable_col = static_cast(*mutable_dst); - auto& nested_col = static_cast(nullable_col.get_nested_column()); - auto& null_map = nullable_col.get_null_map_data(); - null_map.resize_fill(src_col->size(), 0); - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - ASSERT_EQ(3, nested_col.size()); - EXPECT_EQ(42, nested_col.get_data()[0]); - EXPECT_EQ(1, null_map[1]); // Invalid format - EXPECT_EQ(1, null_map[2]); // Out of range - EXPECT_EQ(0, null_map[0]); - } - // TEST DECIMAL -> STRING - { - TypeDescriptor src_type(TYPE_DECIMAL32); - src_type.precision = 9; - src_type.scale = 2; - - auto dst_type = std::make_shared(); - - auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, - converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnDecimal::create(9, 2); - auto& src_data = src_col->get_data(); - // Add test values - src_data.resize(0); - src_data.push_back(Decimal32(12345)); // 123.45 - src_data.push_back(Decimal32(-67890)); // -678.90 - src_data.push_back(Decimal32(0)); // Zero - - auto dst_col = dst_type->create_column(); - dst_col->resize(0); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(3, string_col.size()); - EXPECT_EQ("123.45", string_col.get_data_at(0).to_string()); // 123.45 - EXPECT_EQ("-678.90", string_col.get_data_at(1).to_string()); // -678.90 - EXPECT_EQ("0.00", string_col.get_data_at(2).to_string()); // Zero value - } - - // TEST DATE/TIMESTAMP -> STRING - { - TypeDescriptor src_type(TYPE_DATEV2); - auto dst_type = std::make_shared(); - - auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, - converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnDateV2::create(); - auto& src_data = src_col->get_data(); - // Add test date values - src_data.resize(0); - DateV2Value value; - value.unchecked_set_time(2021, 1, 1, 0, 0, 0); - src_data.push_back( - *reinterpret_cast(&value)); // "2021-01-01" in days format - value.unchecked_set_time(1970, 1, 1, 0, 0, 0); - src_data.push_back(*reinterpret_cast( - &value)); // "1970-01-01" in days format (epoch start) - value.unchecked_set_time(2070, 1, 1, 0, 0, 0); - src_data.push_back( - *reinterpret_cast(&value)); // "2070-01-01" in days format - - auto dst_col = dst_type->create_column(); - dst_col->resize(0); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(3, string_col.size()); - EXPECT_EQ("2021-01-01", string_col.get_data_at(0).to_string()); - EXPECT_EQ("1970-01-01", string_col.get_data_at(1).to_string()); - EXPECT_EQ("2070-01-01", string_col.get_data_at(2).to_string()); - } - - // TEST BOOLEAN -> STRING - { - TypeDescriptor src_type(TYPE_BOOLEAN); - auto dst_type = std::make_shared(); - - auto converter = converter::ColumnTypeConverter::get_converter(src_type, dst_type, - converter::COMMON); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnUInt8::create(); - auto& src_data = src_col->get_data(); - src_data.resize(0); - // Add boolean values - src_data.push_back(1); // true - src_data.push_back(0); // false - src_data.push_back(1); // true - src_data.push_back(0); // false - - auto dst_col = dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); - - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); - - auto& string_col = static_cast(*mutable_dst); - ASSERT_EQ(4, string_col.size()); - EXPECT_EQ("TRUE", string_col.get_data_at(0).to_string()); // true - EXPECT_EQ("FALSE", string_col.get_data_at(1).to_string()); // false - EXPECT_EQ("TRUE", string_col.get_data_at(2).to_string()); // true - EXPECT_EQ("FALSE", string_col.get_data_at(3).to_string()); // false - } - - // TEST STRING -> BOOLEAN (for ORC file format, Apache Hive behavior) - { - TypeDescriptor src_type(TYPE_STRING); - auto dst_type = std::make_shared(); // BOOLEAN represented as UInt8 - auto nullable_dst_type = std::make_shared(dst_type); - - auto converter = converter::ColumnTypeConverter::get_converter(src_type, nullable_dst_type, - converter::ORC); - ASSERT_TRUE(converter->support()); - ASSERT_FALSE(converter->is_consistent()); - - auto src_col = ColumnString::create(); - // Add test strings - src_col->resize(0); - src_col->insert_data("0", 1); // Hive: false - src_col->insert_data("123", 3); // Hive: true - src_col->insert_data("-1", 2); // Hive: true - src_col->insert_data(" ", 1); // Hive: null - src_col->insert_data("not_a_number", 13); // Hive: null - src_col->insert_data("1.5", 3); // Hive: null (not an integer) - src_col->insert_data("", 0); // Hive: null - - auto dst_col = nullable_dst_type->create_column(); - auto mutable_dst = dst_col->assume_mutable(); + {// INT -> STRING + {TypeDescriptor src_type(TYPE_INT); + auto dst_type = std::make_shared(); + + auto converter = + converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnInt32::create(); + auto& src_data = src_col->get_data(); + src_data.push_back(std::numeric_limits::max()); + src_data.push_back(std::numeric_limits::min()); + src_data.push_back(0); + + auto dst_col = dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(3, string_col.size()); + EXPECT_EQ(std::to_string(std::numeric_limits::max()), + string_col.get_data_at(0).to_string()); + EXPECT_EQ(std::to_string(std::numeric_limits::min()), + string_col.get_data_at(1).to_string()); + EXPECT_EQ("0", string_col.get_data_at(2).to_string()); +} - auto& nullable_col = static_cast(*mutable_dst); - auto& nested_col = static_cast( - nullable_col.get_nested_column()); // Boolean as UInt8 (0 or 1) - auto& null_map = nullable_col.get_null_map_data(); - null_map.resize_fill(src_col->size(), 0); +// DOUBLE -> STRING +{ + TypeDescriptor src_type(TYPE_DOUBLE); + auto dst_type = std::make_shared(); + + auto converter = + converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnFloat64::create(); + auto& src_data = src_col->get_data(); + src_data.push_back(3.14159265359); + src_data.push_back(-2.71828182846); + src_data.push_back(std::numeric_limits::infinity()); + src_data.push_back(std::numeric_limits::quiet_NaN()); + + auto dst_col = dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(4, string_col.size()); + // Note: Exact string representation may vary by platform + EXPECT_TRUE(string_col.get_data_at(0).to_string().find("3.14159") == 0); + EXPECT_TRUE(string_col.get_data_at(1).to_string().find("-2.71828") == 0); + EXPECT_TRUE(string_col.get_data_at(2).to_string().find("inf") != std::string::npos); + EXPECT_TRUE(string_col.get_data_at(3).to_string().find("nan") != std::string::npos); +} +} // namespace doris::vectorized + +// Test string to numeric conversions with invalid input +{ + TypeDescriptor src_type(TYPE_STRING); + auto dst_type = std::make_shared(); + auto nullable_dst_type = std::make_shared(dst_type); + + auto converter = converter::ColumnTypeConverter::get_converter(src_type, nullable_dst_type, + converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnString::create(); + src_col->resize(0); + src_col->insert_data("42", 2); + src_col->insert_data("not a number", 11); + src_col->insert_data("2147483648", 10); // Greater than INT32_MAX + + auto dst_col = nullable_dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + auto& nullable_col = static_cast(*mutable_dst); + auto& nested_col = static_cast(nullable_col.get_nested_column()); + auto& null_map = nullable_col.get_null_map_data(); + null_map.resize_fill(src_col->size(), 0); + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + ASSERT_EQ(3, nested_col.size()); + EXPECT_EQ(42, nested_col.get_data()[0]); + EXPECT_EQ(1, null_map[1]); // Invalid format + EXPECT_EQ(1, null_map[2]); // Out of range + EXPECT_EQ(0, null_map[0]); +} +// TEST DECIMAL -> STRING +{ + TypeDescriptor src_type(TYPE_DECIMAL32); + src_type.precision = 9; + src_type.scale = 2; + + auto dst_type = std::make_shared(); + + auto converter = + converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnDecimal::create(9, 2); + auto& src_data = src_col->get_data(); + // Add test values + src_data.resize(0); + src_data.push_back(Decimal32(12345)); // 123.45 + src_data.push_back(Decimal32(-67890)); // -678.90 + src_data.push_back(Decimal32(0)); // Zero + + auto dst_col = dst_type->create_column(); + dst_col->resize(0); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(3, string_col.size()); + EXPECT_EQ("123.45", string_col.get_data_at(0).to_string()); // 123.45 + EXPECT_EQ("-678.90", string_col.get_data_at(1).to_string()); // -678.90 + EXPECT_EQ("0.00", string_col.get_data_at(2).to_string()); // Zero value +} - // Perform conversion - Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); - ASSERT_TRUE(st.ok()); +// TEST DATE/TIMESTAMP -> STRING +{ + TypeDescriptor src_type(TYPE_DATEV2); + auto dst_type = std::make_shared(); + + auto converter = + converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnDateV2::create(); + auto& src_data = src_col->get_data(); + // Add test date values + src_data.resize(0); + DateV2Value value; + value.unchecked_set_time(2021, 1, 1, 0, 0, 0); + src_data.push_back( + *reinterpret_cast(&value)); // "2021-01-01" in days format + value.unchecked_set_time(1970, 1, 1, 0, 0, 0); + src_data.push_back(*reinterpret_cast( + &value)); // "1970-01-01" in days format (epoch start) + value.unchecked_set_time(2070, 1, 1, 0, 0, 0); + src_data.push_back( + *reinterpret_cast(&value)); // "2070-01-01" in days format + + auto dst_col = dst_type->create_column(); + dst_col->resize(0); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(3, string_col.size()); + EXPECT_EQ("2021-01-01", string_col.get_data_at(0).to_string()); + EXPECT_EQ("1970-01-01", string_col.get_data_at(1).to_string()); + EXPECT_EQ("2070-01-01", string_col.get_data_at(2).to_string()); +} - ASSERT_EQ(7, nested_col.size()); - EXPECT_EQ(0, nested_col.get_data()[0]); // "0" -> false (0) - EXPECT_EQ(1, nested_col.get_data()[1]); // "123" -> true (1) - EXPECT_EQ(1, nested_col.get_data()[2]); // "-1" -> true (1) - EXPECT_EQ(1, null_map[3]); // " " -> null - EXPECT_EQ(1, null_map[4]); // "not_a_number" -> null - EXPECT_EQ(1, null_map[5]); // "1.5" -> null - EXPECT_EQ(1, null_map[6]); // "" -> null +// TEST BOOLEAN -> STRING +{ + TypeDescriptor src_type(TYPE_BOOLEAN); + auto dst_type = std::make_shared(); + + auto converter = + converter::ColumnTypeConverter::get_converter(src_type, dst_type, converter::COMMON); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnUInt8::create(); + auto& src_data = src_col->get_data(); + src_data.resize(0); + // Add boolean values + src_data.push_back(1); // true + src_data.push_back(0); // false + src_data.push_back(1); // true + src_data.push_back(0); // false + + auto dst_col = dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + auto& string_col = static_cast(*mutable_dst); + ASSERT_EQ(4, string_col.size()); + EXPECT_EQ("TRUE", string_col.get_data_at(0).to_string()); // true + EXPECT_EQ("FALSE", string_col.get_data_at(1).to_string()); // false + EXPECT_EQ("TRUE", string_col.get_data_at(2).to_string()); // true + EXPECT_EQ("FALSE", string_col.get_data_at(3).to_string()); // false +} - for (int i = 0; i < 3; i++) { - EXPECT_EQ(0, null_map[i]); - } +// TEST STRING -> BOOLEAN (for ORC file format, Apache Hive behavior) +{ + TypeDescriptor src_type(TYPE_STRING); + auto dst_type = std::make_shared(); // BOOLEAN represented as UInt8 + auto nullable_dst_type = std::make_shared(dst_type); + + auto converter = converter::ColumnTypeConverter::get_converter(src_type, nullable_dst_type, + converter::ORC); + ASSERT_TRUE(converter->support()); + ASSERT_FALSE(converter->is_consistent()); + + auto src_col = ColumnString::create(); + // Add test strings + src_col->resize(0); + src_col->insert_data("0", 1); // Hive: false + src_col->insert_data("123", 3); // Hive: true + src_col->insert_data("-1", 2); // Hive: true + src_col->insert_data(" ", 1); // Hive: null + src_col->insert_data("not_a_number", 13); // Hive: null + src_col->insert_data("1.5", 3); // Hive: null (not an integer) + src_col->insert_data("", 0); // Hive: null + + auto dst_col = nullable_dst_type->create_column(); + auto mutable_dst = dst_col->assume_mutable(); + + auto& nullable_col = static_cast(*mutable_dst); + auto& nested_col = static_cast( + nullable_col.get_nested_column()); // Boolean as UInt8 (0 or 1) + auto& null_map = nullable_col.get_null_map_data(); + null_map.resize_fill(src_col->size(), 0); + + // Perform conversion + Status st = converter->convert(reinterpret_cast(src_col), mutable_dst); + ASSERT_TRUE(st.ok()); + + ASSERT_EQ(7, nested_col.size()); + EXPECT_EQ(0, nested_col.get_data()[0]); // "0" -> false (0) + EXPECT_EQ(1, nested_col.get_data()[1]); // "123" -> true (1) + EXPECT_EQ(1, nested_col.get_data()[2]); // "-1" -> true (1) + EXPECT_EQ(1, null_map[3]); // " " -> null + EXPECT_EQ(1, null_map[4]); // "not_a_number" -> null + EXPECT_EQ(1, null_map[5]); // "1.5" -> null + EXPECT_EQ(1, null_map[6]); // "" -> null + + for (int i = 0; i < 3; i++) { + EXPECT_EQ(0, null_map[i]); } } +} TEST_F(ColumnTypeConverterTest, TestUnsupportedConversions) { { From 7d348f8d6f6ec2c57f3db4696f00b6e7535e9936 Mon Sep 17 00:00:00 2001 From: amorynan Date: Thu, 24 Jul 2025 15:48:46 +0800 Subject: [PATCH 07/11] fix ut dir --- be/test/vec/columns/column_variant_test.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/be/test/vec/columns/column_variant_test.cpp b/be/test/vec/columns/column_variant_test.cpp index 57d9544b9abf67..fa789710136c56 100644 --- a/be/test/vec/columns/column_variant_test.cpp +++ b/be/test/vec/columns/column_variant_test.cpp @@ -52,9 +52,10 @@ class ColumnObjectTest : public CommonColumnTest { column_variant = VariantUtil::construct_advanced_varint_column(); std::cout << column_variant->get_name() << std::endl; root_dir = std::string(getenv("DORIS_HOME")); + // which is /root/doris/be/ut_build_ASAN/test// std::cout << "root_dir: " << root_dir << std::endl; - test_data_dir = root_dir + "/be/test/data/vec/columns"; - test_result_dir = root_dir + "/be/test/expected_result/vec/columns"; + test_data_dir = root_dir + "../../../be/test/data/vec/columns"; + test_result_dir = root_dir + "../../../be/test/expected_result/vec/columns"; //load_json_columns_data(); } From 79c98cb86b78c5ddebaee827ab076beaefd6db0e Mon Sep 17 00:00:00 2001 From: amorynan Date: Thu, 24 Jul 2025 16:29:42 +0800 Subject: [PATCH 08/11] fix format --- be/test/vec/columns/column_variant_test.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/be/test/vec/columns/column_variant_test.cpp b/be/test/vec/columns/column_variant_test.cpp index fa789710136c56..d6f35a50bb1350 100644 --- a/be/test/vec/columns/column_variant_test.cpp +++ b/be/test/vec/columns/column_variant_test.cpp @@ -52,7 +52,7 @@ class ColumnObjectTest : public CommonColumnTest { column_variant = VariantUtil::construct_advanced_varint_column(); std::cout << column_variant->get_name() << std::endl; root_dir = std::string(getenv("DORIS_HOME")); - // which is /root/doris/be/ut_build_ASAN/test// + // which is /root/doris/be/ut_build_ASAN/test// std::cout << "root_dir: " << root_dir << std::endl; test_data_dir = root_dir + "../../../be/test/data/vec/columns"; test_result_dir = root_dir + "../../../be/test/expected_result/vec/columns"; From 9da64734d102fc0912b2c12c4d0841bb18f222c1 Mon Sep 17 00:00:00 2001 From: amorynan Date: Thu, 24 Jul 2025 18:16:49 +0800 Subject: [PATCH 09/11] fix case out file --- regression-test/data/variant_p0/nested2.out | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/regression-test/data/variant_p0/nested2.out b/regression-test/data/variant_p0/nested2.out index 472abecb63672f..7e6f2a24825fd7 100644 --- a/regression-test/data/variant_p0/nested2.out +++ b/regression-test/data/variant_p0/nested2.out @@ -1,7 +1,7 @@ -- This file is automatically generated. You should know what you did if you want to edit this -- !sql_desc_1 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE @@ -50,7 +50,7 @@ v.nested.c array Yes false \N NONE -- !sql_desc_2 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE @@ -169,7 +169,7 @@ v.nested.c array Yes false \N NONE -- !sql_desc_4 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE @@ -218,7 +218,7 @@ v.nested.c array Yes false \N NONE -- !sql_desc_5 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE From 1cc9e0ef7a8662dbb55c754342e7e0784a20ea07 Mon Sep 17 00:00:00 2001 From: amorynan Date: Thu, 24 Jul 2025 20:49:54 +0800 Subject: [PATCH 10/11] fixed --- regression-test/data/variant_p0/nested2.out | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/regression-test/data/variant_p0/nested2.out b/regression-test/data/variant_p0/nested2.out index 7e6f2a24825fd7..a77cc055155a9d 100644 --- a/regression-test/data/variant_p0/nested2.out +++ b/regression-test/data/variant_p0/nested2.out @@ -1,7 +1,7 @@ -- This file is automatically generated. You should know what you did if you want to edit this -- !sql_desc_1 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE @@ -50,7 +50,7 @@ v.nested.c array Yes false \N NONE -- !sql_desc_2 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE @@ -169,7 +169,7 @@ v.nested.c array Yes false \N NONE -- !sql_desc_4 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE @@ -218,7 +218,7 @@ v.nested.c array Yes false \N NONE -- !sql_desc_5 -- k bigint Yes true \N -v variant Yes false \N NONE +v variant Yes false \N NONE v.nested.a array Yes false \N NONE v.nested.b array Yes false \N NONE v.nested.c array Yes false \N NONE From c19fdd4fe4b716b876aa7ae1be35cda69d5ee5a2 Mon Sep 17 00:00:00 2001 From: amorynan Date: Fri, 25 Jul 2025 11:40:05 +0800 Subject: [PATCH 11/11] update groovy cases --- regression-test/data/variant_p0/nested2.out | 26 +++++-------------- .../suites/variant_p0/nested2.groovy | 8 +++--- 2 files changed, 10 insertions(+), 24 deletions(-) diff --git a/regression-test/data/variant_p0/nested2.out b/regression-test/data/variant_p0/nested2.out index a77cc055155a9d..3703c7e5aa8021 100644 --- a/regression-test/data/variant_p0/nested2.out +++ b/regression-test/data/variant_p0/nested2.out @@ -1,10 +1,6 @@ -- This file is automatically generated. You should know what you did if you want to edit this -- !sql_desc_1 -- -k bigint Yes true \N -v variant Yes false \N NONE -v.nested.a array Yes false \N NONE -v.nested.b array Yes false \N NONE -v.nested.c array Yes false \N NONE +{"nested":"Variant"} -- !sql_0 -- 1 {"nested":[{"a":1,"c":1.1}, {"b":"1"}]} @@ -49,11 +45,8 @@ v.nested.c array Yes false \N NONE [1.1, null] 2 -- !sql_desc_2 -- -k bigint Yes true \N -v variant Yes false \N NONE -v.nested.a array Yes false \N NONE -v.nested.b array Yes false \N NONE -v.nested.c array Yes false \N NONE +{"nested":"Variant"} +{"nested":"Variant"} -- !sql_0 -- 1 {"nested":[{"a":1,"c":1.1}, {"b":"1"}]} @@ -168,11 +161,7 @@ v.nested.c array Yes false \N NONE [null] 1 -- !sql_desc_4 -- -k bigint Yes true \N -v variant Yes false \N NONE -v.nested.a array Yes false \N NONE -v.nested.b array Yes false \N NONE -v.nested.c array Yes false \N NONE +{"nested":"Variant"} -- !sql_0 -- 1 {"nested":[{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}]} @@ -217,11 +206,8 @@ v.nested.c array Yes false \N NONE [null, 1] 2 -- !sql_desc_5 -- -k bigint Yes true \N -v variant Yes false \N NONE -v.nested.a array Yes false \N NONE -v.nested.b array Yes false \N NONE -v.nested.c array Yes false \N NONE +{"nested":"Variant"} +{"nested":"Variant"} -- !sql_0 -- 1 {"nested":[{"a":1,"b":1.1}, {"a":"1","b":"1","c":"1"}]} diff --git a/regression-test/suites/variant_p0/nested2.groovy b/regression-test/suites/variant_p0/nested2.groovy index 8d48fcfce9b1c0..73180128bfb92d 100644 --- a/regression-test/suites/variant_p0/nested2.groovy +++ b/regression-test/suites/variant_p0/nested2.groovy @@ -78,7 +78,7 @@ suite("variant_nested_type_conflict", "p0"){ select * from ${table_name} order by k limit 1; """ qt_sql_desc_1 """ - desc ${table_name}; + select variant_type(v) from ${table_name} order by k """ // now select for a, b, c sql_select_batch() @@ -92,7 +92,7 @@ suite("variant_nested_type_conflict", "p0"){ select * from ${table_name} order by k limit 1; """ qt_sql_desc_2 """ - desc ${table_name}; + select variant_type(v) from ${table_name} order by k """ // now select for a, b, c sql_select_batch() @@ -117,7 +117,7 @@ suite("variant_nested_type_conflict", "p0"){ select * from ${table_name} order by k limit 1; """ qt_sql_desc_4 """ - desc ${table_name}; + select variant_type(v) from ${table_name} order by k """ // now select for a, b, c sql_select_batch() @@ -132,7 +132,7 @@ suite("variant_nested_type_conflict", "p0"){ select * from ${table_name} order by k limit 1; """ qt_sql_desc_5 """ - desc ${table_name}; + select variant_type(v) from ${table_name} order by k """ // now select for a, b, c sql_select_batch()