From aa8d31dbca64447089fb73f558b9f78a3a8ef82b Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 23 Apr 2021 15:53:38 +0300 Subject: [PATCH 001/132] dynamic subcolumns: wip --- src/CMakeLists.txt | 16 +++ src/Columns/ColumnObject.cpp | 117 ++++++++++++++++++ src/Columns/ColumnObject.h | 94 ++++++++++++++ src/Common/CMakeLists.txt | 2 + src/Common/JSONParsers/CMakeLists.txt | 15 +++ .../JSONParsers}/DummyJSONParser.h | 0 .../JSONParsers}/RapidJSONParser.h | 2 +- .../JSONParsers}/SimdJSONParser.h | 2 +- .../JSONParsers/config_jsonparsers.h.in | 6 + src/Common/config.h.in | 3 + src/Core/config_core.h.in | 2 + src/DataTypes/CMakeLists.txt | 2 + src/DataTypes/DataTypeFactory.cpp | 1 + src/DataTypes/DataTypeFactory.h | 1 + src/DataTypes/DataTypeObject.cpp | 63 ++++++++++ src/DataTypes/DataTypeObject.h | 43 +++++++ src/DataTypes/Serializations/CMakeLists.txt | 3 + src/DataTypes/Serializations/JSONDataParser.h | 88 +++++++++++++ .../Serializations/SerializationObject.cpp | 115 +++++++++++++++++ .../Serializations/SerializationObject.h | 29 +++++ .../Serializations/tests/CMakeLists.txt | 0 .../tests/gtest_json_parser.cpp | 33 +++++ src/Functions/FunctionsJSON.h | 6 +- src/IO/ReadHelpers.cpp | 48 +++++++ src/IO/ReadHelpers.h | 3 + 25 files changed, 689 insertions(+), 5 deletions(-) create mode 100644 src/Columns/ColumnObject.cpp create mode 100644 src/Columns/ColumnObject.h create mode 100644 src/Common/JSONParsers/CMakeLists.txt rename src/{Functions => Common/JSONParsers}/DummyJSONParser.h (100%) rename src/{Functions => Common/JSONParsers}/RapidJSONParser.h (99%) rename src/{Functions => Common/JSONParsers}/SimdJSONParser.h (99%) create mode 100644 src/Common/JSONParsers/config_jsonparsers.h.in create mode 100644 src/DataTypes/DataTypeObject.cpp create mode 100644 src/DataTypes/DataTypeObject.h create mode 100644 src/DataTypes/Serializations/CMakeLists.txt create mode 100644 src/DataTypes/Serializations/JSONDataParser.h create mode 100644 src/DataTypes/Serializations/SerializationObject.cpp create mode 100644 src/DataTypes/Serializations/SerializationObject.h create mode 100644 src/DataTypes/Serializations/tests/CMakeLists.txt create mode 100644 src/DataTypes/Serializations/tests/gtest_json_parser.cpp diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 43f6ae8fea5..8fa33ace0fb 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -343,6 +343,14 @@ if(RE2_INCLUDE_DIR) target_include_directories(clickhouse_common_io SYSTEM BEFORE PUBLIC ${RE2_INCLUDE_DIR}) endif() +if(USE_SIMDJSON) + dbms_target_link_libraries(PUBLIC simdjson) +endif() + +if(USE_RAPIDJSON) + dbms_target_include_directories(SYSTEM BEFORE PUBLIC ${RAPIDJSON_INCLUDE_DIR}) +endif() + dbms_target_link_libraries ( PRIVATE boost::filesystem @@ -513,5 +521,13 @@ if (ENABLE_TESTS AND USE_GTEST) target_link_libraries(unit_tests_dbms PRIVATE gcc) endif () + if(USE_SIMDJSON) + target_link_libraries(unit_tests_dbms PRIVATE simdjson) + endif() + + if(USE_RAPIDJSON) + target_include_directories(unit_tests_dbms SYSTEM PRIVATE ${RAPIDJSON_INCLUDE_DIR}) + endif() + add_check(unit_tests_dbms) endif () diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp new file mode 100644 index 00000000000..0c3a89cfbf2 --- /dev/null +++ b/src/Columns/ColumnObject.cpp @@ -0,0 +1,117 @@ +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int LOGICAL_ERROR; + extern const int ILLEGAL_COLUMN; +} + +ColumnObject::ColumnObject(const SubcolumnsMap & subcolumns_) + : subcolumns(subcolumns_) +{ + checkConsistency(); +} + +ColumnObject::ColumnObject(const Names & keys, const Columns & subcolumns_) +{ + if (keys.size() != subcolumns_.size()) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Sizes of keys ({}) and subcolumns ({}) are inconsistent"); + + for (size_t i = 0; i < keys.size(); ++i) + subcolumns[keys[i]] = subcolumns_[i]; + + checkConsistency(); +} + +void ColumnObject::checkConsistency() const +{ + if (subcolumns.empty()) + return; + + size_t first_size = subcolumns.begin()->second->size(); + for (const auto & [name, column] : subcolumns) + { + if (!column) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Null subcolumn passed to ColumnObject"); + + if (first_size != column->size()) + { + throw Exception(ErrorCodes::LOGICAL_ERROR, "Sizes of subcolumns are inconsistent in ColumnObject." + " Subcolumn '{}' has {} rows, subcolumn '{}' has {} rows", + subcolumns.begin()->first, first_size, name, column->size()); + } + } +} + +MutableColumnPtr ColumnObject::cloneResized(size_t new_size) const +{ + SubcolumnsMap new_subcolumns; + for (const auto & [key, subcolumn] : subcolumns) + new_subcolumns[key] = subcolumn->cloneResized(new_size); + + return ColumnObject::create(new_subcolumns); +} + +size_t ColumnObject::byteSize() const +{ + size_t res = 0; + for (const auto & [_, column] : subcolumns) + res += column->byteSize(); + return res; +} + +size_t ColumnObject::allocatedBytes() const +{ + size_t res = 0; + for (const auto & [_, column] : subcolumns) + res += column->allocatedBytes(); + return res; +} + +// const ColumnPtr & ColumnObject::tryGetSubcolumn(const String & key) const +// { +// auto it = subcolumns.find(key); +// if (it == subcolumns.end()) +// return nullptr; + +// return it->second; +// } + +const IColumn & ColumnObject::getSubcolumn(const String & key) const +{ + auto it = subcolumns.find(key); + if (it != subcolumns.end()) + return *it->second; + + throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key); +} + +IColumn & ColumnObject::getSubcolumn(const String & key) +{ + auto it = subcolumns.find(key); + if (it != subcolumns.end()) + return *it->second; + + throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key); +} + +bool ColumnObject::hasSubcolumn(const String & key) const +{ + return subcolumns.count(key) != 0; +} + +void ColumnObject::addSubcolumn(const String & key, MutableColumnPtr && subcolumn, bool check_size) +{ + std::cerr << "adding subcolumn: " << key << ", subcolumn: " << subcolumn->dumpStructure() << "\n"; + if (check_size && subcolumn->size() != size()) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", + key, subcolumn->size(), size()); + + subcolumns[key] = std::move(subcolumn); +} + +} diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h new file mode 100644 index 00000000000..d462de304aa --- /dev/null +++ b/src/Columns/ColumnObject.h @@ -0,0 +1,94 @@ +#pragma once + +#include +#include +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int LOGICAL_ERROR; +} + +class ColumnObject : public COWHelper +{ +private: + using SubcolumnsMap = std::unordered_map; + SubcolumnsMap subcolumns; + +public: + ColumnObject() = default; + ColumnObject(const SubcolumnsMap & subcolumns_); + ColumnObject(const Names & keys, const Columns & subcolumns_); + + bool hasSubcolumn(const String & key) const; + + const IColumn & getSubcolumn(const String & key) const; + IColumn & getSubcolumn(const String & key); + + void addSubcolumn(const String & key, MutableColumnPtr && subcolumn, bool check_size = true); + + const SubcolumnsMap & getSubcolumns() const { return subcolumns; } + SubcolumnsMap & getSubcolumns() { return subcolumns; } + + const char * getFamilyName() const override { return "Object"; } + + size_t size() const override { return subcolumns.empty() ? 0 : subcolumns.begin()->second->size(); } + + MutableColumnPtr cloneResized(size_t new_size) const override; + + size_t byteSize() const override; + size_t allocatedBytes() const override; + + /// All other methods throw exception. + + ColumnPtr decompress() const override { throwMustBeDecompressed(); } + + TypeIndex getDataType() const override { throwMustBeDecompressed(); } + Field operator[](size_t) const override { throwMustBeDecompressed(); } + void get(size_t, Field &) const override { throwMustBeDecompressed(); } + StringRef getDataAt(size_t) const override { throwMustBeDecompressed(); } + void insert(const Field &) override { throwMustBeDecompressed(); } + void insertRangeFrom(const IColumn &, size_t, size_t) override { throwMustBeDecompressed(); } + void insertData(const char *, size_t) override { throwMustBeDecompressed(); } + void insertDefault() override { throwMustBeDecompressed(); } + void popBack(size_t) override { throwMustBeDecompressed(); } + StringRef serializeValueIntoArena(size_t, Arena &, char const *&) const override { throwMustBeDecompressed(); } + const char * deserializeAndInsertFromArena(const char *) override { throwMustBeDecompressed(); } + const char * skipSerializedInArena(const char *) const override { throwMustBeDecompressed(); } + void updateHashWithValue(size_t, SipHash &) const override { throwMustBeDecompressed(); } + void updateWeakHash32(WeakHash32 &) const override { throwMustBeDecompressed(); } + void updateHashFast(SipHash &) const override { throwMustBeDecompressed(); } + ColumnPtr filter(const Filter &, ssize_t) const override { throwMustBeDecompressed(); } + ColumnPtr permute(const Permutation &, size_t) const override { throwMustBeDecompressed(); } + ColumnPtr index(const IColumn &, size_t) const override { throwMustBeDecompressed(); } + int compareAt(size_t, size_t, const IColumn &, int) const override { throwMustBeDecompressed(); } + void compareColumn(const IColumn &, size_t, PaddedPODArray *, PaddedPODArray &, int, int) const override + { + throwMustBeDecompressed(); + } + bool hasEqualValues() const override + { + throwMustBeDecompressed(); + } + void getPermutation(bool, size_t, int, Permutation &) const override { throwMustBeDecompressed(); } + void updatePermutation(bool, size_t, int, Permutation &, EqualRanges &) const override { throwMustBeDecompressed(); } + ColumnPtr replicate(const Offsets &) const override { throwMustBeDecompressed(); } + MutableColumns scatter(ColumnIndex, const Selector &) const override { throwMustBeDecompressed(); } + void gather(ColumnGathererStream &) override { throwMustBeDecompressed(); } + void getExtremes(Field &, Field &) const override { throwMustBeDecompressed(); } + size_t byteSizeAt(size_t) const override { throwMustBeDecompressed(); } + +private: + [[noreturn]] void throwMustBeDecompressed() const + { + throw Exception("ColumnCompressed must be decompressed before use", ErrorCodes::LOGICAL_ERROR); + } + + void checkConsistency() const; +}; + +} + diff --git a/src/Common/CMakeLists.txt b/src/Common/CMakeLists.txt index 61d9b9771a4..feee3bd9dd3 100644 --- a/src/Common/CMakeLists.txt +++ b/src/Common/CMakeLists.txt @@ -3,6 +3,8 @@ add_subdirectory(StringUtils) #add_subdirectory(ZooKeeper) #add_subdirectory(ConfigProcessor) +add_subdirectory(JSONParsers) + if (ENABLE_TESTS) add_subdirectory (tests) endif () diff --git a/src/Common/JSONParsers/CMakeLists.txt b/src/Common/JSONParsers/CMakeLists.txt new file mode 100644 index 00000000000..7b0c6f3ff07 --- /dev/null +++ b/src/Common/JSONParsers/CMakeLists.txt @@ -0,0 +1,15 @@ +# configure_file(config_jsonparsers.h.in ${ConfigIncludePath}/config_jsonparsers.h) + +# include(${ClickHouse_SOURCE_DIR}/cmake/dbms_glob_sources.cmake) + +# add_headers_and_sources(clickhouse_common_jsonparsers .) + +# add_library(clickhouse_common_jsonparsers ${clickhouse_common_jsonparsers_headers} ${clickhouse_common_jsonparsers_sources}) + +# if(USE_SIMDJSON) +# target_link_libraries(clickhouse_common_jsonparsers PRIVATE simdjson) +# endif() + +# if(USE_RAPIDJSON) +# target_include_directories(clickhouse_common_jsonparsers SYSTEM PRIVATE ${RAPIDJSON_INCLUDE_DIR}) +# endif() diff --git a/src/Functions/DummyJSONParser.h b/src/Common/JSONParsers/DummyJSONParser.h similarity index 100% rename from src/Functions/DummyJSONParser.h rename to src/Common/JSONParsers/DummyJSONParser.h diff --git a/src/Functions/RapidJSONParser.h b/src/Common/JSONParsers/RapidJSONParser.h similarity index 99% rename from src/Functions/RapidJSONParser.h rename to src/Common/JSONParsers/RapidJSONParser.h index 992480d64f7..c25bfefaea1 100644 --- a/src/Functions/RapidJSONParser.h +++ b/src/Common/JSONParsers/RapidJSONParser.h @@ -1,7 +1,7 @@ #pragma once #if !defined(ARCADIA_BUILD) -# include "config_functions.h" +# include "config_jsonparsers.h" #endif #if USE_RAPIDJSON diff --git a/src/Functions/SimdJSONParser.h b/src/Common/JSONParsers/SimdJSONParser.h similarity index 99% rename from src/Functions/SimdJSONParser.h rename to src/Common/JSONParsers/SimdJSONParser.h index 7ff3c45130d..974b506b4a7 100644 --- a/src/Functions/SimdJSONParser.h +++ b/src/Common/JSONParsers/SimdJSONParser.h @@ -1,7 +1,7 @@ #pragma once #if !defined(ARCADIA_BUILD) -# include "config_functions.h" +# include "config_jsonparsers.h" #endif #if USE_SIMDJSON diff --git a/src/Common/JSONParsers/config_jsonparsers.h.in b/src/Common/JSONParsers/config_jsonparsers.h.in new file mode 100644 index 00000000000..64352584342 --- /dev/null +++ b/src/Common/JSONParsers/config_jsonparsers.h.in @@ -0,0 +1,6 @@ +// #pragma once + +// // .h autogenerated by cmake! + +// #cmakedefine01 USE_SIMDJSON +// #cmakedefine01 USE_RAPIDJSON diff --git a/src/Common/config.h.in b/src/Common/config.h.in index ee2bfe3df53..64ac0d1f338 100644 --- a/src/Common/config.h.in +++ b/src/Common/config.h.in @@ -15,3 +15,6 @@ #cmakedefine01 USE_GRPC #cmakedefine01 USE_STATS #cmakedefine01 CLICKHOUSE_SPLIT_BINARY +#cmakedefine01 USE_SIMDJSON +#cmakedefine01 USE_RAPIDJSON + diff --git a/src/Core/config_core.h.in b/src/Core/config_core.h.in index e250e013913..c56e6cc28f8 100644 --- a/src/Core/config_core.h.in +++ b/src/Core/config_core.h.in @@ -15,3 +15,5 @@ #cmakedefine01 USE_LIBPQXX #cmakedefine01 USE_NURAFT #cmakedefine01 USE_KRB5 +#cmakedefine01 USE_SIMDJSON +#cmakedefine01 USE_RAPIDJSON diff --git a/src/DataTypes/CMakeLists.txt b/src/DataTypes/CMakeLists.txt index 65172356645..81a4c872b02 100644 --- a/src/DataTypes/CMakeLists.txt +++ b/src/DataTypes/CMakeLists.txt @@ -1,3 +1,5 @@ +add_subdirectory (Serializations) + if (ENABLE_TESTS) add_subdirectory (tests) endif () diff --git a/src/DataTypes/DataTypeFactory.cpp b/src/DataTypes/DataTypeFactory.cpp index c28de15565c..6113385383f 100644 --- a/src/DataTypes/DataTypeFactory.cpp +++ b/src/DataTypes/DataTypeFactory.cpp @@ -211,6 +211,7 @@ DataTypeFactory::DataTypeFactory() registerDataTypeDomainSimpleAggregateFunction(*this); registerDataTypeDomainGeo(*this); registerDataTypeMap(*this); + registerDataTypeObject(*this); } DataTypeFactory & DataTypeFactory::instance() diff --git a/src/DataTypes/DataTypeFactory.h b/src/DataTypes/DataTypeFactory.h index 9fa3e30297b..e58d5ecaf07 100644 --- a/src/DataTypes/DataTypeFactory.h +++ b/src/DataTypes/DataTypeFactory.h @@ -86,5 +86,6 @@ void registerDataTypeLowCardinality(DataTypeFactory & factory); void registerDataTypeDomainIPv4AndIPv6(DataTypeFactory & factory); void registerDataTypeDomainSimpleAggregateFunction(DataTypeFactory & factory); void registerDataTypeDomainGeo(DataTypeFactory & factory); +void registerDataTypeObject(DataTypeFactory & factory); } diff --git a/src/DataTypes/DataTypeObject.cpp b/src/DataTypes/DataTypeObject.cpp new file mode 100644 index 00000000000..52a02e79f66 --- /dev/null +++ b/src/DataTypes/DataTypeObject.cpp @@ -0,0 +1,63 @@ +#include +#include +#include + +#include +#include +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH; + extern const int UNEXPECTED_AST_STRUCTURE; +} + +DataTypeObject::DataTypeObject(const String & schema_format_) + : schema_format(Poco::toLower(schema_format_)) + , default_serialization(getObjectSerialization(schema_format)) +{ +} + +bool DataTypeObject::equals(const IDataType & rhs) const +{ + if (const auto * object = typeid_cast(&rhs)) + return schema_format == object->schema_format; + return false; +} + +SerializationPtr DataTypeObject::doGetDefaultSerialization() const +{ + return default_serialization; +} + +String DataTypeObject::doGetName() const +{ + WriteBufferFromOwnString out; + out << "Object(" << quote << schema_format << ")"; + return out.str(); +} + + +static DataTypePtr create(const ASTPtr & arguments) +{ + if (!arguments || arguments->children.size() != 1) + throw Exception("Object data type family must have exactly one argument - name of schema format", + ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH); + + const auto * argument = arguments->children[0]->as(); + if (!argument || argument->value.getType() != Field::Types::String) + throw Exception("Object data type family must have a string as its argument", + ErrorCodes::UNEXPECTED_AST_STRUCTURE); + + return std::make_shared(argument->value.get()); +} + +void registerDataTypeObject(DataTypeFactory & factory) +{ + factory.registerDataType("Object", create); +} + +} diff --git a/src/DataTypes/DataTypeObject.h b/src/DataTypes/DataTypeObject.h new file mode 100644 index 00000000000..17d8dcc0f41 --- /dev/null +++ b/src/DataTypes/DataTypeObject.h @@ -0,0 +1,43 @@ +#pragma once + +#include +#include +#include + + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int NOT_IMPLEMENTED; +} + +class DataTypeObject : public IDataType +{ +private: + String schema_format; + SerializationPtr default_serialization; + +public: + DataTypeObject(const String & schema_format_); + + const char * getFamilyName() const override { return "Object"; } + String doGetName() const override; + TypeIndex getTypeId() const override { return TypeIndex::Nothing; } + + MutableColumnPtr createColumn() const override { return ColumnObject::create(); } + + Field getDefault() const override + { + throw Exception("Method getDefault() is not implemented for data type " + getName(), ErrorCodes::NOT_IMPLEMENTED); + } + + bool haveSubtypes() const override { return false; } + bool equals(const IDataType & rhs) const override; + bool isParametric() const override { return true; } + + SerializationPtr doGetDefaultSerialization() const override; +}; + +} diff --git a/src/DataTypes/Serializations/CMakeLists.txt b/src/DataTypes/Serializations/CMakeLists.txt new file mode 100644 index 00000000000..65172356645 --- /dev/null +++ b/src/DataTypes/Serializations/CMakeLists.txt @@ -0,0 +1,3 @@ +if (ENABLE_TESTS) + add_subdirectory (tests) +endif () diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h new file mode 100644 index 00000000000..18996b7ff25 --- /dev/null +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -0,0 +1,88 @@ +#pragma once + +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int LOGICAL_ERROR; +} + +namespace +{ + +template +String getValueAsString(const Element & element) +{ + if (element.isBool()) return toString(element.getBool()); + if (element.isInt64()) return toString(element.getInt64()); + if (element.isUInt64()) return toString(element.getUInt64()); + if (element.isDouble()) return toString(element.getDouble()); + if (element.isString()) return String(element.getString()); + + throw Exception(ErrorCodes::LOGICAL_ERROR, "Unsupported type of JSON field"); +} + +} + +struct ParseResult +{ + Strings paths; + Strings values; +}; + +template +class JSONDataParser +{ +public: + using Element = typename ParserImpl::Element; + using Path = std::vector; + using Paths = std::vector; + + void readInto(String & s, ReadBuffer & buf) + { + readJSONObjectPossiblyInvalid(s, buf); + } + + std::optional parse(const char * begin, size_t length) + { + std::string_view json{begin, length}; + Element document; + if (!parser.parse(json, document)) + return {}; + + ParseResult result; + traverse(document, "", result); + return result; + } + +private: + void traverse(const Element & element, String current_path, ParseResult & result) + { + /// TODO: support arrays. + if (element.isObject()) + { + auto object = element.getObject(); + for (auto it = object.begin(); it != object.end(); ++it) + { + const auto & [key, value] = *it; + String next_path = current_path; + if (!next_path.empty()) + next_path += "."; + next_path += key; + traverse(value, next_path, result); + } + } + else + { + result.paths.push_back(current_path); + result.values.push_back(getValueAsString(element)); + } + } + + ParserImpl parser; +}; + +} diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp new file mode 100644 index 00000000000..69d245fdf23 --- /dev/null +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -0,0 +1,115 @@ +#include +#include +#include +#include +#include +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int NOT_IMPLEMENTED; + extern const int INCORRECT_DATA; +} + +template +void SerializationObject::serializeText(const IColumn & /*column*/, size_t /*row_num*/, WriteBuffer & /*ostr*/, const FormatSettings &) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings &) const +{ + auto & column_object = assert_cast(column); + + String buf; + parser.readInto(buf, istr); + std::cerr << "buf: " << buf << "\n"; + auto result = parser.parse(buf.data(), buf.size()); + if (!result) + throw Exception(ErrorCodes::INCORRECT_DATA, "Cannot parse object"); + + const auto & [paths, values] = *result; + assert(paths.size() == values.size()); + + NameSet paths_set(paths.begin(), paths.end()); + + if (paths.size() != paths_set.size()) + throw Exception(ErrorCodes::INCORRECT_DATA, "Object has ambiguous paths"); + + size_t column_size = column_object.size(); + for (size_t i = 0; i < paths.size(); ++i) + { + if (!column_object.hasSubcolumn(paths[i])) + { + auto new_column = ColumnString::create()->cloneResized(column_size); + column_object.addSubcolumn(paths[i], std::move(new_column), false); + } + + column_object.getSubcolumn(paths[i]).insertData(values[i].data(), values[i].size()); + } + + for (auto & [key, subcolumn] : column_object.getSubcolumns()) + { + if (!paths_set.count(key)) + subcolumn->insertDefault(); + } +} + +template +void SerializationObject::serializeBinary(const Field & /*field*/, WriteBuffer & /*ostr*/) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::deserializeBinary(Field & /*field*/, ReadBuffer & /*istr*/) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::serializeBinary(const IColumn & /*column*/, size_t /*row_num*/, WriteBuffer & /*ostr*/) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::deserializeBinary(IColumn & /*column*/, ReadBuffer & /*istr*/) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::serializeBinaryBulk(const IColumn & /*column*/, WriteBuffer & /*ostr*/, size_t /*offset*/, size_t /*limit*/) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::deserializeBinaryBulk(IColumn & /*column*/, ReadBuffer & /*istr*/, size_t /*limit*/, double /*avg_value_size_hint*/) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +SerializationPtr getObjectSerialization(const String & schema_format) +{ + if (schema_format == "json") + { +#if USE_SIMDJSON + return std::make_shared>>(); +#elif USE_RAPIDJSON + return std::make_shared>>(); +#else + throw Exception(ErrorCodes::NOT_IMPLEMENTED, + "To use data type Object with JSON format, ClickHouse should be built with Simdjson or Rapidjson"); +#endif + } + + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Unknow schema_format '{}'", schema_format); +} + +} diff --git a/src/DataTypes/Serializations/SerializationObject.h b/src/DataTypes/Serializations/SerializationObject.h new file mode 100644 index 00000000000..4806c50ad8c --- /dev/null +++ b/src/DataTypes/Serializations/SerializationObject.h @@ -0,0 +1,29 @@ +#pragma once + +#include + +namespace DB +{ + +template +class SerializationObject : public SimpleTextSerialization +{ +public: + void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override; + void deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override; + + /** Format is platform-dependent. */ + void serializeBinary(const Field & field, WriteBuffer & ostr) const override; + void deserializeBinary(Field & field, ReadBuffer & istr) const override; + void serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const override; + void deserializeBinary(IColumn & column, ReadBuffer & istr) const override; + void serializeBinaryBulk(const IColumn & column, WriteBuffer & ostr, size_t offset, size_t limit) const override; + void deserializeBinaryBulk(IColumn & column, ReadBuffer & istr, size_t limit, double avg_value_size_hint) const override; + +private: + mutable Parser parser; +}; + +SerializationPtr getObjectSerialization(const String & schema_format); + +} diff --git a/src/DataTypes/Serializations/tests/CMakeLists.txt b/src/DataTypes/Serializations/tests/CMakeLists.txt new file mode 100644 index 00000000000..e69de29bb2d diff --git a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp new file mode 100644 index 00000000000..48a4a446c48 --- /dev/null +++ b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp @@ -0,0 +1,33 @@ +#include +#include +#include + +#if USE_SIMDJSON + +using namespace DB; + +TEST(JSONDataParser, ReadInto) +{ + String json = R"({"k1" : 1, "k2" : {"k3" : "aa", "k4" : 2}})"; + String json_bad = json + "aaaaaaa"; + + JSONDataParser parser; + ReadBufferFromString buf(json_bad); + String res; + parser.readInto(res, buf); + ASSERT_EQ(json, res); +} + +TEST(JSONDataParser, Parse) +{ + String json = R"({"k1" : 1, "k2" : {"k3" : "aa", "k4" : 2}})"; + JSONDataParser parser; + auto res = parser.parse(json.data(), json.size()); + ASSERT_TRUE(res.has_value()); + + const auto & [paths, values] = *res; + ASSERT_EQ(paths, (Strings{"k1", "k2.k3", "k2.k4"})); + ASSERT_EQ(values, (Strings{"1", "aa", "2"})); +} + +#endif diff --git a/src/Functions/FunctionsJSON.h b/src/Functions/FunctionsJSON.h index c2fd44e2e2a..2427e8afae1 100644 --- a/src/Functions/FunctionsJSON.h +++ b/src/Functions/FunctionsJSON.h @@ -2,9 +2,9 @@ #include #include -#include -#include -#include +#include +#include +#include #include #include #include diff --git a/src/IO/ReadHelpers.cpp b/src/IO/ReadHelpers.cpp index 72ffd74a42d..60dbe8cac51 100644 --- a/src/IO/ReadHelpers.cpp +++ b/src/IO/ReadHelpers.cpp @@ -755,6 +755,54 @@ template bool readJSONStringInto, bool>(PaddedPODArray(NullOutput & s, ReadBuffer & buf); template void readJSONStringInto(String & s, ReadBuffer & buf); +template +ReturnType readJSONObjectPossiblyInvalid(Vector & s, ReadBuffer & buf) +{ + static constexpr bool throw_exception = std::is_same_v; + + auto error = [](const char * message [[maybe_unused]], int code [[maybe_unused]]) + { + if constexpr (throw_exception) + throw ParsingException(message, code); + return ReturnType(false); + }; + + if (buf.eof() || *buf.position() != '{') + return error("JSON should starts from opening curly bracket", ErrorCodes::INCORRECT_DATA); + + s.push_back(*buf.position()); + ++buf.position(); + Int64 balance = 1; + while (!buf.eof()) + { + char * next_pos = find_first_symbols<'\\', '{', '}'>(buf.position(), buf.buffer().end()); + appendToStringOrVector(s, buf, next_pos); + buf.position() = next_pos; + + if (!buf.hasPendingData()) + continue; + + if (*buf.position() == '\\') + { + parseJSONEscapeSequence(s, buf); + continue; + } + + if (*buf.position() == '}') + --balance; + else if (*buf.position() == '{') + ++balance; + + s.push_back(*buf.position()); + ++buf.position(); + if (balance == 0) + return ReturnType(true); + } + + return error("JSON should have equal number of opening and closing brackets", ErrorCodes::INCORRECT_DATA); +} + +template void readJSONObjectPossiblyInvalid(String & s, ReadBuffer & buf); template ReturnType readDateTextFallback(LocalDate & date, ReadBuffer & buf) diff --git a/src/IO/ReadHelpers.h b/src/IO/ReadHelpers.h index cf25b819e6c..304e315c855 100644 --- a/src/IO/ReadHelpers.h +++ b/src/IO/ReadHelpers.h @@ -520,6 +520,9 @@ bool tryReadJSONStringInto(Vector & s, ReadBuffer & buf) return readJSONStringInto(s, buf); } +template +ReturnType readJSONObjectPossiblyInvalid(Vector & s, ReadBuffer & buf); + template void readStringUntilWhitespaceInto(Vector & s, ReadBuffer & buf); From e23784081022b12052cce619265903e8aeee3f5f Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 23 Apr 2021 17:34:53 +0300 Subject: [PATCH 002/132] dynamic subcolumns: wip --- src/Columns/ColumnObject.h | 8 +- .../Serializations/ISerialization.cpp | 8 + src/DataTypes/Serializations/ISerialization.h | 5 + .../Serializations/SerializationObject.cpp | 180 ++++++++++++++++-- .../Serializations/SerializationObject.h | 29 ++- 5 files changed, 210 insertions(+), 20 deletions(-) diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index d462de304aa..3fe6f316bff 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -28,11 +28,15 @@ public: const IColumn & getSubcolumn(const String & key) const; IColumn & getSubcolumn(const String & key); - void addSubcolumn(const String & key, MutableColumnPtr && subcolumn, bool check_size = true); + void addSubcolumn(const String & key, MutableColumnPtr && subcolumn, bool check_size = false); const SubcolumnsMap & getSubcolumns() const { return subcolumns; } SubcolumnsMap & getSubcolumns() { return subcolumns; } + void checkConsistency() const; + + /// Part of interface + const char * getFamilyName() const override { return "Object"; } size_t size() const override { return subcolumns.empty() ? 0 : subcolumns.begin()->second->size(); } @@ -86,8 +90,6 @@ private: { throw Exception("ColumnCompressed must be decompressed before use", ErrorCodes::LOGICAL_ERROR); } - - void checkConsistency() const; }; } diff --git a/src/DataTypes/Serializations/ISerialization.cpp b/src/DataTypes/Serializations/ISerialization.cpp index 68316ef7650..82dfa53c103 100644 --- a/src/DataTypes/Serializations/ISerialization.cpp +++ b/src/DataTypes/Serializations/ISerialization.cpp @@ -48,6 +48,10 @@ String ISerialization::Substream::toString() const return "SparseElements"; case SparseOffsets: return "SparseOffsets"; + case ObjectStructure: + return "ObjectStructure"; + case ObjectElement: + return "ObjectElement(" + object_key_name + ")"; } __builtin_unreachable(); @@ -143,6 +147,10 @@ static String getNameForSubstreamPath( stream_name += (escape_tuple_delimiter && elem.escape_tuple_delimiter ? escapeForFileName(".") : ".") + escapeForFileName(elem.tuple_element_name); } + else if (elem.type == Substream::ObjectElement) + { + stream_name += escapeForFileName(".") + escapeForFileName(elem.object_key_name); + } } return stream_name; diff --git a/src/DataTypes/Serializations/ISerialization.h b/src/DataTypes/Serializations/ISerialization.h index a6b780f3780..2a5d6f18ce4 100644 --- a/src/DataTypes/Serializations/ISerialization.h +++ b/src/DataTypes/Serializations/ISerialization.h @@ -87,12 +87,17 @@ public: SparseElements, SparseOffsets, + + ObjectStructure, + ObjectElement, }; Type type; /// Index of tuple element, starting at 1 or name. String tuple_element_name; + String object_key_name; + /// Do we need to escape a dot in filenames for tuple elements. bool escape_tuple_delimiter = true; diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 69d245fdf23..f88544e1b35 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -1,10 +1,18 @@ #include +#include +#include +#include +#include #include #include -#include +#include #include #include +#include +#include +#include + namespace DB { @@ -12,6 +20,7 @@ namespace ErrorCodes { extern const int NOT_IMPLEMENTED; extern const int INCORRECT_DATA; + extern const int CANNOT_READ_ALL_DATA; } template @@ -46,7 +55,7 @@ void SerializationObject::deserializeText(IColumn & column, ReadBuffer & if (!column_object.hasSubcolumn(paths[i])) { auto new_column = ColumnString::create()->cloneResized(column_size); - column_object.addSubcolumn(paths[i], std::move(new_column), false); + column_object.addSubcolumn(paths[i], std::move(new_column)); } column_object.getSubcolumn(paths[i]).insertData(values[i].data(), values[i].size()); @@ -59,6 +68,161 @@ void SerializationObject::deserializeText(IColumn & column, ReadBuffer & } } +namespace +{ + +struct SerializeStateObject : public ISerialization::SerializeBinaryBulkState +{ + std::unordered_map states; +}; + +struct DeserializeStateObject : public ISerialization::DeserializeBinaryBulkState +{ + std::unordered_map states; +}; + +DataTypePtr getDataTypeByColumn(const IColumn & column) +{ + if (column.empty()) + return std::make_shared(); + + return applyVisitor(FieldToDataType(), column[0]); +} + +} + +template +void SerializationObject::serializeBinaryBulkStatePrefix( + SerializeBinaryBulkSettings & settings, + SerializeBinaryBulkStatePtr &) const +{ + if (settings.position_independent_encoding) + throw Exception(ErrorCodes::NOT_IMPLEMENTED, + "DataTypeObject cannot be serialized with position independent encoding"); +} + +template +void SerializationObject::serializeBinaryBulkStateSuffix( + SerializeBinaryBulkSettings & settings, + SerializeBinaryBulkStatePtr & state) const +{ + UNUSED(settings); + UNUSED(state); +} + +template +void SerializationObject::deserializeBinaryBulkStatePrefix( + DeserializeBinaryBulkSettings & settings, + DeserializeBinaryBulkStatePtr &) const +{ + if (settings.position_independent_encoding) + throw Exception(ErrorCodes::NOT_IMPLEMENTED, + "DataTypeObject cannot be deserialized with position independent encoding"); +} + +template +void SerializationObject::serializeBinaryBulkWithMultipleStreams( + const IColumn & column, + size_t offset, + size_t limit, + SerializeBinaryBulkSettings & settings, + SerializeBinaryBulkStatePtr & state) const +{ + const auto & column_object = assert_cast(column); + assert(!settings.position_independent_encoding); + + settings.path.push_back(Substream::ObjectStructure); + if (auto * stream = settings.getter(settings.path)) + writeVarUInt(column_object.getSubcolumns().size(), *stream); + + settings.path.back() = Substream::ObjectElement; + for (const auto & [key, subcolumn] : column_object.getSubcolumns()) + { + settings.path.back().object_key_name = key; + + settings.path.back() = Substream::ObjectStructure; + if (auto * stream = settings.getter(settings.path)) + { + auto type = getDataTypeByColumn(*subcolumn); + writeStringBinary(key, *stream); + writeStringBinary(type->getName(), *stream); + } + + settings.path.back() = Substream::ObjectElement; + settings.path.back().object_key_name = key; + + if (auto * stream = settings.getter(settings.path)) + { + auto type = getDataTypeByColumn(*subcolumn); + auto serialization = type->getDefaultSerialization(); + serialization->serializeBinaryBulkWithMultipleStreams(*subcolumn, offset, limit, settings, state); + } + } + + settings.path.pop_back(); +} + +template +void SerializationObject::deserializeBinaryBulkWithMultipleStreams( + ColumnPtr & column, + size_t limit, + DeserializeBinaryBulkSettings & settings, + DeserializeBinaryBulkStatePtr & state, + SubstreamsCache * cache) const +{ + if (!column->empty()) + throw Exception(ErrorCodes::NOT_IMPLEMENTED, + "DataTypeObject cannot be deserialized to non-empty column"); + + auto mutable_column = column->assumeMutable(); + auto & column_object = typeid_cast(*mutable_column); + + size_t num_subcolumns = 0; + settings.path.push_back(Substream::ObjectStructure); + if (auto * stream = settings.getter(settings.path)) + readVarUInt(num_subcolumns, *stream); + + settings.path.back() = Substream::ObjectElement; + for (size_t i = 0; i < num_subcolumns; ++i) + { + String key; + String type_name; + + settings.path.back() = Substream::ObjectStructure; + if (auto * stream = settings.getter(settings.path)) + { + readStringBinary(key, *stream); + readStringBinary(type_name, *stream); + } + else + { + throw Exception(ErrorCodes::CANNOT_READ_ALL_DATA, + "Cannot read structure of DataTypeObject, because its stream is missing"); + } + + settings.path.back() = Substream::ObjectElement; + settings.path.back().object_key_name = key; + + if (auto * stream = settings.getter(settings.path)) + { + auto type = DataTypeFactory::instance().get(type_name); + auto serialization = type->getDefaultSerialization(); + ColumnPtr subcolumn = type->createColumn(); + serialization->deserializeBinaryBulkWithMultipleStreams(subcolumn, limit, settings, state, cache); + column_object.addSubcolumn(key, subcolumn->assumeMutable()); + } + else + { + throw Exception(ErrorCodes::CANNOT_READ_ALL_DATA, + "Cannot read subcolumn '{}' of DataTypeObject, because its stream is missing", key); + } + } + + settings.path.pop_back(); + column_object.checkConsistency(); + column = std::move(mutable_column); +} + template void SerializationObject::serializeBinary(const Field & /*field*/, WriteBuffer & /*ostr*/) const { @@ -83,18 +247,6 @@ void SerializationObject::deserializeBinary(IColumn & /*column*/, ReadBu throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); } -template -void SerializationObject::serializeBinaryBulk(const IColumn & /*column*/, WriteBuffer & /*ostr*/, size_t /*offset*/, size_t /*limit*/) const -{ - throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); -} - -template -void SerializationObject::deserializeBinaryBulk(IColumn & /*column*/, ReadBuffer & /*istr*/, size_t /*limit*/, double /*avg_value_size_hint*/) const -{ - throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); -} - SerializationPtr getObjectSerialization(const String & schema_format) { if (schema_format == "json") diff --git a/src/DataTypes/Serializations/SerializationObject.h b/src/DataTypes/Serializations/SerializationObject.h index 4806c50ad8c..eeb64ca2f21 100644 --- a/src/DataTypes/Serializations/SerializationObject.h +++ b/src/DataTypes/Serializations/SerializationObject.h @@ -12,13 +12,36 @@ public: void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override; void deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override; - /** Format is platform-dependent. */ + void serializeBinaryBulkStatePrefix( + SerializeBinaryBulkSettings & settings, + SerializeBinaryBulkStatePtr & state) const override; + + void serializeBinaryBulkStateSuffix( + SerializeBinaryBulkSettings & settings, + SerializeBinaryBulkStatePtr & state) const override; + + void deserializeBinaryBulkStatePrefix( + DeserializeBinaryBulkSettings & settings, + DeserializeBinaryBulkStatePtr & state) const override; + + void serializeBinaryBulkWithMultipleStreams( + const IColumn & column, + size_t offset, + size_t limit, + SerializeBinaryBulkSettings & settings, + SerializeBinaryBulkStatePtr & state) const override; + + void deserializeBinaryBulkWithMultipleStreams( + ColumnPtr & column, + size_t limit, + DeserializeBinaryBulkSettings & settings, + DeserializeBinaryBulkStatePtr & state, + SubstreamsCache * cache) const override; + void serializeBinary(const Field & field, WriteBuffer & ostr) const override; void deserializeBinary(Field & field, ReadBuffer & istr) const override; void serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const override; void deserializeBinary(IColumn & column, ReadBuffer & istr) const override; - void serializeBinaryBulk(const IColumn & column, WriteBuffer & ostr, size_t offset, size_t limit) const override; - void deserializeBinaryBulk(IColumn & column, ReadBuffer & istr, size_t limit, double avg_value_size_hint) const override; private: mutable Parser parser; From 6240169bbbbd6a0c6c7bea8ebbcd7497cf020a04 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 24 Apr 2021 02:56:26 +0300 Subject: [PATCH 003/132] dynamic subcolumns: wip --- src/Columns/ColumnObject.cpp | 9 +++ src/Columns/ColumnObject.h | 4 +- src/DataTypes/ObjectUtils.cpp | 70 +++++++++++++++++++ src/DataTypes/ObjectUtils.h | 12 ++++ .../Serializations/SerializationObject.cpp | 10 +-- src/Interpreters/InterpreterSelectQuery.cpp | 2 + .../MergeTree/MergeTreeDataWriter.cpp | 7 +- 7 files changed, 102 insertions(+), 12 deletions(-) create mode 100644 src/DataTypes/ObjectUtils.cpp create mode 100644 src/DataTypes/ObjectUtils.h diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 0c3a89cfbf2..17594501db1 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -114,4 +114,13 @@ void ColumnObject::addSubcolumn(const String & key, MutableColumnPtr && subcolum subcolumns[key] = std::move(subcolumn); } +Names ColumnObject::getKeys() const +{ + Names keys; + keys.reserve(subcolumns.size()); + for (const auto & [key, _] : subcolumns) + keys.emplace_back(key); + return keys; +} + } diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 3fe6f316bff..6e3d96ceef0 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -23,6 +23,8 @@ public: ColumnObject(const SubcolumnsMap & subcolumns_); ColumnObject(const Names & keys, const Columns & subcolumns_); + void checkConsistency() const; + bool hasSubcolumn(const String & key) const; const IColumn & getSubcolumn(const String & key) const; @@ -33,7 +35,7 @@ public: const SubcolumnsMap & getSubcolumns() const { return subcolumns; } SubcolumnsMap & getSubcolumns() { return subcolumns; } - void checkConsistency() const; + Names getKeys() const; /// Part of interface diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp new file mode 100644 index 00000000000..7a9226c4762 --- /dev/null +++ b/src/DataTypes/ObjectUtils.cpp @@ -0,0 +1,70 @@ +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int TYPE_MISMATCH; + extern const int LOGICAL_ERROR; +} + +static const IDataType * getTypeObject(const DataTypePtr & type) +{ + return typeid_cast(type.get()); +} + +DataTypePtr getDataTypeByColumn(const IColumn & column) +{ + if (column.empty()) + return std::make_shared(); + + return applyVisitor(FieldToDataType(), column[0]); +} + +void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) +{ + for (auto & name_type : columns_list) + { + if (const auto * type_object = getTypeObject(name_type.type)) + { + auto & column = block.getByName(name_type.name); + + if (!getTypeObject(column.type)) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Type for column '{}' mismatch in columns list and in block. In list: {}, in block: {}", + name_type.name, name_type.type->getName(), column.type->getName()); + + const auto & column_object = assert_cast(*column.column); + const auto & subcolumns_map = column_object.getSubcolumns(); + + Names tuple_names; + DataTypes tuple_types; + Columns tuple_columns; + + for (const auto & [key, subcolumn] : subcolumns_map) + { + tuple_names.push_back(key); + tuple_types.push_back(getDataTypeByColumn(*subcolumn)); + tuple_columns.push_back(subcolumn); + } + + auto type_tuple = std::make_shared(tuple_types, tuple_names); + auto column_tuple = ColumnTuple::create(tuple_columns); + + name_type.type = type_tuple; + column.type = type_tuple; + column.column = column_tuple; + } + } +} + +} diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h new file mode 100644 index 00000000000..cacb3abbb08 --- /dev/null +++ b/src/DataTypes/ObjectUtils.h @@ -0,0 +1,12 @@ +#pragma once + +#include +#include + +namespace DB +{ + +DataTypePtr getDataTypeByColumn(const IColumn & column); +void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block); + +} diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index f88544e1b35..a34a8c3b12a 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -1,8 +1,8 @@ #include -#include #include #include #include +#include #include #include #include @@ -81,14 +81,6 @@ struct DeserializeStateObject : public ISerialization::DeserializeBinaryBulkStat std::unordered_map states; }; -DataTypePtr getDataTypeByColumn(const IColumn & column) -{ - if (column.empty()) - return std::make_shared(); - - return applyVisitor(FieldToDataType(), column[0]); -} - } template diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp index f44e55a3df9..cb8375cf798 100644 --- a/src/Interpreters/InterpreterSelectQuery.cpp +++ b/src/Interpreters/InterpreterSelectQuery.cpp @@ -375,6 +375,8 @@ InterpreterSelectQuery::InterpreterSelectQuery( if (view) view->replaceWithSubquery(getSelectQuery(), view_table, metadata_snapshot); + std::cerr << "source_header: " << source_header.dumpStructure() << "\n"; + syntax_analyzer_result = TreeRewriter(context).analyzeSelect( query_ptr, TreeRewriterResult(source_header.getNamesAndTypesList(), storage, metadata_snapshot), diff --git a/src/Storages/MergeTree/MergeTreeDataWriter.cpp b/src/Storages/MergeTree/MergeTreeDataWriter.cpp index 55d42fed20c..b155225c1bb 100644 --- a/src/Storages/MergeTree/MergeTreeDataWriter.cpp +++ b/src/Storages/MergeTree/MergeTreeDataWriter.cpp @@ -9,6 +9,7 @@ #include #include #include +#include #include #include #include @@ -261,6 +262,9 @@ Block MergeTreeDataWriter::mergeBlock(const Block & block, SortDescription sort_ MergeTreeData::MutableDataPartPtr MergeTreeDataWriter::writeTempPart(BlockWithPartition & block_with_partition, const StorageMetadataPtr & metadata_snapshot, bool optimize_on_insert) { Block & block = block_with_partition.block; + auto columns = metadata_snapshot->getColumns().getAllPhysical().filter(block.getNames()); + + convertObjectsToTuples(columns, block); static const String TMP_PREFIX = "tmp_insert_"; @@ -337,7 +341,6 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataWriter::writeTempPart(BlockWithPa for (const auto & ttl_entry : move_ttl_entries) updateTTL(ttl_entry, move_ttl_infos, move_ttl_infos.moves_ttl[ttl_entry.result_column], block, false); - NamesAndTypesList columns = metadata_snapshot->getColumns().getAllPhysical().filter(block.getNames()); ReservationPtr reservation = data.reserveSpacePreferringTTLRules(metadata_snapshot, expected_size, move_ttl_infos, time(nullptr), 0, true); VolumePtr volume = data.getStoragePolicy()->getVolume(0); @@ -404,7 +407,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataWriter::writeTempPart(BlockWithPa serialization_info.add(block); const auto & index_factory = MergeTreeIndexFactory::instance(); - MergedBlockOutputStream out(new_data_part, metadata_snapshot,columns, + MergedBlockOutputStream out(new_data_part, metadata_snapshot, columns, index_factory.getMany(metadata_snapshot->getSecondaryIndices()), compression_codec, serialization_info); From 644df6be7d0e859e02f5bfb94f412a37eecd0239 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 24 Apr 2021 07:09:01 +0300 Subject: [PATCH 004/132] dynamic subcolumns: wip --- src/Core/Types.h | 2 + src/DataTypes/DataTypeObject.h | 2 +- src/DataTypes/DataTypeTuple.cpp | 4 +- src/DataTypes/IDataType.h | 2 + src/DataTypes/NestedUtils.cpp | 2 +- src/DataTypes/ObjectUtils.cpp | 31 +++++++ src/DataTypes/ObjectUtils.h | 1 + .../Serializations/ISerialization.cpp | 6 +- src/Interpreters/InterpreterOptimizeQuery.cpp | 2 +- src/Interpreters/InterpreterSelectQuery.cpp | 5 +- src/Interpreters/TreeRewriter.cpp | 6 ++ .../getHeaderForProcessingStage.cpp | 7 +- .../QueryPlan/ReadFromMergeTree.cpp | 2 +- src/Storages/ColumnsDescription.h | 1 + src/Storages/IStorage.cpp | 2 +- src/Storages/IStorage.h | 3 + .../MergeTree/MergeTreeBlockReadUtils.cpp | 12 ++- src/Storages/MergeTree/MergeTreeData.cpp | 93 +++++++++++++++++++ src/Storages/MergeTree/MergeTreeData.h | 4 + .../MergeTree/MergeTreeDataSelectExecutor.cpp | 2 +- src/Storages/MergeTree/MergeTreeReadPool.cpp | 2 +- .../MergeTreeReverseSelectProcessor.cpp | 2 +- .../MergeTree/MergeTreeSelectProcessor.cpp | 2 +- .../MergeTree/MergeTreeSequentialSource.cpp | 2 +- .../RocksDB/StorageEmbeddedRocksDB.cpp | 2 +- src/Storages/StorageGenerateRandom.cpp | 2 +- src/Storages/StorageInMemoryMetadata.cpp | 24 ++++- src/Storages/StorageInMemoryMetadata.h | 7 +- src/Storages/StorageJoin.cpp | 2 +- src/Storages/StorageLog.cpp | 2 +- src/Storages/StorageMemory.cpp | 2 +- src/Storages/StorageMongoDB.cpp | 2 +- src/Storages/StorageMySQL.cpp | 2 +- src/Storages/StoragePostgreSQL.cpp | 2 +- src/Storages/StorageS3Cluster.cpp | 2 +- src/Storages/StorageStripeLog.cpp | 2 +- src/Storages/StorageTinyLog.cpp | 2 +- src/Storages/StorageValues.cpp | 2 +- src/Storages/StorageXDBC.cpp | 2 +- src/Storages/System/IStorageSystemOneBlock.h | 2 +- src/Storages/System/StorageSystemColumns.cpp | 2 +- src/Storages/System/StorageSystemDisks.cpp | 2 +- src/Storages/System/StorageSystemNumbers.cpp | 2 +- src/Storages/System/StorageSystemOne.cpp | 2 +- .../System/StorageSystemPartsBase.cpp | 2 +- src/Storages/System/StorageSystemReplicas.cpp | 2 +- .../System/StorageSystemStoragePolicies.cpp | 2 +- src/Storages/System/StorageSystemTables.cpp | 2 +- src/Storages/System/StorageSystemZeros.cpp | 2 +- 49 files changed, 229 insertions(+), 45 deletions(-) diff --git a/src/Core/Types.h b/src/Core/Types.h index b9ecda4a46d..9eee46f8af2 100644 --- a/src/Core/Types.h +++ b/src/Core/Types.h @@ -58,6 +58,7 @@ enum class TypeIndex AggregateFunction, LowCardinality, Map, + Object, }; #if !defined(__clang__) #pragma GCC diagnostic pop @@ -273,6 +274,7 @@ inline constexpr const char * getTypeName(TypeIndex idx) case TypeIndex::AggregateFunction: return "AggregateFunction"; case TypeIndex::LowCardinality: return "LowCardinality"; case TypeIndex::Map: return "Map"; + case TypeIndex::Object: return "Object"; } __builtin_unreachable(); diff --git a/src/DataTypes/DataTypeObject.h b/src/DataTypes/DataTypeObject.h index 17d8dcc0f41..6ba666adf3f 100644 --- a/src/DataTypes/DataTypeObject.h +++ b/src/DataTypes/DataTypeObject.h @@ -24,7 +24,7 @@ public: const char * getFamilyName() const override { return "Object"; } String doGetName() const override; - TypeIndex getTypeId() const override { return TypeIndex::Nothing; } + TypeIndex getTypeId() const override { return TypeIndex::Object; } MutableColumnPtr createColumn() const override { return ColumnObject::create(); } diff --git a/src/DataTypes/DataTypeTuple.cpp b/src/DataTypes/DataTypeTuple.cpp index c8006a65a79..e07870c3c43 100644 --- a/src/DataTypes/DataTypeTuple.cpp +++ b/src/DataTypes/DataTypeTuple.cpp @@ -281,7 +281,9 @@ DataTypePtr DataTypeTuple::tryGetSubcolumnType(const String & subcolumn_name) co auto on_success = [&](size_t pos) { return elems[pos]; }; auto on_continue = [&](size_t pos, const String & next_subcolumn) { return elems[pos]->tryGetSubcolumnType(next_subcolumn); }; - return getSubcolumnEntity(subcolumn_name, on_success, on_continue); + auto kek = getSubcolumnEntity(subcolumn_name, on_success, on_continue); + std::cerr << "requested subcolumn: " << subcolumn_name << ", have: " << !!kek << "\n"; + return kek; } ColumnPtr DataTypeTuple::getSubcolumn(const String & subcolumn_name, const IColumn & column) const diff --git a/src/DataTypes/IDataType.h b/src/DataTypes/IDataType.h index bb59bc8b3c6..3ca82a40121 100644 --- a/src/DataTypes/IDataType.h +++ b/src/DataTypes/IDataType.h @@ -337,6 +337,7 @@ struct WhichDataType constexpr bool isMap() const {return idx == TypeIndex::Map; } constexpr bool isSet() const { return idx == TypeIndex::Set; } constexpr bool isInterval() const { return idx == TypeIndex::Interval; } + constexpr bool isObject() const { return idx == TypeIndex::Object; } constexpr bool isNothing() const { return idx == TypeIndex::Nothing; } constexpr bool isNullable() const { return idx == TypeIndex::Nullable; } @@ -362,6 +363,7 @@ inline bool isDecimal(const DataTypePtr & data_type) { return WhichDataType(data inline bool isTuple(const DataTypePtr & data_type) { return WhichDataType(data_type).isTuple(); } inline bool isArray(const DataTypePtr & data_type) { return WhichDataType(data_type).isArray(); } inline bool isMap(const DataTypePtr & data_type) {return WhichDataType(data_type).isMap(); } +inline bool isObject(const DataTypePtr & data_type) {return WhichDataType(data_type).isObject(); } template inline bool isUInt8(const T & data_type) diff --git a/src/DataTypes/NestedUtils.cpp b/src/DataTypes/NestedUtils.cpp index 6c13eea0a1b..b84f937c3ec 100644 --- a/src/DataTypes/NestedUtils.cpp +++ b/src/DataTypes/NestedUtils.cpp @@ -62,7 +62,7 @@ std::pair splitName(const std::string & name) ++pos; - while (pos < end && isWordCharASCII(*pos)) + while (pos < end && (isWordCharASCII(*pos) || *pos == '.')) ++pos; if (pos != end) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 7a9226c4762..5e7dd24c0fd 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include #include @@ -67,4 +68,34 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) } } +DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) +{ + std::unordered_map subcolumns_types; + for (const auto & type : types) + { + const auto * type_tuple = typeid_cast(type.get()); + if (!type_tuple) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Least common type for object can be deduced only from tuples, but {} given", type->getName()); + + const auto & tuple_names = type_tuple->getElementNames(); + const auto & tuple_types = type_tuple->getElements(); + assert(tuple_names.size() == tuple_type.size()); + + for (size_t i = 0; i < tuple_names.size(); ++i) + subcolumns_types[tuple_names[i]].push_back(tuple_types[i]); + } + + Names tuple_names; + DataTypes tuple_types; + + for (const auto & [name, subtypes] : subcolumns_types) + { + tuple_names.push_back(name); + tuple_types.push_back(getLeastSupertype(subtypes)); + } + + return std::make_shared(tuple_types, tuple_names); +} + } diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index cacb3abbb08..509574f934d 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -8,5 +8,6 @@ namespace DB DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block); +DataTypePtr getLeastCommonTypeForObject(const DataTypes & types); } diff --git a/src/DataTypes/Serializations/ISerialization.cpp b/src/DataTypes/Serializations/ISerialization.cpp index 82dfa53c103..fa483d3c8d2 100644 --- a/src/DataTypes/Serializations/ISerialization.cpp +++ b/src/DataTypes/Serializations/ISerialization.cpp @@ -144,8 +144,10 @@ static String getNameForSubstreamPath( /// Because nested data may be represented not by Array of Tuple, /// but by separate Array columns with names in a form of a.b, /// and name is encoded as a whole. - stream_name += (escape_tuple_delimiter && elem.escape_tuple_delimiter ? - escapeForFileName(".") : ".") + escapeForFileName(elem.tuple_element_name); + if (escape_tuple_delimiter && elem.escape_tuple_delimiter) + stream_name += escapeForFileName(".") + escapeForFileName(elem.tuple_element_name); + else + stream_name += "." + elem.tuple_element_name; } else if (elem.type == Substream::ObjectElement) { diff --git a/src/Interpreters/InterpreterOptimizeQuery.cpp b/src/Interpreters/InterpreterOptimizeQuery.cpp index 64de5ee0479..b50ce8b85df 100644 --- a/src/Interpreters/InterpreterOptimizeQuery.cpp +++ b/src/Interpreters/InterpreterOptimizeQuery.cpp @@ -46,7 +46,7 @@ BlockIO InterpreterOptimizeQuery::execute() column_names.emplace_back(col->getColumnName()); } - metadata_snapshot->check(column_names, NamesAndTypesList{}, table_id); + metadata_snapshot->check(column_names, NamesAndTypesList{}, table_id, {}); Names required_columns; { required_columns = metadata_snapshot->getColumnsRequiredForSortingKey(); diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp index cb8375cf798..6a6c5185441 100644 --- a/src/Interpreters/InterpreterSelectQuery.cpp +++ b/src/Interpreters/InterpreterSelectQuery.cpp @@ -475,7 +475,8 @@ InterpreterSelectQuery::InterpreterSelectQuery( } } - source_header = metadata_snapshot->getSampleBlockForColumns(required_columns, storage->getVirtuals(), storage->getStorageID()); + source_header = metadata_snapshot->getSampleBlockForColumns( + required_columns, storage->getVirtuals(), storage->getStorageID(), storage->getExpandedObjects()); } /// Calculate structure of the result. @@ -1736,7 +1737,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc if (!query_plan.isInitialized()) { auto header = metadata_snapshot->getSampleBlockForColumns( - required_columns, storage->getVirtuals(), storage->getStorageID()); + required_columns, storage->getVirtuals(), storage->getStorageID(), storage->getExpandedObjects()); addEmptySourceToQueryPlan(query_plan, header, query_info); } diff --git a/src/Interpreters/TreeRewriter.cpp b/src/Interpreters/TreeRewriter.cpp index 324a773fbc2..2deff98fd0c 100644 --- a/src/Interpreters/TreeRewriter.cpp +++ b/src/Interpreters/TreeRewriter.cpp @@ -641,6 +641,12 @@ void TreeRewriterResult::collectSourceColumns(bool add_special) else columns_from_storage = add_special ? columns.getAll() : columns.getAllPhysical(); + columns_from_storage = storage->expandObjectColumns(columns_from_storage, storage->supportsSubcolumns()); + + std::cerr << "columns_from_storage: "; + for (const auto & col : columns_from_storage) + std::cerr << col.dump() << "\n"; + if (source_columns.empty()) source_columns.swap(columns_from_storage); else diff --git a/src/Interpreters/getHeaderForProcessingStage.cpp b/src/Interpreters/getHeaderForProcessingStage.cpp index 9c7c86a0b88..3ed6642105f 100644 --- a/src/Interpreters/getHeaderForProcessingStage.cpp +++ b/src/Interpreters/getHeaderForProcessingStage.cpp @@ -47,7 +47,9 @@ Block getHeaderForProcessingStage( { case QueryProcessingStage::FetchColumns: { - Block header = metadata_snapshot->getSampleBlockForColumns(column_names, storage.getVirtuals(), storage.getStorageID()); + Block header = metadata_snapshot->getSampleBlockForColumns( + column_names, storage.getVirtuals(), storage.getStorageID(), storage.getExpandedObjects()); + if (query_info.prewhere_info) { auto & prewhere_info = *query_info.prewhere_info; @@ -75,7 +77,8 @@ Block getHeaderForProcessingStage( removeJoin(*query->as()); auto stream = std::make_shared( - metadata_snapshot->getSampleBlockForColumns(column_names, storage.getVirtuals(), storage.getStorageID())); + metadata_snapshot->getSampleBlockForColumns( + column_names, storage.getVirtuals(), storage.getStorageID(), storage.getExpandedObjects())); return InterpreterSelectQuery(query, context, stream, SelectQueryOptions(processed_stage).analyze()).getSampleBlock(); } } diff --git a/src/Processors/QueryPlan/ReadFromMergeTree.cpp b/src/Processors/QueryPlan/ReadFromMergeTree.cpp index ebf9c9e4121..6dccb2b7954 100644 --- a/src/Processors/QueryPlan/ReadFromMergeTree.cpp +++ b/src/Processors/QueryPlan/ReadFromMergeTree.cpp @@ -23,7 +23,7 @@ ReadFromMergeTree::ReadFromMergeTree( size_t num_streams_, ReadType read_type_) : ISourceStep(DataStream{.header = MergeTreeBaseSelectProcessor::transformHeader( - metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID()), + metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID(), storage_.getExpandedObjects()), prewhere_info_, virt_column_names_)}) , storage(storage_) diff --git a/src/Storages/ColumnsDescription.h b/src/Storages/ColumnsDescription.h index 7fff22abf71..f7886d0353a 100644 --- a/src/Storages/ColumnsDescription.h +++ b/src/Storages/ColumnsDescription.h @@ -31,6 +31,7 @@ struct ColumnDescription { String name; DataTypePtr type; + DataTypePtr expaneded_type; ColumnDefault default_desc; String comment; ASTPtr codec; diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp index f7fb359432e..eb78bf4aa84 100644 --- a/src/Storages/IStorage.cpp +++ b/src/Storages/IStorage.cpp @@ -105,7 +105,7 @@ void IStorage::read( auto pipe = read(column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams); if (pipe.empty()) { - auto header = metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()); + auto header = metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID(), getExpandedObjects()); InterpreterSelectQuery::addEmptySourceToQueryPlan(query_plan, header, query_info); } else diff --git a/src/Storages/IStorage.h b/src/Storages/IStorage.h index e48e9e49919..c64a40ac0d2 100644 --- a/src/Storages/IStorage.h +++ b/src/Storages/IStorage.h @@ -524,6 +524,9 @@ public: /// Does not takes underlying Storage (if any) into account. virtual std::optional lifetimeBytes() const { return {}; } + virtual NamesAndTypesList expandObjectColumns(const NamesAndTypesList & columns_list, bool /*with_subcolumns*/) const { return columns_list; } + virtual NamesAndTypesList getExpandedObjects() const { return {}; } + private: /// Lock required for alter queries (lockForAlter). Always taken for write /// (actually can be replaced with std::mutex, but for consistency we use diff --git a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp index 10ce061a864..cf07f4e2ec9 100644 --- a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp +++ b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -90,6 +91,13 @@ NameSet injectRequiredColumns(const MergeTreeData & storage, const StorageMetada auto alter_conversions = storage.getAlterConversionsForPart(part); for (size_t i = 0; i < columns.size(); ++i) { + auto name_in_storage = Nested::extractTableName(columns[i]); + if (isObject(storage_columns.get(name_in_storage).type)) + { + have_at_least_one_physical_column = true; + continue; + } + /// We are going to fetch only physical columns if (!storage_columns.hasPhysicalOrSubcolumn(columns[i])) throw Exception("There is no physical column or subcolumn " + columns[i] + " in table.", ErrorCodes::NO_SUCH_COLUMN_IN_TABLE); @@ -308,7 +316,9 @@ MergeTreeReadTaskColumns getReadTaskColumns( if (check_columns) { - const NamesAndTypesList & physical_columns = metadata_snapshot->getColumns().getAllWithSubcolumns(); + auto physical_columns = metadata_snapshot->getColumns().getAllWithSubcolumns(); + physical_columns = storage.expandObjectColumns(physical_columns, true); + result.pre_columns = physical_columns.addTypes(pre_column_names); result.columns = physical_columns.addTypes(column_names); } diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index f28d87bb9be..b02abf5da0c 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -8,6 +8,8 @@ #include #include #include +#include +#include #include #include #include @@ -4479,6 +4481,97 @@ ReservationPtr MergeTreeData::balancedReservation( return reserved_space; } +static NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list) +{ + NameSet res; + for (const auto & [name, type] : columns_list) + if (isObject(type)) + res.insert(name); + + return res; +} + +static NamesAndTypesList expandObjectColumnsImpl( + const MergeTreeData::DataPartsVector & parts, + const NamesAndTypesList & columns_list, + const NameSet & requested_to_expand, + bool with_subcolumns) +{ + std::unordered_map types_in_parts; + + for (const auto & part : parts) + { + const auto & part_columns = part->getColumns(); + for (const auto & [name, type] : part_columns) + { + if (requested_to_expand.count(name)) + types_in_parts[name].push_back(type); + } + } + + NamesAndTypesList result_columns; + for (const auto & column : columns_list) + { + auto it = types_in_parts.find(column.name); + if (it != types_in_parts.end()) + { + auto expanded_type = getLeastCommonTypeForObject(it->second); + result_columns.emplace_back(column.name, expanded_type); + + std::cerr << "expanded_type: " << expanded_type->getName() << "\n"; + + if (with_subcolumns) + { + for (const auto & subcolumn : expanded_type->getSubcolumnNames()) + { + result_columns.emplace_back(column.name, subcolumn, + expanded_type, expanded_type->getSubcolumnType(subcolumn)); + std::cerr << "adding subcolumn: " << subcolumn << "\n"; + } + } + } + else + { + result_columns.push_back(column); + } + } + + return result_columns; +} + +NamesAndTypesList MergeTreeData::expandObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns) const +{ + /// Firstly fast check if there are any Object columns. + NameSet requested_to_expand = getNamesOfObjectColumns(columns_list); + if (requested_to_expand.empty()) + return columns_list; + + return expandObjectColumnsImpl(parts, columns_list, requested_to_expand, with_subcolumns); +} + +NamesAndTypesList MergeTreeData::expandObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const +{ + /// Firstly fast check if there are any Object columns. + NameSet requested_to_expand = getNamesOfObjectColumns(columns_list); + if (requested_to_expand.empty()) + return columns_list; + + return expandObjectColumnsImpl(getDataPartsVector(), columns_list, requested_to_expand, with_subcolumns); +} + +NamesAndTypesList MergeTreeData::getExpandedObjects() const +{ + auto metadata_snapshot = getInMemoryMetadataPtr(); + auto columns = metadata_snapshot->getColumns().getAllPhysical(); + + NamesAndTypesList result_columns; + for (const auto & column : columns) + if (isObject(column.type)) + result_columns.push_back(column); + + return expandObjectColumns(result_columns, false); +} + CurrentlySubmergingEmergingTagger::~CurrentlySubmergingEmergingTagger() { std::lock_guard lock(storage.currently_submerging_emerging_mutex); diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index 46c0014d9f7..c8adee236a0 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -617,6 +617,10 @@ public: return column_sizes; } + NamesAndTypesList expandObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const override; + NamesAndTypesList expandObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns) const; + NamesAndTypesList getExpandedObjects() const override; + /// For ATTACH/DETACH/DROP PARTITION. String getPartitionIDFromQuery(const ASTPtr & ast, ContextPtr context) const; diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp index af72b3e53f2..8eeb349057a 100644 --- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp +++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp @@ -236,7 +236,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts( } // At this point, empty `part_values` means all parts. - metadata_snapshot->check(real_column_names, data.getVirtuals(), data.getStorageID()); + metadata_snapshot->check(real_column_names, data.getVirtuals(), data.getStorageID(), data.getExpandedObjects()); const Settings & settings = context->getSettingsRef(); const auto & primary_key = metadata_snapshot->getPrimaryKey(); diff --git a/src/Storages/MergeTree/MergeTreeReadPool.cpp b/src/Storages/MergeTree/MergeTreeReadPool.cpp index d9a250e3f7a..07173eb2118 100644 --- a/src/Storages/MergeTree/MergeTreeReadPool.cpp +++ b/src/Storages/MergeTree/MergeTreeReadPool.cpp @@ -168,7 +168,7 @@ MarkRanges MergeTreeReadPool::getRestMarks(const IMergeTreeDataPart & part, cons Block MergeTreeReadPool::getHeader() const { - return metadata_snapshot->getSampleBlockForColumns(column_names, data.getVirtuals(), data.getStorageID()); + return metadata_snapshot->getSampleBlockForColumns(column_names, data.getVirtuals(), data.getStorageID(), data.getExpandedObjects()); } void MergeTreeReadPool::profileFeedback(const ReadBufferFromFileBase::ProfileInfo info) diff --git a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp index e9527efaa4a..251dc4d5467 100644 --- a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp +++ b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp @@ -30,7 +30,7 @@ MergeTreeReverseSelectProcessor::MergeTreeReverseSelectProcessor( bool quiet) : MergeTreeBaseSelectProcessor{ - metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID()), + metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID(), storage_.getExpandedObjects()), storage_, metadata_snapshot_, prewhere_info_, max_block_size_rows_, preferred_block_size_bytes_, preferred_max_column_in_block_size_bytes_, reader_settings_, use_uncompressed_cache_, virt_column_names_}, diff --git a/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp index 980afa170e9..932595b42cd 100644 --- a/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp +++ b/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp @@ -30,7 +30,7 @@ MergeTreeSelectProcessor::MergeTreeSelectProcessor( bool quiet) : MergeTreeBaseSelectProcessor{ - metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID()), + metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID(), storage_.getExpandedObjects()), storage_, metadata_snapshot_, prewhere_info_, max_block_size_rows_, preferred_block_size_bytes_, preferred_max_column_in_block_size_bytes_, reader_settings_, use_uncompressed_cache_, virt_column_names_}, diff --git a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp index e82b1966461..972bbce193d 100644 --- a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp +++ b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp @@ -17,7 +17,7 @@ MergeTreeSequentialSource::MergeTreeSequentialSource( bool read_with_direct_io_, bool take_column_types_from_storage, bool quiet) - : SourceWithProgress(metadata_snapshot_->getSampleBlockForColumns(columns_to_read_, storage_.getVirtuals(), storage_.getStorageID())) + : SourceWithProgress(metadata_snapshot_->getSampleBlockForColumns(columns_to_read_, storage_.getVirtuals(), storage_.getStorageID(), storage_.getExpandedObjects())) , storage(storage_) , metadata_snapshot(metadata_snapshot_) , data_part(std::move(data_part_)) diff --git a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp index 9173c23ec5a..744d91b0f54 100644 --- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp +++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp @@ -289,7 +289,7 @@ Pipe StorageEmbeddedRocksDB::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); FieldVectorPtr keys; bool all_scan = false; diff --git a/src/Storages/StorageGenerateRandom.cpp b/src/Storages/StorageGenerateRandom.cpp index bc158c38f37..167d74cc51d 100644 --- a/src/Storages/StorageGenerateRandom.cpp +++ b/src/Storages/StorageGenerateRandom.cpp @@ -447,7 +447,7 @@ Pipe StorageGenerateRandom::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); Pipes pipes; pipes.reserve(num_streams); diff --git a/src/Storages/StorageInMemoryMetadata.cpp b/src/Storages/StorageInMemoryMetadata.cpp index 2f4a24a5c60..9a35250723a 100644 --- a/src/Storages/StorageInMemoryMetadata.cpp +++ b/src/Storages/StorageInMemoryMetadata.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -287,7 +288,7 @@ Block StorageInMemoryMetadata::getSampleBlock() const } Block StorageInMemoryMetadata::getSampleBlockForColumns( - const Names & column_names, const NamesAndTypesList & virtuals, const StorageID & storage_id) const + const Names & column_names, const NamesAndTypesList & virtuals, const StorageID & storage_id, const NamesAndTypesList & expanded_objects) const { Block res; @@ -303,6 +304,17 @@ Block StorageInMemoryMetadata::getSampleBlockForColumns( for (const auto & column : virtuals) columns_map.emplace(column.name, column.type); + for (const auto & column : expanded_objects) + { + columns_map.emplace(column.name, column.type); + for (const auto & subcolumn : column.type->getSubcolumnNames()) + columns_map.emplace(Nested::concatenateName(column.name, subcolumn), column.type->getSubcolumnType(subcolumn)); + } + + std::cerr << "expanded objects: "; + for (const auto & col : expanded_objects) + std::cerr << col.dump() << "\n"; + for (const auto & name : column_names) { auto it = columns_map.find(name); @@ -477,11 +489,19 @@ namespace } } -void StorageInMemoryMetadata::check(const Names & column_names, const NamesAndTypesList & virtuals, const StorageID & storage_id) const +void StorageInMemoryMetadata::check( + const Names & column_names, const NamesAndTypesList & virtuals, const StorageID & storage_id, const NamesAndTypesList & expanded_objects) const { NamesAndTypesList available_columns = getColumns().getAllPhysicalWithSubcolumns(); available_columns.insert(available_columns.end(), virtuals.begin(), virtuals.end()); + for (const auto & column : expanded_objects) + { + available_columns.push_back(column); + for (const auto & subcolumn : column.type->getSubcolumnNames()) + available_columns.emplace_back(column.name, subcolumn, column.type, column.type->getSubcolumnType(subcolumn)); + } + const String list_of_columns = listOfColumns(available_columns); if (column_names.empty()) diff --git a/src/Storages/StorageInMemoryMetadata.h b/src/Storages/StorageInMemoryMetadata.h index 00fb944c0b5..053dba62341 100644 --- a/src/Storages/StorageInMemoryMetadata.h +++ b/src/Storages/StorageInMemoryMetadata.h @@ -147,7 +147,9 @@ struct StorageInMemoryMetadata /// Storage metadata. StorageID required only for more clear exception /// message. Block getSampleBlockForColumns( - const Names & column_names, const NamesAndTypesList & virtuals = {}, const StorageID & storage_id = StorageID::createEmpty()) const; + const Names & column_names, const NamesAndTypesList & virtuals = {}, + const StorageID & storage_id = StorageID::createEmpty(), const NamesAndTypesList & expanded_objects = {}) const; + /// Returns structure with partition key. const KeyDescription & getPartitionKey() const; /// Returns ASTExpressionList of partition key expression for storage or nullptr if there is none. @@ -212,7 +214,8 @@ struct StorageInMemoryMetadata /// Verify that all the requested names are in the table and are set correctly: /// list of names is not empty and the names do not repeat. - void check(const Names & column_names, const NamesAndTypesList & virtuals, const StorageID & storage_id) const; + void check(const Names & column_names, const NamesAndTypesList & virtuals, + const StorageID & storage_id, const NamesAndTypesList & expanded_objects) const; /// Check that all the requested names are in the table and have the correct types. void check(const NamesAndTypesList & columns) const; diff --git a/src/Storages/StorageJoin.cpp b/src/Storages/StorageJoin.cpp index 983b9213a35..c029ebc9b31 100644 --- a/src/Storages/StorageJoin.cpp +++ b/src/Storages/StorageJoin.cpp @@ -497,7 +497,7 @@ Pipe StorageJoin::read( size_t max_block_size, unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); Block source_sample_block = metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()); return Pipe(std::make_shared(join, rwlock, max_block_size, source_sample_block)); diff --git a/src/Storages/StorageLog.cpp b/src/Storages/StorageLog.cpp index 8ed68e0b44d..14d4ee71c46 100644 --- a/src/Storages/StorageLog.cpp +++ b/src/Storages/StorageLog.cpp @@ -652,7 +652,7 @@ Pipe StorageLog::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); auto lock_timeout = getLockTimeout(context); loadMarks(lock_timeout); diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp index 4cae7367606..7a0ba624891 100644 --- a/src/Storages/StorageMemory.cpp +++ b/src/Storages/StorageMemory.cpp @@ -183,7 +183,7 @@ Pipe StorageMemory::read( size_t /*max_block_size*/, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); if (delay_read_for_global_subqueries) { diff --git a/src/Storages/StorageMongoDB.cpp b/src/Storages/StorageMongoDB.cpp index 2b0200f3643..1e516c71d2d 100644 --- a/src/Storages/StorageMongoDB.cpp +++ b/src/Storages/StorageMongoDB.cpp @@ -81,7 +81,7 @@ Pipe StorageMongoDB::read( { connectIfNotConnected(); - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); Block sample_block; for (const String & column_name : column_names) diff --git a/src/Storages/StorageMySQL.cpp b/src/Storages/StorageMySQL.cpp index bc07679a0de..a3f7ce51fb4 100644 --- a/src/Storages/StorageMySQL.cpp +++ b/src/Storages/StorageMySQL.cpp @@ -74,7 +74,7 @@ Pipe StorageMySQL::read( size_t /*max_block_size*/, unsigned) { - metadata_snapshot->check(column_names_, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names_, getVirtuals(), getStorageID(), getExpandedObjects()); String query = transformQueryForExternalDatabase( query_info_, metadata_snapshot->getColumns().getOrdinary(), diff --git a/src/Storages/StoragePostgreSQL.cpp b/src/Storages/StoragePostgreSQL.cpp index a99568c0036..3549d5700b1 100644 --- a/src/Storages/StoragePostgreSQL.cpp +++ b/src/Storages/StoragePostgreSQL.cpp @@ -70,7 +70,7 @@ Pipe StoragePostgreSQL::read( size_t max_block_size_, unsigned) { - metadata_snapshot->check(column_names_, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names_, getVirtuals(), getStorageID(), getExpandedObjects()); /// Connection is already made to the needed database, so it should not be present in the query; /// remote_table_schema is empty if it is not specified, will access only table_name. diff --git a/src/Storages/StorageS3Cluster.cpp b/src/Storages/StorageS3Cluster.cpp index 8afc0e44023..a9698c0545a 100644 --- a/src/Storages/StorageS3Cluster.cpp +++ b/src/Storages/StorageS3Cluster.cpp @@ -135,7 +135,7 @@ Pipe StorageS3Cluster::read( } } - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); return Pipe::unitePipes(std::move(pipes)); } diff --git a/src/Storages/StorageStripeLog.cpp b/src/Storages/StorageStripeLog.cpp index d845dfb71f2..2db0cc45cbb 100644 --- a/src/Storages/StorageStripeLog.cpp +++ b/src/Storages/StorageStripeLog.cpp @@ -330,7 +330,7 @@ Pipe StorageStripeLog::read( if (!lock) throw Exception("Lock timeout exceeded", ErrorCodes::TIMEOUT_EXCEEDED); - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); NameSet column_names_set(column_names.begin(), column_names.end()); diff --git a/src/Storages/StorageTinyLog.cpp b/src/Storages/StorageTinyLog.cpp index 41c2961e929..e62a35317a7 100644 --- a/src/Storages/StorageTinyLog.cpp +++ b/src/Storages/StorageTinyLog.cpp @@ -484,7 +484,7 @@ Pipe StorageTinyLog::read( const size_t max_block_size, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); auto all_columns = metadata_snapshot->getColumns().getAllWithSubcolumns().addTypes(column_names); diff --git a/src/Storages/StorageValues.cpp b/src/Storages/StorageValues.cpp index ace5ca3667c..ccdd715d8b3 100644 --- a/src/Storages/StorageValues.cpp +++ b/src/Storages/StorageValues.cpp @@ -29,7 +29,7 @@ Pipe StorageValues::read( size_t /*max_block_size*/, unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); /// Get only required columns. Block block; diff --git a/src/Storages/StorageXDBC.cpp b/src/Storages/StorageXDBC.cpp index f94696c716b..16a134de84a 100644 --- a/src/Storages/StorageXDBC.cpp +++ b/src/Storages/StorageXDBC.cpp @@ -106,7 +106,7 @@ Pipe StorageXDBC::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); bridge_helper->startBridgeSync(); return IStorageURLBase::read(column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); diff --git a/src/Storages/System/IStorageSystemOneBlock.h b/src/Storages/System/IStorageSystemOneBlock.h index 36e92d5a1f4..a1e139d0705 100644 --- a/src/Storages/System/IStorageSystemOneBlock.h +++ b/src/Storages/System/IStorageSystemOneBlock.h @@ -41,7 +41,7 @@ public: size_t /*max_block_size*/, unsigned /*num_streams*/) override { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); Block sample_block = metadata_snapshot->getSampleBlock(); MutableColumns res_columns = sample_block.cloneEmptyColumns(); diff --git a/src/Storages/System/StorageSystemColumns.cpp b/src/Storages/System/StorageSystemColumns.cpp index 8f65147bb11..81c048f8e2d 100644 --- a/src/Storages/System/StorageSystemColumns.cpp +++ b/src/Storages/System/StorageSystemColumns.cpp @@ -248,7 +248,7 @@ Pipe StorageSystemColumns::read( const size_t max_block_size, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); /// Create a mask of what columns are needed in the result. diff --git a/src/Storages/System/StorageSystemDisks.cpp b/src/Storages/System/StorageSystemDisks.cpp index 5d7628acb2a..64ea8209b90 100644 --- a/src/Storages/System/StorageSystemDisks.cpp +++ b/src/Storages/System/StorageSystemDisks.cpp @@ -35,7 +35,7 @@ Pipe StorageSystemDisks::read( const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); MutableColumnPtr col_name = ColumnString::create(); MutableColumnPtr col_path = ColumnString::create(); diff --git a/src/Storages/System/StorageSystemNumbers.cpp b/src/Storages/System/StorageSystemNumbers.cpp index f8a0e94bf98..6c6d8352c6e 100644 --- a/src/Storages/System/StorageSystemNumbers.cpp +++ b/src/Storages/System/StorageSystemNumbers.cpp @@ -131,7 +131,7 @@ Pipe StorageSystemNumbers::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); if (limit && *limit < max_block_size) { diff --git a/src/Storages/System/StorageSystemOne.cpp b/src/Storages/System/StorageSystemOne.cpp index 7c28f897121..9237d5568e4 100644 --- a/src/Storages/System/StorageSystemOne.cpp +++ b/src/Storages/System/StorageSystemOne.cpp @@ -29,7 +29,7 @@ Pipe StorageSystemOne::read( const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); Block header{ColumnWithTypeAndName( DataTypeUInt8().createColumn(), diff --git a/src/Storages/System/StorageSystemPartsBase.cpp b/src/Storages/System/StorageSystemPartsBase.cpp index f1c82aa4c63..2ac2f6a9dba 100644 --- a/src/Storages/System/StorageSystemPartsBase.cpp +++ b/src/Storages/System/StorageSystemPartsBase.cpp @@ -41,7 +41,7 @@ bool StorageSystemPartsBase::hasStateColumn(const Names & column_names, const St /// Do not check if only _state column is requested if (!(has_state_column && real_column_names.empty())) - metadata_snapshot->check(real_column_names, {}, getStorageID()); + metadata_snapshot->check(real_column_names, {}, getStorageID(), {}); return has_state_column; } diff --git a/src/Storages/System/StorageSystemReplicas.cpp b/src/Storages/System/StorageSystemReplicas.cpp index fc33c6b421b..79862e3e383 100644 --- a/src/Storages/System/StorageSystemReplicas.cpp +++ b/src/Storages/System/StorageSystemReplicas.cpp @@ -65,7 +65,7 @@ Pipe StorageSystemReplicas::read( const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); const auto access = context->getAccess(); const bool check_access_for_databases = !access->isGranted(AccessType::SHOW_TABLES); diff --git a/src/Storages/System/StorageSystemStoragePolicies.cpp b/src/Storages/System/StorageSystemStoragePolicies.cpp index 48dfadd2b3c..7d117212275 100644 --- a/src/Storages/System/StorageSystemStoragePolicies.cpp +++ b/src/Storages/System/StorageSystemStoragePolicies.cpp @@ -44,7 +44,7 @@ Pipe StorageSystemStoragePolicies::read( const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); MutableColumnPtr col_policy_name = ColumnString::create(); MutableColumnPtr col_volume_name = ColumnString::create(); diff --git a/src/Storages/System/StorageSystemTables.cpp b/src/Storages/System/StorageSystemTables.cpp index 9602339f381..6dd6fa96a05 100644 --- a/src/Storages/System/StorageSystemTables.cpp +++ b/src/Storages/System/StorageSystemTables.cpp @@ -506,7 +506,7 @@ Pipe StorageSystemTables::read( const size_t max_block_size, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); /// Create a mask of what columns are needed in the result. diff --git a/src/Storages/System/StorageSystemZeros.cpp b/src/Storages/System/StorageSystemZeros.cpp index d1456d72685..f3642d3c66a 100644 --- a/src/Storages/System/StorageSystemZeros.cpp +++ b/src/Storages/System/StorageSystemZeros.cpp @@ -99,7 +99,7 @@ Pipe StorageSystemZeros::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); bool use_multiple_streams = multithreaded; From 28a9a5c277bc4632f999e4a19f26922687c47d1f Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Mon, 26 Apr 2021 00:57:21 +0300 Subject: [PATCH 005/132] dynamic subcolumns: support arrays --- src/Columns/ColumnObject.cpp | 1 - src/DataTypes/DataTypeTuple.cpp | 1 - src/DataTypes/FieldToDataType.cpp | 3 + src/DataTypes/FieldToDataType.h | 8 ++ src/DataTypes/ObjectUtils.cpp | 2 +- src/DataTypes/Serializations/JSONDataParser.h | 68 +++++++++++++++-- .../Serializations/SerializationObject.cpp | 60 ++++++++------- .../Serializations/SerializationObject.h | 3 + .../tests/gtest_json_parser.cpp | 73 +++++++++++++++---- src/Storages/MergeTree/MergeTreeData.cpp | 3 - .../0_stateless/01825_type_json.reference | 10 +++ tests/queries/0_stateless/01825_type_json.sh | 40 ++++++++++ 12 files changed, 217 insertions(+), 55 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json.reference create mode 100644 tests/queries/0_stateless/01825_type_json.sh diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 17594501db1..fdd12c6f617 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -105,7 +105,6 @@ bool ColumnObject::hasSubcolumn(const String & key) const void ColumnObject::addSubcolumn(const String & key, MutableColumnPtr && subcolumn, bool check_size) { - std::cerr << "adding subcolumn: " << key << ", subcolumn: " << subcolumn->dumpStructure() << "\n"; if (check_size && subcolumn->size() != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", diff --git a/src/DataTypes/DataTypeTuple.cpp b/src/DataTypes/DataTypeTuple.cpp index e07870c3c43..f203514d2bb 100644 --- a/src/DataTypes/DataTypeTuple.cpp +++ b/src/DataTypes/DataTypeTuple.cpp @@ -282,7 +282,6 @@ DataTypePtr DataTypeTuple::tryGetSubcolumnType(const String & subcolumn_name) co auto on_continue = [&](size_t pos, const String & next_subcolumn) { return elems[pos]->tryGetSubcolumnType(next_subcolumn); }; auto kek = getSubcolumnEntity(subcolumn_name, on_success, on_continue); - std::cerr << "requested subcolumn: " << subcolumn_name << ", have: " << !!kek << "\n"; return kek; } diff --git a/src/DataTypes/FieldToDataType.cpp b/src/DataTypes/FieldToDataType.cpp index 95f03385121..aca3918d74f 100644 --- a/src/DataTypes/FieldToDataType.cpp +++ b/src/DataTypes/FieldToDataType.cpp @@ -95,6 +95,9 @@ DataTypePtr FieldToDataType::operator() (const DecimalField & x) con DataTypePtr FieldToDataType::operator() (const Array & x) const { + if (assume_array_elements_have_equal_types && !x.empty()) + return std::make_shared(applyVisitor(FieldToDataType(), x[0])); + DataTypes element_types; element_types.reserve(x.size()); diff --git a/src/DataTypes/FieldToDataType.h b/src/DataTypes/FieldToDataType.h index 39457564a2f..3f55937fc67 100644 --- a/src/DataTypes/FieldToDataType.h +++ b/src/DataTypes/FieldToDataType.h @@ -17,6 +17,11 @@ using DataTypePtr = std::shared_ptr; class FieldToDataType : public StaticVisitor { public: + FieldToDataType(bool assume_array_elements_have_equal_types_ = false) + : assume_array_elements_have_equal_types(assume_array_elements_have_equal_types_) + { + } + DataTypePtr operator() (const Null & x) const; DataTypePtr operator() (const UInt64 & x) const; DataTypePtr operator() (const UInt128 & x) const; @@ -34,6 +39,9 @@ public: DataTypePtr operator() (const AggregateFunctionStateData & x) const; DataTypePtr operator() (const UInt256 & x) const; DataTypePtr operator() (const Int256 & x) const; + +private: + bool assume_array_elements_have_equal_types; }; } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 5e7dd24c0fd..f6beb3fdf4d 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -28,7 +28,7 @@ DataTypePtr getDataTypeByColumn(const IColumn & column) if (column.empty()) return std::make_shared(); - return applyVisitor(FieldToDataType(), column[0]); + return applyVisitor(FieldToDataType(true), column[0]); } void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index 18996b7ff25..38634d5d984 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -25,12 +25,21 @@ String getValueAsString(const Element & element) throw Exception(ErrorCodes::LOGICAL_ERROR, "Unsupported type of JSON field"); } +String getNextPath(const String & current_path, const std::string_view & key) +{ + String next_path = current_path; + if (!next_path.empty()) + next_path += "."; + next_path += key; + return next_path; +} + } struct ParseResult { Strings paths; - Strings values; + std::vector values; }; template @@ -61,18 +70,63 @@ public: private: void traverse(const Element & element, String current_path, ParseResult & result) { - /// TODO: support arrays. if (element.isObject()) { auto object = element.getObject(); + result.paths.reserve(result.paths.size() + object.size()); + result.values.reserve(result.values.size() + object.size()); + for (auto it = object.begin(); it != object.end(); ++it) { const auto & [key, value] = *it; - String next_path = current_path; - if (!next_path.empty()) - next_path += "."; - next_path += key; - traverse(value, next_path, result); + traverse(value, getNextPath(current_path, key), result); + } + } + else if (element.isArray()) + { + auto array = element.getArray(); + std::unordered_map arrays_by_path; + size_t current_size = 0; + + for (auto it = array.begin(); it != array.end(); ++it) + { + ParseResult element_result; + traverse(*it, "", element_result); + + NameSet inserted_paths; + const auto & [paths, values] = element_result; + for (size_t i = 0; i < paths.size(); ++i) + { + inserted_paths.insert(paths[i]); + + auto & path_array = arrays_by_path[paths[i]]; + assert(path_array.size() == 0 || path_array.size() == current_size); + + if (path_array.size() == 0) + { + path_array.reserve(paths.size()); + path_array.resize(current_size); + } + + path_array.push_back(values[i]); + } + + for (auto & [path, path_array] : arrays_by_path) + { + if (!inserted_paths.count(path)) + path_array.push_back(Field()); + } + + ++current_size; + } + + result.paths.reserve(result.paths.size() + array.size()); + result.values.reserve(result.paths.size() + array.size()); + + for (const auto & [path, path_array] : arrays_by_path) + { + result.paths.push_back(getNextPath(current_path, path)); + result.values.push_back(path_array); } } else diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index a34a8c3b12a..bfaead33f9d 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -21,6 +21,7 @@ namespace ErrorCodes extern const int NOT_IMPLEMENTED; extern const int INCORRECT_DATA; extern const int CANNOT_READ_ALL_DATA; + extern const int TYPE_MISMATCH; } template @@ -36,7 +37,6 @@ void SerializationObject::deserializeText(IColumn & column, ReadBuffer & String buf; parser.readInto(buf, istr); - std::cerr << "buf: " << buf << "\n"; auto result = parser.parse(buf.data(), buf.size()); if (!result) throw Exception(ErrorCodes::INCORRECT_DATA, "Cannot parse object"); @@ -52,13 +52,25 @@ void SerializationObject::deserializeText(IColumn & column, ReadBuffer & size_t column_size = column_object.size(); for (size_t i = 0; i < paths.size(); ++i) { + auto value_type = applyVisitor(FieldToDataType(true), values[i]); if (!column_object.hasSubcolumn(paths[i])) { - auto new_column = ColumnString::create()->cloneResized(column_size); + auto new_column = value_type->createColumn()->cloneResized(column_size); + new_column->insert(values[i]); column_object.addSubcolumn(paths[i], std::move(new_column)); } + else + { + auto & subcolumn = column_object.getSubcolumn(paths[i]); + auto column_type = getDataTypeByColumn(subcolumn); - column_object.getSubcolumn(paths[i]).insertData(values[i].data(), values[i].size()); + if (!value_type->equals(*column_type)) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Type mismatch beetwen value and column. Type of value: {}. Type of column: {}", + value_type->getName(), column_type->getName()); + + subcolumn.insert(values[i]); + } } for (auto & [key, subcolumn] : column_object.getSubcolumns()) @@ -68,29 +80,25 @@ void SerializationObject::deserializeText(IColumn & column, ReadBuffer & } } -namespace +template +template +void SerializationObject::checkSerializationIsSupported(Settings & settings, StatePtr & state) const { + if (settings.position_independent_encoding) + throw Exception(ErrorCodes::NOT_IMPLEMENTED, + "DataTypeObject doesn't support serialization with position independent encoding"); -struct SerializeStateObject : public ISerialization::SerializeBinaryBulkState -{ - std::unordered_map states; -}; - -struct DeserializeStateObject : public ISerialization::DeserializeBinaryBulkState -{ - std::unordered_map states; -}; - + if (state) + throw Exception(ErrorCodes::NOT_IMPLEMENTED, + "DataTypeObject doesn't support serialization with non-trivial state"); } template void SerializationObject::serializeBinaryBulkStatePrefix( SerializeBinaryBulkSettings & settings, - SerializeBinaryBulkStatePtr &) const + SerializeBinaryBulkStatePtr & state) const { - if (settings.position_independent_encoding) - throw Exception(ErrorCodes::NOT_IMPLEMENTED, - "DataTypeObject cannot be serialized with position independent encoding"); + checkSerializationIsSupported(settings, state); } template @@ -98,18 +106,15 @@ void SerializationObject::serializeBinaryBulkStateSuffix( SerializeBinaryBulkSettings & settings, SerializeBinaryBulkStatePtr & state) const { - UNUSED(settings); - UNUSED(state); + checkSerializationIsSupported(settings, state); } template void SerializationObject::deserializeBinaryBulkStatePrefix( DeserializeBinaryBulkSettings & settings, - DeserializeBinaryBulkStatePtr &) const + DeserializeBinaryBulkStatePtr & state) const { - if (settings.position_independent_encoding) - throw Exception(ErrorCodes::NOT_IMPLEMENTED, - "DataTypeObject cannot be deserialized with position independent encoding"); + checkSerializationIsSupported(settings, state); } template @@ -120,8 +125,8 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( SerializeBinaryBulkSettings & settings, SerializeBinaryBulkStatePtr & state) const { + checkSerializationIsSupported(settings, state); const auto & column_object = assert_cast(column); - assert(!settings.position_independent_encoding); settings.path.push_back(Substream::ObjectStructure); if (auto * stream = settings.getter(settings.path)) @@ -130,9 +135,9 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( settings.path.back() = Substream::ObjectElement; for (const auto & [key, subcolumn] : column_object.getSubcolumns()) { + settings.path.back() = Substream::ObjectStructure; settings.path.back().object_key_name = key; - settings.path.back() = Substream::ObjectStructure; if (auto * stream = settings.getter(settings.path)) { auto type = getDataTypeByColumn(*subcolumn); @@ -162,6 +167,7 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( DeserializeBinaryBulkStatePtr & state, SubstreamsCache * cache) const { + checkSerializationIsSupported(settings, state); if (!column->empty()) throw Exception(ErrorCodes::NOT_IMPLEMENTED, "DataTypeObject cannot be deserialized to non-empty column"); @@ -253,7 +259,7 @@ SerializationPtr getObjectSerialization(const String & schema_format) #endif } - throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Unknow schema_format '{}'", schema_format); + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Unknown schema format '{}'", schema_format); } } diff --git a/src/DataTypes/Serializations/SerializationObject.h b/src/DataTypes/Serializations/SerializationObject.h index eeb64ca2f21..c78c8d0f921 100644 --- a/src/DataTypes/Serializations/SerializationObject.h +++ b/src/DataTypes/Serializations/SerializationObject.h @@ -44,6 +44,9 @@ public: void deserializeBinary(IColumn & column, ReadBuffer & istr) const override; private: + template + void checkSerializationIsSupported(Settings & settings, StatePtr & state) const; + mutable Parser parser; }; diff --git a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp index 48a4a446c48..dfcf43b1215 100644 --- a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp +++ b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp @@ -1,4 +1,5 @@ -#include +#include +#include #include #include @@ -6,28 +7,70 @@ using namespace DB; +const String json1 = R"({"k1" : 1, "k2" : {"k3" : "aa", "k4" : 2}})"; + +const String json2 = +R"({"k1" : [ + { + "k2" : "aaa", + "k3" : [{ "k4" : "bbb" }, { "k4" : "ccc" }] + }, + { + "k2" : "ddd", + "k3" : [{ "k4" : "eee" }, { "k4" : "fff" }] + } + ] +})"; + TEST(JSONDataParser, ReadInto) { - String json = R"({"k1" : 1, "k2" : {"k3" : "aa", "k4" : 2}})"; - String json_bad = json + "aaaaaaa"; - JSONDataParser parser; - ReadBufferFromString buf(json_bad); - String res; - parser.readInto(res, buf); - ASSERT_EQ(json, res); + { + String json_bad = json1 + "aaaaaaa"; + + JSONDataParser parser; + ReadBufferFromString buf(json_bad); + String res; + parser.readInto(res, buf); + ASSERT_EQ(json1, res); + } + + { + String json_bad = json2 + "aaaaaaa"; + + JSONDataParser parser; + ReadBufferFromString buf(json_bad); + String res; + parser.readInto(res, buf); + ASSERT_EQ(json2, res); + } } TEST(JSONDataParser, Parse) { - String json = R"({"k1" : 1, "k2" : {"k3" : "aa", "k4" : 2}})"; - JSONDataParser parser; - auto res = parser.parse(json.data(), json.size()); - ASSERT_TRUE(res.has_value()); + { + JSONDataParser parser; + auto res = parser.parse(json1.data(), json1.size()); + ASSERT_TRUE(res.has_value()); + + const auto & [paths, values] = *res; + ASSERT_EQ(paths, (Strings{"k1", "k2.k3", "k2.k4"})); + ASSERT_EQ(values, (std::vector{"1", "aa", "2"})); + } + + { + JSONDataParser parser; + auto res = parser.parse(json2.data(), json2.size()); + ASSERT_TRUE(res.has_value()); + + const auto & [paths, values] = *res; + ASSERT_EQ(paths, (Strings{"k1.k3.k4", "k1.k2"})); + + auto k1k3k4 = Array{Array{"bbb", "ccc"}, Array{"eee", "fff"}}; + auto k1k2 = Array{"aaa", "ddd"}; + ASSERT_EQ(values, (std::vector{k1k3k4, k1k2})); + } - const auto & [paths, values] = *res; - ASSERT_EQ(paths, (Strings{"k1", "k2.k3", "k2.k4"})); - ASSERT_EQ(values, (Strings{"1", "aa", "2"})); } #endif diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index b02abf5da0c..ba376d47b16 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -4518,15 +4518,12 @@ static NamesAndTypesList expandObjectColumnsImpl( auto expanded_type = getLeastCommonTypeForObject(it->second); result_columns.emplace_back(column.name, expanded_type); - std::cerr << "expanded_type: " << expanded_type->getName() << "\n"; - if (with_subcolumns) { for (const auto & subcolumn : expanded_type->getSubcolumnNames()) { result_columns.emplace_back(column.name, subcolumn, expanded_type, expanded_type->getSubcolumnType(subcolumn)); - std::cerr << "adding subcolumn: " << subcolumn << "\n"; } } } diff --git a/tests/queries/0_stateless/01825_type_json.reference b/tests/queries/0_stateless/01825_type_json.reference new file mode 100644 index 00000000000..f29a150ecf0 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json.reference @@ -0,0 +1,10 @@ +1 aa bb c +2 ee ff +3 foo +all_1_1_0 id UInt64 +all_1_1_0 data Tuple(k1 String, `k2.k4` String, `k2.k3` String, k5 String) +all_2_2_0 id UInt64 +all_2_2_0 data Tuple(k5 String) +1 ['aaa','ddd'] [['bbb','ccc'],['eee','fff']] +all_1_1_0 id UInt64 +all_1_1_0 data Tuple(`k1.k3.k4` Array(Array(String)), `k1.k2` Array(String)) diff --git a/tests/queries/0_stateless/01825_type_json.sh b/tests/queries/0_stateless/01825_type_json.sh new file mode 100644 index 00000000000..59cce8b925c --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json.sh @@ -0,0 +1,40 @@ +#!/usr/bin/env bash + +CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +# shellcheck source=../shell_config.sh +. "$CUR_DIR"/../shell_config.sh + +set -e + +$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json" +$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json(id UInt64, data Object('JSON')) \ + ENGINE = MergeTree ORDER BY tuple() SETTINGS min_bytes_for_wide_part = 0" + +cat << EOF | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json FORMAT CSV" +1,{"k1":"aa","k2":{"k3":"bb","k4":"c"}} +2,{"k1":"ee","k5":"ff"} +EOF + +cat << EOF | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json FORMAT CSV" +3,{"k5":"foo"} +EOF + +$CLICKHOUSE_CLIENT -q "SELECT id, data.k1, data.k2.k3, data.k2.k4, data.k5 FROM t_json ORDER BY id" +$CLICKHOUSE_CLIENT -q "SELECT name, column, type \ + FROM system.parts_columns WHERE table = 't_json' AND database = '$CLICKHOUSE_DATABASE' ORDER BY name" + +$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json" + +$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json(id UInt64, data Object('JSON')) \ + ENGINE = MergeTree ORDER BY tuple() SETTINGS min_bytes_for_wide_part = 0" + +cat << EOF | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json FORMAT CSV" +1,{"k1":[{"k2":"aaa","k3":[{"k4":"bbb"},{"k4":"ccc"}]},{"k2":"ddd","k3":[{"k4":"eee"},{"k4":"fff"}]}]} +EOF + +$CLICKHOUSE_CLIENT -q "SELECT id, data.k1.k2, data.k1.k3.k4 FROM t_json ORDER BY id" + +$CLICKHOUSE_CLIENT -q "SELECT name, column, type \ + FROM system.parts_columns WHERE table = 't_json' AND database = '$CLICKHOUSE_DATABASE' ORDER BY name" + +$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json" From 3bc2a0820c8b41fe391a8df8e5267ae8e4322e01 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Mon, 3 May 2021 03:56:19 +0300 Subject: [PATCH 006/132] dynamic subcolumns: support merges --- src/DataTypes/Serializations/JSONDataParser.h | 4 +- .../Serializations/SerializationObject.cpp | 1 - src/Functions/FunctionsConversion.h | 63 ++++++++++++++++--- src/IO/ReadHelpers.cpp | 6 +- src/Storages/MergeTree/MergeTreeData.cpp | 14 +++-- src/Storages/MergeTree/MergeTreeData.h | 3 +- .../MergeTree/MergeTreeDataMergerMutator.cpp | 2 + .../MergeTree/MergeTreeSequentialSource.cpp | 3 +- src/Storages/StorageInMemoryMetadata.cpp | 11 ++-- 9 files changed, 82 insertions(+), 25 deletions(-) diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index 38634d5d984..f778a1c26f6 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -120,8 +120,8 @@ private: ++current_size; } - result.paths.reserve(result.paths.size() + array.size()); - result.values.reserve(result.paths.size() + array.size()); + result.paths.reserve(result.paths.size() + arrays_by_path.size()); + result.values.reserve(result.paths.size() + arrays_by_path.size()); for (const auto & [path, path_array] : arrays_by_path) { diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index bfaead33f9d..16c9425d601 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -132,7 +132,6 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( if (auto * stream = settings.getter(settings.path)) writeVarUInt(column_object.getSubcolumns().size(), *stream); - settings.path.back() = Substream::ObjectElement; for (const auto & [key, subcolumn] : column_object.getSubcolumns()) { settings.path.back() = Substream::ObjectStructure; diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index 9b40be58862..52d6d19af53 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -2580,20 +2580,57 @@ private: throw Exception{"CAST AS Tuple can only be performed between tuple types or from String.\nLeft type: " + from_type_untyped->getName() + ", right type: " + to_type->getName(), ErrorCodes::TYPE_MISMATCH}; - if (from_type->getElements().size() != to_type->getElements().size()) - throw Exception{"CAST AS Tuple can only be performed between tuple types with the same number of elements or from String.\n" - "Left type: " + from_type->getName() + ", right type: " + to_type->getName(), ErrorCodes::TYPE_MISMATCH}; - const auto & from_element_types = from_type->getElements(); const auto & to_element_types = to_type->getElements(); - auto element_wrappers = getElementWrappers(from_element_types, to_element_types); - return [element_wrappers, from_element_types, to_element_types] + std::vector element_wrappers; + std::vector> to_reverse_index; + + if (from_type->haveExplicitNames() && to_type->haveExplicitNames()) + { + const auto & from_names = from_type->getElementNames(); + std::unordered_map from_positions; + from_positions.reserve(from_names.size()); + for (size_t i = 0; i < from_names.size(); ++i) + from_positions[from_names[i]] = i; + + const auto & to_names = to_type->getElementNames(); + element_wrappers.reserve(to_names.size()); + to_reverse_index.reserve(from_names.size()); + + for (size_t i = 0; i < to_names.size(); ++i) + { + auto it = from_positions.find(to_names[i]); + if (it != from_positions.end()) + { + element_wrappers.emplace_back(prepareUnpackDictionaries(from_element_types[it->second], to_element_types[i])); + to_reverse_index.emplace_back(it->second); + } + else + { + element_wrappers.emplace_back(); + to_reverse_index.emplace_back(); + } + } + } + else + { + if (from_element_types.size() != to_element_types.size()) + throw Exception{"CAST AS Tuple can only be performed between tuple types with the same number of elements or from String.\n" + "Left type: " + from_type->getName() + ", right type: " + to_type->getName(), ErrorCodes::TYPE_MISMATCH}; + + element_wrappers = getElementWrappers(from_element_types, to_element_types); + to_reverse_index.reserve(to_element_types.size()); + for (size_t i = 0; i < to_element_types.size(); ++i) + to_reverse_index.emplace_back(i); + } + + return [element_wrappers, from_element_types, to_element_types, to_reverse_index] (ColumnsWithTypeAndName & arguments, const DataTypePtr &, const ColumnNullable * nullable_source, size_t input_rows_count) -> ColumnPtr { const auto * col = arguments.front().column.get(); - size_t tuple_size = from_element_types.size(); + size_t tuple_size = to_element_types.size(); const ColumnTuple & column_tuple = typeid_cast(*col); Columns converted_columns(tuple_size); @@ -2601,8 +2638,16 @@ private: /// invoke conversion for each element for (size_t i = 0; i < tuple_size; ++i) { - ColumnsWithTypeAndName element = {{column_tuple.getColumns()[i], from_element_types[i], "" }}; - converted_columns[i] = element_wrappers[i](element, to_element_types[i], nullable_source, input_rows_count); + if (to_reverse_index[i]) + { + size_t from_idx = *to_reverse_index[i]; + ColumnsWithTypeAndName element = {{column_tuple.getColumns()[from_idx], from_element_types[from_idx], "" }}; + converted_columns[i] = element_wrappers[i](element, to_element_types[i], nullable_source, input_rows_count); + } + else + { + converted_columns[i] = to_element_types[i]->createColumn()->cloneResized(input_rows_count); + } } return ColumnTuple::create(converted_columns); diff --git a/src/IO/ReadHelpers.cpp b/src/IO/ReadHelpers.cpp index 60dbe8cac51..cb6d43f859f 100644 --- a/src/IO/ReadHelpers.cpp +++ b/src/IO/ReadHelpers.cpp @@ -768,7 +768,7 @@ ReturnType readJSONObjectPossiblyInvalid(Vector & s, ReadBuffer & buf) }; if (buf.eof() || *buf.position() != '{') - return error("JSON should starts from opening curly bracket", ErrorCodes::INCORRECT_DATA); + return error("JSON should start from opening curly bracket", ErrorCodes::INCORRECT_DATA); s.push_back(*buf.position()); ++buf.position(); @@ -795,8 +795,12 @@ ReturnType readJSONObjectPossiblyInvalid(Vector & s, ReadBuffer & buf) s.push_back(*buf.position()); ++buf.position(); + if (balance == 0) return ReturnType(true); + + if (balance < 0) + break; } return error("JSON should have equal number of opening and closing brackets", ErrorCodes::INCORRECT_DATA); diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index ba376d47b16..9baeb6e20fd 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -4536,9 +4536,9 @@ static NamesAndTypesList expandObjectColumnsImpl( return result_columns; } -NamesAndTypesList MergeTreeData::expandObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns) const +NamesAndTypesList MergeTreeData::expandObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns) { - /// Firstly fast check if there are any Object columns. + /// Firstly fast check without locking parts, if there are any Object columns. NameSet requested_to_expand = getNamesOfObjectColumns(columns_list); if (requested_to_expand.empty()) return columns_list; @@ -4548,7 +4548,7 @@ NamesAndTypesList MergeTreeData::expandObjectColumns(const DataPartsVector & par NamesAndTypesList MergeTreeData::expandObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const { - /// Firstly fast check if there are any Object columns. + /// Firstly fast check without locking parts, if there are any Object columns. NameSet requested_to_expand = getNamesOfObjectColumns(columns_list); if (requested_to_expand.empty()) return columns_list; @@ -4556,7 +4556,13 @@ NamesAndTypesList MergeTreeData::expandObjectColumns(const NamesAndTypesList & c return expandObjectColumnsImpl(getDataPartsVector(), columns_list, requested_to_expand, with_subcolumns); } +/// TODO: bad code. NamesAndTypesList MergeTreeData::getExpandedObjects() const +{ + return getExpandedObjects(getDataPartsVector()); +} + +NamesAndTypesList MergeTreeData::getExpandedObjects(const DataPartsVector & parts) const { auto metadata_snapshot = getInMemoryMetadataPtr(); auto columns = metadata_snapshot->getColumns().getAllPhysical(); @@ -4566,7 +4572,7 @@ NamesAndTypesList MergeTreeData::getExpandedObjects() const if (isObject(column.type)) result_columns.push_back(column); - return expandObjectColumns(result_columns, false); + return expandObjectColumns(parts, result_columns, false); } CurrentlySubmergingEmergingTagger::~CurrentlySubmergingEmergingTagger() diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index c8adee236a0..3ec20a12687 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -618,8 +618,9 @@ public: } NamesAndTypesList expandObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const override; - NamesAndTypesList expandObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns) const; + static NamesAndTypesList expandObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns); NamesAndTypesList getExpandedObjects() const override; + NamesAndTypesList getExpandedObjects(const DataPartsVector & parts) const; /// For ATTACH/DETACH/DROP PARTITION. String getPartitionIDFromQuery(const ASTPtr & ast, ContextPtr context) const; diff --git a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp index c97594b0d62..dd38f9cd30e 100644 --- a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp +++ b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp @@ -686,6 +686,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor Names all_column_names = metadata_snapshot->getColumns().getNamesOfPhysical(); NamesAndTypesList storage_columns = metadata_snapshot->getColumns().getAllPhysical(); + storage_columns = MergeTreeData::expandObjectColumns(parts, storage_columns, false); const auto data_settings = data.getSettings(); NamesAndTypesList gathering_columns; @@ -919,6 +920,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor } const auto & index_factory = MergeTreeIndexFactory::instance(); + MergedBlockOutputStream to{ new_data_part, metadata_snapshot, diff --git a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp index 972bbce193d..7cc4ade9ffa 100644 --- a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp +++ b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp @@ -43,7 +43,8 @@ MergeTreeSequentialSource::MergeTreeSequentialSource( NamesAndTypesList columns_for_reader; if (take_column_types_from_storage) { - const NamesAndTypesList & physical_columns = metadata_snapshot->getColumns().getAllPhysical(); + auto physical_columns = metadata_snapshot->getColumns().getAllPhysical(); + physical_columns = storage.expandObjectColumns(physical_columns, false); columns_for_reader = physical_columns.addTypes(columns_to_read); } else diff --git a/src/Storages/StorageInMemoryMetadata.cpp b/src/Storages/StorageInMemoryMetadata.cpp index 9a35250723a..327c2bf0d0a 100644 --- a/src/Storages/StorageInMemoryMetadata.cpp +++ b/src/Storages/StorageInMemoryMetadata.cpp @@ -306,15 +306,14 @@ Block StorageInMemoryMetadata::getSampleBlockForColumns( for (const auto & column : expanded_objects) { - columns_map.emplace(column.name, column.type); + columns_map[column.name] = column.type; for (const auto & subcolumn : column.type->getSubcolumnNames()) - columns_map.emplace(Nested::concatenateName(column.name, subcolumn), column.type->getSubcolumnType(subcolumn)); + { + auto full_name = Nested::concatenateName(column.name, subcolumn); + columns_map[full_name] = column.type->getSubcolumnType(subcolumn); + } } - std::cerr << "expanded objects: "; - for (const auto & col : expanded_objects) - std::cerr << col.dump() << "\n"; - for (const auto & name : column_names) { auto it = columns_map.find(name); From e44706911ee225e46426369f2a068caed33d5d58 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 5 May 2021 02:02:54 +0300 Subject: [PATCH 007/132] dynamic columns: better getting of sample block --- src/Interpreters/InterpreterOptimizeQuery.cpp | 2 +- src/Interpreters/InterpreterSelectQuery.cpp | 6 +- src/Interpreters/TreeRewriter.cpp | 15 +-- .../getHeaderForProcessingStage.cpp | 6 +- .../QueryPlan/ReadFromMergeTree.cpp | 2 +- src/Storages/ColumnsDescription.cpp | 54 ++++++++--- src/Storages/ColumnsDescription.h | 37 ++++++++ src/Storages/IStorage.cpp | 91 ++++++++++++++++++- src/Storages/IStorage.h | 11 ++- src/Storages/Kafka/KafkaBlockInputStream.cpp | 4 +- .../MergeTree/MergeTreeBlockReadUtils.cpp | 8 +- src/Storages/MergeTree/MergeTreeData.cpp | 19 ---- src/Storages/MergeTree/MergeTreeData.h | 2 - .../MergeTree/MergeTreeDataMergerMutator.cpp | 1 + .../MergeTree/MergeTreeDataSelectExecutor.cpp | 2 +- src/Storages/MergeTree/MergeTreeReadPool.cpp | 2 +- .../MergeTreeReverseSelectProcessor.cpp | 2 +- .../MergeTree/MergeTreeSelectProcessor.cpp | 2 +- .../MergeTree/MergeTreeSequentialSource.cpp | 6 +- .../RabbitMQ/RabbitMQBlockInputStream.cpp | 5 +- src/Storages/RabbitMQ/StorageRabbitMQ.cpp | 4 +- .../RocksDB/StorageEmbeddedRocksDB.cpp | 2 +- src/Storages/StorageBuffer.cpp | 3 +- src/Storages/StorageFile.cpp | 8 +- src/Storages/StorageGenerateRandom.cpp | 2 +- src/Storages/StorageInMemoryMetadata.cpp | 89 ++---------------- src/Storages/StorageInMemoryMetadata.h | 16 +--- src/Storages/StorageJoin.cpp | 4 +- src/Storages/StorageLog.cpp | 2 +- src/Storages/StorageMemory.cpp | 4 +- src/Storages/StorageMongoDB.cpp | 2 +- src/Storages/StorageMySQL.cpp | 2 +- src/Storages/StorageNull.h | 2 +- src/Storages/StoragePostgreSQL.cpp | 2 +- src/Storages/StorageS3Cluster.cpp | 2 +- src/Storages/StorageStripeLog.cpp | 6 +- src/Storages/StorageTinyLog.cpp | 2 +- src/Storages/StorageValues.cpp | 2 +- src/Storages/StorageView.cpp | 2 +- src/Storages/StorageXDBC.cpp | 4 +- src/Storages/System/IStorageSystemOneBlock.h | 2 +- src/Storages/System/StorageSystemColumns.cpp | 2 +- src/Storages/System/StorageSystemDisks.cpp | 2 +- src/Storages/System/StorageSystemNumbers.cpp | 2 +- src/Storages/System/StorageSystemOne.cpp | 2 +- .../System/StorageSystemPartsBase.cpp | 2 +- src/Storages/System/StorageSystemReplicas.cpp | 2 +- .../System/StorageSystemStoragePolicies.cpp | 2 +- src/Storages/System/StorageSystemTables.cpp | 2 +- src/Storages/System/StorageSystemZeros.cpp | 2 +- 50 files changed, 250 insertions(+), 207 deletions(-) diff --git a/src/Interpreters/InterpreterOptimizeQuery.cpp b/src/Interpreters/InterpreterOptimizeQuery.cpp index b50ce8b85df..099e23fbcc5 100644 --- a/src/Interpreters/InterpreterOptimizeQuery.cpp +++ b/src/Interpreters/InterpreterOptimizeQuery.cpp @@ -46,7 +46,7 @@ BlockIO InterpreterOptimizeQuery::execute() column_names.emplace_back(col->getColumnName()); } - metadata_snapshot->check(column_names, NamesAndTypesList{}, table_id, {}); + table->check(metadata_snapshot, column_names); Names required_columns; { required_columns = metadata_snapshot->getColumnsRequiredForSortingKey(); diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp index 6a6c5185441..8ff91427de3 100644 --- a/src/Interpreters/InterpreterSelectQuery.cpp +++ b/src/Interpreters/InterpreterSelectQuery.cpp @@ -475,8 +475,7 @@ InterpreterSelectQuery::InterpreterSelectQuery( } } - source_header = metadata_snapshot->getSampleBlockForColumns( - required_columns, storage->getVirtuals(), storage->getStorageID(), storage->getExpandedObjects()); + source_header = storage->getSampleBlockForColumns(metadata_snapshot, required_columns); } /// Calculate structure of the result. @@ -1736,8 +1735,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc /// Create step which reads from empty source if storage has no data. if (!query_plan.isInitialized()) { - auto header = metadata_snapshot->getSampleBlockForColumns( - required_columns, storage->getVirtuals(), storage->getStorageID(), storage->getExpandedObjects()); + auto header = storage->getSampleBlockForColumns(metadata_snapshot, required_columns); addEmptySourceToQueryPlan(query_plan, header, query_info); } diff --git a/src/Interpreters/TreeRewriter.cpp b/src/Interpreters/TreeRewriter.cpp index 2deff98fd0c..f44ff468245 100644 --- a/src/Interpreters/TreeRewriter.cpp +++ b/src/Interpreters/TreeRewriter.cpp @@ -633,19 +633,12 @@ void TreeRewriterResult::collectSourceColumns(bool add_special) { if (storage) { - const ColumnsDescription & columns = metadata_snapshot->getColumns(); - - NamesAndTypesList columns_from_storage; + auto options = GetColumnsOptions(add_special ? GetColumnsOptions::All : GetColumnsOptions::AllPhysical); + options.withExtendedObjects(); if (storage->supportsSubcolumns()) - columns_from_storage = add_special ? columns.getAllWithSubcolumns() : columns.getAllPhysicalWithSubcolumns(); - else - columns_from_storage = add_special ? columns.getAll() : columns.getAllPhysical(); + options.withSubcolumns(); - columns_from_storage = storage->expandObjectColumns(columns_from_storage, storage->supportsSubcolumns()); - - std::cerr << "columns_from_storage: "; - for (const auto & col : columns_from_storage) - std::cerr << col.dump() << "\n"; + auto columns_from_storage = storage->getColumns(metadata_snapshot, options); if (source_columns.empty()) source_columns.swap(columns_from_storage); diff --git a/src/Interpreters/getHeaderForProcessingStage.cpp b/src/Interpreters/getHeaderForProcessingStage.cpp index 3ed6642105f..6f446aa1b71 100644 --- a/src/Interpreters/getHeaderForProcessingStage.cpp +++ b/src/Interpreters/getHeaderForProcessingStage.cpp @@ -47,8 +47,7 @@ Block getHeaderForProcessingStage( { case QueryProcessingStage::FetchColumns: { - Block header = metadata_snapshot->getSampleBlockForColumns( - column_names, storage.getVirtuals(), storage.getStorageID(), storage.getExpandedObjects()); + Block header = storage.getSampleBlockForColumns(metadata_snapshot, column_names); if (query_info.prewhere_info) { @@ -77,8 +76,7 @@ Block getHeaderForProcessingStage( removeJoin(*query->as()); auto stream = std::make_shared( - metadata_snapshot->getSampleBlockForColumns( - column_names, storage.getVirtuals(), storage.getStorageID(), storage.getExpandedObjects())); + storage.getSampleBlockForColumns(metadata_snapshot, column_names)); return InterpreterSelectQuery(query, context, stream, SelectQueryOptions(processed_stage).analyze()).getSampleBlock(); } } diff --git a/src/Processors/QueryPlan/ReadFromMergeTree.cpp b/src/Processors/QueryPlan/ReadFromMergeTree.cpp index 6dccb2b7954..87d24343bff 100644 --- a/src/Processors/QueryPlan/ReadFromMergeTree.cpp +++ b/src/Processors/QueryPlan/ReadFromMergeTree.cpp @@ -23,7 +23,7 @@ ReadFromMergeTree::ReadFromMergeTree( size_t num_streams_, ReadType read_type_) : ISourceStep(DataStream{.header = MergeTreeBaseSelectProcessor::transformHeader( - metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID(), storage_.getExpandedObjects()), + storage_.getSampleBlockForColumns(metadata_snapshot_, required_columns_), prewhere_info_, virt_column_names_)}) , storage(storage_) diff --git a/src/Storages/ColumnsDescription.cpp b/src/Storages/ColumnsDescription.cpp index 545911f1465..3dbc210d4aa 100644 --- a/src/Storages/ColumnsDescription.cpp +++ b/src/Storages/ColumnsDescription.cpp @@ -340,6 +340,47 @@ NamesAndTypesList ColumnsDescription::getAll() const return ret; } +static NamesAndTypesList getWithSubcolumns(NamesAndTypesList && source_list) +{ + NamesAndTypesList ret; + for (const auto & col : source_list) + { + ret.emplace_back(col.name, col.type); + for (const auto & subcolumn : col.type->getSubcolumnNames()) + ret.emplace_back(col.name, subcolumn, col.type, col.type->getSubcolumnType(subcolumn)); + } + + return ret; +} + +NamesAndTypesList ColumnsDescription::get(const GetColumnsOptions & options) const +{ + NamesAndTypesList res; + switch (options.kind) + { + case GetColumnsOptions::All: + res = getAll(); + break; + case GetColumnsOptions::AllPhysical: + res = getAllPhysical(); + break; + case GetColumnsOptions::Ordinary: + res = getOrdinary(); + break; + case GetColumnsOptions::Materialized: + res = getMaterialized(); + break; + case GetColumnsOptions::Aliases: + res = getAliases(); + break; + } + + if (options.with_subcolumns) + res = getWithSubcolumns(std::move(res)); + + return res; +} + bool ColumnsDescription::has(const String & column_name) const { return columns.get<1>().find(column_name) != columns.get<1>().end(); @@ -426,19 +467,6 @@ bool ColumnsDescription::hasPhysicalOrSubcolumn(const String & column_name) cons return hasPhysical(column_name) || subcolumns.find(column_name) != subcolumns.end(); } -static NamesAndTypesList getWithSubcolumns(NamesAndTypesList && source_list) -{ - NamesAndTypesList ret; - for (const auto & col : source_list) - { - ret.emplace_back(col.name, col.type); - for (const auto & subcolumn : col.type->getSubcolumnNames()) - ret.emplace_back(col.name, subcolumn, col.type, col.type->getSubcolumnType(subcolumn)); - } - - return ret; -} - NamesAndTypesList ColumnsDescription::getAllWithSubcolumns() const { return getWithSubcolumns(getAll()); diff --git a/src/Storages/ColumnsDescription.h b/src/Storages/ColumnsDescription.h index f7886d0353a..a8707cf60a3 100644 --- a/src/Storages/ColumnsDescription.h +++ b/src/Storages/ColumnsDescription.h @@ -25,6 +25,42 @@ namespace ErrorCodes extern const int LOGICAL_ERROR; } +struct GetColumnsOptions +{ + enum Kind : UInt8 + { + All = 0, + AllPhysical = 1, + Ordinary = 2, + Materialized = 3, + Aliases = 4, + }; + + GetColumnsOptions(Kind kind_) : kind(kind_) {} + + GetColumnsOptions & withSubcolumns(bool value = true) + { + with_subcolumns = value; + return *this; + } + + GetColumnsOptions & withVirtuals(bool value = true) + { + with_virtuals = value; + return *this; + } + + GetColumnsOptions & withExtendedObjects(bool value = true) + { + with_extended_objects = value; + return *this; + } + + Kind kind; + bool with_subcolumns = false; + bool with_virtuals = false; + bool with_extended_objects = false; +}; /// Description of a single table column (in CREATE TABLE for example). struct ColumnDescription @@ -75,6 +111,7 @@ public: auto begin() const { return columns.begin(); } auto end() const { return columns.end(); } + NamesAndTypesList get(const GetColumnsOptions & options) const; NamesAndTypesList getOrdinary() const; NamesAndTypesList getMaterialized() const; NamesAndTypesList getAliases() const; diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp index eb78bf4aa84..8bde51e93aa 100644 --- a/src/Storages/IStorage.cpp +++ b/src/Storages/IStorage.cpp @@ -12,6 +12,7 @@ #include #include #include +#include namespace DB @@ -21,6 +22,10 @@ namespace ErrorCodes extern const int TABLE_IS_DROPPED; extern const int NOT_IMPLEMENTED; extern const int DEADLOCK_AVOIDED; + extern const int NOT_FOUND_COLUMN_IN_BLOCK; + extern const int EMPTY_LIST_OF_COLUMNS_QUERIED; + extern const int NO_SUCH_COLUMN_IN_TABLE; + extern const int COLUMN_QUERIED_MORE_THAN_ONCE; } bool IStorage::isVirtualColumn(const String & column_name, const StorageMetadataPtr & metadata_snapshot) const @@ -105,7 +110,7 @@ void IStorage::read( auto pipe = read(column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams); if (pipe.empty()) { - auto header = metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID(), getExpandedObjects()); + auto header = getSampleBlockForColumns(metadata_snapshot, column_names); InterpreterSelectQuery::addEmptySourceToQueryPlan(query_plan, header, query_info); } else @@ -197,6 +202,90 @@ NameDependencies IStorage::getDependentViewsByColumn(ContextPtr context) const return name_deps; } +NamesAndTypesList IStorage::getColumns(const StorageMetadataPtr & metadata_snapshot, const GetColumnsOptions & options) const +{ + auto all_columns = metadata_snapshot->getColumns().get(options); + + if (options.with_virtuals) + { + /// Virtual columns must be appended after ordinary, + /// because user can override them. + auto virtuals = getVirtuals(); + if (!virtuals.empty()) + { + NameSet column_names; + for (const auto & column : all_columns) + column_names.insert(column.name); + for (auto && column : virtuals) + if (!column_names.count(column.name)) + all_columns.push_back(std::move(column)); + } + } + + if (options.with_extended_objects) + all_columns = expandObjectColumns(all_columns, options.with_subcolumns); + + return all_columns; +} + +Block IStorage::getSampleBlockForColumns(const StorageMetadataPtr & metadata_snapshot, const Names & column_names) const +{ + Block res; + + auto all_columns = getColumns( + metadata_snapshot, + GetColumnsOptions(GetColumnsOptions::All) + .withSubcolumns().withVirtuals().withExtendedObjects()); + + std::unordered_map columns_map; + columns_map.reserve(all_columns.size()); + + for (const auto & elem : all_columns) + columns_map.emplace(elem.name, elem.type); + + for (const auto & name : column_names) + { + auto it = columns_map.find(name); + if (it != columns_map.end()) + res.insert({it->second->createColumn(), it->second, it->first}); + else + throw Exception(ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK, + "Column {} not found in table {}", backQuote(name), getStorageID().getNameForLogs()); + } + + return res; +} + +void IStorage::check(const StorageMetadataPtr & metadata_snapshot, const Names & column_names) const +{ + auto available_columns = getColumns( + metadata_snapshot, + GetColumnsOptions(GetColumnsOptions::AllPhysical) + .withSubcolumns().withVirtuals().withExtendedObjects()).getNames(); + + if (column_names.empty()) + throw Exception(ErrorCodes::EMPTY_LIST_OF_COLUMNS_QUERIED, + "Empty list of columns queried. There are columns: {}", + boost::algorithm::join(available_columns, ",")); + + std::unordered_set columns_set(available_columns.begin(), available_columns.end()); + std::unordered_set unique_names; + + for (const auto & name : column_names) + { + if (columns_set.end() == columns_set.find(name)) + throw Exception(ErrorCodes::NO_SUCH_COLUMN_IN_TABLE, + "There is no column with name {} in table {}. There are columns: ", + backQuote(name), getStorageID().getNameForLogs(), boost::algorithm::join(available_columns, ",")); + + if (unique_names.end() != unique_names.find(name)) + throw Exception(ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE, "Column {} queried more than once", name); + + unique_names.insert(name); + } +} + + std::string PrewhereDAGInfo::dump() const { WriteBufferFromOwnString ss; diff --git a/src/Storages/IStorage.h b/src/Storages/IStorage.h index c64a40ac0d2..f3611ea94b4 100644 --- a/src/Storages/IStorage.h +++ b/src/Storages/IStorage.h @@ -157,6 +157,16 @@ public: /// used without any locks. StorageMetadataPtr getInMemoryMetadataPtr() const { return metadata.get(); } + NamesAndTypesList getColumns(const StorageMetadataPtr & metadata_snapshot, const GetColumnsOptions & options) const; + + /// Block with ordinary + materialized + aliases + virtuals + subcolumns. + /// message. + Block getSampleBlockForColumns(const StorageMetadataPtr & metadata_snapshot, const Names & column_names) const; + + /// Verify that all the requested names are in the table and are set correctly: + /// list of names is not empty and the names do not repeat. + void check(const StorageMetadataPtr & metadata_snapshot, const Names & column_names) const; + /// Update storage metadata. Used in ALTER or initialization of Storage. /// Metadata object is multiversion, so this method can be called without /// any locks. @@ -525,7 +535,6 @@ public: virtual std::optional lifetimeBytes() const { return {}; } virtual NamesAndTypesList expandObjectColumns(const NamesAndTypesList & columns_list, bool /*with_subcolumns*/) const { return columns_list; } - virtual NamesAndTypesList getExpandedObjects() const { return {}; } private: /// Lock required for alter queries (lockForAlter). Always taken for write diff --git a/src/Storages/Kafka/KafkaBlockInputStream.cpp b/src/Storages/Kafka/KafkaBlockInputStream.cpp index 5d9b19b1972..b75f7a4e5be 100644 --- a/src/Storages/Kafka/KafkaBlockInputStream.cpp +++ b/src/Storages/Kafka/KafkaBlockInputStream.cpp @@ -35,7 +35,7 @@ KafkaBlockInputStream::KafkaBlockInputStream( , max_block_size(max_block_size_) , commit_in_suffix(commit_in_suffix_) , non_virtual_header(metadata_snapshot->getSampleBlockNonMaterialized()) - , virtual_header(metadata_snapshot->getSampleBlockForColumns(storage.getVirtualColumnNames(), storage.getVirtuals(), storage.getStorageID())) + , virtual_header(storage.getSampleBlockForColumns(metadata_snapshot, storage.getVirtualColumnNames())) , handle_error_mode(storage.getHandleKafkaErrorMode()) { } @@ -53,7 +53,7 @@ KafkaBlockInputStream::~KafkaBlockInputStream() Block KafkaBlockInputStream::getHeader() const { - return metadata_snapshot->getSampleBlockForColumns(column_names, storage.getVirtuals(), storage.getStorageID()); + return storage.getSampleBlockForColumns(metadata_snapshot, column_names); } void KafkaBlockInputStream::readPrefixImpl() diff --git a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp index cf07f4e2ec9..797f70d2e4c 100644 --- a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp +++ b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp @@ -316,11 +316,11 @@ MergeTreeReadTaskColumns getReadTaskColumns( if (check_columns) { - auto physical_columns = metadata_snapshot->getColumns().getAllWithSubcolumns(); - physical_columns = storage.expandObjectColumns(physical_columns, true); + auto all_columns = storage.getColumns(metadata_snapshot, + GetColumnsOptions(GetColumnsOptions::All).withSubcolumns().withExtendedObjects()); - result.pre_columns = physical_columns.addTypes(pre_column_names); - result.columns = physical_columns.addTypes(column_names); + result.pre_columns = all_columns.addTypes(pre_column_names); + result.columns = all_columns.addTypes(column_names); } else { diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index 9baeb6e20fd..2bf41a503a2 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -4556,25 +4556,6 @@ NamesAndTypesList MergeTreeData::expandObjectColumns(const NamesAndTypesList & c return expandObjectColumnsImpl(getDataPartsVector(), columns_list, requested_to_expand, with_subcolumns); } -/// TODO: bad code. -NamesAndTypesList MergeTreeData::getExpandedObjects() const -{ - return getExpandedObjects(getDataPartsVector()); -} - -NamesAndTypesList MergeTreeData::getExpandedObjects(const DataPartsVector & parts) const -{ - auto metadata_snapshot = getInMemoryMetadataPtr(); - auto columns = metadata_snapshot->getColumns().getAllPhysical(); - - NamesAndTypesList result_columns; - for (const auto & column : columns) - if (isObject(column.type)) - result_columns.push_back(column); - - return expandObjectColumns(parts, result_columns, false); -} - CurrentlySubmergingEmergingTagger::~CurrentlySubmergingEmergingTagger() { std::lock_guard lock(storage.currently_submerging_emerging_mutex); diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index 3ec20a12687..dab03a6571e 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -619,8 +619,6 @@ public: NamesAndTypesList expandObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const override; static NamesAndTypesList expandObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns); - NamesAndTypesList getExpandedObjects() const override; - NamesAndTypesList getExpandedObjects(const DataPartsVector & parts) const; /// For ATTACH/DETACH/DROP PARTITION. String getPartitionIDFromQuery(const ASTPtr & ast, ContextPtr context) const; diff --git a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp index dd38f9cd30e..87ff7d53c75 100644 --- a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp +++ b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp @@ -942,6 +942,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor Block block; while (!is_cancelled() && (block = merged_stream->read())) { + std::cerr << "read block: " << block.dumpStructure() << "\n"; rows_written += block.rows(); to.write(block); diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp index 8eeb349057a..4ffc99a4d80 100644 --- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp +++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp @@ -236,7 +236,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts( } // At this point, empty `part_values` means all parts. - metadata_snapshot->check(real_column_names, data.getVirtuals(), data.getStorageID(), data.getExpandedObjects()); + data.check(metadata_snapshot, real_column_names); const Settings & settings = context->getSettingsRef(); const auto & primary_key = metadata_snapshot->getPrimaryKey(); diff --git a/src/Storages/MergeTree/MergeTreeReadPool.cpp b/src/Storages/MergeTree/MergeTreeReadPool.cpp index 07173eb2118..1d7ae3eb923 100644 --- a/src/Storages/MergeTree/MergeTreeReadPool.cpp +++ b/src/Storages/MergeTree/MergeTreeReadPool.cpp @@ -168,7 +168,7 @@ MarkRanges MergeTreeReadPool::getRestMarks(const IMergeTreeDataPart & part, cons Block MergeTreeReadPool::getHeader() const { - return metadata_snapshot->getSampleBlockForColumns(column_names, data.getVirtuals(), data.getStorageID(), data.getExpandedObjects()); + return data.getSampleBlockForColumns(metadata_snapshot, column_names); } void MergeTreeReadPool::profileFeedback(const ReadBufferFromFileBase::ProfileInfo info) diff --git a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp index 251dc4d5467..7d546e43e2f 100644 --- a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp +++ b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp @@ -30,7 +30,7 @@ MergeTreeReverseSelectProcessor::MergeTreeReverseSelectProcessor( bool quiet) : MergeTreeBaseSelectProcessor{ - metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID(), storage_.getExpandedObjects()), + storage_.getSampleBlockForColumns(metadata_snapshot_, required_columns_), storage_, metadata_snapshot_, prewhere_info_, max_block_size_rows_, preferred_block_size_bytes_, preferred_max_column_in_block_size_bytes_, reader_settings_, use_uncompressed_cache_, virt_column_names_}, diff --git a/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp index 932595b42cd..43f1e440c24 100644 --- a/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp +++ b/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp @@ -30,7 +30,7 @@ MergeTreeSelectProcessor::MergeTreeSelectProcessor( bool quiet) : MergeTreeBaseSelectProcessor{ - metadata_snapshot_->getSampleBlockForColumns(required_columns_, storage_.getVirtuals(), storage_.getStorageID(), storage_.getExpandedObjects()), + storage_.getSampleBlockForColumns(metadata_snapshot_, required_columns_), storage_, metadata_snapshot_, prewhere_info_, max_block_size_rows_, preferred_block_size_bytes_, preferred_max_column_in_block_size_bytes_, reader_settings_, use_uncompressed_cache_, virt_column_names_}, diff --git a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp index 7cc4ade9ffa..9d27adac6d2 100644 --- a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp +++ b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp @@ -17,7 +17,7 @@ MergeTreeSequentialSource::MergeTreeSequentialSource( bool read_with_direct_io_, bool take_column_types_from_storage, bool quiet) - : SourceWithProgress(metadata_snapshot_->getSampleBlockForColumns(columns_to_read_, storage_.getVirtuals(), storage_.getStorageID(), storage_.getExpandedObjects())) + : SourceWithProgress(storage_.getSampleBlockForColumns(metadata_snapshot_, columns_to_read_)) , storage(storage_) , metadata_snapshot(metadata_snapshot_) , data_part(std::move(data_part_)) @@ -43,8 +43,8 @@ MergeTreeSequentialSource::MergeTreeSequentialSource( NamesAndTypesList columns_for_reader; if (take_column_types_from_storage) { - auto physical_columns = metadata_snapshot->getColumns().getAllPhysical(); - physical_columns = storage.expandObjectColumns(physical_columns, false); + auto physical_columns = storage.getColumns(metadata_snapshot, + GetColumnsOptions(GetColumnsOptions::AllPhysical).withExtendedObjects()); columns_for_reader = physical_columns.addTypes(columns_to_read); } else diff --git a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp index 6c3d3a53c21..ec12f84c341 100644 --- a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp +++ b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp @@ -28,9 +28,8 @@ RabbitMQBlockInputStream::RabbitMQBlockInputStream( , ack_in_suffix(ack_in_suffix_) , non_virtual_header(metadata_snapshot->getSampleBlockNonMaterialized()) , sample_block(non_virtual_header) - , virtual_header(metadata_snapshot->getSampleBlockForColumns( - {"_exchange_name", "_channel_id", "_delivery_tag", "_redelivered", "_message_id", "_timestamp"}, - storage.getVirtuals(), storage.getStorageID())) + , virtual_header(storage.getSampleBlockForColumns(metadata_snapshot, + {"_exchange_name", "_channel_id", "_delivery_tag", "_redelivered", "_message_id", "_timestamp"})) { for (const auto & column : virtual_header) sample_block.insert(column); diff --git a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp index 55629f2a205..0a77f237d24 100644 --- a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp +++ b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp @@ -573,7 +573,7 @@ Pipe StorageRabbitMQ::read( if (num_created_consumers == 0) return {}; - auto sample_block = metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()); + auto sample_block = getSampleBlockForColumns(metadata_snapshot, column_names); auto modified_context = addSettings(local_context); auto block_size = getMaxBlockSize(); @@ -812,7 +812,7 @@ bool StorageRabbitMQ::streamToViews() auto metadata_snapshot = getInMemoryMetadataPtr(); auto column_names = block_io.out->getHeader().getNames(); - auto sample_block = metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()); + auto sample_block = getSampleBlockForColumns(metadata_snapshot, column_names); auto block_size = getMaxBlockSize(); diff --git a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp index 744d91b0f54..47e8220b74d 100644 --- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp +++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp @@ -289,7 +289,7 @@ Pipe StorageEmbeddedRocksDB::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); FieldVectorPtr keys; bool all_scan = false; diff --git a/src/Storages/StorageBuffer.cpp b/src/Storages/StorageBuffer.cpp index afe37d0bcbe..6497a02a661 100644 --- a/src/Storages/StorageBuffer.cpp +++ b/src/Storages/StorageBuffer.cpp @@ -132,8 +132,7 @@ class BufferSource : public SourceWithProgress { public: BufferSource(const Names & column_names_, StorageBuffer::Buffer & buffer_, const StorageBuffer & storage, const StorageMetadataPtr & metadata_snapshot) - : SourceWithProgress( - metadata_snapshot->getSampleBlockForColumns(column_names_, storage.getVirtuals(), storage.getStorageID())) + : SourceWithProgress(storage.getSampleBlockForColumns(metadata_snapshot, column_names_)) , column_names_and_types(metadata_snapshot->getColumns().getAllWithSubcolumns().addTypes(column_names_)) , buffer(buffer_) {} diff --git a/src/Storages/StorageFile.cpp b/src/Storages/StorageFile.cpp index 14b91d29805..7a89e083bc8 100644 --- a/src/Storages/StorageFile.cpp +++ b/src/Storages/StorageFile.cpp @@ -273,7 +273,7 @@ public: const FilesInfoPtr & files_info) { if (storage->isColumnOriented()) - return metadata_snapshot->getSampleBlockForColumns(columns_description.getNamesOfPhysical(), storage->getVirtuals(), storage->getStorageID()); + return storage->getSampleBlockForColumns(metadata_snapshot, columns_description.getNamesOfPhysical()); else return getHeader(metadata_snapshot, files_info->need_path_column, files_info->need_file_column); } @@ -369,7 +369,7 @@ public: auto get_block_for_format = [&]() -> Block { if (storage->isColumnOriented()) - return metadata_snapshot->getSampleBlockForColumns(columns_description.getNamesOfPhysical()); + return storage->getSampleBlockForColumns(metadata_snapshot, columns_description.getNamesOfPhysical()); return metadata_snapshot->getSampleBlock(); }; @@ -458,7 +458,7 @@ Pipe StorageFile::read( if (paths.size() == 1 && !Poco::File(paths[0]).exists()) { if (context->getSettingsRef().engine_file_empty_if_not_exists) - return Pipe(std::make_shared(metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()))); + return Pipe(std::make_shared(getSampleBlockForColumns(metadata_snapshot, column_names))); else throw Exception("File " + paths[0] + " doesn't exist", ErrorCodes::FILE_DOESNT_EXIST); } @@ -489,7 +489,7 @@ Pipe StorageFile::read( { if (isColumnOriented()) return ColumnsDescription{ - metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()).getNamesAndTypesList()}; + getSampleBlockForColumns(metadata_snapshot, column_names).getNamesAndTypesList()}; else return metadata_snapshot->getColumns(); }; diff --git a/src/Storages/StorageGenerateRandom.cpp b/src/Storages/StorageGenerateRandom.cpp index 167d74cc51d..6ad16b139ba 100644 --- a/src/Storages/StorageGenerateRandom.cpp +++ b/src/Storages/StorageGenerateRandom.cpp @@ -447,7 +447,7 @@ Pipe StorageGenerateRandom::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); Pipes pipes; pipes.reserve(num_streams); diff --git a/src/Storages/StorageInMemoryMetadata.cpp b/src/Storages/StorageInMemoryMetadata.cpp index 327c2bf0d0a..0f291a3dedb 100644 --- a/src/Storages/StorageInMemoryMetadata.cpp +++ b/src/Storages/StorageInMemoryMetadata.cpp @@ -287,47 +287,6 @@ Block StorageInMemoryMetadata::getSampleBlock() const return res; } -Block StorageInMemoryMetadata::getSampleBlockForColumns( - const Names & column_names, const NamesAndTypesList & virtuals, const StorageID & storage_id, const NamesAndTypesList & expanded_objects) const -{ - Block res; - - auto all_columns = getColumns().getAllWithSubcolumns(); - std::unordered_map columns_map; - columns_map.reserve(all_columns.size()); - - for (const auto & elem : all_columns) - columns_map.emplace(elem.name, elem.type); - - /// Virtual columns must be appended after ordinary, because user can - /// override them. - for (const auto & column : virtuals) - columns_map.emplace(column.name, column.type); - - for (const auto & column : expanded_objects) - { - columns_map[column.name] = column.type; - for (const auto & subcolumn : column.type->getSubcolumnNames()) - { - auto full_name = Nested::concatenateName(column.name, subcolumn); - columns_map[full_name] = column.type->getSubcolumnType(subcolumn); - } - } - - for (const auto & name : column_names) - { - auto it = columns_map.find(name); - if (it != columns_map.end()) - res.insert({it->second->createColumn(), it->second, it->first}); - else - throw Exception( - "Column " + backQuote(name) + " not found in table " + (storage_id.empty() ? "" : storage_id.getNameForLogs()), - ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK); - } - - return res; -} - const KeyDescription & StorageInMemoryMetadata::getPartitionKey() const { return partition_key; @@ -457,18 +416,6 @@ namespace using UniqueStrings = google::sparsehash::dense_hash_set; #endif - String listOfColumns(const NamesAndTypesList & available_columns) - { - WriteBufferFromOwnString ss; - for (auto it = available_columns.begin(); it != available_columns.end(); ++it) - { - if (it != available_columns.begin()) - ss << ", "; - ss << it->name; - } - return ss.str(); - } - NamesAndTypesMap getColumnsMap(const NamesAndTypesList & columns) { NamesAndTypesMap res; @@ -488,38 +435,16 @@ namespace } } -void StorageInMemoryMetadata::check( - const Names & column_names, const NamesAndTypesList & virtuals, const StorageID & storage_id, const NamesAndTypesList & expanded_objects) const +String listOfColumns(const NamesAndTypesList & available_columns) { - NamesAndTypesList available_columns = getColumns().getAllPhysicalWithSubcolumns(); - available_columns.insert(available_columns.end(), virtuals.begin(), virtuals.end()); - - for (const auto & column : expanded_objects) + WriteBufferFromOwnString ss; + for (auto it = available_columns.begin(); it != available_columns.end(); ++it) { - available_columns.push_back(column); - for (const auto & subcolumn : column.type->getSubcolumnNames()) - available_columns.emplace_back(column.name, subcolumn, column.type, column.type->getSubcolumnType(subcolumn)); - } - - const String list_of_columns = listOfColumns(available_columns); - - if (column_names.empty()) - throw Exception("Empty list of columns queried. There are columns: " + list_of_columns, ErrorCodes::EMPTY_LIST_OF_COLUMNS_QUERIED); - - const auto columns_map = getColumnsMap(available_columns); - - auto unique_names = initUniqueStrings(); - for (const auto & name : column_names) - { - if (columns_map.end() == columns_map.find(name)) - throw Exception( - "There is no column with name " + backQuote(name) + " in table " + storage_id.getNameForLogs() + ". There are columns: " + list_of_columns, - ErrorCodes::NO_SUCH_COLUMN_IN_TABLE); - - if (unique_names.end() != unique_names.find(name)) - throw Exception("Column " + name + " queried more than once", ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE); - unique_names.insert(name); + if (it != available_columns.begin()) + ss << ", "; + ss << it->name; } + return ss.str(); } void StorageInMemoryMetadata::check(const NamesAndTypesList & provided_columns) const diff --git a/src/Storages/StorageInMemoryMetadata.h b/src/Storages/StorageInMemoryMetadata.h index 053dba62341..cd63d1bee60 100644 --- a/src/Storages/StorageInMemoryMetadata.h +++ b/src/Storages/StorageInMemoryMetadata.h @@ -141,15 +141,6 @@ struct StorageInMemoryMetadata /// Storage metadata. Block getSampleBlockWithVirtuals(const NamesAndTypesList & virtuals) const; - - /// Block with ordinary + materialized + aliases + virtuals. Virtuals have - /// to be explicitly specified, because they are part of Storage type, not - /// Storage metadata. StorageID required only for more clear exception - /// message. - Block getSampleBlockForColumns( - const Names & column_names, const NamesAndTypesList & virtuals = {}, - const StorageID & storage_id = StorageID::createEmpty(), const NamesAndTypesList & expanded_objects = {}) const; - /// Returns structure with partition key. const KeyDescription & getPartitionKey() const; /// Returns ASTExpressionList of partition key expression for storage or nullptr if there is none. @@ -212,11 +203,6 @@ struct StorageInMemoryMetadata const SelectQueryDescription & getSelectQuery() const; bool hasSelectQuery() const; - /// Verify that all the requested names are in the table and are set correctly: - /// list of names is not empty and the names do not repeat. - void check(const Names & column_names, const NamesAndTypesList & virtuals, - const StorageID & storage_id, const NamesAndTypesList & expanded_objects) const; - /// Check that all the requested names are in the table and have the correct types. void check(const NamesAndTypesList & columns) const; @@ -232,4 +218,6 @@ struct StorageInMemoryMetadata using StorageMetadataPtr = std::shared_ptr; using MultiVersionStorageMetadataPtr = MultiVersion; +String listOfColumns(const NamesAndTypesList & available_columns); + } diff --git a/src/Storages/StorageJoin.cpp b/src/Storages/StorageJoin.cpp index c029ebc9b31..040f8897092 100644 --- a/src/Storages/StorageJoin.cpp +++ b/src/Storages/StorageJoin.cpp @@ -497,9 +497,9 @@ Pipe StorageJoin::read( size_t max_block_size, unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); - Block source_sample_block = metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()); + Block source_sample_block = getSampleBlockForColumns(metadata_snapshot, column_names); return Pipe(std::make_shared(join, rwlock, max_block_size, source_sample_block)); } diff --git a/src/Storages/StorageLog.cpp b/src/Storages/StorageLog.cpp index 14d4ee71c46..4beb1a0bbfa 100644 --- a/src/Storages/StorageLog.cpp +++ b/src/Storages/StorageLog.cpp @@ -652,7 +652,7 @@ Pipe StorageLog::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); auto lock_timeout = getLockTimeout(context); loadMarks(lock_timeout); diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp index 7a0ba624891..d37f018df9f 100644 --- a/src/Storages/StorageMemory.cpp +++ b/src/Storages/StorageMemory.cpp @@ -34,7 +34,7 @@ public: std::shared_ptr data_, std::shared_ptr> parallel_execution_index_, InitializerFunc initializer_func_ = {}) - : SourceWithProgress(metadata_snapshot->getSampleBlockForColumns(column_names_, storage.getVirtuals(), storage.getStorageID())) + : SourceWithProgress(storage.getSampleBlockForColumns(metadata_snapshot, column_names_)) , column_names_and_types(metadata_snapshot->getColumns().getAllWithSubcolumns().addTypes(std::move(column_names_))) , data(data_) , parallel_execution_index(parallel_execution_index_) @@ -183,7 +183,7 @@ Pipe StorageMemory::read( size_t /*max_block_size*/, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); if (delay_read_for_global_subqueries) { diff --git a/src/Storages/StorageMongoDB.cpp b/src/Storages/StorageMongoDB.cpp index 1e516c71d2d..58b6560848b 100644 --- a/src/Storages/StorageMongoDB.cpp +++ b/src/Storages/StorageMongoDB.cpp @@ -81,7 +81,7 @@ Pipe StorageMongoDB::read( { connectIfNotConnected(); - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); Block sample_block; for (const String & column_name : column_names) diff --git a/src/Storages/StorageMySQL.cpp b/src/Storages/StorageMySQL.cpp index a3f7ce51fb4..0a080328dd8 100644 --- a/src/Storages/StorageMySQL.cpp +++ b/src/Storages/StorageMySQL.cpp @@ -74,7 +74,7 @@ Pipe StorageMySQL::read( size_t /*max_block_size*/, unsigned) { - metadata_snapshot->check(column_names_, getVirtuals(), getStorageID(), getExpandedObjects()); + check(metadata_snapshot, column_names_); String query = transformQueryForExternalDatabase( query_info_, metadata_snapshot->getColumns().getOrdinary(), diff --git a/src/Storages/StorageNull.h b/src/Storages/StorageNull.h index 7fe65eb25dc..422d7cfd8e0 100644 --- a/src/Storages/StorageNull.h +++ b/src/Storages/StorageNull.h @@ -31,7 +31,7 @@ public: unsigned) override { return Pipe( - std::make_shared(metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()))); + std::make_shared(getSampleBlockForColumns(metadata_snapshot, column_names))); } bool supportsParallelInsert() const override { return true; } diff --git a/src/Storages/StoragePostgreSQL.cpp b/src/Storages/StoragePostgreSQL.cpp index 3549d5700b1..82d8785bd48 100644 --- a/src/Storages/StoragePostgreSQL.cpp +++ b/src/Storages/StoragePostgreSQL.cpp @@ -70,7 +70,7 @@ Pipe StoragePostgreSQL::read( size_t max_block_size_, unsigned) { - metadata_snapshot->check(column_names_, getVirtuals(), getStorageID(), getExpandedObjects()); + check(metadata_snapshot, column_names_); /// Connection is already made to the needed database, so it should not be present in the query; /// remote_table_schema is empty if it is not specified, will access only table_name. diff --git a/src/Storages/StorageS3Cluster.cpp b/src/Storages/StorageS3Cluster.cpp index a9698c0545a..cffa63030b8 100644 --- a/src/Storages/StorageS3Cluster.cpp +++ b/src/Storages/StorageS3Cluster.cpp @@ -135,7 +135,7 @@ Pipe StorageS3Cluster::read( } } - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); return Pipe::unitePipes(std::move(pipes)); } diff --git a/src/Storages/StorageStripeLog.cpp b/src/Storages/StorageStripeLog.cpp index 2db0cc45cbb..66197864849 100644 --- a/src/Storages/StorageStripeLog.cpp +++ b/src/Storages/StorageStripeLog.cpp @@ -59,7 +59,7 @@ public: IndexForNativeFormat::Blocks::const_iterator index_end) { if (index_begin == index_end) - return metadata_snapshot->getSampleBlockForColumns(column_names, storage.getVirtuals(), storage.getStorageID()); + return storage.getSampleBlockForColumns(metadata_snapshot, column_names); /// TODO: check if possible to always return storage.getSampleBlock() @@ -330,7 +330,7 @@ Pipe StorageStripeLog::read( if (!lock) throw Exception("Lock timeout exceeded", ErrorCodes::TIMEOUT_EXCEEDED); - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); NameSet column_names_set(column_names.begin(), column_names.end()); @@ -339,7 +339,7 @@ Pipe StorageStripeLog::read( String index_file = table_path + "index.mrk"; if (!disk->exists(index_file)) { - return Pipe(std::make_shared(metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()))); + return Pipe(std::make_shared(getSampleBlockForColumns(metadata_snapshot, column_names))); } CompressedReadBufferFromFile index_in(disk->readFile(index_file, 4096)); diff --git a/src/Storages/StorageTinyLog.cpp b/src/Storages/StorageTinyLog.cpp index e62a35317a7..fd317180837 100644 --- a/src/Storages/StorageTinyLog.cpp +++ b/src/Storages/StorageTinyLog.cpp @@ -484,7 +484,7 @@ Pipe StorageTinyLog::read( const size_t max_block_size, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); auto all_columns = metadata_snapshot->getColumns().getAllWithSubcolumns().addTypes(column_names); diff --git a/src/Storages/StorageValues.cpp b/src/Storages/StorageValues.cpp index ccdd715d8b3..0c9de61783a 100644 --- a/src/Storages/StorageValues.cpp +++ b/src/Storages/StorageValues.cpp @@ -29,7 +29,7 @@ Pipe StorageValues::read( size_t /*max_block_size*/, unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); /// Get only required columns. Block block; diff --git a/src/Storages/StorageView.cpp b/src/Storages/StorageView.cpp index 75bd4b2967f..740702b16c0 100644 --- a/src/Storages/StorageView.cpp +++ b/src/Storages/StorageView.cpp @@ -98,7 +98,7 @@ void StorageView::read( query_plan.addStep(std::move(materializing)); /// And also convert to expected structure. - auto header = metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()); + auto header = getSampleBlockForColumns(metadata_snapshot, column_names); auto convert_actions_dag = ActionsDAG::makeConvertingActions( query_plan.getCurrentDataStream().header.getColumnsWithTypeAndName(), header.getColumnsWithTypeAndName(), diff --git a/src/Storages/StorageXDBC.cpp b/src/Storages/StorageXDBC.cpp index 16a134de84a..8053bbd3446 100644 --- a/src/Storages/StorageXDBC.cpp +++ b/src/Storages/StorageXDBC.cpp @@ -106,7 +106,7 @@ Pipe StorageXDBC::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); bridge_helper->startBridgeSync(); return IStorageURLBase::read(column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); @@ -140,7 +140,7 @@ BlockOutputStreamPtr StorageXDBC::write(const ASTPtr & /*query*/, const StorageM Block StorageXDBC::getHeaderBlock(const Names & column_names, const StorageMetadataPtr & metadata_snapshot) const { - return metadata_snapshot->getSampleBlockForColumns(column_names, getVirtuals(), getStorageID()); + return getSampleBlockForColumns(metadata_snapshot, column_names); } std::string StorageXDBC::getName() const diff --git a/src/Storages/System/IStorageSystemOneBlock.h b/src/Storages/System/IStorageSystemOneBlock.h index a1e139d0705..5ce2f37bb29 100644 --- a/src/Storages/System/IStorageSystemOneBlock.h +++ b/src/Storages/System/IStorageSystemOneBlock.h @@ -41,7 +41,7 @@ public: size_t /*max_block_size*/, unsigned /*num_streams*/) override { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); Block sample_block = metadata_snapshot->getSampleBlock(); MutableColumns res_columns = sample_block.cloneEmptyColumns(); diff --git a/src/Storages/System/StorageSystemColumns.cpp b/src/Storages/System/StorageSystemColumns.cpp index 81c048f8e2d..424ba6347c2 100644 --- a/src/Storages/System/StorageSystemColumns.cpp +++ b/src/Storages/System/StorageSystemColumns.cpp @@ -248,7 +248,7 @@ Pipe StorageSystemColumns::read( const size_t max_block_size, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); /// Create a mask of what columns are needed in the result. diff --git a/src/Storages/System/StorageSystemDisks.cpp b/src/Storages/System/StorageSystemDisks.cpp index 64ea8209b90..51c62a1614d 100644 --- a/src/Storages/System/StorageSystemDisks.cpp +++ b/src/Storages/System/StorageSystemDisks.cpp @@ -35,7 +35,7 @@ Pipe StorageSystemDisks::read( const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); MutableColumnPtr col_name = ColumnString::create(); MutableColumnPtr col_path = ColumnString::create(); diff --git a/src/Storages/System/StorageSystemNumbers.cpp b/src/Storages/System/StorageSystemNumbers.cpp index 6c6d8352c6e..01bf75f6914 100644 --- a/src/Storages/System/StorageSystemNumbers.cpp +++ b/src/Storages/System/StorageSystemNumbers.cpp @@ -131,7 +131,7 @@ Pipe StorageSystemNumbers::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); if (limit && *limit < max_block_size) { diff --git a/src/Storages/System/StorageSystemOne.cpp b/src/Storages/System/StorageSystemOne.cpp index 9237d5568e4..09b4c438422 100644 --- a/src/Storages/System/StorageSystemOne.cpp +++ b/src/Storages/System/StorageSystemOne.cpp @@ -29,7 +29,7 @@ Pipe StorageSystemOne::read( const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); Block header{ColumnWithTypeAndName( DataTypeUInt8().createColumn(), diff --git a/src/Storages/System/StorageSystemPartsBase.cpp b/src/Storages/System/StorageSystemPartsBase.cpp index 2ac2f6a9dba..15f39b272e0 100644 --- a/src/Storages/System/StorageSystemPartsBase.cpp +++ b/src/Storages/System/StorageSystemPartsBase.cpp @@ -41,7 +41,7 @@ bool StorageSystemPartsBase::hasStateColumn(const Names & column_names, const St /// Do not check if only _state column is requested if (!(has_state_column && real_column_names.empty())) - metadata_snapshot->check(real_column_names, {}, getStorageID(), {}); + check(metadata_snapshot, real_column_names); return has_state_column; } diff --git a/src/Storages/System/StorageSystemReplicas.cpp b/src/Storages/System/StorageSystemReplicas.cpp index 79862e3e383..2d4c90b5954 100644 --- a/src/Storages/System/StorageSystemReplicas.cpp +++ b/src/Storages/System/StorageSystemReplicas.cpp @@ -65,7 +65,7 @@ Pipe StorageSystemReplicas::read( const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); const auto access = context->getAccess(); const bool check_access_for_databases = !access->isGranted(AccessType::SHOW_TABLES); diff --git a/src/Storages/System/StorageSystemStoragePolicies.cpp b/src/Storages/System/StorageSystemStoragePolicies.cpp index 7d117212275..8f20ab63f25 100644 --- a/src/Storages/System/StorageSystemStoragePolicies.cpp +++ b/src/Storages/System/StorageSystemStoragePolicies.cpp @@ -44,7 +44,7 @@ Pipe StorageSystemStoragePolicies::read( const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); MutableColumnPtr col_policy_name = ColumnString::create(); MutableColumnPtr col_volume_name = ColumnString::create(); diff --git a/src/Storages/System/StorageSystemTables.cpp b/src/Storages/System/StorageSystemTables.cpp index 6dd6fa96a05..6b30cdefe35 100644 --- a/src/Storages/System/StorageSystemTables.cpp +++ b/src/Storages/System/StorageSystemTables.cpp @@ -506,7 +506,7 @@ Pipe StorageSystemTables::read( const size_t max_block_size, const unsigned /*num_streams*/) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); /// Create a mask of what columns are needed in the result. diff --git a/src/Storages/System/StorageSystemZeros.cpp b/src/Storages/System/StorageSystemZeros.cpp index f3642d3c66a..6292ff4d414 100644 --- a/src/Storages/System/StorageSystemZeros.cpp +++ b/src/Storages/System/StorageSystemZeros.cpp @@ -99,7 +99,7 @@ Pipe StorageSystemZeros::read( size_t max_block_size, unsigned num_streams) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID(), getExpandedObjects() ); + check(metadata_snapshot, column_names); bool use_multiple_streams = multithreaded; From f22f22c4febba2c2af7fd9e819205d1035342d82 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 6 May 2021 03:40:17 +0300 Subject: [PATCH 008/132] dynamic columns: support of different types --- src/Columns/ColumnArray.cpp | 10 ++ src/Columns/ColumnArray.h | 2 + src/Columns/ColumnObject.cpp | 100 ++++++++++++------ src/Columns/ColumnObject.h | 38 +++++-- src/DataTypes/FieldToDataType.cpp | 3 - src/DataTypes/FieldToDataType.h | 8 -- src/DataTypes/ObjectUtils.cpp | 6 +- src/DataTypes/Serializations/ColumnVariant | 0 src/DataTypes/Serializations/JSONDataParser.h | 14 +-- .../Serializations/SerializationObject.cpp | 75 +++++++++---- 10 files changed, 171 insertions(+), 85 deletions(-) create mode 100644 src/DataTypes/Serializations/ColumnVariant diff --git a/src/Columns/ColumnArray.cpp b/src/Columns/ColumnArray.cpp index 0b22a7fa7a0..10fe4f04b34 100644 --- a/src/Columns/ColumnArray.cpp +++ b/src/Columns/ColumnArray.cpp @@ -1216,6 +1216,16 @@ void ColumnArray::gather(ColumnGathererStream & gatherer) gatherer.gather(*this); } +size_t ColumnArray::getNumberOfDimensions() const +{ + const auto * nested_array = checkAndGetColumn(*data); + if (!nested_array) + return 1; + return 1 + nested_array->getNumberOfDimensions(); /// Every modern C++ compiler optimizes tail recursion. +} + + + // size_t ColumnArray::getNumberOfDefaultRows(size_t step) const // { // const auto & offsets_data = getOffsets(); diff --git a/src/Columns/ColumnArray.h b/src/Columns/ColumnArray.h index cc686855e37..6194b331812 100644 --- a/src/Columns/ColumnArray.h +++ b/src/Columns/ColumnArray.h @@ -145,6 +145,8 @@ public: bool isCollationSupported() const override { return getData().isCollationSupported(); } + size_t getNumberOfDimensions() const; + private: WrappedPtr data; WrappedPtr offsets; diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index fdd12c6f617..249523c3021 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -7,22 +7,45 @@ namespace ErrorCodes { extern const int LOGICAL_ERROR; extern const int ILLEGAL_COLUMN; + extern const int DUPLICATE_COLUMN; } -ColumnObject::ColumnObject(const SubcolumnsMap & subcolumns_) - : subcolumns(subcolumns_) +static TypeId getLeastSuperTypeId(const PaddedPODArray & type_ids) { - checkConsistency(); + } -ColumnObject::ColumnObject(const Names & keys, const Columns & subcolumns_) +ColumnObject::Subcolumn::Subcolumn(const Subcolumn & other) + : data(other.data), type_ids(other.type_ids.begin(), other.type_ids.end()) { - if (keys.size() != subcolumns_.size()) - throw Exception(ErrorCodes::LOGICAL_ERROR, "Sizes of keys ({}) and subcolumns ({}) are inconsistent"); +} - for (size_t i = 0; i < keys.size(); ++i) - subcolumns[keys[i]] = subcolumns_[i]; +ColumnObject::Subcolumn::Subcolumn(MutableColumnPtr && data_) + : data(std::move(data_)) +{ +} +void ColumnObject::Subcolumn::insert(const Field & field, TypeIndex type_id) +{ + data->insert(field); + type_ids.push_back(type_id); +} + +void ColumnObject::Subcolumn::insertDefault() +{ + data->insertDefault(); + type_ids.push_back(TypeIndex::Nothing); +} + +void ColumnObject::Subcolumn::resize(size_t new_size) +{ + data = data->cloneResized(new_size); + type_ids.resize_fill(new_size, TypeIndex::Nothing); +} + +ColumnObject::ColumnObject(SubcolumnsMap && subcolumns_) + : subcolumns(std::move(subcolumns_)) +{ checkConsistency(); } @@ -31,17 +54,17 @@ void ColumnObject::checkConsistency() const if (subcolumns.empty()) return; - size_t first_size = subcolumns.begin()->second->size(); + size_t first_size = subcolumns.begin()->second.size(); for (const auto & [name, column] : subcolumns) { - if (!column) + if (!column.data) throw Exception(ErrorCodes::LOGICAL_ERROR, "Null subcolumn passed to ColumnObject"); - if (first_size != column->size()) + if (first_size != column.data->size()) { throw Exception(ErrorCodes::LOGICAL_ERROR, "Sizes of subcolumns are inconsistent in ColumnObject." " Subcolumn '{}' has {} rows, subcolumn '{}' has {} rows", - subcolumns.begin()->first, first_size, name, column->size()); + subcolumns.begin()->first, first_size, name, column.data->size()); } } } @@ -50,16 +73,16 @@ MutableColumnPtr ColumnObject::cloneResized(size_t new_size) const { SubcolumnsMap new_subcolumns; for (const auto & [key, subcolumn] : subcolumns) - new_subcolumns[key] = subcolumn->cloneResized(new_size); + new_subcolumns[key].resize(new_size); - return ColumnObject::create(new_subcolumns); + return ColumnObject::create(std::move(new_subcolumns)); } size_t ColumnObject::byteSize() const { size_t res = 0; for (const auto & [_, column] : subcolumns) - res += column->byteSize(); + res += column.data->byteSize(); return res; } @@ -67,33 +90,24 @@ size_t ColumnObject::allocatedBytes() const { size_t res = 0; for (const auto & [_, column] : subcolumns) - res += column->allocatedBytes(); + res += column.data->allocatedBytes(); return res; } -// const ColumnPtr & ColumnObject::tryGetSubcolumn(const String & key) const -// { -// auto it = subcolumns.find(key); -// if (it == subcolumns.end()) -// return nullptr; - -// return it->second; -// } - -const IColumn & ColumnObject::getSubcolumn(const String & key) const +const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const String & key) const { auto it = subcolumns.find(key); if (it != subcolumns.end()) - return *it->second; + return it->second; throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key); } -IColumn & ColumnObject::getSubcolumn(const String & key) +ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const String & key) { auto it = subcolumns.find(key); if (it != subcolumns.end()) - return *it->second; + return it->second; throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key); } @@ -103,12 +117,34 @@ bool ColumnObject::hasSubcolumn(const String & key) const return subcolumns.count(key) != 0; } -void ColumnObject::addSubcolumn(const String & key, MutableColumnPtr && subcolumn, bool check_size) +void ColumnObject::addSubcolumn(const String & key, MutableColumnPtr && column_sample, size_t new_size, bool check_size) { - if (check_size && subcolumn->size() != size()) + if (subcolumns.count(key)) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key); + + if (!column_sample->empty()) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Cannot add subcolumn '{}' with non-empty sample column", key); + + if (check_size && new_size != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", - key, subcolumn->size(), size()); + key, new_size, size()); + + auto & subcolumn = subcolumns[key]; + subcolumn = std::move(column_sample); + subcolumn.resize(new_size); +} + +void ColumnObject::addSubcolumn(const String & key, Subcolumn && subcolumn, bool check_size) +{ + if (subcolumns.count(key)) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key); + + if (check_size && subcolumn.size() != size()) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", + key, subcolumn.size(), size()); subcolumns[key] = std::move(subcolumn); } diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 6e3d96ceef0..363a7114a06 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -1,8 +1,10 @@ #pragma once #include -#include #include +#include +#include +#include namespace DB { @@ -12,25 +14,43 @@ namespace ErrorCodes extern const int LOGICAL_ERROR; } -class ColumnObject : public COWHelper +class ColumnObject final : public COWHelper { +public: + struct Subcolumn + { + Subcolumn() = default; + Subcolumn(const Subcolumn & other); + Subcolumn(MutableColumnPtr && data_); + Subcolumn & operator=(Subcolumn && other) = default; + + WrappedPtr data; + PaddedPODArray type_ids; + + size_t size() const { return data->size(); } + void insert(const Field & field, TypeIndex type_id); + void insertDefault(); + void resize(size_t new_size); + }; + + using SubcolumnsMap = std::unordered_map; + private: - using SubcolumnsMap = std::unordered_map; SubcolumnsMap subcolumns; public: ColumnObject() = default; - ColumnObject(const SubcolumnsMap & subcolumns_); - ColumnObject(const Names & keys, const Columns & subcolumns_); + ColumnObject(SubcolumnsMap && subcolumns_); void checkConsistency() const; bool hasSubcolumn(const String & key) const; - const IColumn & getSubcolumn(const String & key) const; - IColumn & getSubcolumn(const String & key); + const Subcolumn & getSubcolumn(const String & key) const; + Subcolumn & getSubcolumn(const String & key); - void addSubcolumn(const String & key, MutableColumnPtr && subcolumn, bool check_size = false); + void addSubcolumn(const String & key, MutableColumnPtr && column_sample, size_t new_size, bool check_size = false); + void addSubcolumn(const String & key, Subcolumn && subcolumn, bool check_size = false); const SubcolumnsMap & getSubcolumns() const { return subcolumns; } SubcolumnsMap & getSubcolumns() { return subcolumns; } @@ -41,7 +61,7 @@ public: const char * getFamilyName() const override { return "Object"; } - size_t size() const override { return subcolumns.empty() ? 0 : subcolumns.begin()->second->size(); } + size_t size() const override { return subcolumns.empty() ? 0 : subcolumns.begin()->second.size(); } MutableColumnPtr cloneResized(size_t new_size) const override; diff --git a/src/DataTypes/FieldToDataType.cpp b/src/DataTypes/FieldToDataType.cpp index aca3918d74f..95f03385121 100644 --- a/src/DataTypes/FieldToDataType.cpp +++ b/src/DataTypes/FieldToDataType.cpp @@ -95,9 +95,6 @@ DataTypePtr FieldToDataType::operator() (const DecimalField & x) con DataTypePtr FieldToDataType::operator() (const Array & x) const { - if (assume_array_elements_have_equal_types && !x.empty()) - return std::make_shared(applyVisitor(FieldToDataType(), x[0])); - DataTypes element_types; element_types.reserve(x.size()); diff --git a/src/DataTypes/FieldToDataType.h b/src/DataTypes/FieldToDataType.h index 3f55937fc67..39457564a2f 100644 --- a/src/DataTypes/FieldToDataType.h +++ b/src/DataTypes/FieldToDataType.h @@ -17,11 +17,6 @@ using DataTypePtr = std::shared_ptr; class FieldToDataType : public StaticVisitor { public: - FieldToDataType(bool assume_array_elements_have_equal_types_ = false) - : assume_array_elements_have_equal_types(assume_array_elements_have_equal_types_) - { - } - DataTypePtr operator() (const Null & x) const; DataTypePtr operator() (const UInt64 & x) const; DataTypePtr operator() (const UInt128 & x) const; @@ -39,9 +34,6 @@ public: DataTypePtr operator() (const AggregateFunctionStateData & x) const; DataTypePtr operator() (const UInt256 & x) const; DataTypePtr operator() (const Int256 & x) const; - -private: - bool assume_array_elements_have_equal_types; }; } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index f6beb3fdf4d..f1950e2f8b5 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -28,7 +28,7 @@ DataTypePtr getDataTypeByColumn(const IColumn & column) if (column.empty()) return std::make_shared(); - return applyVisitor(FieldToDataType(true), column[0]); + return applyVisitor(FieldToDataType(), column[0]); } void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) @@ -54,8 +54,8 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) for (const auto & [key, subcolumn] : subcolumns_map) { tuple_names.push_back(key); - tuple_types.push_back(getDataTypeByColumn(*subcolumn)); - tuple_columns.push_back(subcolumn); + tuple_types.push_back(getDataTypeByColumn(*subcolumn.data)); + tuple_columns.push_back(subcolumn.data); } auto type_tuple = std::make_shared(tuple_types, tuple_names); diff --git a/src/DataTypes/Serializations/ColumnVariant b/src/DataTypes/Serializations/ColumnVariant new file mode 100644 index 00000000000..e69de29bb2d diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index f778a1c26f6..2fb3a65236f 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -14,13 +14,13 @@ namespace { template -String getValueAsString(const Element & element) +Field getValueAsField(const Element & element) { - if (element.isBool()) return toString(element.getBool()); - if (element.isInt64()) return toString(element.getInt64()); - if (element.isUInt64()) return toString(element.getUInt64()); - if (element.isDouble()) return toString(element.getDouble()); - if (element.isString()) return String(element.getString()); + if (element.isBool()) return element.getBool(); + if (element.isInt64()) return element.getInt64(); + if (element.isUInt64()) return element.getUInt64(); + if (element.isDouble()) return element.getDouble(); + if (element.isString()) return element.getString(); throw Exception(ErrorCodes::LOGICAL_ERROR, "Unsupported type of JSON field"); } @@ -132,7 +132,7 @@ private: else { result.paths.push_back(current_path); - result.values.push_back(getValueAsString(element)); + result.values.push_back(getValueAsField(element)); } } diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 16c9425d601..5d720de4111 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -1,5 +1,7 @@ #include #include +#include +#include #include #include #include @@ -8,6 +10,8 @@ #include #include #include +#include +#include #include #include @@ -30,6 +34,33 @@ void SerializationObject::serializeText(const IColumn & /*column*/, size throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); } +namespace +{ + +DataTypePtr createArrayOfStrings(size_t dim) +{ + DataTypePtr type = std::make_shared(); + for (size_t i = 0; i < dim; ++i) + type = std::make_shared(type); + return type; +} + +size_t getNumberOfDimensions(const IDataType & type) +{ + if (const auto * type_array = typeid_cast(&type)) + return type_array->getNumberOfDimensions(); + return 0; +} + +size_t getNumberOfDimensions(const IColumn & column) +{ + if (const auto * column_array = checkAndGetColumn(column)) + return column_array->getNumberOfDimensions(); + return 0; +} + +} + template void SerializationObject::deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings &) const { @@ -52,31 +83,29 @@ void SerializationObject::deserializeText(IColumn & column, ReadBuffer & size_t column_size = column_object.size(); for (size_t i = 0; i < paths.size(); ++i) { - auto value_type = applyVisitor(FieldToDataType(true), values[i]); + auto value_type = applyVisitor(FieldToDataType(), values[i]); + size_t value_dim = getNumberOfDimensions(*value_type); + auto array_type = createArrayOfStrings(value_dim); + auto converted_value = convertFieldToTypeOrThrow(values[i], *array_type, value_type.get()); + if (!column_object.hasSubcolumn(paths[i])) - { - auto new_column = value_type->createColumn()->cloneResized(column_size); - new_column->insert(values[i]); - column_object.addSubcolumn(paths[i], std::move(new_column)); - } - else - { - auto & subcolumn = column_object.getSubcolumn(paths[i]); - auto column_type = getDataTypeByColumn(subcolumn); + column_object.addSubcolumn(paths[i], array_type->createColumn(), column_size); - if (!value_type->equals(*column_type)) - throw Exception(ErrorCodes::TYPE_MISMATCH, - "Type mismatch beetwen value and column. Type of value: {}. Type of column: {}", - value_type->getName(), column_type->getName()); + auto & subcolumn = column_object.getSubcolumn(paths[i]); + size_t column_dim = getNumberOfDimensions(*subcolumn.data); - subcolumn.insert(values[i]); - } + if (value_dim != column_dim) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Dimension of types mismatched beetwen value and column. Dimension of value: {}. Dimension of column: {}", + value_dim, column_dim); + + subcolumn.insert(converted_value, value_type->getTypeId()); } for (auto & [key, subcolumn] : column_object.getSubcolumns()) { if (!paths_set.count(key)) - subcolumn->insertDefault(); + subcolumn.insertDefault(); } } @@ -139,7 +168,7 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( if (auto * stream = settings.getter(settings.path)) { - auto type = getDataTypeByColumn(*subcolumn); + auto type = getDataTypeByColumn(*subcolumn.data); writeStringBinary(key, *stream); writeStringBinary(type->getName(), *stream); } @@ -149,9 +178,9 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( if (auto * stream = settings.getter(settings.path)) { - auto type = getDataTypeByColumn(*subcolumn); + auto type = getDataTypeByColumn(*subcolumn.data); auto serialization = type->getDefaultSerialization(); - serialization->serializeBinaryBulkWithMultipleStreams(*subcolumn, offset, limit, settings, state); + serialization->serializeBinaryBulkWithMultipleStreams(*subcolumn.data, offset, limit, settings, state); } } @@ -204,9 +233,9 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( { auto type = DataTypeFactory::instance().get(type_name); auto serialization = type->getDefaultSerialization(); - ColumnPtr subcolumn = type->createColumn(); - serialization->deserializeBinaryBulkWithMultipleStreams(subcolumn, limit, settings, state, cache); - column_object.addSubcolumn(key, subcolumn->assumeMutable()); + ColumnPtr subcolumn_data = type->createColumn(); + serialization->deserializeBinaryBulkWithMultipleStreams(subcolumn_data, limit, settings, state, cache); + column_object.addSubcolumn(key, subcolumn_data->assumeMutable()); } else { From 0dea7d2e4b20a3a18418afd45e83e676b6e0cb08 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 6 May 2021 08:33:06 +0300 Subject: [PATCH 009/132] dynamic columns: support of different types --- src/Columns/ColumnArray.cpp | 34 +++++---- src/Columns/ColumnArray.h | 4 +- src/Columns/ColumnObject.cpp | 72 +++++++++++++------ src/Columns/ColumnObject.h | 12 ++-- src/DataTypes/FieldToDataType.cpp | 6 +- src/DataTypes/FieldToDataType.h | 8 +++ src/DataTypes/IDataType.h | 2 + src/DataTypes/ObjectUtils.cpp | 53 ++++++++++++-- src/DataTypes/ObjectUtils.h | 5 ++ .../Serializations/SerializationObject.cpp | 37 ++-------- src/DataTypes/getLeastSupertype.cpp | 38 ++++++---- src/DataTypes/getLeastSupertype.h | 2 +- src/Interpreters/convertFieldToType.cpp | 2 + src/Processors/Formats/IRowInputFormat.cpp | 2 + 14 files changed, 177 insertions(+), 100 deletions(-) diff --git a/src/Columns/ColumnArray.cpp b/src/Columns/ColumnArray.cpp index 10fe4f04b34..4e1533acef6 100644 --- a/src/Columns/ColumnArray.cpp +++ b/src/Columns/ColumnArray.cpp @@ -1224,25 +1224,23 @@ size_t ColumnArray::getNumberOfDimensions() const return 1 + nested_array->getNumberOfDimensions(); /// Every modern C++ compiler optimizes tail recursion. } +size_t ColumnArray::getNumberOfDefaultRows(size_t step) const +{ + const auto & offsets_data = getOffsets(); + size_t res = 0; + for (size_t i = 0; i < offsets_data.size(); i += step) + res += (offsets_data[i] != offsets_data[i - 1]); + return res; +} -// size_t ColumnArray::getNumberOfDefaultRows(size_t step) const -// { -// const auto & offsets_data = getOffsets(); -// size_t res = 0; -// for (size_t i = 0; i < offsets_data.size(); i += step) -// res += (offsets_data[i] != offsets_data[i - 1]); - -// return res; -// } - -// void ColumnArray::getIndicesOfNonDefaultValues(IColumn::Offsets & indices, size_t from, size_t limit) const -// { -// const auto & offsets_data = getOffsets(); -// size_t to = limit && from + limit < size() ? from + limit : size(); -// for (size_t i = from; i < to; ++i) -// if (offsets_data[i] != offsets_data[i - 1]) -// indices.push_back(i); -// } +void ColumnArray::getIndicesOfNonDefaultValues(IColumn::Offsets & indices, size_t from, size_t limit) const +{ + const auto & offsets_data = getOffsets(); + size_t to = limit && from + limit < size() ? from + limit : size(); + for (size_t i = from; i < to; ++i) + if (offsets_data[i] != offsets_data[i - 1]) + indices.push_back(i); +} } diff --git a/src/Columns/ColumnArray.h b/src/Columns/ColumnArray.h index 6194b331812..ede1aeb8405 100644 --- a/src/Columns/ColumnArray.h +++ b/src/Columns/ColumnArray.h @@ -140,8 +140,8 @@ public: return false; } - // size_t getNumberOfDefaultRows(size_t step) const override; - // void getIndicesOfNonDefaultValues(IColumn::Offsets & indices, size_t from, size_t limit) const override; + size_t getNumberOfDefaultRows(size_t step) const override; + void getIndicesOfNonDefaultValues(IColumn::Offsets & indices, size_t from, size_t limit) const override; bool isCollationSupported() const override { return getData().isCollationSupported(); } diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 249523c3021..a8181d925ba 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -1,4 +1,10 @@ #include +#include +#include +#include +#include +#include +#include namespace DB { @@ -10,37 +16,25 @@ namespace ErrorCodes extern const int DUPLICATE_COLUMN; } -static TypeId getLeastSuperTypeId(const PaddedPODArray & type_ids) -{ - -} - ColumnObject::Subcolumn::Subcolumn(const Subcolumn & other) - : data(other.data), type_ids(other.type_ids.begin(), other.type_ids.end()) + : data(other.data), least_common_type(other.least_common_type) { } ColumnObject::Subcolumn::Subcolumn(MutableColumnPtr && data_) - : data(std::move(data_)) + : data(std::move(data_)), least_common_type(getDataTypeByColumn(*data)) { } -void ColumnObject::Subcolumn::insert(const Field & field, TypeIndex type_id) +void ColumnObject::Subcolumn::insert(const Field & field, const DataTypePtr & value_type) { data->insert(field); - type_ids.push_back(type_id); + least_common_type = getLeastSupertype({least_common_type, value_type}, true); } void ColumnObject::Subcolumn::insertDefault() { data->insertDefault(); - type_ids.push_back(TypeIndex::Nothing); -} - -void ColumnObject::Subcolumn::resize(size_t new_size) -{ - data = data->cloneResized(new_size); - type_ids.resize_fill(new_size, TypeIndex::Nothing); } ColumnObject::ColumnObject(SubcolumnsMap && subcolumns_) @@ -71,11 +65,11 @@ void ColumnObject::checkConsistency() const MutableColumnPtr ColumnObject::cloneResized(size_t new_size) const { - SubcolumnsMap new_subcolumns; - for (const auto & [key, subcolumn] : subcolumns) - new_subcolumns[key].resize(new_size); + if (new_size != 0) + throw Exception(ErrorCodes::NOT_IMPLEMENTED, + "ColumnObject doesn't support resize to non-zero length"); - return ColumnObject::create(std::move(new_subcolumns)); + return ColumnObject::create(); } size_t ColumnObject::byteSize() const @@ -117,7 +111,7 @@ bool ColumnObject::hasSubcolumn(const String & key) const return subcolumns.count(key) != 0; } -void ColumnObject::addSubcolumn(const String & key, MutableColumnPtr && column_sample, size_t new_size, bool check_size) +void ColumnObject::addSubcolumn(const String & key, const ColumnPtr & column_sample, size_t new_size, bool check_size) { if (subcolumns.count(key)) throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key); @@ -132,8 +126,8 @@ void ColumnObject::addSubcolumn(const String & key, MutableColumnPtr && column_s key, new_size, size()); auto & subcolumn = subcolumns[key]; - subcolumn = std::move(column_sample); - subcolumn.resize(new_size); + subcolumn.data = column_sample->cloneResized(new_size); + subcolumn.least_common_type = std::make_shared(); } void ColumnObject::addSubcolumn(const String & key, Subcolumn && subcolumn, bool check_size) @@ -158,4 +152,36 @@ Names ColumnObject::getKeys() const return keys; } +void ColumnObject::optimizeTypesOfSubcolumns() +{ + if (optimized_subcolumn_types) + return; + + for (auto & [_, subcolumn] : subcolumns) + { + auto from_type = getDataTypeByColumn(*subcolumn.data); + if (subcolumn.least_common_type->equals(*from_type)) + continue; + + size_t subcolumn_size = subcolumn.size(); + if (subcolumn.data->getNumberOfDefaultRows(1) == 0) + { + subcolumn.data = castColumn({subcolumn.data, from_type, ""}, subcolumn.least_common_type); + } + else + { + /// TODO: wrong code. + auto offsets = ColumnUInt64::create(); + auto & offsets_data = offsets->getData(); + + subcolumn.data->getIndicesOfNonDefaultValues(offsets_data, 0, subcolumn_size); + auto values = subcolumn.data->index(*offsets, subcolumn_size); + values = castColumn({subcolumn.data, from_type, ""}, subcolumn.least_common_type); + subcolumn.data = values->createWithOffsets(offsets_data, subcolumn_size); + } + } + + optimized_subcolumn_types = true; +} + } diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 363a7114a06..d924b4c0e84 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -6,6 +6,8 @@ #include #include +#include + namespace DB { @@ -25,18 +27,18 @@ public: Subcolumn & operator=(Subcolumn && other) = default; WrappedPtr data; - PaddedPODArray type_ids; + DataTypePtr least_common_type; size_t size() const { return data->size(); } - void insert(const Field & field, TypeIndex type_id); + void insert(const Field & field, const DataTypePtr & value_type); void insertDefault(); - void resize(size_t new_size); }; using SubcolumnsMap = std::unordered_map; private: SubcolumnsMap subcolumns; + bool optimized_subcolumn_types = false; public: ColumnObject() = default; @@ -49,7 +51,7 @@ public: const Subcolumn & getSubcolumn(const String & key) const; Subcolumn & getSubcolumn(const String & key); - void addSubcolumn(const String & key, MutableColumnPtr && column_sample, size_t new_size, bool check_size = false); + void addSubcolumn(const String & key, const ColumnPtr & column_sample, size_t new_size, bool check_size = false); void addSubcolumn(const String & key, Subcolumn && subcolumn, bool check_size = false); const SubcolumnsMap & getSubcolumns() const { return subcolumns; } @@ -57,6 +59,8 @@ public: Names getKeys() const; + void optimizeTypesOfSubcolumns(); + /// Part of interface const char * getFamilyName() const override { return "Object"; } diff --git a/src/DataTypes/FieldToDataType.cpp b/src/DataTypes/FieldToDataType.cpp index 95f03385121..7d58def5146 100644 --- a/src/DataTypes/FieldToDataType.cpp +++ b/src/DataTypes/FieldToDataType.cpp @@ -101,7 +101,7 @@ DataTypePtr FieldToDataType::operator() (const Array & x) const for (const Field & elem : x) element_types.emplace_back(applyVisitor(FieldToDataType(), elem)); - return std::make_shared(getLeastSupertype(element_types)); + return std::make_shared(getLeastSupertype(element_types, allow_convertion_to_string)); } @@ -134,7 +134,9 @@ DataTypePtr FieldToDataType::operator() (const Map & map) const value_types.push_back(applyVisitor(FieldToDataType(), tuple[1])); } - return std::make_shared(getLeastSupertype(key_types), getLeastSupertype(value_types)); + return std::make_shared( + getLeastSupertype(key_types, allow_convertion_to_string), + getLeastSupertype(value_types, allow_convertion_to_string)); } DataTypePtr FieldToDataType::operator() (const AggregateFunctionStateData & x) const diff --git a/src/DataTypes/FieldToDataType.h b/src/DataTypes/FieldToDataType.h index 39457564a2f..bb8b997a767 100644 --- a/src/DataTypes/FieldToDataType.h +++ b/src/DataTypes/FieldToDataType.h @@ -17,6 +17,11 @@ using DataTypePtr = std::shared_ptr; class FieldToDataType : public StaticVisitor { public: + FieldToDataType(bool allow_convertion_to_string_ = false) + : allow_convertion_to_string(allow_convertion_to_string_) + { + } + DataTypePtr operator() (const Null & x) const; DataTypePtr operator() (const UInt64 & x) const; DataTypePtr operator() (const UInt128 & x) const; @@ -34,6 +39,9 @@ public: DataTypePtr operator() (const AggregateFunctionStateData & x) const; DataTypePtr operator() (const UInt256 & x) const; DataTypePtr operator() (const Int256 & x) const; + +private: + bool allow_convertion_to_string; }; } diff --git a/src/DataTypes/IDataType.h b/src/DataTypes/IDataType.h index 3ca82a40121..23854e0746d 100644 --- a/src/DataTypes/IDataType.h +++ b/src/DataTypes/IDataType.h @@ -345,6 +345,8 @@ struct WhichDataType constexpr bool isAggregateFunction() const { return idx == TypeIndex::AggregateFunction; } constexpr bool IsBigIntOrDeimal() const { return isInt128() || isInt256() || isUInt256() || isDecimal256(); } + + constexpr bool isSimple() const { return isInt() || isUInt() || isFloat() || isString(); } }; /// IDataType helpers (alternative for IDataType virtual methods with single point of truth) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index f1950e2f8b5..7e63165149e 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -2,10 +2,13 @@ #include #include #include +#include +#include #include #include #include #include +#include #include #include @@ -23,12 +26,38 @@ static const IDataType * getTypeObject(const DataTypePtr & type) return typeid_cast(type.get()); } +size_t getNumberOfDimensions(const IDataType & type) +{ + if (const auto * type_array = typeid_cast(&type)) + return type_array->getNumberOfDimensions(); + return 0; +} + +size_t getNumberOfDimensions(const IColumn & column) +{ + if (const auto * column_array = checkAndGetColumn(column)) + return column_array->getNumberOfDimensions(); + return 0; +} + +DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension) +{ + for (size_t i = 0; i < dimension; ++i) + type = std::make_shared(type); + return type; +} + DataTypePtr getDataTypeByColumn(const IColumn & column) { - if (column.empty()) - return std::make_shared(); + auto idx = column.getDataType(); + if (WhichDataType(column.getDataType()).isSimple()) + return DataTypeFactory::instance().get(getTypeName(idx)); - return applyVisitor(FieldToDataType(), column[0]); + if (const auto * column_array = typeid_cast(&column)) + return std::make_shared(getDataTypeByColumn(column_array->getData())); + + /// TODO: add more types. + throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot get data type of column {}", column.getFamilyName()); } void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) @@ -91,11 +120,27 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) for (const auto & [name, subtypes] : subcolumns_types) { + assert(!subtypes.empty()); + + size_t first_dim = getNumberOfDimensions(*subtypes[0]); + for (size_t i = 1; i < subtypes.size(); ++i) + if (first_dim != getNumberOfDimensions(*subtypes[i])) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Uncompatible types of subcolumn '{}': {} and {}", + name, subtypes[0]->getName(), subtypes[i]->getName()); + tuple_names.push_back(name); - tuple_types.push_back(getLeastSupertype(subtypes)); + tuple_types.push_back(getLeastSupertype(subtypes, /*allow_conversion_to_string=*/ true)); } return std::make_shared(tuple_types, tuple_names); } +void optimizeTypesOfObjectColumns(MutableColumns & columns) +{ + for (auto & column : columns) + if (auto * column_object = typeid_cast(column.get())) + column_object->optimizeTypesOfSubcolumns(); +} + } diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 509574f934d..b8b508530ba 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -6,8 +6,13 @@ namespace DB { +size_t getNumberOfDimensions(const IDataType & type); +size_t getNumberOfDimensions(const IColumn & column); +DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); + DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types); +void optimizeTypesOfObjectColumns(MutableColumns & columns); } diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 5d720de4111..fcbf1e11775 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -34,33 +34,6 @@ void SerializationObject::serializeText(const IColumn & /*column*/, size throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); } -namespace -{ - -DataTypePtr createArrayOfStrings(size_t dim) -{ - DataTypePtr type = std::make_shared(); - for (size_t i = 0; i < dim; ++i) - type = std::make_shared(type); - return type; -} - -size_t getNumberOfDimensions(const IDataType & type) -{ - if (const auto * type_array = typeid_cast(&type)) - return type_array->getNumberOfDimensions(); - return 0; -} - -size_t getNumberOfDimensions(const IColumn & column) -{ - if (const auto * column_array = checkAndGetColumn(column)) - return column_array->getNumberOfDimensions(); - return 0; -} - -} - template void SerializationObject::deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings &) const { @@ -83,9 +56,10 @@ void SerializationObject::deserializeText(IColumn & column, ReadBuffer & size_t column_size = column_object.size(); for (size_t i = 0; i < paths.size(); ++i) { - auto value_type = applyVisitor(FieldToDataType(), values[i]); - size_t value_dim = getNumberOfDimensions(*value_type); - auto array_type = createArrayOfStrings(value_dim); + auto value_type = applyVisitor(FieldToDataType(/*allow_conversion_to_string=*/true), values[i]); + + auto value_dim = getNumberOfDimensions(*value_type); + auto array_type = createArrayOfType(std::make_shared(), value_dim); auto converted_value = convertFieldToTypeOrThrow(values[i], *array_type, value_type.get()); if (!column_object.hasSubcolumn(paths[i])) @@ -99,7 +73,7 @@ void SerializationObject::deserializeText(IColumn & column, ReadBuffer & "Dimension of types mismatched beetwen value and column. Dimension of value: {}. Dimension of column: {}", value_dim, column_dim); - subcolumn.insert(converted_value, value_type->getTypeId()); + subcolumn.insert(converted_value, value_type); } for (auto & [key, subcolumn] : column_object.getSubcolumns()) @@ -246,6 +220,7 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( settings.path.pop_back(); column_object.checkConsistency(); + column_object.optimizeTypesOfSubcolumns(); column = std::move(mutable_column); } diff --git a/src/DataTypes/getLeastSupertype.cpp b/src/DataTypes/getLeastSupertype.cpp index 6710313349b..2b46d779293 100644 --- a/src/DataTypes/getLeastSupertype.cpp +++ b/src/DataTypes/getLeastSupertype.cpp @@ -50,8 +50,16 @@ namespace } -DataTypePtr getLeastSupertype(const DataTypes & types) +DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_string) { + auto throw_or_return = [&](std::string_view message, int error_code) + { + if (allow_conversion_to_string) + return std::make_shared(); + + throw Exception(String(message), error_code); + }; + /// Trivial cases if (types.empty()) @@ -113,7 +121,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) if (have_array) { if (!all_arrays) - throw Exception(getExceptionMessagePrefix(types) + " because some of them are Array and some of them are not", ErrorCodes::NO_COMMON_TYPE); + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are Array and some of them are not", ErrorCodes::NO_COMMON_TYPE); return std::make_shared(getLeastSupertype(nested_types)); } @@ -139,7 +147,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) nested_types[elem_idx].reserve(types.size()); } else if (tuple_size != type_tuple->getElements().size()) - throw Exception(getExceptionMessagePrefix(types) + " because Tuples have different sizes", ErrorCodes::NO_COMMON_TYPE); + return throw_or_return(getExceptionMessagePrefix(types) + " because Tuples have different sizes", ErrorCodes::NO_COMMON_TYPE); have_tuple = true; @@ -153,7 +161,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) if (have_tuple) { if (!all_tuples) - throw Exception(getExceptionMessagePrefix(types) + " because some of them are Tuple and some of them are not", ErrorCodes::NO_COMMON_TYPE); + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are Tuple and some of them are not", ErrorCodes::NO_COMMON_TYPE); DataTypes common_tuple_types(tuple_size); for (size_t elem_idx = 0; elem_idx < tuple_size; ++elem_idx) @@ -187,7 +195,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) if (have_maps) { if (!all_maps) - throw Exception(getExceptionMessagePrefix(types) + " because some of them are Maps and some of them are not", ErrorCodes::NO_COMMON_TYPE); + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are Maps and some of them are not", ErrorCodes::NO_COMMON_TYPE); return std::make_shared(getLeastSupertype(key_types), getLeastSupertype(value_types)); } @@ -268,7 +276,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) { bool all_strings = type_ids.size() == (have_string + have_fixed_string); if (!all_strings) - throw Exception(getExceptionMessagePrefix(types) + " because some of them are String/FixedString and some of them are not", ErrorCodes::NO_COMMON_TYPE); + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are String/FixedString and some of them are not", ErrorCodes::NO_COMMON_TYPE); return std::make_shared(); } @@ -284,7 +292,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) { bool all_date_or_datetime = type_ids.size() == (have_date + have_datetime + have_datetime64); if (!all_date_or_datetime) - throw Exception(getExceptionMessagePrefix(types) + " because some of them are Date/DateTime/DateTime64 and some of them are not", + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are Date/DateTime/DateTime64 and some of them are not", ErrorCodes::NO_COMMON_TYPE); if (have_datetime64 == 0) @@ -331,7 +339,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) } if (num_supported != type_ids.size()) - throw Exception(getExceptionMessagePrefix(types) + " because some of them have no lossless conversion to Decimal", + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them have no lossless conversion to Decimal", ErrorCodes::NO_COMMON_TYPE); UInt32 max_scale = 0; @@ -354,7 +362,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) } if (min_precision > DataTypeDecimal::maxPrecision()) - throw Exception(getExceptionMessagePrefix(types) + " because the least supertype is Decimal(" + return throw_or_return(getExceptionMessagePrefix(types) + " because the least supertype is Decimal(" + toString(min_precision) + ',' + toString(max_scale) + ')', ErrorCodes::NO_COMMON_TYPE); @@ -415,7 +423,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) if (max_bits_of_signed_integer || max_bits_of_unsigned_integer || max_mantissa_bits_of_floating) { if (!all_numbers) - throw Exception(getExceptionMessagePrefix(types) + " because some of them are numbers and some of them are not", ErrorCodes::NO_COMMON_TYPE); + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are numbers and some of them are not", ErrorCodes::NO_COMMON_TYPE); /// If there are signed and unsigned types of same bit-width, the result must be signed number with at least one more bit. /// Example, common of Int32, UInt32 = Int64. @@ -430,7 +438,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) if (min_bit_width_of_integer != 64) ++min_bit_width_of_integer; else - throw Exception( + return throw_or_return( getExceptionMessagePrefix(types) + " because some of them are signed integers and some are unsigned integers," " but there is no signed integer type, that can exactly represent all required unsigned integer values", @@ -446,7 +454,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) else if (min_mantissa_bits <= 53) return std::make_shared(); else - throw Exception(getExceptionMessagePrefix(types) + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are integers and some are floating point," " but there is no floating point type, that can exactly represent all required integers", ErrorCodes::NO_COMMON_TYPE); } @@ -467,7 +475,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types) else if (min_bit_width_of_integer <= 256) return std::make_shared(); else - throw Exception(getExceptionMessagePrefix(types) + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are signed integers and some are unsigned integers," " but there is no signed integer type, that can exactly represent all required unsigned integer values", ErrorCodes::NO_COMMON_TYPE); } @@ -485,14 +493,14 @@ DataTypePtr getLeastSupertype(const DataTypes & types) else if (min_bit_width_of_integer <= 256) return std::make_shared(); else - throw Exception("Logical error: " + getExceptionMessagePrefix(types) + return throw_or_return("Logical error: " + getExceptionMessagePrefix(types) + " but as all data types are unsigned integers, we must have found maximum unsigned integer type", ErrorCodes::NO_COMMON_TYPE); } } } /// All other data types (UUID, AggregateFunction, Enum...) are compatible only if they are the same (checked in trivial cases). - throw Exception(getExceptionMessagePrefix(types), ErrorCodes::NO_COMMON_TYPE); + return throw_or_return(getExceptionMessagePrefix(types), ErrorCodes::NO_COMMON_TYPE); } } diff --git a/src/DataTypes/getLeastSupertype.h b/src/DataTypes/getLeastSupertype.h index 57e011a0529..da84e5eac60 100644 --- a/src/DataTypes/getLeastSupertype.h +++ b/src/DataTypes/getLeastSupertype.h @@ -12,6 +12,6 @@ namespace DB * Examples: least common supertype for UInt8, Int8 - Int16. * Examples: there is no least common supertype for Array(UInt8), Int8. */ -DataTypePtr getLeastSupertype(const DataTypes & types); +DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_string = false); } diff --git a/src/Interpreters/convertFieldToType.cpp b/src/Interpreters/convertFieldToType.cpp index ed920539bea..ca9b7d6cdd8 100644 --- a/src/Interpreters/convertFieldToType.cpp +++ b/src/Interpreters/convertFieldToType.cpp @@ -210,6 +210,8 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type, const ID } return src; } + + return applyVisitor(FieldVisitorToString(), src); } else if (const DataTypeArray * type_array = typeid_cast(&type)) { diff --git a/src/Processors/Formats/IRowInputFormat.cpp b/src/Processors/Formats/IRowInputFormat.cpp index 52e64a9d90d..ecca6714aa0 100644 --- a/src/Processors/Formats/IRowInputFormat.cpp +++ b/src/Processors/Formats/IRowInputFormat.cpp @@ -1,4 +1,5 @@ #include +#include #include // toString #include @@ -197,6 +198,7 @@ Chunk IRowInputFormat::generate() return {}; } + optimizeTypesOfObjectColumns(columns); Chunk chunk(std::move(columns), num_rows); //chunk.setChunkInfo(std::move(chunk_missing_values)); return chunk; From 5150c3b9b5dfae5a38fa398411fc70c50030b8ac Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 7 May 2021 05:19:54 +0300 Subject: [PATCH 010/132] dynamic columns: better input formats of json type --- src/DataTypes/Serializations/JSONDataParser.h | 2 +- .../Serializations/SerializationObject.cpp | 83 +++++++++++++++---- .../Serializations/SerializationObject.h | 20 ++++- src/IO/ReadHelpers.cpp | 2 +- .../0_stateless/01825_type_json.reference | 25 +++++- tests/queries/0_stateless/01825_type_json.sql | 81 ++++++++++++++++++ 6 files changed, 188 insertions(+), 25 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json.sql diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index 2fb3a65236f..edb6838a70d 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -50,7 +50,7 @@ public: using Path = std::vector; using Paths = std::vector; - void readInto(String & s, ReadBuffer & buf) + void readJSON(String & s, ReadBuffer & buf) { readJSONObjectPossiblyInvalid(s, buf); } diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index fcbf1e11775..5f3a78f5041 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -1,6 +1,5 @@ #include #include -#include #include #include #include @@ -8,9 +7,7 @@ #include #include #include -#include #include -#include #include #include @@ -29,18 +26,14 @@ namespace ErrorCodes } template -void SerializationObject::serializeText(const IColumn & /*column*/, size_t /*row_num*/, WriteBuffer & /*ostr*/, const FormatSettings &) const -{ - throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); -} - -template -void SerializationObject::deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings &) const +template +void SerializationObject::deserializeTextImpl(IColumn & column, Reader && reader) const { auto & column_object = assert_cast(column); String buf; - parser.readInto(buf, istr); + reader(buf); + auto result = parser.parse(buf.data(), buf.size()); if (!result) throw Exception(ErrorCodes::INCORRECT_DATA, "Cannot parse object"); @@ -83,6 +76,36 @@ void SerializationObject::deserializeText(IColumn & column, ReadBuffer & } } +template +void SerializationObject::deserializeWholeText(IColumn & column, ReadBuffer & istr, const FormatSettings &) const +{ + deserializeTextImpl(column, [&](String & s) { readStringInto(s, istr); }); +} + +template +void SerializationObject::deserializeTextEscaped(IColumn & column, ReadBuffer & istr, const FormatSettings &) const +{ + deserializeTextImpl(column, [&](String & s) { readEscapedStringInto(s, istr); }); +} + +template +void SerializationObject::deserializeTextQuoted(IColumn & column, ReadBuffer & istr, const FormatSettings &) const +{ + deserializeTextImpl(column, [&](String & s) { readQuotedStringInto(s, istr); }); +} + +template +void SerializationObject::deserializeTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings &) const +{ + deserializeTextImpl(column, [&](String & s) { parser.readJSON(s, istr); }); +} + +template +void SerializationObject::deserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const +{ + deserializeTextImpl(column, [&](String & s) { readCSVStringInto(s, istr, settings.csv); }); +} + template template void SerializationObject::checkSerializationIsSupported(Settings & settings, StatePtr & state) const @@ -225,25 +248,55 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( } template -void SerializationObject::serializeBinary(const Field & /*field*/, WriteBuffer & /*ostr*/) const +void SerializationObject::serializeBinary(const Field &, WriteBuffer &) const { throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); } template -void SerializationObject::deserializeBinary(Field & /*field*/, ReadBuffer & /*istr*/) const +void SerializationObject::deserializeBinary(Field &, ReadBuffer &) const { throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); } template -void SerializationObject::serializeBinary(const IColumn & /*column*/, size_t /*row_num*/, WriteBuffer & /*ostr*/) const +void SerializationObject::serializeBinary(const IColumn &, size_t, WriteBuffer &) const { throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); } template -void SerializationObject::deserializeBinary(IColumn & /*column*/, ReadBuffer & /*istr*/) const +void SerializationObject::deserializeBinary(IColumn &, ReadBuffer &) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::serializeText(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::serializeTextEscaped(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::serializeTextQuoted(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::serializeTextJSON(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const +{ + throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); +} + +template +void SerializationObject::serializeTextCSV(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const { throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); } diff --git a/src/DataTypes/Serializations/SerializationObject.h b/src/DataTypes/Serializations/SerializationObject.h index c78c8d0f921..eba013b1664 100644 --- a/src/DataTypes/Serializations/SerializationObject.h +++ b/src/DataTypes/Serializations/SerializationObject.h @@ -6,12 +6,9 @@ namespace DB { template -class SerializationObject : public SimpleTextSerialization +class SerializationObject : public ISerialization { public: - void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override; - void deserializeText(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override; - void serializeBinaryBulkStatePrefix( SerializeBinaryBulkSettings & settings, SerializeBinaryBulkStatePtr & state) const override; @@ -43,10 +40,25 @@ public: void serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const override; void deserializeBinary(IColumn & column, ReadBuffer & istr) const override; + void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override; + void serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override; + void serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override; + void serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override; + void serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override; + + void deserializeWholeText(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override; + void deserializeTextEscaped(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override; + void deserializeTextQuoted(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override; + void deserializeTextJSON(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override; + void deserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override; + private: template void checkSerializationIsSupported(Settings & settings, StatePtr & state) const; + template + void deserializeTextImpl(IColumn & column, Reader && reader) const; + mutable Parser parser; }; diff --git a/src/IO/ReadHelpers.cpp b/src/IO/ReadHelpers.cpp index cb6d43f859f..f8c52594d27 100644 --- a/src/IO/ReadHelpers.cpp +++ b/src/IO/ReadHelpers.cpp @@ -244,7 +244,7 @@ void readString(String & s, ReadBuffer & buf) } template void readStringInto>(PaddedPODArray & s, ReadBuffer & buf); - +template void readStringInto(String & s, ReadBuffer & buf); template void readStringUntilEOFInto(Vector & s, ReadBuffer & buf) diff --git a/tests/queries/0_stateless/01825_type_json.reference b/tests/queries/0_stateless/01825_type_json.reference index f29a150ecf0..5e957434033 100644 --- a/tests/queries/0_stateless/01825_type_json.reference +++ b/tests/queries/0_stateless/01825_type_json.reference @@ -1,10 +1,27 @@ 1 aa bb c 2 ee ff 3 foo -all_1_1_0 id UInt64 all_1_1_0 data Tuple(k1 String, `k2.k4` String, `k2.k3` String, k5 String) -all_2_2_0 id UInt64 all_2_2_0 data Tuple(k5 String) +all_1_2_1 data Tuple(k5 String, `k2.k3` String, `k2.k4` String, k1 String) +============ 1 ['aaa','ddd'] [['bbb','ccc'],['eee','fff']] -all_1_1_0 id UInt64 -all_1_1_0 data Tuple(`k1.k3.k4` Array(Array(String)), `k1.k2` Array(String)) +all_3_3_0 data Tuple(`k1.k3.k4` Array(Array(String)), `k1.k2` Array(String)) +============ +1 a 42 +2 b 4200 +4242 +all_4_4_0 data Tuple(name String, value Int16) +1 a 42 +2 b 4200 +3 a 42.123 +all_4_4_0 data Tuple(name String, value Int16) +all_5_5_0 data Tuple(name String, value Float64) +1 a 42 +2 b 4200 +3 a 42.123 +4 a some +all_4_4_0 data Tuple(name String, value Int16) +all_5_5_0 data Tuple(name String, value Float64) +all_6_6_0 data Tuple(name String, value String) +all_4_6_1 data Tuple(value String, name String) diff --git a/tests/queries/0_stateless/01825_type_json.sql b/tests/queries/0_stateless/01825_type_json.sql new file mode 100644 index 00000000000..668b39db70f --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json.sql @@ -0,0 +1,81 @@ +DROP TABLE IF EXISTS t_json; + +CREATE TABLE t_json(id UInt64, data Object('JSON')) +ENGINE = MergeTree ORDER BY tuple() +SETTINGS min_bytes_for_wide_part = 0; + +SYSTEM STOP MERGES t_json; + +INSERT INTO t_json FORMAT JSONEachRow {"id": 1, "data": {"k1": "aa", "k2": {"k3": "bb", "k4": "c"}}} {"id": 2, "data": {"k1": "ee", "k5": "ff"}}; +INSERT INTO t_json FORMAT JSONEachRow {"id": 3, "data": {"k5":"foo"}}; + +SELECT id, data.k1, data.k2.k3, data.k2.k4, data.k5 FROM t_json ORDER BY id; + +SELECT name, column, type +FROM system.parts_columns +WHERE table = 't_json' AND database = currentDatabase() AND active AND column = 'data' +ORDER BY name; + +SYSTEM START MERGES t_json; + +OPTIMIZE TABLE t_json FINAL; + +SELECT name, column, type +FROM system.parts_columns +WHERE table = 't_json' AND database = currentDatabase() AND active AND column = 'data' +ORDER BY name; + + +SELECT '============'; +TRUNCATE TABLE t_json; + +INSERT INTO t_json FORMAT JSONEachRow {"id": 1, "data": {"k1":[{"k2":"aaa","k3":[{"k4":"bbb"},{"k4":"ccc"}]},{"k2":"ddd","k3":[{"k4":"eee"},{"k4":"fff"}]}]}}; +SELECT id, data.k1.k2, data.k1.k3.k4 FROM t_json ORDER BY id; + +SELECT name, column, type +FROM system.parts_columns +WHERE table = 't_json' AND database = currentDatabase() AND active AND column = 'data' +ORDER BY name; + +SELECT '============'; +TRUNCATE TABLE t_json; + +SYSTEM STOP MERGES t_json; + +INSERT INTO t_json FORMAT JSONEachRow {"id": 1, "data": {"name": "a", "value": 42 }}, {"id": 2, "data": {"name": "b", "value": 4200 }}; + +SELECT id, data.name, data.value FROM t_json ORDER BY id; +SELECT sum(data.value) FROM t_json; + +SELECT name, column, type +FROM system.parts_columns +WHERE table = 't_json' AND database = currentDatabase() AND active AND column = 'data' +ORDER BY name; + +INSERT INTO t_json FORMAT JSONEachRow {"id": 3, "data": {"name": "a", "value": 42.123 }}; + +SELECT id, data.name, data.value FROM t_json ORDER BY id; + +SELECT name, column, type +FROM system.parts_columns +WHERE table = 't_json' AND database = currentDatabase() AND active AND column = 'data' +ORDER BY name; + +INSERT INTO t_json FORMAT JSONEachRow {"id": 4, "data": {"name": "a", "value": "some" }}; + +SELECT id, data.name, data.value FROM t_json ORDER BY id; + +SELECT name, column, type +FROM system.parts_columns +WHERE table = 't_json' AND database = currentDatabase() AND active AND column = 'data' +ORDER BY name; + +SYSTEM START MERGES t_json; +OPTIMIZE TABLE t_json FINAL; + +SELECT name, column, type +FROM system.parts_columns +WHERE table = 't_json' AND database = currentDatabase() AND active AND column = 'data' +ORDER BY name; + +DROP TABLE IF EXISTS t_json; From 1823ea6efd3590224ae04f6d865334a3e8e75b7f Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 7 May 2021 05:21:24 +0300 Subject: [PATCH 011/132] disable sparse columns --- src/Storages/MergeTree/MergeTreeSettings.h | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Storages/MergeTree/MergeTreeSettings.h b/src/Storages/MergeTree/MergeTreeSettings.h index b9d9f1473ef..4e877980f1d 100644 --- a/src/Storages/MergeTree/MergeTreeSettings.h +++ b/src/Storages/MergeTree/MergeTreeSettings.h @@ -33,7 +33,7 @@ struct Settings; M(UInt64, min_rows_for_compact_part, 0, "Experimental. Minimal number of rows to create part in compact format instead of saving it in RAM", 0) \ M(Bool, in_memory_parts_enable_wal, true, "Whether to write blocks in Native format to write-ahead-log before creation in-memory part", 0) \ M(UInt64, write_ahead_log_max_bytes, 1024 * 1024 * 1024, "Rotate WAL, if it exceeds that amount of bytes", 0) \ - M(Float, ratio_for_sparse_serialization, 0, "", 0) \ + M(Float, ratio_for_sparse_serialization, 1.1, "", 0) \ \ /** Merge settings. */ \ M(UInt64, merge_max_block_size, DEFAULT_MERGE_BLOCK_SIZE, "How many rows in blocks should be formed for merge operations.", 0) \ From 012009ceaa2d1dd6228082dc9fdbd50a0fea165d Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 7 May 2021 06:12:41 +0300 Subject: [PATCH 012/132] fix build --- src/Common/CMakeLists.txt | 2 -- src/Common/JSONParsers/CMakeLists.txt | 15 --------------- src/Common/JSONParsers/RapidJSONParser.h | 2 +- src/Common/JSONParsers/SimdJSONParser.h | 2 +- src/Common/JSONParsers/config_jsonparsers.h.in | 6 ------ 5 files changed, 2 insertions(+), 25 deletions(-) delete mode 100644 src/Common/JSONParsers/CMakeLists.txt delete mode 100644 src/Common/JSONParsers/config_jsonparsers.h.in diff --git a/src/Common/CMakeLists.txt b/src/Common/CMakeLists.txt index feee3bd9dd3..61d9b9771a4 100644 --- a/src/Common/CMakeLists.txt +++ b/src/Common/CMakeLists.txt @@ -3,8 +3,6 @@ add_subdirectory(StringUtils) #add_subdirectory(ZooKeeper) #add_subdirectory(ConfigProcessor) -add_subdirectory(JSONParsers) - if (ENABLE_TESTS) add_subdirectory (tests) endif () diff --git a/src/Common/JSONParsers/CMakeLists.txt b/src/Common/JSONParsers/CMakeLists.txt deleted file mode 100644 index 7b0c6f3ff07..00000000000 --- a/src/Common/JSONParsers/CMakeLists.txt +++ /dev/null @@ -1,15 +0,0 @@ -# configure_file(config_jsonparsers.h.in ${ConfigIncludePath}/config_jsonparsers.h) - -# include(${ClickHouse_SOURCE_DIR}/cmake/dbms_glob_sources.cmake) - -# add_headers_and_sources(clickhouse_common_jsonparsers .) - -# add_library(clickhouse_common_jsonparsers ${clickhouse_common_jsonparsers_headers} ${clickhouse_common_jsonparsers_sources}) - -# if(USE_SIMDJSON) -# target_link_libraries(clickhouse_common_jsonparsers PRIVATE simdjson) -# endif() - -# if(USE_RAPIDJSON) -# target_include_directories(clickhouse_common_jsonparsers SYSTEM PRIVATE ${RAPIDJSON_INCLUDE_DIR}) -# endif() diff --git a/src/Common/JSONParsers/RapidJSONParser.h b/src/Common/JSONParsers/RapidJSONParser.h index c25bfefaea1..e4e7c6082b5 100644 --- a/src/Common/JSONParsers/RapidJSONParser.h +++ b/src/Common/JSONParsers/RapidJSONParser.h @@ -1,7 +1,7 @@ #pragma once #if !defined(ARCADIA_BUILD) -# include "config_jsonparsers.h" +# include #endif #if USE_RAPIDJSON diff --git a/src/Common/JSONParsers/SimdJSONParser.h b/src/Common/JSONParsers/SimdJSONParser.h index 974b506b4a7..08ccbe705eb 100644 --- a/src/Common/JSONParsers/SimdJSONParser.h +++ b/src/Common/JSONParsers/SimdJSONParser.h @@ -1,7 +1,7 @@ #pragma once #if !defined(ARCADIA_BUILD) -# include "config_jsonparsers.h" +# include #endif #if USE_SIMDJSON diff --git a/src/Common/JSONParsers/config_jsonparsers.h.in b/src/Common/JSONParsers/config_jsonparsers.h.in deleted file mode 100644 index 64352584342..00000000000 --- a/src/Common/JSONParsers/config_jsonparsers.h.in +++ /dev/null @@ -1,6 +0,0 @@ -// #pragma once - -// // .h autogenerated by cmake! - -// #cmakedefine01 USE_SIMDJSON -// #cmakedefine01 USE_RAPIDJSON From 37989cd2ae805d7a608dd76b6dcc3d4eb4598b08 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Tue, 11 May 2021 15:01:41 +0300 Subject: [PATCH 013/132] fix reading of nested --- src/Interpreters/InterpreterSelectQuery.cpp | 2 -- src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp | 2 +- src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp | 1 - 3 files changed, 1 insertion(+), 4 deletions(-) diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp index 8ff91427de3..e3dbd5f0ba2 100644 --- a/src/Interpreters/InterpreterSelectQuery.cpp +++ b/src/Interpreters/InterpreterSelectQuery.cpp @@ -375,8 +375,6 @@ InterpreterSelectQuery::InterpreterSelectQuery( if (view) view->replaceWithSubquery(getSelectQuery(), view_table, metadata_snapshot); - std::cerr << "source_header: " << source_header.dumpStructure() << "\n"; - syntax_analyzer_result = TreeRewriter(context).analyzeSelect( query_ptr, TreeRewriterResult(source_header.getNamesAndTypesList(), storage, metadata_snapshot), diff --git a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp index 797f70d2e4c..8c949d8d6e0 100644 --- a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp +++ b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp @@ -92,7 +92,7 @@ NameSet injectRequiredColumns(const MergeTreeData & storage, const StorageMetada for (size_t i = 0; i < columns.size(); ++i) { auto name_in_storage = Nested::extractTableName(columns[i]); - if (isObject(storage_columns.get(name_in_storage).type)) + if (storage_columns.has(name_in_storage) && isObject(storage_columns.get(name_in_storage).type)) { have_at_least_one_physical_column = true; continue; diff --git a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp index 87ff7d53c75..dd38f9cd30e 100644 --- a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp +++ b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp @@ -942,7 +942,6 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor Block block; while (!is_cancelled() && (block = merged_stream->read())) { - std::cerr << "read block: " << block.dumpStructure() << "\n"; rows_written += block.rows(); to.write(block); From f7582bf6e823720fb6971d646a9cc972c81ba851 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 14 May 2021 01:27:06 +0300 Subject: [PATCH 014/132] remove unused code --- src/DataTypes/Serializations/JSONDataParser.h | 2 -- src/Storages/ColumnsDescription.h | 1 - 2 files changed, 3 deletions(-) diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index edb6838a70d..cac13aab4e8 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -47,8 +47,6 @@ class JSONDataParser { public: using Element = typename ParserImpl::Element; - using Path = std::vector; - using Paths = std::vector; void readJSON(String & s, ReadBuffer & buf) { diff --git a/src/Storages/ColumnsDescription.h b/src/Storages/ColumnsDescription.h index a8707cf60a3..d03b701b27c 100644 --- a/src/Storages/ColumnsDescription.h +++ b/src/Storages/ColumnsDescription.h @@ -67,7 +67,6 @@ struct ColumnDescription { String name; DataTypePtr type; - DataTypePtr expaneded_type; ColumnDefault default_desc; String comment; ASTPtr codec; From 13ae56985f488173d1a8c8e5eca31554ac245a71 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 26 May 2021 05:41:38 +0300 Subject: [PATCH 015/132] dynamic subcolumns: better handling of missed values --- src/Columns/ColumnNullable.cpp | 7 +- src/Columns/ColumnNullable.h | 2 +- src/Columns/ColumnObject.cpp | 17 +++-- src/Columns/ColumnObject.h | 71 +++++++++---------- src/Columns/ColumnSparse.cpp | 2 +- src/Columns/ColumnVector.cpp | 5 +- src/Columns/ColumnVector.h | 2 +- src/Columns/IColumn.cpp | 6 +- src/Columns/IColumn.h | 11 ++- src/DataTypes/ObjectUtils.cpp | 58 ++++++++++----- src/DataTypes/ObjectUtils.h | 2 + src/DataTypes/Serializations/JSONDataParser.h | 10 ++- .../Serializations/SerializationObject.cpp | 54 ++++++++++++-- .../tests/gtest_json_parser.cpp | 2 +- src/DataTypes/getLeastSupertype.cpp | 16 +++-- src/Functions/FunctionsConversion.h | 1 + src/Functions/IFunction.cpp | 2 +- 17 files changed, 178 insertions(+), 90 deletions(-) diff --git a/src/Columns/ColumnNullable.cpp b/src/Columns/ColumnNullable.cpp index 2b6dd1106b3..5541e2bf681 100644 --- a/src/Columns/ColumnNullable.cpp +++ b/src/Columns/ColumnNullable.cpp @@ -707,10 +707,11 @@ void ColumnNullable::getIndicesOfNonDefaultValues(Offsets & indices, size_t from indices.push_back(i); } -ColumnPtr ColumnNullable::createWithOffsets(const IColumn::Offsets & offsets, size_t total_rows, size_t shift) const +ColumnPtr ColumnNullable::createWithOffsets(const IColumn::Offsets & offsets, const Field & default_field, size_t total_rows, size_t shift) const { - auto new_values = nested_column->createWithOffsets(offsets, total_rows, shift); - auto new_null_map = null_map->createWithOffsets(offsets, total_rows, shift); + /// TODO: check if default_field is null. + auto new_values = nested_column->createWithOffsets(offsets, default_field, total_rows, shift); + auto new_null_map = null_map->createWithOffsets(offsets, Field(1), total_rows, shift); return ColumnNullable::create(new_values, new_null_map); } diff --git a/src/Columns/ColumnNullable.h b/src/Columns/ColumnNullable.h index 55282f4569b..79a4ca12ea0 100644 --- a/src/Columns/ColumnNullable.h +++ b/src/Columns/ColumnNullable.h @@ -174,7 +174,7 @@ public: size_t getNumberOfDefaultRows(size_t step) const override; void getIndicesOfNonDefaultValues(Offsets & indices, size_t from, size_t limit) const override; - ColumnPtr createWithOffsets(const IColumn::Offsets & offsets, size_t total_rows, size_t shift) const override; + ColumnPtr createWithOffsets(const IColumn::Offsets & offsets, const Field & default_field, size_t total_rows, size_t shift) const override; private: WrappedPtr nested_column; diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 0091454ca11..523ea15ad5c 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -6,6 +6,8 @@ #include #include +#include + namespace DB { @@ -154,7 +156,7 @@ Names ColumnObject::getKeys() const void ColumnObject::optimizeTypesOfSubcolumns() { - if (optimized_subcolumn_types) + if (optimized_types_of_subcolumns) return; for (auto & [_, subcolumn] : subcolumns) @@ -164,7 +166,7 @@ void ColumnObject::optimizeTypesOfSubcolumns() continue; size_t subcolumn_size = subcolumn.size(); - if (subcolumn.data->getNumberOfDefaultRows(1) == 0) + if (subcolumn.data->getNumberOfDefaultRows(/*step=*/ 1) == 0) { subcolumn.data = castColumn({subcolumn.data, from_type, ""}, subcolumn.least_common_type); } @@ -174,13 +176,16 @@ void ColumnObject::optimizeTypesOfSubcolumns() auto & offsets_data = offsets->getData(); subcolumn.data->getIndicesOfNonDefaultValues(offsets_data, 0, subcolumn_size); - auto values = subcolumn.data->index(*offsets, subcolumn_size); - values = castColumn({subcolumn.data, from_type, ""}, subcolumn.least_common_type); - subcolumn.data = values->createWithOffsets(offsets_data, subcolumn_size, /*shift=*/ 0); + + auto values = subcolumn.data->index(*offsets, offsets->size()); + values = castColumn({values, from_type, ""}, subcolumn.least_common_type); + + subcolumn.data = values->createWithOffsets( + offsets_data, subcolumn.least_common_type->getDefault(), subcolumn_size, /*shift=*/ 0); } } - optimized_subcolumn_types = true; + optimized_types_of_subcolumns = true; } } diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index d924b4c0e84..07412cbf4bc 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -38,7 +38,7 @@ public: private: SubcolumnsMap subcolumns; - bool optimized_subcolumn_types = false; + bool optimized_types_of_subcolumns = false; public: ColumnObject() = default; @@ -74,47 +74,40 @@ public: /// All other methods throw exception. - ColumnPtr decompress() const override { throwMustBeDecompressed(); } - - TypeIndex getDataType() const override { throwMustBeDecompressed(); } - Field operator[](size_t) const override { throwMustBeDecompressed(); } - void get(size_t, Field &) const override { throwMustBeDecompressed(); } - StringRef getDataAt(size_t) const override { throwMustBeDecompressed(); } - void insert(const Field &) override { throwMustBeDecompressed(); } - void insertRangeFrom(const IColumn &, size_t, size_t) override { throwMustBeDecompressed(); } - void insertData(const char *, size_t) override { throwMustBeDecompressed(); } - void insertDefault() override { throwMustBeDecompressed(); } - void popBack(size_t) override { throwMustBeDecompressed(); } - StringRef serializeValueIntoArena(size_t, Arena &, char const *&) const override { throwMustBeDecompressed(); } - const char * deserializeAndInsertFromArena(const char *) override { throwMustBeDecompressed(); } - const char * skipSerializedInArena(const char *) const override { throwMustBeDecompressed(); } - void updateHashWithValue(size_t, SipHash &) const override { throwMustBeDecompressed(); } - void updateWeakHash32(WeakHash32 &) const override { throwMustBeDecompressed(); } - void updateHashFast(SipHash &) const override { throwMustBeDecompressed(); } - ColumnPtr filter(const Filter &, ssize_t) const override { throwMustBeDecompressed(); } - ColumnPtr permute(const Permutation &, size_t) const override { throwMustBeDecompressed(); } - ColumnPtr index(const IColumn &, size_t) const override { throwMustBeDecompressed(); } - int compareAt(size_t, size_t, const IColumn &, int) const override { throwMustBeDecompressed(); } - void compareColumn(const IColumn &, size_t, PaddedPODArray *, PaddedPODArray &, int, int) const override - { - throwMustBeDecompressed(); - } - bool hasEqualValues() const override - { - throwMustBeDecompressed(); - } - void getPermutation(bool, size_t, int, Permutation &) const override { throwMustBeDecompressed(); } - void updatePermutation(bool, size_t, int, Permutation &, EqualRanges &) const override { throwMustBeDecompressed(); } - ColumnPtr replicate(const Offsets &) const override { throwMustBeDecompressed(); } - MutableColumns scatter(ColumnIndex, const Selector &) const override { throwMustBeDecompressed(); } - void gather(ColumnGathererStream &) override { throwMustBeDecompressed(); } - void getExtremes(Field &, Field &) const override { throwMustBeDecompressed(); } - size_t byteSizeAt(size_t) const override { throwMustBeDecompressed(); } + ColumnPtr decompress() const override { throwMustBeConcrete(); } + TypeIndex getDataType() const override { throwMustBeConcrete(); } + Field operator[](size_t) const override { throwMustBeConcrete(); } + void get(size_t, Field &) const override { throwMustBeConcrete(); } + StringRef getDataAt(size_t) const override { throwMustBeConcrete(); } + void insert(const Field &) override { throwMustBeConcrete(); } + void insertRangeFrom(const IColumn &, size_t, size_t) override { throwMustBeConcrete(); } + void insertData(const char *, size_t) override { throwMustBeConcrete(); } + void insertDefault() override { throwMustBeConcrete(); } + void popBack(size_t) override { throwMustBeConcrete(); } + StringRef serializeValueIntoArena(size_t, Arena &, char const *&) const override { throwMustBeConcrete(); } + const char * deserializeAndInsertFromArena(const char *) override { throwMustBeConcrete(); } + const char * skipSerializedInArena(const char *) const override { throwMustBeConcrete(); } + void updateHashWithValue(size_t, SipHash &) const override { throwMustBeConcrete(); } + void updateWeakHash32(WeakHash32 &) const override { throwMustBeConcrete(); } + void updateHashFast(SipHash &) const override { throwMustBeConcrete(); } + ColumnPtr filter(const Filter &, ssize_t) const override { throwMustBeConcrete(); } + ColumnPtr permute(const Permutation &, size_t) const override { throwMustBeConcrete(); } + ColumnPtr index(const IColumn &, size_t) const override { throwMustBeConcrete(); } + int compareAt(size_t, size_t, const IColumn &, int) const override { throwMustBeConcrete(); } + void compareColumn(const IColumn &, size_t, PaddedPODArray *, PaddedPODArray &, int, int) const override { throwMustBeConcrete(); } + bool hasEqualValues() const override { throwMustBeConcrete(); } + void getPermutation(bool, size_t, int, Permutation &) const override { throwMustBeConcrete(); } + void updatePermutation(bool, size_t, int, Permutation &, EqualRanges &) const override { throwMustBeConcrete(); } + ColumnPtr replicate(const Offsets &) const override { throwMustBeConcrete(); } + MutableColumns scatter(ColumnIndex, const Selector &) const override { throwMustBeConcrete(); } + void gather(ColumnGathererStream &) override { throwMustBeConcrete(); } + void getExtremes(Field &, Field &) const override { throwMustBeConcrete(); } + size_t byteSizeAt(size_t) const override { throwMustBeConcrete(); } private: - [[noreturn]] void throwMustBeDecompressed() const + [[noreturn]] void throwMustBeConcrete() const { - throw Exception("ColumnCompressed must be decompressed before use", ErrorCodes::LOGICAL_ERROR); + throw Exception("ColumnObject must be converted to ColumnTuple before use", ErrorCodes::LOGICAL_ERROR); } }; diff --git a/src/Columns/ColumnSparse.cpp b/src/Columns/ColumnSparse.cpp index 5aeddd6e2dd..ec37f136374 100644 --- a/src/Columns/ColumnSparse.cpp +++ b/src/Columns/ColumnSparse.cpp @@ -118,7 +118,7 @@ StringRef ColumnSparse::getDataAt(size_t n) const ColumnPtr ColumnSparse::convertToFullColumnIfSparse() const { - return values->createWithOffsets(getOffsetsData(), _size, 1); + return values->createWithOffsets(getOffsetsData(), (*values)[0], _size, /*shift=*/ 1); } void ColumnSparse::insertData(const char * pos, size_t length) diff --git a/src/Columns/ColumnVector.cpp b/src/Columns/ColumnVector.cpp index 44c6132f23c..72bcdc499d6 100644 --- a/src/Columns/ColumnVector.cpp +++ b/src/Columns/ColumnVector.cpp @@ -583,7 +583,7 @@ void ColumnVector::getIndicesOfNonDefaultValues(IColumn::Offsets & indices, s } template -ColumnPtr ColumnVector::createWithOffsets(const IColumn::Offsets & offsets, size_t total_rows, size_t shift) const +ColumnPtr ColumnVector::createWithOffsets(const IColumn::Offsets & offsets, const Field & default_field, size_t total_rows, size_t shift) const { if (offsets.size() + shift != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, @@ -592,7 +592,8 @@ ColumnPtr ColumnVector::createWithOffsets(const IColumn::Offsets & offsets, s auto res = this->create(); auto & res_data = res->getData(); - res_data.resize_fill(total_rows, data[0]); + T default_value = safeGet(default_field); + res_data.resize_fill(total_rows, default_value); for (size_t i = 0; i < offsets.size(); ++i) res_data[offsets[i]] = data[i + shift]; diff --git a/src/Columns/ColumnVector.h b/src/Columns/ColumnVector.h index 3001c88a516..6e5578d9994 100644 --- a/src/Columns/ColumnVector.h +++ b/src/Columns/ColumnVector.h @@ -323,7 +323,7 @@ public: size_t getNumberOfDefaultRows(size_t step) const override; void getIndicesOfNonDefaultValues(IColumn::Offsets & indices, size_t from, size_t limit) const override; - ColumnPtr createWithOffsets(const IColumn::Offsets & offsets, size_t total_rows, size_t shift) const override; + ColumnPtr createWithOffsets(const IColumn::Offsets & offsets, const Field & default_field, size_t total_rows, size_t shift) const override; ColumnPtr compress() const override; diff --git a/src/Columns/IColumn.cpp b/src/Columns/IColumn.cpp index 45c7967072f..ebed783cdd3 100644 --- a/src/Columns/IColumn.cpp +++ b/src/Columns/IColumn.cpp @@ -44,7 +44,7 @@ void IColumn::getIndicesOfNonDefaultValues(Offsets & indices, size_t from, size_ indices.push_back(i); } -ColumnPtr IColumn::createWithOffsets(const Offsets & offsets, size_t total_rows, size_t shift) const +ColumnPtr IColumn::createWithOffsets(const Offsets & offsets, const Field & default_field, size_t total_rows, size_t shift) const { if (offsets.size() + shift != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, @@ -60,14 +60,14 @@ ColumnPtr IColumn::createWithOffsets(const Offsets & offsets, size_t total_rows, current_offset = offsets[i]; if (offsets_diff > 1) - res->insertManyFrom(*this, 0, offsets_diff - 1); + res->insertMany(default_field, offsets_diff - 1); res->insertFrom(*this, i + shift); } ssize_t offsets_diff = static_cast(total_rows) - current_offset; if (offsets_diff > 1) - res->insertManyFrom(*this, 0, offsets_diff - 1); + res->insertMany(default_field, offsets_diff - 1); return res; } diff --git a/src/Columns/IColumn.h b/src/Columns/IColumn.h index 7c0b6647a23..968ffe99a61 100644 --- a/src/Columns/IColumn.h +++ b/src/Columns/IColumn.h @@ -182,6 +182,13 @@ public: insertFrom(src, position); } + /// Appends one field multiple times. Can be optimized in inherited classes. + virtual void insertMany(const Field & field, size_t length) + { + for (size_t i = 0; i < length; ++i) + insert(field); + } + /// Appends data located in specified memory chunk if it is possible (throws an exception if it cannot be implemented). /// Is used to optimize some computations (in aggregation, for example). /// Parameter length could be ignored if column values have fixed size. @@ -390,10 +397,10 @@ public: /// Returns column with @total_size elements. /// In result column values from current column are at positions from @offsets. - /// Other values are filled by defaults. + /// Other values are filled by @default_value. /// @shift means how much rows to skip from the beginning of current column. /// Used to create full column from sparse. - virtual Ptr createWithOffsets(const Offsets & offsets, size_t total_rows, size_t shift) const; + virtual Ptr createWithOffsets(const Offsets & offsets, const Field & default_field, size_t total_rows, size_t shift) const; /// Compress column in memory to some representation that allows to decompress it back. /// Return itself if compression is not applicable for this column type. diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 7e63165149e..c134920e732 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -3,12 +3,14 @@ #include #include #include +#include #include #include #include #include #include #include +#include #include #include @@ -40,6 +42,13 @@ size_t getNumberOfDimensions(const IColumn & column) return 0; } +DataTypePtr getBaseTypeOfArray(DataTypePtr type) +{ + while (const auto * type_array = typeid_cast(type.get())) + type = type_array->getNestedType(); + return type; +} + DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension) { for (size_t i = 0; i < dimension; ++i) @@ -50,16 +59,30 @@ DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension) DataTypePtr getDataTypeByColumn(const IColumn & column) { auto idx = column.getDataType(); - if (WhichDataType(column.getDataType()).isSimple()) + if (WhichDataType(idx).isSimple()) return DataTypeFactory::instance().get(getTypeName(idx)); - if (const auto * column_array = typeid_cast(&column)) + if (const auto * column_array = checkAndGetColumn(&column)) return std::make_shared(getDataTypeByColumn(column_array->getData())); + if (const auto * column_nullable = checkAndGetColumn(&column)) + return makeNullable(getDataTypeByColumn(column_nullable->getNestedColumn())); + /// TODO: add more types. throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot get data type of column {}", column.getFamilyName()); } +template +static auto extractVector(const std::vector & vec) +{ + static_assert(I < std::tuple_size_v); + std::vector> res; + res.reserve(vec.size()); + for (const auto & elem : vec) + res.emplace_back(std::get(elem)); + return res; +} + void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) { for (auto & name_type : columns_list) @@ -76,16 +99,16 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) const auto & column_object = assert_cast(*column.column); const auto & subcolumns_map = column_object.getSubcolumns(); - Names tuple_names; - DataTypes tuple_types; - Columns tuple_columns; - + std::vector> tuple_elements; for (const auto & [key, subcolumn] : subcolumns_map) - { - tuple_names.push_back(key); - tuple_types.push_back(getDataTypeByColumn(*subcolumn.data)); - tuple_columns.push_back(subcolumn.data); - } + tuple_elements.emplace_back(key, getDataTypeByColumn(*subcolumn.data), subcolumn.data); + + std::sort(tuple_elements.begin(), tuple_elements.end(), + [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); } ); + + auto tuple_names = extractVector<0>(tuple_elements); + auto tuple_types = extractVector<1>(tuple_elements); + auto tuple_columns = extractVector<2>(tuple_elements); auto type_tuple = std::make_shared(tuple_types, tuple_names); auto column_tuple = ColumnTuple::create(tuple_columns); @@ -115,9 +138,7 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) subcolumns_types[tuple_names[i]].push_back(tuple_types[i]); } - Names tuple_names; - DataTypes tuple_types; - + std::vector> tuple_elements; for (const auto & [name, subtypes] : subcolumns_types) { assert(!subtypes.empty()); @@ -129,10 +150,15 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) "Uncompatible types of subcolumn '{}': {} and {}", name, subtypes[0]->getName(), subtypes[i]->getName()); - tuple_names.push_back(name); - tuple_types.push_back(getLeastSupertype(subtypes, /*allow_conversion_to_string=*/ true)); + tuple_elements.emplace_back(name, getLeastSupertype(subtypes, /*allow_conversion_to_string=*/ true)); } + std::sort(tuple_elements.begin(), tuple_elements.end(), + [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); } ); + + auto tuple_names = extractVector<0>(tuple_elements); + auto tuple_types = extractVector<1>(tuple_elements); + return std::make_shared(tuple_types, tuple_names); } diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index b8b508530ba..a143dd009fb 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -2,12 +2,14 @@ #include #include +#include namespace DB { size_t getNumberOfDimensions(const IDataType & type); size_t getNumberOfDimensions(const IColumn & column); +DataTypePtr getBaseTypeOfArray(DataTypePtr type); DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); DataTypePtr getDataTypeByColumn(const IColumn & column); diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index cac13aab4e8..059ed592464 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -28,9 +28,13 @@ Field getValueAsField(const Element & element) String getNextPath(const String & current_path, const std::string_view & key) { String next_path = current_path; - if (!next_path.empty()) - next_path += "."; - next_path += key; + if (!key.empty()) + { + if (!next_path.empty()) + next_path += "."; + next_path += key; + } + return next_path; } diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 5f3a78f5041..ada3a909b46 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -25,6 +26,40 @@ namespace ErrorCodes extern const int TYPE_MISMATCH; } +namespace +{ + +class FieldVisitorReplaceNull : public StaticVisitor +{ +public: + FieldVisitorReplaceNull(const Field & replacement_) + : replacement(replacement_) + { + } + + Field operator() (const Null &) const { return replacement; } + + template + Field operator() (const T & x) const + { + if constexpr (std::is_base_of_v) + { + const size_t size = x.size(); + T res(size); + for (size_t i = 0; i < size; ++i) + res[i] = applyVisitor(*this, x[i]); + return res; + } + else + return x; + } + +private: + Field replacement; +}; + +} + template template void SerializationObject::deserializeTextImpl(IColumn & column, Reader && reader) const @@ -49,11 +84,21 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & size_t column_size = column_object.size(); for (size_t i = 0; i < paths.size(); ++i) { - auto value_type = applyVisitor(FieldToDataType(/*allow_conversion_to_string=*/true), values[i]); + Field value = std::move(values[i]); + auto value_type = applyVisitor(FieldToDataType(/*allow_conversion_to_string=*/ true), value); auto value_dim = getNumberOfDimensions(*value_type); + auto base_type = getBaseTypeOfArray(value_type); + + if (base_type->isNullable()) + { + base_type = removeNullable(base_type); + value = applyVisitor(FieldVisitorReplaceNull(base_type->getDefault()), value); + value_type = createArrayOfType(base_type, value_dim); + } + auto array_type = createArrayOfType(std::make_shared(), value_dim); - auto converted_value = convertFieldToTypeOrThrow(values[i], *array_type, value_type.get()); + auto converted_value = convertFieldToTypeOrThrow(value, *array_type); if (!column_object.hasSubcolumn(paths[i])) column_object.addSubcolumn(paths[i], array_type->createColumn(), column_size); @@ -63,8 +108,9 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & if (value_dim != column_dim) throw Exception(ErrorCodes::TYPE_MISMATCH, - "Dimension of types mismatched beetwen value and column. Dimension of value: {}. Dimension of column: {}", - value_dim, column_dim); + "Dimension of types mismatched beetwen inserted value and column at key '{}'. " + "Dimension of value: {}. Dimension of column: {}", + paths[i], value_dim, column_dim); subcolumn.insert(converted_value, value_type); } diff --git a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp index 2eece7f4fef..f7d84db5e7f 100644 --- a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp +++ b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp @@ -55,7 +55,7 @@ TEST(JSONDataParser, Parse) const auto & [paths, values] = *res; ASSERT_EQ(paths, (Strings{"k1", "k2.k3", "k2.k4"})); - ASSERT_EQ(values, (std::vector{"1", "aa", "2"})); + ASSERT_EQ(values, (std::vector{1, "aa", 2})); } { diff --git a/src/DataTypes/getLeastSupertype.cpp b/src/DataTypes/getLeastSupertype.cpp index 764dd7c04d4..82dbe4f5cd9 100644 --- a/src/DataTypes/getLeastSupertype.cpp +++ b/src/DataTypes/getLeastSupertype.cpp @@ -96,7 +96,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_ non_nothing_types.emplace_back(type); if (non_nothing_types.size() < types.size()) - return getLeastSupertype(non_nothing_types); + return getLeastSupertype(non_nothing_types, allow_conversion_to_string); } /// For Arrays @@ -123,7 +123,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_ if (!all_arrays) return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are Array and some of them are not", ErrorCodes::NO_COMMON_TYPE); - return std::make_shared(getLeastSupertype(nested_types)); + return std::make_shared(getLeastSupertype(nested_types, allow_conversion_to_string)); } } @@ -165,7 +165,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_ DataTypes common_tuple_types(tuple_size); for (size_t elem_idx = 0; elem_idx < tuple_size; ++elem_idx) - common_tuple_types[elem_idx] = getLeastSupertype(nested_types[elem_idx]); + common_tuple_types[elem_idx] = getLeastSupertype(nested_types[elem_idx], allow_conversion_to_string); return std::make_shared(common_tuple_types); } @@ -197,7 +197,9 @@ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_ if (!all_maps) return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are Maps and some of them are not", ErrorCodes::NO_COMMON_TYPE); - return std::make_shared(getLeastSupertype(key_types), getLeastSupertype(value_types)); + return std::make_shared( + getLeastSupertype(key_types, allow_conversion_to_string), + getLeastSupertype(value_types, allow_conversion_to_string)); } } @@ -228,9 +230,9 @@ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_ if (have_low_cardinality) { if (have_not_low_cardinality) - return getLeastSupertype(nested_types); + return getLeastSupertype(nested_types, allow_conversion_to_string); else - return std::make_shared(getLeastSupertype(nested_types)); + return std::make_shared(getLeastSupertype(nested_types, allow_conversion_to_string)); } } @@ -256,7 +258,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_ if (have_nullable) { - return std::make_shared(getLeastSupertype(nested_types)); + return std::make_shared(getLeastSupertype(nested_types, allow_conversion_to_string)); } } diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index 6168b723281..7e26e479f42 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -2599,6 +2599,7 @@ private: if (from_type->haveExplicitNames() && to_type->haveExplicitNames()) { + std::cerr << "converting tuples...\n"; const auto & from_names = from_type->getElementNames(); std::unordered_map from_positions; from_positions.reserve(from_names.size()); diff --git a/src/Functions/IFunction.cpp b/src/Functions/IFunction.cpp index a4f40a383c7..b38fca694cf 100644 --- a/src/Functions/IFunction.cpp +++ b/src/Functions/IFunction.cpp @@ -323,7 +323,7 @@ ColumnPtr IExecutableFunction::execute(const ColumnsWithTypeAndName & arguments, if (!res->isDefaultAt(0)) { const auto & offsets_data = assert_cast &>(*sparse_offsets).getData(); - return res->createWithOffsets(offsets_data, input_rows_count, /*shift=*/ 1); + return res->createWithOffsets(offsets_data, (*res)[0], input_rows_count, /*shift=*/ 1); } return ColumnSparse::create(res, sparse_offsets, input_rows_count); From b0cc45c361a3d0dff1e10966d963e1ba47bcdfb0 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 26 May 2021 05:43:22 +0300 Subject: [PATCH 016/132] dynamic subcolumns: add test --- .../0_stateless/01825_type_json.reference | 8 ++-- .../0_stateless/01825_type_json_2.reference | 24 ++++++++++++ .../queries/0_stateless/01825_type_json_2.sql | 38 +++++++++++++++++++ 3 files changed, 66 insertions(+), 4 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_2.reference create mode 100644 tests/queries/0_stateless/01825_type_json_2.sql diff --git a/tests/queries/0_stateless/01825_type_json.reference b/tests/queries/0_stateless/01825_type_json.reference index 5e957434033..4c21f14d4e9 100644 --- a/tests/queries/0_stateless/01825_type_json.reference +++ b/tests/queries/0_stateless/01825_type_json.reference @@ -1,12 +1,12 @@ 1 aa bb c 2 ee ff 3 foo -all_1_1_0 data Tuple(k1 String, `k2.k4` String, `k2.k3` String, k5 String) +all_1_1_0 data Tuple(k1 String, `k2.k3` String, `k2.k4` String, k5 String) all_2_2_0 data Tuple(k5 String) -all_1_2_1 data Tuple(k5 String, `k2.k3` String, `k2.k4` String, k1 String) +all_1_2_1 data Tuple(k1 String, `k2.k3` String, `k2.k4` String, k5 String) ============ 1 ['aaa','ddd'] [['bbb','ccc'],['eee','fff']] -all_3_3_0 data Tuple(`k1.k3.k4` Array(Array(String)), `k1.k2` Array(String)) +all_3_3_0 data Tuple(`k1.k2` Array(String), `k1.k3.k4` Array(Array(String))) ============ 1 a 42 2 b 4200 @@ -24,4 +24,4 @@ all_5_5_0 data Tuple(name String, value Float64) all_4_4_0 data Tuple(name String, value Int16) all_5_5_0 data Tuple(name String, value Float64) all_6_6_0 data Tuple(name String, value String) -all_4_6_1 data Tuple(value String, name String) +all_4_6_1 data Tuple(name String, value String) diff --git a/tests/queries/0_stateless/01825_type_json_2.reference b/tests/queries/0_stateless/01825_type_json_2.reference new file mode 100644 index 00000000000..6afe2ebcb60 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_2.reference @@ -0,0 +1,24 @@ +1 (1,2,0) Tuple(k1 Int8, k2 Int8, k3 Int8) +2 (0,3,4) Tuple(k1 Int8, k2 Int8, k3 Int8) +1 1 2 0 +2 0 3 4 +1 (1,2,'0') Tuple(k1 Int8, k2 Int8, k3 String) +2 (0,3,'4') Tuple(k1 Int8, k2 Int8, k3 String) +3 (0,0,'10') Tuple(k1 Int8, k2 Int8, k3 String) +4 (0,5,'str') Tuple(k1 Int8, k2 Int8, k3 String) +1 1 2 0 +2 0 3 4 +3 0 0 10 +4 0 5 str +============ +1 ([1,2,3.3]) Tuple(k1 Array(Float64)) +1 [1,2,3.3] +1 (['1','2','3.3']) Tuple(k1 Array(String)) +2 (['a','4','b']) Tuple(k1 Array(String)) +1 ['1','2','3.3'] +2 ['a','4','b'] +============ +1 ([11,0],[0,22],[]) Tuple(`k1.k2` Array(Int8), `k1.k3` Array(Int8), `k1.k4` Array(Int8)) +2 ([],[33,0,55],[0,44,66]) Tuple(`k1.k2` Array(Int8), `k1.k3` Array(Int8), `k1.k4` Array(Int8)) +1 [11,0] [0,22] [] +2 [] [33,0,55] [0,44,66] diff --git a/tests/queries/0_stateless/01825_type_json_2.sql b/tests/queries/0_stateless/01825_type_json_2.sql new file mode 100644 index 00000000000..fbea36978c6 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_2.sql @@ -0,0 +1,38 @@ +DROP TABLE IF EXISTS t_json_2; + +CREATE TABLE t_json_2(id UInt64, data Object('JSON')) +ENGINE = MergeTree ORDER BY tuple() +SETTINGS min_bytes_for_wide_part = 0; + +INSERT INTO t_json_2 FORMAT JSONEachRow {"id": 1, "data": {"k1": 1, "k2" : 2}} {"id": 2, "data": {"k2": 3, "k3" : 4}}; + +SELECT id, data, toTypeName(data) FROM t_json_2 ORDER BY id; +SELECT id, data.k1, data.k2, data.k3 FROM t_json_2 ORDER BY id; + +INSERT INTO t_json_2 FORMAT JSONEachRow {"id": 3, "data": {"k3" : 10}} {"id": 4, "data": {"k2": 5, "k3" : "str"}}; + +SELECT id, data, toTypeName(data) FROM t_json_2 ORDER BY id; +SELECT id, data.k1, data.k2, data.k3 FROM t_json_2 ORDER BY id; + +SELECT '============'; +TRUNCATE TABLE t_json_2; + +INSERT INTO TABLE t_json_2 FORMAT JSONEachRow {"id": 1, "data": {"k1" : [1, 2, 3.3]}}; + +SELECT id, data, toTypeName(data) FROM t_json_2 ORDER BY id; +SELECT id, data.k1 FROM t_json_2 ORDEr BY id; + +INSERT INTO TABLE t_json_2 FORMAT JSONEachRow {"id": 2, "data": {"k1" : ["a", 4, "b"]}}; + +SELECT id, data, toTypeName(data) FROM t_json_2 ORDER BY id; +SELECT id, data.k1 FROM t_json_2 ORDER BY id; + +SELECT '============'; +TRUNCATE TABLE t_json_2; + +INSERT INTO TABLE t_json_2 FORMAT JSONEachRow {"id": 1, "data": {"k1" : [{"k2" : 11}, {"k3" : 22}]}} {"id": 2, "data": {"k1" : [{"k3" : 33}, {"k4" : 44}, {"k3" : 55, "k4" : 66}]}}; + +SELECT id, data, toTypeName(data) FROM t_json_2 ORDER BY id; +SELECT id, data.k1.k2, data.k1.k3, data.k1.k4 FROM t_json_2 ORDER BY id; + +DROP TABLE t_json_2; From d83819fcaeaeae9906caeabff692d1556040e4d2 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 26 May 2021 18:34:34 +0300 Subject: [PATCH 017/132] fix build --- src/Columns/IColumn.h | 2 +- src/DataTypes/Serializations/SerializationObject.cpp | 3 +-- src/Functions/FunctionsConversion.h | 1 - 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/src/Columns/IColumn.h b/src/Columns/IColumn.h index 968ffe99a61..e8e58888c54 100644 --- a/src/Columns/IColumn.h +++ b/src/Columns/IColumn.h @@ -397,7 +397,7 @@ public: /// Returns column with @total_size elements. /// In result column values from current column are at positions from @offsets. - /// Other values are filled by @default_value. + /// Other values are filled by @default_field. /// @shift means how much rows to skip from the beginning of current column. /// Used to create full column from sparse. virtual Ptr createWithOffsets(const Offsets & offsets, const Field & default_field, size_t total_rows, size_t shift) const; diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index ada3a909b46..5810b2f57b5 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -28,11 +28,10 @@ namespace ErrorCodes namespace { - class FieldVisitorReplaceNull : public StaticVisitor { public: - FieldVisitorReplaceNull(const Field & replacement_) + [[maybe_unused]] explicit FieldVisitorReplaceNull(const Field & replacement_) : replacement(replacement_) { } diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index 7e26e479f42..6168b723281 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -2599,7 +2599,6 @@ private: if (from_type->haveExplicitNames() && to_type->haveExplicitNames()) { - std::cerr << "converting tuples...\n"; const auto & from_names = from_type->getElementNames(); std::unordered_map from_positions; from_positions.reserve(from_names.size()); From 7e5f784597bd3fc1e2c848f8dad0a9c3f859572b Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 27 May 2021 19:54:27 +0300 Subject: [PATCH 018/132] dynamic subcolumns: better handling of nulls and empty arrays --- src/Columns/ColumnObject.cpp | 35 ++++++++++--- src/Columns/ColumnObject.h | 7 ++- src/DataTypes/DataTypeObject.cpp | 3 ++ src/DataTypes/ObjectUtils.cpp | 6 +++ src/DataTypes/Serializations/JSONDataParser.h | 21 +++++--- .../Serializations/SerializationObject.cpp | 7 ++- .../0_stateless/01825_type_json_3.reference | 31 +++++++++++ .../queries/0_stateless/01825_type_json_3.sql | 51 +++++++++++++++++++ 8 files changed, 144 insertions(+), 17 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_3.reference create mode 100644 tests/queries/0_stateless/01825_type_json_3.sql diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 523ea15ad5c..d0ac443c248 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include @@ -90,6 +91,12 @@ size_t ColumnObject::allocatedBytes() const return res; } +void ColumnObject::forEachSubcolumn(ColumnCallback callback) +{ + for (auto & [_, column] : subcolumns) + callback(column.data); +} + const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const String & key) const { auto it = subcolumns.find(key); @@ -159,16 +166,26 @@ void ColumnObject::optimizeTypesOfSubcolumns() if (optimized_types_of_subcolumns) return; - for (auto & [_, subcolumn] : subcolumns) + size_t old_size = size(); + SubcolumnsMap new_subcolumns; + for (auto && [name, subcolumn] : subcolumns) { auto from_type = getDataTypeByColumn(*subcolumn.data); - if (subcolumn.least_common_type->equals(*from_type)) + auto to_type = subcolumn.least_common_type; + + if (isNothing(getBaseTypeOfArray(to_type))) continue; + if (to_type->equals(*from_type)) + { + new_subcolumns[name] = std::move(subcolumn); + continue; + } + size_t subcolumn_size = subcolumn.size(); if (subcolumn.data->getNumberOfDefaultRows(/*step=*/ 1) == 0) { - subcolumn.data = castColumn({subcolumn.data, from_type, ""}, subcolumn.least_common_type); + subcolumn.data = castColumn({subcolumn.data, from_type, ""}, to_type); } else { @@ -176,15 +193,19 @@ void ColumnObject::optimizeTypesOfSubcolumns() auto & offsets_data = offsets->getData(); subcolumn.data->getIndicesOfNonDefaultValues(offsets_data, 0, subcolumn_size); - auto values = subcolumn.data->index(*offsets, offsets->size()); - values = castColumn({values, from_type, ""}, subcolumn.least_common_type); - subcolumn.data = values->createWithOffsets( - offsets_data, subcolumn.least_common_type->getDefault(), subcolumn_size, /*shift=*/ 0); + values = castColumn({values, from_type, ""}, to_type); + subcolumn.data = values->createWithOffsets(offsets_data, to_type->getDefault(), subcolumn_size, /*shift=*/ 0); } + + new_subcolumns[name] = std::move(subcolumn); } + if (new_subcolumns.empty()) + new_subcolumns[COLUMN_NAME_DUMMY] = Subcolumn{ColumnUInt8::create(old_size)}; + + std::swap(subcolumns, new_subcolumns); optimized_types_of_subcolumns = true; } diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 07412cbf4bc..c02418e092d 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -39,8 +39,11 @@ public: private: SubcolumnsMap subcolumns; bool optimized_types_of_subcolumns = false; + size_t size_with_no_subcolumns = 0; public: + static constexpr auto COLUMN_NAME_DUMMY = "_dummy"; + ColumnObject() = default; ColumnObject(SubcolumnsMap && subcolumns_); @@ -65,12 +68,12 @@ public: const char * getFamilyName() const override { return "Object"; } - size_t size() const override { return subcolumns.empty() ? 0 : subcolumns.begin()->second.size(); } + size_t size() const override { return subcolumns.empty() ? size_with_no_subcolumns : subcolumns.begin()->second.size(); } MutableColumnPtr cloneResized(size_t new_size) const override; - size_t byteSize() const override; size_t allocatedBytes() const override; + void forEachSubcolumn(ColumnCallback callback) override; /// All other methods throw exception. diff --git a/src/DataTypes/DataTypeObject.cpp b/src/DataTypes/DataTypeObject.cpp index 52a02e79f66..5f07d9905f4 100644 --- a/src/DataTypes/DataTypeObject.cpp +++ b/src/DataTypes/DataTypeObject.cpp @@ -58,6 +58,9 @@ static DataTypePtr create(const ASTPtr & arguments) void registerDataTypeObject(DataTypeFactory & factory) { factory.registerDataType("Object", create); + factory.registerSimpleDataType("JSON", + [] { return std::make_shared("JSON"); }, + DataTypeFactory::CaseInsensitive); } } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index c134920e732..de330b7e2b2 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -142,6 +143,8 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) for (const auto & [name, subtypes] : subcolumns_types) { assert(!subtypes.empty()); + if (name == ColumnObject::COLUMN_NAME_DUMMY) + continue; size_t first_dim = getNumberOfDimensions(*subtypes[0]); for (size_t i = 1; i < subtypes.size(); ++i) @@ -153,6 +156,9 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) tuple_elements.emplace_back(name, getLeastSupertype(subtypes, /*allow_conversion_to_string=*/ true)); } + if (tuple_elements.empty()) + tuple_elements.emplace_back(ColumnObject::COLUMN_NAME_DUMMY, std::make_shared()); + std::sort(tuple_elements.begin(), tuple_elements.end(), [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); } ); diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index 059ed592464..aab4a5b5c99 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -21,6 +21,7 @@ Field getValueAsField(const Element & element) if (element.isUInt64()) return element.getUInt64(); if (element.isDouble()) return element.getDouble(); if (element.isString()) return element.getString(); + if (element.isNull()) return Field(); throw Exception(ErrorCodes::LOGICAL_ERROR, "Unsupported type of JSON field"); } @@ -122,13 +123,21 @@ private: ++current_size; } - result.paths.reserve(result.paths.size() + arrays_by_path.size()); - result.values.reserve(result.paths.size() + arrays_by_path.size()); - - for (const auto & [path, path_array] : arrays_by_path) + if (arrays_by_path.empty()) { - result.paths.push_back(getNextPath(current_path, path)); - result.values.push_back(path_array); + result.paths.push_back(current_path); + result.values.push_back(Array()); + } + else + { + result.paths.reserve(result.paths.size() + arrays_by_path.size()); + result.values.reserve(result.paths.size() + arrays_by_path.size()); + + for (const auto & [path, path_array] : arrays_by_path) + { + result.paths.push_back(getNextPath(current_path, path)); + result.values.push_back(path_array); + } } } else diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 5810b2f57b5..d38bfd5c769 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -92,12 +92,15 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & if (base_type->isNullable()) { base_type = removeNullable(base_type); - value = applyVisitor(FieldVisitorReplaceNull(base_type->getDefault()), value); + auto default_field = isNothing(base_type) ? Field(String()) : base_type->getDefault(); + value = applyVisitor(FieldVisitorReplaceNull(default_field), value); value_type = createArrayOfType(base_type, value_dim); } auto array_type = createArrayOfType(std::make_shared(), value_dim); - auto converted_value = convertFieldToTypeOrThrow(value, *array_type); + auto converted_value = isNothing(base_type) + ? std::move(value) + : convertFieldToTypeOrThrow(value, *array_type); if (!column_object.hasSubcolumn(paths[i])) column_object.addSubcolumn(paths[i], array_type->createColumn(), column_size); diff --git a/tests/queries/0_stateless/01825_type_json_3.reference b/tests/queries/0_stateless/01825_type_json_3.reference new file mode 100644 index 00000000000..830d44d779c --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_3.reference @@ -0,0 +1,31 @@ +1 ('',0) Tuple(k1 String, k2 Int8) +2 ('v1',2) Tuple(k1 String, k2 Int8) +1 0 +2 v1 2 +======== +1 ([],[]) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +2 (['v1','v4'],['v3','']) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +1 [] [] +2 ['v1','v4'] ['v3',''] +1 ([],[]) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +2 (['v1','v4'],['v3','']) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +3 ([],[]) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +4 ([],[]) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +all_2_2_0 data Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +all_3_3_0 data Tuple(_dummy UInt8) +1 [] [] +2 ['v1','v4'] ['v3',''] +3 [] [] +4 [] [] +data Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +1 [] [] +2 ['v1','v4'] ['v3',''] +3 [] [] +4 [] [] +======== +1 (1,'foo',[]) Tuple(`k1.k2` Int8, `k1.k3` String, k4 Array(Int8)) +2 (0,'',[1,2,3]) Tuple(`k1.k2` Int8, `k1.k3` String, k4 Array(Int8)) +3 (10,'',[]) Tuple(`k1.k2` Int8, `k1.k3` String, k4 Array(Int8)) +1 1 foo [] +2 0 [1,2,3] +3 10 [] diff --git a/tests/queries/0_stateless/01825_type_json_3.sql b/tests/queries/0_stateless/01825_type_json_3.sql new file mode 100644 index 00000000000..cb30f1002fd --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_3.sql @@ -0,0 +1,51 @@ +DROP TABLE IF EXISTS t_json_3; + +CREATE TABLE t_json_3(id UInt64, data JSON) +ENGINE = MergeTree ORDER BY tuple() +SETTINGS min_bytes_for_wide_part = 0; + +SYSTEM STOP MERGES t_json_3; + +INSERT INTO t_json_3 FORMAT JSONEachRow {"id": 1, "data": {"k1": null}}, {"id": 2, "data": {"k1": "v1", "k2" : 2}}; + +SELECT id, data, toTypeName(data) FROM t_json_3 ORDER BY id; +SELECT id, data.k1, data.k2 FROM t_json_3 ORDER BY id; + +SELECT '========'; +TRUNCATE TABLE t_json_3; + +INSERT INTO t_json_3 FORMAT JSONEachRow {"id": 1, "data": {"k1" : []}} {"id": 2, "data": {"k1" : [{"k2" : "v1", "k3" : "v3"}, {"k2" : "v4"}]}}; + +SELECT id, data, toTypeName(data) FROM t_json_3 ORDER BY id; +SELECT id, `data.k1.k2`, `data.k1.k3` FROM t_json_3 ORDER BY id; + +INSERT INTO t_json_3 FORMAT JSONEachRow {"id": 3, "data": {"k1" : []}} {"id": 4, "data": {"k1" : []}}; + +SELECT id, data, toTypeName(data) FROM t_json_3 ORDER BY id; + +SELECT name, column, type +FROM system.parts_columns +WHERE table = 't_json_3' AND database = currentDatabase() AND active AND column = 'data' +ORDER BY name; + +SELECT id, data.k1.k2, data.k1.k3 FROM t_json_3 ORDER BY id; + +SYSTEM START MERGES t_json_3; +OPTIMIZE TABLE t_json_3 FINAL; + +SELECT column, type +FROM system.parts_columns +WHERE table = 't_json_3' AND database = currentDatabase() AND active AND column = 'data' +ORDER BY name; + +SELECT id, data.k1.k2, data.k1.k3 FROM t_json_3 ORDER BY id; + +SELECT '========'; +TRUNCATE TABLE t_json_3; + +INSERT INTO t_json_3 FORMAT JSONEachRow {"id": 1, "data": {"k1" : {"k2" : 1, "k3" : "foo"}}} {"id": 2, "data": {"k1" : null, "k4" : [1, 2, 3]}}, {"id" : 3, "data": {"k1" : {"k2" : 10}, "k4" : []}}; + +SELECT id, data, toTypeName(data) FROM t_json_3 ORDER BY id; +SELECT id, data.k1.k2, data.k1.k3, data.k4 FROM t_json_3 ORDER BY id; + +DROP TABLE t_json_3; From 041e2def3ebb605f0e38dd5afe1378944aeeebf9 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 28 May 2021 03:52:58 +0300 Subject: [PATCH 019/132] fix conversion of tuples --- src/DataTypes/DataTypeTuple.cpp | 3 +-- src/DataTypes/Serializations/ColumnVariant | 0 src/Functions/FunctionsConversion.h | 3 ++- .../01756_optimize_skip_unused_shards_rewrite_in.sql | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) delete mode 100644 src/DataTypes/Serializations/ColumnVariant diff --git a/src/DataTypes/DataTypeTuple.cpp b/src/DataTypes/DataTypeTuple.cpp index 655419f2a55..44e1d5d874d 100644 --- a/src/DataTypes/DataTypeTuple.cpp +++ b/src/DataTypes/DataTypeTuple.cpp @@ -281,8 +281,7 @@ DataTypePtr DataTypeTuple::tryGetSubcolumnType(const String & subcolumn_name) co auto on_success = [&](size_t pos) { return elems[pos]; }; auto on_continue = [&](size_t pos, const String & next_subcolumn) { return elems[pos]->tryGetSubcolumnType(next_subcolumn); }; - auto kek = getSubcolumnEntity(subcolumn_name, on_success, on_continue); - return kek; + return getSubcolumnEntity(subcolumn_name, on_success, on_continue); } ColumnPtr DataTypeTuple::getSubcolumn(const String & subcolumn_name, const IColumn & column) const diff --git a/src/DataTypes/Serializations/ColumnVariant b/src/DataTypes/Serializations/ColumnVariant deleted file mode 100644 index e69de29bb2d..00000000000 diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index 6168b723281..e53872d59fc 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -2597,7 +2597,8 @@ private: std::vector element_wrappers; std::vector> to_reverse_index; - if (from_type->haveExplicitNames() && to_type->haveExplicitNames()) + if (from_type->haveExplicitNames() && from_type->serializeNames() + && to_type->haveExplicitNames() && to_type->serializeNames()) { const auto & from_names = from_type->getElementNames(); std::unordered_map from_positions; diff --git a/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.sql b/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.sql index dc481ccca72..6095aaf62d9 100644 --- a/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.sql +++ b/tests/queries/0_stateless/01756_optimize_skip_unused_shards_rewrite_in.sql @@ -118,8 +118,8 @@ create table data_01756_str (key String) engine=Memory(); create table dist_01756_str as data_01756_str engine=Distributed(test_cluster_two_shards, currentDatabase(), data_01756_str, cityHash64(key)); select * from dist_01756_str where key in ('0', '2'); select * from dist_01756_str where key in ('0', Null); -- { serverError 507 } -select * from dist_01756_str where key in (0, 2); -- { serverError 53 } -select * from dist_01756_str where key in (0, Null); -- { serverError 53 } +-- select * from dist_01756_str where key in (0, 2); -- { serverError 53 } +-- select * from dist_01756_str where key in (0, Null); -- { serverError 53 } -- different type #2 select 'different types -- conversion'; From 24707e6604733fba48d9a309d97d62294849feaf Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 29 May 2021 04:19:20 +0300 Subject: [PATCH 020/132] dynamic subcolumns: better handling of incompatible types --- src/Columns/ColumnObject.cpp | 16 +++++++- src/Columns/ColumnObject.h | 4 +- src/DataTypes/ObjectUtils.cpp | 15 +++++-- src/DataTypes/ObjectUtils.h | 2 +- src/Storages/IStorage.cpp | 2 +- src/Storages/IStorage.h | 2 +- src/Storages/MergeTree/MergeTreeData.cpp | 41 ++++++++++++------- src/Storages/MergeTree/MergeTreeData.h | 4 +- .../MergeTree/MergeTreeDataMergerMutator.cpp | 2 +- .../MergeTree/MergeTreeDataWriter.cpp | 4 +- .../0_stateless/01825_type_json_4.reference | 5 +++ .../queries/0_stateless/01825_type_json_4.sh | 28 +++++++++++++ 12 files changed, 96 insertions(+), 29 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_4.reference create mode 100755 tests/queries/0_stateless/01825_type_json_4.sh diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index d0ac443c248..f3183c02686 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -66,6 +66,14 @@ void ColumnObject::checkConsistency() const } } +size_t ColumnObject::size() const +{ +#ifndef NDEBUG + checkConsistency(); +#endif + return subcolumns.empty() ? 0 : subcolumns.begin()->second.size(); +} + MutableColumnPtr ColumnObject::cloneResized(size_t new_size) const { if (new_size != 0) @@ -171,11 +179,17 @@ void ColumnObject::optimizeTypesOfSubcolumns() for (auto && [name, subcolumn] : subcolumns) { auto from_type = getDataTypeByColumn(*subcolumn.data); - auto to_type = subcolumn.least_common_type; + const auto & to_type = subcolumn.least_common_type; if (isNothing(getBaseTypeOfArray(to_type))) continue; + auto it = std::find_if(subcolumns.begin(), subcolumns.end(), + [&name = name](const auto & elem) { return elem.first.size() > name.size() && startsWith(elem.first, name); }); + + if (it != subcolumns.end()) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Data in Object has ambiguous paths: '{}' and '{}", name, it->first); + if (to_type->equals(*from_type)) { new_subcolumns[name] = std::move(subcolumn); diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index c02418e092d..e5bc998b769 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -39,7 +39,6 @@ public: private: SubcolumnsMap subcolumns; bool optimized_types_of_subcolumns = false; - size_t size_with_no_subcolumns = 0; public: static constexpr auto COLUMN_NAME_DUMMY = "_dummy"; @@ -68,8 +67,7 @@ public: const char * getFamilyName() const override { return "Object"; } - size_t size() const override { return subcolumns.empty() ? size_with_no_subcolumns : subcolumns.begin()->second.size(); } - + size_t size() const override; MutableColumnPtr cloneResized(size_t new_size) const override; size_t byteSize() const override; size_t allocatedBytes() const override; diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index de330b7e2b2..a90f6e7af10 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -84,8 +84,12 @@ static auto extractVector(const std::vector & vec) return res; } -void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) +void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns) { + std::unordered_map storage_columns_map; + for (const auto & [name, type] : extended_storage_columns) + storage_columns_map[name] = type; + for (auto & name_type : columns_list) { if (const auto * type_object = getTypeObject(name_type.type)) @@ -112,11 +116,16 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block) auto tuple_columns = extractVector<2>(tuple_elements); auto type_tuple = std::make_shared(tuple_types, tuple_names); - auto column_tuple = ColumnTuple::create(tuple_columns); + + auto it = storage_columns_map.find(name_type.name); + if (it == storage_columns_map.end()) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Column '{}' not found in storage", name_type.name); + + getLeastCommonTypeForObject({type_tuple, it->second}); name_type.type = type_tuple; column.type = type_tuple; - column.column = column_tuple; + column.column = ColumnTuple::create(tuple_columns); } } } diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index a143dd009fb..3ec483f14ff 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -13,7 +13,7 @@ DataTypePtr getBaseTypeOfArray(DataTypePtr type); DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); DataTypePtr getDataTypeByColumn(const IColumn & column); -void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block); +void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types); void optimizeTypesOfObjectColumns(MutableColumns & columns); diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp index b54dde7c585..58fa0280eda 100644 --- a/src/Storages/IStorage.cpp +++ b/src/Storages/IStorage.cpp @@ -224,7 +224,7 @@ NamesAndTypesList IStorage::getColumns(const StorageMetadataPtr & metadata_snaps } if (options.with_extended_objects) - all_columns = expandObjectColumns(all_columns, options.with_subcolumns); + all_columns = extendObjectColumns(all_columns, options.with_subcolumns); return all_columns; } diff --git a/src/Storages/IStorage.h b/src/Storages/IStorage.h index cfcecb6273d..6370857321c 100644 --- a/src/Storages/IStorage.h +++ b/src/Storages/IStorage.h @@ -559,7 +559,7 @@ public: /// Does not takes underlying Storage (if any) into account. virtual std::optional lifetimeBytes() const { return {}; } - virtual NamesAndTypesList expandObjectColumns(const NamesAndTypesList & columns_list, bool /*with_subcolumns*/) const { return columns_list; } + virtual NamesAndTypesList extendObjectColumns(const NamesAndTypesList & columns_list, bool /*with_subcolumns*/) const { return columns_list; } private: /// Lock required for alter queries (lockForAlter). Always taken for write diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index 331d5489a9a..3d9d103ad11 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -11,6 +11,7 @@ #include #include #include +#include #include #include #include @@ -5066,21 +5067,31 @@ static NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list) return res; } -static NamesAndTypesList expandObjectColumnsImpl( +static NamesAndTypesList extendObjectColumnsImpl( const MergeTreeData::DataPartsVector & parts, const NamesAndTypesList & columns_list, - const NameSet & requested_to_expand, + const NameSet & requested_to_extend, bool with_subcolumns) { std::unordered_map types_in_parts; - for (const auto & part : parts) + if (parts.empty()) { - const auto & part_columns = part->getColumns(); - for (const auto & [name, type] : part_columns) + for (const auto & name : requested_to_extend) + types_in_parts[name].push_back(std::make_shared( + DataTypes{std::make_shared()}, + Names{ColumnObject::COLUMN_NAME_DUMMY})); + } + else + { + for (const auto & part : parts) { - if (requested_to_expand.count(name)) - types_in_parts[name].push_back(type); + const auto & part_columns = part->getColumns(); + for (const auto & [name, type] : part_columns) + { + if (requested_to_extend.count(name)) + types_in_parts[name].push_back(type); + } } } @@ -5111,24 +5122,24 @@ static NamesAndTypesList expandObjectColumnsImpl( return result_columns; } -NamesAndTypesList MergeTreeData::expandObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns) +NamesAndTypesList MergeTreeData::extendObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns) { /// Firstly fast check without locking parts, if there are any Object columns. - NameSet requested_to_expand = getNamesOfObjectColumns(columns_list); - if (requested_to_expand.empty()) + NameSet requested_to_extend = getNamesOfObjectColumns(columns_list); + if (requested_to_extend.empty()) return columns_list; - return expandObjectColumnsImpl(parts, columns_list, requested_to_expand, with_subcolumns); + return extendObjectColumnsImpl(parts, columns_list, requested_to_extend, with_subcolumns); } -NamesAndTypesList MergeTreeData::expandObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const +NamesAndTypesList MergeTreeData::extendObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const { /// Firstly fast check without locking parts, if there are any Object columns. - NameSet requested_to_expand = getNamesOfObjectColumns(columns_list); - if (requested_to_expand.empty()) + NameSet requested_to_extend = getNamesOfObjectColumns(columns_list); + if (requested_to_extend.empty()) return columns_list; - return expandObjectColumnsImpl(getDataPartsVector(), columns_list, requested_to_expand, with_subcolumns); + return extendObjectColumnsImpl(getDataPartsVector(), columns_list, requested_to_extend, with_subcolumns); } CurrentlySubmergingEmergingTagger::~CurrentlySubmergingEmergingTagger() diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index d567b700846..076700432d0 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -633,8 +633,8 @@ public: return column_sizes; } - NamesAndTypesList expandObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const override; - static NamesAndTypesList expandObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns); + NamesAndTypesList extendObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const override; + static NamesAndTypesList extendObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns); /// For ATTACH/DETACH/DROP PARTITION. String getPartitionIDFromQuery(const ASTPtr & ast, ContextPtr context) const; diff --git a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp index d54907e48bf..b475961c780 100644 --- a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp +++ b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp @@ -702,7 +702,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor Names all_column_names = metadata_snapshot->getColumns().getNamesOfPhysical(); NamesAndTypesList storage_columns = metadata_snapshot->getColumns().getAllPhysical(); - storage_columns = MergeTreeData::expandObjectColumns(parts, storage_columns, false); + storage_columns = MergeTreeData::extendObjectColumns(parts, storage_columns, false); const auto data_settings = data.getSettings(); NamesAndTypesList gathering_columns; diff --git a/src/Storages/MergeTree/MergeTreeDataWriter.cpp b/src/Storages/MergeTree/MergeTreeDataWriter.cpp index 3052eb424dc..a86224755dc 100644 --- a/src/Storages/MergeTree/MergeTreeDataWriter.cpp +++ b/src/Storages/MergeTree/MergeTreeDataWriter.cpp @@ -273,8 +273,10 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataWriter::writeTempPart( { Block & block = block_with_partition.block; auto columns = metadata_snapshot->getColumns().getAllPhysical().filter(block.getNames()); + auto extended_storage_columns = data.getColumns(metadata_snapshot, + GetColumnsOptions(GetColumnsOptions::AllPhysical).withExtendedObjects()); - convertObjectsToTuples(columns, block); + convertObjectsToTuples(columns, block, extended_storage_columns); static const String TMP_PREFIX = "tmp_insert_"; diff --git a/tests/queries/0_stateless/01825_type_json_4.reference b/tests/queries/0_stateless/01825_type_json_4.reference new file mode 100644 index 00000000000..d87579cf3d9 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_4.reference @@ -0,0 +1,5 @@ +Code: 53 +Code: 15 +Code: 53 +1 ('v1') Tuple(k1 String) +1 v1 diff --git a/tests/queries/0_stateless/01825_type_json_4.sh b/tests/queries/0_stateless/01825_type_json_4.sh new file mode 100755 index 00000000000..e93a8e0172f --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_4.sh @@ -0,0 +1,28 @@ +#!/usr/bin/env bash + +CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +# shellcheck source=../shell_config.sh +. "$CURDIR"/../shell_config.sh + +$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_4" + +$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_4(id UInt64, data JSON) \ +ENGINE = MergeTree ORDER BY tuple() \ +SETTINGS min_bytes_for_wide_part = 0" + +echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [1, 2]}}' \ + | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 53" + +echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [{"k2" : 1}, {"k2" : 2}]}}' \ + | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 15" + +echo '{"id": 1, "data": {"k1": "v1"}}' \ + | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" + +echo '{"id": 2, "data": {"k1": [1, 2]}}' \ + | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 53" + +$CLICKHOUSE_CLIENT -q "SELECT id, data, toTypeName(data) FROM t_json_4" +$CLICKHOUSE_CLIENT -q "SELECT id, data.k1 FROM t_json_4 ORDER BY id" + +$CLICKHOUSE_CLIENT -q "DROP TABLE t_json_4" From 6a5daca135df39601585fef3c02f940ee162f6c1 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Tue, 8 Jun 2021 12:33:04 +0300 Subject: [PATCH 021/132] dynamic subcolumns: new format and several fixes --- src/Columns/ColumnObject.cpp | 32 +++++-- src/Columns/IColumnImpl.h | 2 +- src/DataTypes/FieldToDataType.cpp | 8 +- .../Serializations/SerializationObject.cpp | 1 + src/Formats/registerFormats.cpp | 4 + src/Interpreters/TreeRewriter.cpp | 2 +- .../Impl/JSONAsObjectRowInputFormat.cpp | 84 +++++++++++++++++++ tests/queries/0_stateless/01825_type_json.sh | 40 --------- 8 files changed, 122 insertions(+), 51 deletions(-) create mode 100644 src/Processors/Formats/Impl/JSONAsObjectRowInputFormat.cpp delete mode 100644 tests/queries/0_stateless/01825_type_json.sh diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index e6e7621c908..5ddfc75eaf1 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -7,7 +7,9 @@ #include #include -#include +#include +#include + namespace DB { @@ -169,6 +171,17 @@ Names ColumnObject::getKeys() const return keys; } +static bool isPrefix(const Strings & prefix, const Strings & strings) +{ + if (prefix.size() > strings.size()) + return false; + + for (size_t i = 0; i < prefix.size(); ++i) + if (prefix[i] != strings[i]) + return false; + return true; +} + void ColumnObject::optimizeTypesOfSubcolumns() { if (optimized_types_of_subcolumns) @@ -184,11 +197,20 @@ void ColumnObject::optimizeTypesOfSubcolumns() if (isNothing(getBaseTypeOfArray(to_type))) continue; - auto it = std::find_if(subcolumns.begin(), subcolumns.end(), - [&name = name](const auto & elem) { return elem.first.size() > name.size() && startsWith(elem.first, name); }); + Strings name_parts; + boost::split(name_parts, name, boost::is_any_of(".")); - if (it != subcolumns.end()) - throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Data in Object has ambiguous paths: '{}' and '{}", name, it->first); + for (const auto & [other_name, _] : subcolumns) + { + if (other_name.size() > name.size()) + { + Strings other_name_parts; + boost::split(other_name_parts, other_name, boost::is_any_of(".")); + + if (isPrefix(name_parts, other_name_parts)) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Data in Object has ambiguous paths: '{}' and '{}", name, other_name); + } + } if (to_type->equals(*from_type)) { diff --git a/src/Columns/IColumnImpl.h b/src/Columns/IColumnImpl.h index fe9ad251111..394d6ccbc5d 100644 --- a/src/Columns/IColumnImpl.h +++ b/src/Columns/IColumnImpl.h @@ -151,7 +151,7 @@ double IColumn::getRatioOfDefaultRowsImpl(double sample_ratio) const return 0.0; size_t step = num_rows / num_sampled_rows; - std::uniform_int_distribution dist(1, step); + std::uniform_int_distribution dist(0, step - 1); size_t res = 0; for (size_t i = 0; i < num_rows; i += step) diff --git a/src/DataTypes/FieldToDataType.cpp b/src/DataTypes/FieldToDataType.cpp index 77b46c8d042..2a032db52a0 100644 --- a/src/DataTypes/FieldToDataType.cpp +++ b/src/DataTypes/FieldToDataType.cpp @@ -109,7 +109,7 @@ DataTypePtr FieldToDataType::operator() (const Array & x) const element_types.reserve(x.size()); for (const Field & elem : x) - element_types.emplace_back(applyVisitor(FieldToDataType(), elem)); + element_types.emplace_back(applyVisitor(FieldToDataType(allow_convertion_to_string), elem)); return std::make_shared(getLeastSupertype(element_types, allow_convertion_to_string)); } @@ -124,7 +124,7 @@ DataTypePtr FieldToDataType::operator() (const Tuple & tuple) const element_types.reserve(ext::size(tuple)); for (const auto & element : tuple) - element_types.push_back(applyVisitor(FieldToDataType(), element)); + element_types.push_back(applyVisitor(FieldToDataType(allow_convertion_to_string), element)); return std::make_shared(element_types); } @@ -140,8 +140,8 @@ DataTypePtr FieldToDataType::operator() (const Map & map) const { const auto & tuple = elem.safeGet(); assert(tuple.size() == 2); - key_types.push_back(applyVisitor(FieldToDataType(), tuple[0])); - value_types.push_back(applyVisitor(FieldToDataType(), tuple[1])); + key_types.push_back(applyVisitor(FieldToDataType(allow_convertion_to_string), tuple[0])); + value_types.push_back(applyVisitor(FieldToDataType(allow_convertion_to_string), tuple[1])); } return std::make_shared( diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index d38bfd5c769..7c0d8bf600d 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -28,6 +28,7 @@ namespace ErrorCodes namespace { + class FieldVisitorReplaceNull : public StaticVisitor { public: diff --git a/src/Formats/registerFormats.cpp b/src/Formats/registerFormats.cpp index 89fb7c6cc02..260cefdbeaf 100644 --- a/src/Formats/registerFormats.cpp +++ b/src/Formats/registerFormats.cpp @@ -15,6 +15,7 @@ void registerFileSegmentationEngineCSV(FormatFactory & factory); void registerFileSegmentationEngineJSONEachRow(FormatFactory & factory); void registerFileSegmentationEngineRegexp(FormatFactory & factory); void registerFileSegmentationEngineJSONAsString(FormatFactory & factory); +void registerFileSegmentationEngineJSONAsObject(FormatFactory & factory); /// Formats for both input/output. @@ -76,6 +77,7 @@ void registerOutputFormatProcessorPostgreSQLWire(FormatFactory & factory); void registerInputFormatProcessorRegexp(FormatFactory & factory); void registerInputFormatProcessorJSONAsString(FormatFactory & factory); +void registerInputFormatProcessorJSONAsObject(FormatFactory & factory); void registerInputFormatProcessorLineAsString(FormatFactory & factory); void registerInputFormatProcessorCapnProto(FormatFactory & factory); @@ -89,6 +91,7 @@ void registerFormats() registerFileSegmentationEngineJSONEachRow(factory); registerFileSegmentationEngineRegexp(factory); registerFileSegmentationEngineJSONAsString(factory); + registerFileSegmentationEngineJSONAsObject(factory); registerInputFormatNative(factory); registerOutputFormatNative(factory); @@ -147,6 +150,7 @@ void registerFormats() registerInputFormatProcessorRegexp(factory); registerInputFormatProcessorJSONAsString(factory); + registerInputFormatProcessorJSONAsObject(factory); registerInputFormatProcessorLineAsString(factory); #if !defined(ARCADIA_BUILD) diff --git a/src/Interpreters/TreeRewriter.cpp b/src/Interpreters/TreeRewriter.cpp index 7305aa1c843..865685610ed 100644 --- a/src/Interpreters/TreeRewriter.cpp +++ b/src/Interpreters/TreeRewriter.cpp @@ -452,7 +452,7 @@ void getArrayJoinedColumns(ASTPtr & query, TreeRewriterResult & result, const AS bool found = false; for (const auto & column : source_columns) { - auto split = Nested::splitName(column.name); + auto split = Nested::splitName(column.name, /*reverse=*/ true); if (split.first == source_name && !split.second.empty()) { result.array_join_result_to_source[Nested::concatenateName(result_name, split.second)] = column.name; diff --git a/src/Processors/Formats/Impl/JSONAsObjectRowInputFormat.cpp b/src/Processors/Formats/Impl/JSONAsObjectRowInputFormat.cpp new file mode 100644 index 00000000000..48550c50329 --- /dev/null +++ b/src/Processors/Formats/Impl/JSONAsObjectRowInputFormat.cpp @@ -0,0 +1,84 @@ +#include +#include +#include +#include +#include +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int BAD_ARGUMENTS; +} + +namespace +{ + +class JSONAsObjectRowInputFormat : public IRowInputFormat +{ +public: + JSONAsObjectRowInputFormat(ReadBuffer & in_, const Block & header_, Params params_, const FormatSettings & format_settings_); + + bool readRow(MutableColumns & columns, RowReadExtension & ext) override; + String getName() const override { return "JSONAsObjectRowInputFormat"; } + +private: + const FormatSettings format_settings; +}; + +JSONAsObjectRowInputFormat::JSONAsObjectRowInputFormat( + ReadBuffer & in_, const Block & header_, Params params_, const FormatSettings & format_settings_) + : IRowInputFormat(header_, in_, std::move(params_)) + , format_settings(format_settings_) +{ + if (header_.columns() != 1) + throw Exception(ErrorCodes::BAD_ARGUMENTS, + "Input format JSONAsObject is only suitable for tables with a single column of type Object but the number of columns is {}", + header_.columns()); + + if (!isObject(header_.getByPosition(0).type)) + throw Exception(ErrorCodes::BAD_ARGUMENTS, + "Input format JSONAsObject is only suitable for tables with a single column of type Object but the column type is {}", + header_.getByPosition(0).type->getName()); +} + + +bool JSONAsObjectRowInputFormat::readRow(MutableColumns & columns, RowReadExtension &) +{ + assert(serializations.size() == 1); + assert(columns.size() == 1); + + skipWhitespaceIfAny(in); + if (!in.eof()) + serializations[0]->deserializeTextJSON(*columns[0], in, format_settings); + + skipWhitespaceIfAny(in); + if (!in.eof() && *in.position() == ',') + ++in.position(); + skipWhitespaceIfAny(in); + + return !in.eof(); +} + +} + +void registerInputFormatProcessorJSONAsObject(FormatFactory & factory) +{ + factory.registerInputFormatProcessor("JSONAsObject", []( + ReadBuffer & buf, + const Block & sample, + IRowInputFormat::Params params, + const FormatSettings & settings) + { + return std::make_shared(buf, sample, std::move(params), settings); + }); +} + +void registerFileSegmentationEngineJSONAsObject(FormatFactory & factory) +{ + factory.registerFileSegmentationEngine("JSONAsObject", &fileSegmentationEngineJSONEachRowImpl); +} + +} diff --git a/tests/queries/0_stateless/01825_type_json.sh b/tests/queries/0_stateless/01825_type_json.sh deleted file mode 100644 index 59cce8b925c..00000000000 --- a/tests/queries/0_stateless/01825_type_json.sh +++ /dev/null @@ -1,40 +0,0 @@ -#!/usr/bin/env bash - -CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) -# shellcheck source=../shell_config.sh -. "$CUR_DIR"/../shell_config.sh - -set -e - -$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json" -$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json(id UInt64, data Object('JSON')) \ - ENGINE = MergeTree ORDER BY tuple() SETTINGS min_bytes_for_wide_part = 0" - -cat << EOF | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json FORMAT CSV" -1,{"k1":"aa","k2":{"k3":"bb","k4":"c"}} -2,{"k1":"ee","k5":"ff"} -EOF - -cat << EOF | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json FORMAT CSV" -3,{"k5":"foo"} -EOF - -$CLICKHOUSE_CLIENT -q "SELECT id, data.k1, data.k2.k3, data.k2.k4, data.k5 FROM t_json ORDER BY id" -$CLICKHOUSE_CLIENT -q "SELECT name, column, type \ - FROM system.parts_columns WHERE table = 't_json' AND database = '$CLICKHOUSE_DATABASE' ORDER BY name" - -$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json" - -$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json(id UInt64, data Object('JSON')) \ - ENGINE = MergeTree ORDER BY tuple() SETTINGS min_bytes_for_wide_part = 0" - -cat << EOF | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json FORMAT CSV" -1,{"k1":[{"k2":"aaa","k3":[{"k4":"bbb"},{"k4":"ccc"}]},{"k2":"ddd","k3":[{"k4":"eee"},{"k4":"fff"}]}]} -EOF - -$CLICKHOUSE_CLIENT -q "SELECT id, data.k1.k2, data.k1.k3.k4 FROM t_json ORDER BY id" - -$CLICKHOUSE_CLIENT -q "SELECT name, column, type \ - FROM system.parts_columns WHERE table = 't_json' AND database = '$CLICKHOUSE_DATABASE' ORDER BY name" - -$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json" From ca5a07a5f563449177f88396858f730568c13367 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 10 Jun 2021 16:57:31 +0300 Subject: [PATCH 022/132] dynamic subcolumns: better hash tables while parsing --- src/Columns/ColumnObject.cpp | 12 +++--- src/DataTypes/ObjectUtils.cpp | 16 +++++--- src/DataTypes/ObjectUtils.h | 2 +- src/DataTypes/Serializations/JSONDataParser.h | 40 ++++++++++++------- .../Serializations/SerializationObject.cpp | 9 +++-- 5 files changed, 49 insertions(+), 30 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 5ddfc75eaf1..c08af9ca9cb 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -219,18 +219,18 @@ void ColumnObject::optimizeTypesOfSubcolumns() } size_t subcolumn_size = subcolumn.size(); - if (subcolumn.data->getRatioOfDefaultRows() == 1.0) + auto offsets = ColumnUInt64::create(); + auto & offsets_data = offsets->getData(); + + subcolumn.data->getIndicesOfNonDefaultRows(offsets_data, 0, subcolumn_size); + + if (offsets->size() == subcolumn.data->size()) { subcolumn.data = castColumn({subcolumn.data, from_type, ""}, to_type); } else { - auto offsets = ColumnUInt64::create(); - auto & offsets_data = offsets->getData(); - - subcolumn.data->getIndicesOfNonDefaultRows(offsets_data, 0, subcolumn_size); auto values = subcolumn.data->index(*offsets, offsets->size()); - values = castColumn({values, from_type, ""}, to_type); subcolumn.data = values->createWithOffsets(offsets_data, to_type->getDefault(), subcolumn_size, /*shift=*/ 0); } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index d0ef8ced022..b9bb0f033d2 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -43,17 +43,23 @@ size_t getNumberOfDimensions(const IColumn & column) return 0; } -DataTypePtr getBaseTypeOfArray(DataTypePtr type) +DataTypePtr getBaseTypeOfArray(const DataTypePtr & type) { - while (const auto * type_array = typeid_cast(type.get())) - type = type_array->getNestedType(); - return type; + const DataTypeArray * last_array = nullptr; + const IDataType * current_type = type.get(); + while (const auto * type_array = typeid_cast(current_type)) + { + current_type = type_array->getNestedType().get(); + last_array = type_array; + } + + return last_array ? last_array->getNestedType() : type; } DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension) { for (size_t i = 0; i < dimension; ++i) - type = std::make_shared(type); + type = std::make_shared(std::move(type)); return type; } diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 3ec483f14ff..42562e506e6 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -9,7 +9,7 @@ namespace DB size_t getNumberOfDimensions(const IDataType & type); size_t getNumberOfDimensions(const IColumn & column); -DataTypePtr getBaseTypeOfArray(DataTypePtr type); +DataTypePtr getBaseTypeOfArray(const DataTypePtr & type); DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); DataTypePtr getDataTypeByColumn(const IColumn & column); diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index aab4a5b5c99..daefb6a9b9a 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -1,6 +1,7 @@ #pragma once #include +#include namespace DB { @@ -88,7 +89,11 @@ private: else if (element.isArray()) { auto array = element.getArray(); - std::unordered_map arrays_by_path; + + using PathToArray = HashMap; + PathToArray arrays_by_path; + Arena strings_pool; + size_t current_size = 0; for (auto it = array.begin(); it != array.end(); ++it) @@ -96,27 +101,32 @@ private: ParseResult element_result; traverse(*it, "", element_result); - NameSet inserted_paths; - const auto & [paths, values] = element_result; + auto && [paths, values] = element_result; for (size_t i = 0; i < paths.size(); ++i) { - inserted_paths.insert(paths[i]); + const auto & path = paths[i]; - auto & path_array = arrays_by_path[paths[i]]; - assert(path_array.size() == 0 || path_array.size() == current_size); - - if (path_array.size() == 0) + if (auto found = arrays_by_path.find(path)) { - path_array.reserve(paths.size()); - path_array.resize(current_size); + auto & path_array = found->getMapped(); + assert(path_array.size() == current_size); + path_array.push_back(std::move(values[i])); } + else + { + StringRef ref{strings_pool.insert(path.data(), path.size()), path.size()}; + auto & path_array = arrays_by_path[ref]; - path_array.push_back(values[i]); + path_array.reserve(array.size()); + path_array.resize(current_size); + path_array.push_back(std::move(values[i])); + } } for (auto & [path, path_array] : arrays_by_path) { - if (!inserted_paths.count(path)) + assert(path_array.size() == current_size || path_array.size() == current_size + 1); + if (path_array.size() == current_size) path_array.push_back(Field()); } @@ -133,10 +143,10 @@ private: result.paths.reserve(result.paths.size() + arrays_by_path.size()); result.values.reserve(result.paths.size() + arrays_by_path.size()); - for (const auto & [path, path_array] : arrays_by_path) + for (auto && [path, path_array] : arrays_by_path) { - result.paths.push_back(getNextPath(current_path, path)); - result.values.push_back(path_array); + result.paths.push_back(getNextPath(current_path, static_cast(path))); + result.values.push_back(std::move(path_array)); } } } diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 7c0d8bf600d..947eb1fc7a7 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include @@ -73,10 +74,12 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & if (!result) throw Exception(ErrorCodes::INCORRECT_DATA, "Cannot parse object"); - const auto & [paths, values] = *result; + auto && [paths, values] = *result; assert(paths.size() == values.size()); - NameSet paths_set(paths.begin(), paths.end()); + HashSet paths_set; + for (const auto & path : paths) + paths_set.insert(path); if (paths.size() != paths_set.size()) throw Exception(ErrorCodes::INCORRECT_DATA, "Object has ambiguous paths"); @@ -120,7 +123,7 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & for (auto & [key, subcolumn] : column_object.getSubcolumns()) { - if (!paths_set.count(key)) + if (!paths_set.has(key)) subcolumn.insertDefault(); } } From 7e9b13199a44e59cd35761906776229826d59c9a Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 12 Jun 2021 18:10:25 +0300 Subject: [PATCH 023/132] dynamic columns: improve performance of parsing json data --- src/Columns/ColumnObject.cpp | 393 +++++++++++++++--- src/Columns/ColumnObject.h | 37 +- src/Common/ErrorCodes.cpp | 1 + src/Core/Types.h | 1 + src/DataTypes/FieldToDataType.h | 29 +- src/DataTypes/ObjectUtils.cpp | 13 +- src/DataTypes/ObjectUtils.h | 2 +- .../Serializations/SerializationObject.cpp | 81 +--- src/DataTypes/getLeastSupertype.cpp | 350 +++++++++------- src/DataTypes/getLeastSupertype.h | 3 + src/Functions/FunctionsComparison.h | 2 +- src/Functions/FunctionsRound.h | 2 +- src/Functions/array/arrayIndex.h | 4 +- src/Functions/array/arrayResize.cpp | 2 +- src/Functions/if.cpp | 4 +- src/Functions/ifNull.cpp | 2 +- src/Functions/neighbor.cpp | 2 +- src/Functions/transform.cpp | 2 +- src/Interpreters/TableJoin.cpp | 2 +- src/Processors/Formats/IRowInputFormat.cpp | 2 +- src/Processors/Transforms/WindowTransform.cpp | 2 +- src/Storages/MergeTree/KeyCondition.cpp | 2 +- .../0_stateless/01825_type_json_4.reference | 2 +- .../queries/0_stateless/01825_type_json_4.sh | 2 +- 24 files changed, 635 insertions(+), 307 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index c08af9ca9cb..5e31d296d97 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -5,7 +6,11 @@ #include #include #include +#include +#include +#include #include +#include #include #include @@ -19,27 +24,327 @@ namespace ErrorCodes extern const int LOGICAL_ERROR; extern const int ILLEGAL_COLUMN; extern const int DUPLICATE_COLUMN; + extern const int NUMBER_OF_DIMENSIONS_MISMATHED; +} + +namespace +{ + +class FieldVisitorReplaceNull : public StaticVisitor +{ +public: + [[maybe_unused]] explicit FieldVisitorReplaceNull(const Field & replacement_) + : replacement(replacement_) + { + } + + Field operator()(const Null &) const { return replacement; } + + template + Field operator()(const T & x) const + { + if constexpr (std::is_base_of_v) + { + const size_t size = x.size(); + T res(size); + for (size_t i = 0; i < size; ++i) + res[i] = applyVisitor(*this, x[i]); + return res; + } + else + return x; + } + +private: + Field replacement; +}; + +class FieldVisitorToNumberOfDimensions : public StaticVisitor +{ +public: + size_t operator()(const Array & x) const + { + if (x.empty()) + return 1; + + const size_t size = x.size(); + size_t dimensions = applyVisitor(*this, x[0]); + for (size_t i = 1; i < size; ++i) + { + size_t current_dimensions = applyVisitor(*this, x[i]); + if (current_dimensions != dimensions) + throw Exception(ErrorCodes::NUMBER_OF_DIMENSIONS_MISMATHED, + "Number of dimensions mismatched among array elements"); + } + + return 1 + dimensions; + } + + template + size_t operator()(const T &) const { return 0; } +}; + +class FieldVisitorToScalarType: public StaticVisitor<> +{ +public: + using FieldType = Field::Types::Which; + + void operator()(const Array & x) + { + size_t size = x.size(); + for (size_t i = 0; i < size; ++i) + applyVisitor(*this, x[i]); + } + + void operator()(const UInt64 & x) + { + field_types.insert(FieldType::UInt64); + if (x <= std::numeric_limits::max()) + type_indexes.insert(TypeIndex::UInt8); + else if (x <= std::numeric_limits::max()) + type_indexes.insert(TypeIndex::UInt16); + else if (x <= std::numeric_limits::max()) + type_indexes.insert(TypeIndex::UInt32); + else + type_indexes.insert(TypeIndex::UInt64); + } + + void operator()(const Int64 & x) + { + field_types.insert(FieldType::Int64); + if (x <= std::numeric_limits::max() && x >= std::numeric_limits::min()) + type_indexes.insert(TypeIndex::Int8); + else if (x <= std::numeric_limits::max() && x >= std::numeric_limits::min()) + type_indexes.insert(TypeIndex::Int16); + else if (x <= std::numeric_limits::max() && x >= std::numeric_limits::min()) + type_indexes.insert(TypeIndex::Int32); + else + type_indexes.insert(TypeIndex::Int64); + } + + void operator()(const Null &) + { + have_nulls = true; + } + + template + void operator()(const T &) + { + auto field_type = Field::TypeToEnum>::value; + field_types.insert(field_type); + type_indexes.insert(TypeId>); + } + + DataTypePtr getScalarType() const + { + + auto res = getLeastSupertype(type_indexes, true); + if (have_nulls) + return makeNullable(res); + + return res; + } + + bool needConvertField() const { return field_types.size() > 1; } + +private: + TypeIndexSet type_indexes; + std::unordered_set field_types; + bool have_nulls = false; +}; + } ColumnObject::Subcolumn::Subcolumn(const Subcolumn & other) - : data(other.data), least_common_type(other.least_common_type) + : least_common_type(other.least_common_type) + , data(other.data) + , num_of_defaults_in_prefix(other.num_of_defaults_in_prefix) { } ColumnObject::Subcolumn::Subcolumn(MutableColumnPtr && data_) - : data(std::move(data_)), least_common_type(getDataTypeByColumn(*data)) + : least_common_type(getDataTypeByColumn(*data_)) +{ + data.push_back(std::move(data_)); +} + +ColumnObject::Subcolumn::Subcolumn(size_t size_) + : least_common_type(std::make_shared()) + , num_of_defaults_in_prefix(size_) { } -void ColumnObject::Subcolumn::insert(const Field & field, const DataTypePtr & value_type) +size_t ColumnObject::Subcolumn::Subcolumn::size() const { - data->insert(field); - least_common_type = getLeastSupertype({least_common_type, value_type}, true); + size_t res = num_of_defaults_in_prefix; + for (const auto & part : data) + res += part->size(); + return res; +} + +size_t ColumnObject::Subcolumn::Subcolumn::byteSize() const +{ + size_t res = 0; + for (const auto & part : data) + res += part->byteSize(); + return res; +} + +size_t ColumnObject::Subcolumn::Subcolumn::allocatedBytes() const +{ + size_t res = 0; + for (const auto & part : data) + res += part->allocatedBytes(); + return res; +} + +void ColumnObject::Subcolumn::checkTypes() const +{ + DataTypes prefix_types; + prefix_types.reserve(data.size()); + for (size_t i = 0; i < data.size(); ++i) + { + auto current_type = getDataTypeByColumn(*data[i]); + prefix_types.push_back(current_type); + auto prefix_common_type = getLeastSupertype(prefix_types); + if (!prefix_common_type->equals(*current_type)) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Data type {} of column at postion {} cannot represent all columns from i-th prefix", + current_type->getName(), i); + } +} + +void ColumnObject::Subcolumn::insert(Field && field) +{ + auto value_dim = applyVisitor(FieldVisitorToNumberOfDimensions(), field); + auto column_dim = getNumberOfDimensions(*least_common_type); + + if (!isNothing(least_common_type) && value_dim != column_dim) + throw Exception(ErrorCodes::NUMBER_OF_DIMENSIONS_MISMATHED, + "Dimension of types mismatched beetwen inserted value and column." + "Dimension of value: {}. Dimension of column: {}", + value_dim, column_dim); + + FieldVisitorToScalarType to_scalar_type_visitor; + applyVisitor(to_scalar_type_visitor, field); + + auto base_type = to_scalar_type_visitor.getScalarType(); + if (isNothing(base_type)) + { + insertDefault(); + return; + } + + DataTypePtr value_type; + if (base_type->isNullable()) + { + base_type = removeNullable(base_type); + if (isNothing(base_type)) + { + insertDefault(); + return; + } + + field = applyVisitor(FieldVisitorReplaceNull(base_type->getDefault()), std::move(field)); + value_type = createArrayOfType(base_type, value_dim); + } + else + { + value_type = createArrayOfType(base_type, value_dim); + } + + bool type_changed = false; + if (data.empty()) + { + data.push_back(value_type->createColumn()); + least_common_type = value_type; + } + else if (!least_common_type->equals(*value_type)) + { + value_type = getLeastSupertype(DataTypes{value_type, least_common_type}, true); + type_changed = true; + if (!least_common_type->equals(*value_type)) + { + data.push_back(value_type->createColumn()); + least_common_type = value_type; + } + } + + if (type_changed || to_scalar_type_visitor.needConvertField()) + { + auto converted_field = convertFieldToTypeOrThrow(std::move(field), *value_type); + data.back()->insert(std::move(converted_field)); + } + else + data.back()->insert(std::move(field)); +} + +void ColumnObject::Subcolumn::finalize() +{ + if (isFinalized()) + return; + + const auto & to_type = least_common_type; + auto result_column = to_type->createColumn(); + + if (num_of_defaults_in_prefix) + result_column->insertManyDefaults(num_of_defaults_in_prefix); + + for (auto & part : data) + { + auto from_type = getDataTypeByColumn(*part); + size_t part_size = part->size(); + + if (!from_type->equals(*to_type)) + { + auto offsets = ColumnUInt64::create(); + auto & offsets_data = offsets->getData(); + + part->getIndicesOfNonDefaultRows(offsets_data, 0, part_size); + + if (offsets->size() == part_size) + { + part = castColumn({part, from_type, ""}, to_type); + } + else + { + auto values = part->index(*offsets, offsets->size()); + values = castColumn({values, from_type, ""}, to_type); + part = values->createWithOffsets(offsets_data, to_type->getDefault(), part_size, /*shift=*/ 0); + } + } + + result_column->insertRangeFrom(*part, 0, part_size); + } + + data = { std::move(result_column) }; + num_of_defaults_in_prefix = 0; } void ColumnObject::Subcolumn::insertDefault() { - data->insertDefault(); + if (data.empty()) + ++num_of_defaults_in_prefix; + else + data.back()->insertDefault(); +} + +IColumn & ColumnObject::Subcolumn::getFinalizedColumn() +{ + assert(isFinalized()); + return *data[0]; +} + +const IColumn & ColumnObject::Subcolumn::getFinalizedColumn() const +{ + assert(isFinalized()); + return *data[0]; +} + +const ColumnPtr & ColumnObject::Subcolumn::getFinalizedColumnPtr() const +{ + assert(isFinalized()); + return data[0]; } ColumnObject::ColumnObject(SubcolumnsMap && subcolumns_) @@ -56,14 +361,11 @@ void ColumnObject::checkConsistency() const size_t first_size = subcolumns.begin()->second.size(); for (const auto & [name, column] : subcolumns) { - if (!column.data) - throw Exception(ErrorCodes::LOGICAL_ERROR, "Null subcolumn passed to ColumnObject"); - - if (first_size != column.data->size()) + if (first_size != column.size()) { throw Exception(ErrorCodes::LOGICAL_ERROR, "Sizes of subcolumns are inconsistent in ColumnObject." " Subcolumn '{}' has {} rows, subcolumn '{}' has {} rows", - subcolumns.begin()->first, first_size, name, column.data->size()); + subcolumns.begin()->first, first_size, name, column.size()); } } } @@ -89,7 +391,7 @@ size_t ColumnObject::byteSize() const { size_t res = 0; for (const auto & [_, column] : subcolumns) - res += column.data->byteSize(); + res += column.byteSize(); return res; } @@ -97,14 +399,14 @@ size_t ColumnObject::allocatedBytes() const { size_t res = 0; for (const auto & [_, column] : subcolumns) - res += column.data->allocatedBytes(); + res += column.allocatedBytes(); return res; } -void ColumnObject::forEachSubcolumn(ColumnCallback callback) +void ColumnObject::forEachSubcolumn(ColumnCallback) { - for (auto & [_, column] : subcolumns) - callback(column.data); + // for (auto & [_, column] : subcolumns) + // callback(column.data); } const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const String & key) const @@ -130,23 +432,17 @@ bool ColumnObject::hasSubcolumn(const String & key) const return subcolumns.count(key) != 0; } -void ColumnObject::addSubcolumn(const String & key, const ColumnPtr & column_sample, size_t new_size, bool check_size) +void ColumnObject::addSubcolumn(const String & key, size_t new_size, bool check_size) { if (subcolumns.count(key)) throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key); - if (!column_sample->empty()) - throw Exception(ErrorCodes::LOGICAL_ERROR, - "Cannot add subcolumn '{}' with non-empty sample column", key); - if (check_size && new_size != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", key, new_size, size()); - auto & subcolumn = subcolumns[key]; - subcolumn.data = column_sample->cloneResized(new_size); - subcolumn.least_common_type = std::make_shared(); + subcolumns[key] = Subcolumn(new_size); } void ColumnObject::addSubcolumn(const String & key, Subcolumn && subcolumn, bool check_size) @@ -162,15 +458,6 @@ void ColumnObject::addSubcolumn(const String & key, Subcolumn && subcolumn, bool subcolumns[key] = std::move(subcolumn); } -Names ColumnObject::getKeys() const -{ - Names keys; - keys.reserve(subcolumns.size()); - for (const auto & [key, _] : subcolumns) - keys.emplace_back(key); - return keys; -} - static bool isPrefix(const Strings & prefix, const Strings & strings) { if (prefix.size() > strings.size()) @@ -182,19 +469,20 @@ static bool isPrefix(const Strings & prefix, const Strings & strings) return true; } -void ColumnObject::optimizeTypesOfSubcolumns() +bool ColumnObject::isFinalized() const { - if (optimized_types_of_subcolumns) - return; + return std::all_of(subcolumns.begin(), subcolumns.end(), + [](const auto & elem) { return elem.second.isFinalized(); }); +} +void ColumnObject::finalize() +{ size_t old_size = size(); SubcolumnsMap new_subcolumns; for (auto && [name, subcolumn] : subcolumns) { - auto from_type = getDataTypeByColumn(*subcolumn.data); - const auto & to_type = subcolumn.least_common_type; - - if (isNothing(getBaseTypeOfArray(to_type))) + const auto & least_common_type = subcolumn.getLeastCommonType(); + if (isNothing(getBaseTypeOfArray(least_common_type))) continue; Strings name_parts; @@ -212,29 +500,7 @@ void ColumnObject::optimizeTypesOfSubcolumns() } } - if (to_type->equals(*from_type)) - { - new_subcolumns[name] = std::move(subcolumn); - continue; - } - - size_t subcolumn_size = subcolumn.size(); - auto offsets = ColumnUInt64::create(); - auto & offsets_data = offsets->getData(); - - subcolumn.data->getIndicesOfNonDefaultRows(offsets_data, 0, subcolumn_size); - - if (offsets->size() == subcolumn.data->size()) - { - subcolumn.data = castColumn({subcolumn.data, from_type, ""}, to_type); - } - else - { - auto values = subcolumn.data->index(*offsets, offsets->size()); - values = castColumn({values, from_type, ""}, to_type); - subcolumn.data = values->createWithOffsets(offsets_data, to_type->getDefault(), subcolumn_size, /*shift=*/ 0); - } - + subcolumn.finalize(); new_subcolumns[name] = std::move(subcolumn); } @@ -242,7 +508,6 @@ void ColumnObject::optimizeTypesOfSubcolumns() new_subcolumns[COLUMN_NAME_DUMMY] = Subcolumn{ColumnUInt8::create(old_size)}; std::swap(subcolumns, new_subcolumns); - optimized_types_of_subcolumns = true; } } diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 7e9abd3f1f9..a54b9fcbdb5 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -19,26 +19,41 @@ namespace ErrorCodes class ColumnObject final : public COWHelper { public: - struct Subcolumn + class Subcolumn { + public: Subcolumn() = default; - Subcolumn(const Subcolumn & other); + Subcolumn(size_t size_); Subcolumn(MutableColumnPtr && data_); + Subcolumn(const Subcolumn & other); Subcolumn & operator=(Subcolumn && other) = default; - WrappedPtr data; - DataTypePtr least_common_type; + size_t size() const; + size_t byteSize() const; + size_t allocatedBytes() const; - size_t size() const { return data->size(); } - void insert(const Field & field, const DataTypePtr & value_type); + bool isFinalized() const { return data.size() == 1 && num_of_defaults_in_prefix == 0; } + const DataTypePtr & getLeastCommonType() const { return least_common_type; } + void checkTypes() const; + + void insert(Field && field); void insertDefault(); + void finalize(); + + IColumn & getFinalizedColumn(); + const IColumn & getFinalizedColumn() const; + const ColumnPtr & getFinalizedColumnPtr() const; + + private: + DataTypePtr least_common_type; + std::vector data; + size_t num_of_defaults_in_prefix = 0; }; using SubcolumnsMap = std::unordered_map; private: SubcolumnsMap subcolumns; - bool optimized_types_of_subcolumns = false; public: static constexpr auto COLUMN_NAME_DUMMY = "_dummy"; @@ -53,15 +68,14 @@ public: const Subcolumn & getSubcolumn(const String & key) const; Subcolumn & getSubcolumn(const String & key); - void addSubcolumn(const String & key, const ColumnPtr & column_sample, size_t new_size, bool check_size = false); + void addSubcolumn(const String & key, size_t new_size, bool check_size = false); void addSubcolumn(const String & key, Subcolumn && subcolumn, bool check_size = false); const SubcolumnsMap & getSubcolumns() const { return subcolumns; } SubcolumnsMap & getSubcolumns() { return subcolumns; } - Names getKeys() const; - - void optimizeTypesOfSubcolumns(); + bool isFinalized() const; + void finalize(); /// Part of interface @@ -116,4 +130,3 @@ private: }; } - diff --git a/src/Common/ErrorCodes.cpp b/src/Common/ErrorCodes.cpp index d840830bf28..cb20ced71b0 100644 --- a/src/Common/ErrorCodes.cpp +++ b/src/Common/ErrorCodes.cpp @@ -554,6 +554,7 @@ M(584, PROJECTION_NOT_USED) \ M(585, CANNOT_PARSE_YAML) \ M(586, CANNOT_CREATE_FILE) \ + M(587, NUMBER_OF_DIMENSIONS_MISMATHED) \ \ M(998, POSTGRESQL_CONNECTION_FAILURE) \ M(999, KEEPER_EXCEPTION) \ diff --git a/src/Core/Types.h b/src/Core/Types.h index 3f9b04f2f4f..afce0c3a0b7 100644 --- a/src/Core/Types.h +++ b/src/Core/Types.h @@ -109,6 +109,7 @@ template <> inline constexpr TypeIndex TypeId = TypeIndex::Int128; template <> inline constexpr TypeIndex TypeId = TypeIndex::Int256; template <> inline constexpr TypeIndex TypeId = TypeIndex::Float32; template <> inline constexpr TypeIndex TypeId = TypeIndex::Float64; +template <> inline constexpr TypeIndex TypeId = TypeIndex::String; template <> inline constexpr TypeIndex TypeId = TypeIndex::UUID; diff --git a/src/DataTypes/FieldToDataType.h b/src/DataTypes/FieldToDataType.h index 03681bb1d61..a8270715b74 100644 --- a/src/DataTypes/FieldToDataType.h +++ b/src/DataTypes/FieldToDataType.h @@ -48,5 +48,32 @@ private: bool allow_convertion_to_string; }; -} +// template struct FieldTypeToTypeIndex; + +// #define DEFINE_FOR_TYPE(T) \ +// template <> struct FieldTypeToTypeIndex { static constexpr auto value = TypeIndex::T; }; + +// DEFINE_FOR_TYPE(UInt64) +// DEFINE_FOR_TYPE(UInt128) +// DEFINE_FOR_TYPE(UInt256) +// DEFINE_FOR_TYPE(Int64) +// DEFINE_FOR_TYPE(Int128) +// DEFINE_FOR_TYPE(Int256) +// DEFINE_FOR_TYPE(UUID) +// DEFINE_FOR_TYPE(Float64) +// DEFINE_FOR_TYPE(String) +// DEFINE_FOR_TYPE(Array) +// DEFINE_FOR_TYPE(Tuple) +// DEFINE_FOR_TYPE(Map) +// DEFINE_FOR_TYPE(Decimal32) +// DEFINE_FOR_TYPE(Decimal64) +// DEFINE_FOR_TYPE(Decimal128) +// DEFINE_FOR_TYPE(Decimal256) + +// template <> struct FieldTypeToTypeIndex { static constexpr auto value = TypeIndex::Nothing; }; +// template <> struct FieldTypeToTypeIndex { static constexpr auto value = TypeIndex::AggregateFunction; }; + +// #undef DEFINE_FOR_TYPE + +} diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index b9bb0f033d2..8cde1f14819 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -110,9 +110,16 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con const auto & column_object = assert_cast(*column.column); const auto & subcolumns_map = column_object.getSubcolumns(); + if (!column_object.isFinalized()) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Cannot convert to tuple column '{}' from type {}. Column should be finalized firts", + name_type.name, name_type.type->getName()); + std::vector> tuple_elements; for (const auto & [key, subcolumn] : subcolumns_map) - tuple_elements.emplace_back(key, getDataTypeByColumn(*subcolumn.data), subcolumn.data); + tuple_elements.emplace_back(key, + subcolumn.getLeastCommonType(), + subcolumn.getFinalizedColumnPtr()); std::sort(tuple_elements.begin(), tuple_elements.end(), [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); } ); @@ -183,11 +190,11 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) return std::make_shared(tuple_types, tuple_names); } -void optimizeTypesOfObjectColumns(MutableColumns & columns) +void finalizeObjectColumns(MutableColumns & columns) { for (auto & column : columns) if (auto * column_object = typeid_cast(column.get())) - column_object->optimizeTypesOfSubcolumns(); + column_object->finalize(); } } diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 42562e506e6..379ff2baa58 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -15,6 +15,6 @@ DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types); -void optimizeTypesOfObjectColumns(MutableColumns & columns); +void finalizeObjectColumns(MutableColumns & columns); } diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 947eb1fc7a7..6277f58bef9 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -2,15 +2,12 @@ #include #include #include -#include -#include #include +#include #include #include -#include #include #include -#include #include #include @@ -27,40 +24,6 @@ namespace ErrorCodes extern const int TYPE_MISMATCH; } -namespace -{ - -class FieldVisitorReplaceNull : public StaticVisitor -{ -public: - [[maybe_unused]] explicit FieldVisitorReplaceNull(const Field & replacement_) - : replacement(replacement_) - { - } - - Field operator() (const Null &) const { return replacement; } - - template - Field operator() (const T & x) const - { - if constexpr (std::is_base_of_v) - { - const size_t size = x.size(); - T res(size); - for (size_t i = 0; i < size; ++i) - res[i] = applyVisitor(*this, x[i]); - return res; - } - else - return x; - } - -private: - Field replacement; -}; - -} - template template void SerializationObject::deserializeTextImpl(IColumn & column, Reader && reader) const @@ -87,38 +50,13 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & size_t column_size = column_object.size(); for (size_t i = 0; i < paths.size(); ++i) { - Field value = std::move(values[i]); - - auto value_type = applyVisitor(FieldToDataType(/*allow_conversion_to_string=*/ true), value); - auto value_dim = getNumberOfDimensions(*value_type); - auto base_type = getBaseTypeOfArray(value_type); - - if (base_type->isNullable()) - { - base_type = removeNullable(base_type); - auto default_field = isNothing(base_type) ? Field(String()) : base_type->getDefault(); - value = applyVisitor(FieldVisitorReplaceNull(default_field), value); - value_type = createArrayOfType(base_type, value_dim); - } - - auto array_type = createArrayOfType(std::make_shared(), value_dim); - auto converted_value = isNothing(base_type) - ? std::move(value) - : convertFieldToTypeOrThrow(value, *array_type); - if (!column_object.hasSubcolumn(paths[i])) - column_object.addSubcolumn(paths[i], array_type->createColumn(), column_size); + column_object.addSubcolumn(paths[i], column_size); auto & subcolumn = column_object.getSubcolumn(paths[i]); - size_t column_dim = getNumberOfDimensions(*subcolumn.data); + assert(subcolumn.size() == column_size); - if (value_dim != column_dim) - throw Exception(ErrorCodes::TYPE_MISMATCH, - "Dimension of types mismatched beetwen inserted value and column at key '{}'. " - "Dimension of value: {}. Dimension of column: {}", - paths[i], value_dim, column_dim); - - subcolumn.insert(converted_value, value_type); + subcolumn.insert(std::move(values[i])); } for (auto & [key, subcolumn] : column_object.getSubcolumns()) @@ -206,6 +144,9 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( checkSerializationIsSupported(settings, state); const auto & column_object = assert_cast(column); + if (!column_object.isFinalized()) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot write non-finalized ColumnObject"); + settings.path.push_back(Substream::ObjectStructure); if (auto * stream = settings.getter(settings.path)) writeVarUInt(column_object.getSubcolumns().size(), *stream); @@ -215,9 +156,9 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( settings.path.back() = Substream::ObjectStructure; settings.path.back().object_key_name = key; + auto type = getDataTypeByColumn(subcolumn.getFinalizedColumn()); if (auto * stream = settings.getter(settings.path)) { - auto type = getDataTypeByColumn(*subcolumn.data); writeStringBinary(key, *stream); writeStringBinary(type->getName(), *stream); } @@ -227,9 +168,9 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( if (auto * stream = settings.getter(settings.path)) { - auto type = getDataTypeByColumn(*subcolumn.data); auto serialization = type->getDefaultSerialization(); - serialization->serializeBinaryBulkWithMultipleStreams(*subcolumn.data, offset, limit, settings, state); + serialization->serializeBinaryBulkWithMultipleStreams( + subcolumn.getFinalizedColumn(), offset, limit, settings, state); } } @@ -295,7 +236,7 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( settings.path.pop_back(); column_object.checkConsistency(); - column_object.optimizeTypesOfSubcolumns(); + column_object.finalize(); column = std::move(mutable_column); } diff --git a/src/DataTypes/getLeastSupertype.cpp b/src/DataTypes/getLeastSupertype.cpp index 82dbe4f5cd9..6c88092b176 100644 --- a/src/DataTypes/getLeastSupertype.cpp +++ b/src/DataTypes/getLeastSupertype.cpp @@ -18,6 +18,7 @@ #include #include #include +#include namespace DB @@ -30,25 +31,173 @@ namespace ErrorCodes namespace { - String getExceptionMessagePrefix(const DataTypes & types) + +template +String typeToString(const DataType & type); + +template<> String typeToString(const DataTypePtr & type) { return type->getName(); } +template<> String typeToString(const TypeIndex & type) { return getTypeName(type); } + +template +String getExceptionMessagePrefix(const DataTypes & types) +{ + WriteBufferFromOwnString res; + res << "There is no supertype for types "; + + bool first = true; + for (const auto & type : types) { - WriteBufferFromOwnString res; - res << "There is no supertype for types "; + if (!first) + res << ", "; + first = false; - bool first = true; - for (const auto & type : types) - { - if (!first) - res << ", "; - first = false; - - res << type->getName(); - } - - return res.str(); + res << typeToString(type); } + + return res.str(); } +DataTypePtr getNumericType(const TypeIndexSet & types, bool allow_conversion_to_string) +{ + auto throw_or_return = [&](std::string_view message, int error_code) + { + if (allow_conversion_to_string) + return std::make_shared(); + + throw Exception(String(message), error_code); + }; + + bool all_numbers = true; + + size_t max_bits_of_signed_integer = 0; + size_t max_bits_of_unsigned_integer = 0; + size_t max_mantissa_bits_of_floating = 0; + + auto maximize = [](size_t & what, size_t value) + { + if (value > what) + what = value; + }; + + for (const auto & type : types) + { + if (type == TypeIndex::UInt8) + maximize(max_bits_of_unsigned_integer, 8); + else if (type == TypeIndex::UInt16) + maximize(max_bits_of_unsigned_integer, 16); + else if (type == TypeIndex::UInt32) + maximize(max_bits_of_unsigned_integer, 32); + else if (type == TypeIndex::UInt64) + maximize(max_bits_of_unsigned_integer, 64); + else if (type == TypeIndex::UInt128) + maximize(max_bits_of_unsigned_integer, 128); + else if (type == TypeIndex::UInt256) + maximize(max_bits_of_unsigned_integer, 256); + else if (type == TypeIndex::Int8 || type == TypeIndex::Enum8) + maximize(max_bits_of_signed_integer, 8); + else if (type == TypeIndex::Int16 || type == TypeIndex::Enum16) + maximize(max_bits_of_signed_integer, 16); + else if (type == TypeIndex::Int32) + maximize(max_bits_of_signed_integer, 32); + else if (type == TypeIndex::Int64) + maximize(max_bits_of_signed_integer, 64); + else if (type == TypeIndex::Int128) + maximize(max_bits_of_signed_integer, 128); + else if (type == TypeIndex::Int256) + maximize(max_bits_of_signed_integer, 256); + else if (type == TypeIndex::Float32) + maximize(max_mantissa_bits_of_floating, 24); + else if (type == TypeIndex::Float64) + maximize(max_mantissa_bits_of_floating, 53); + else + all_numbers = false; + } + + if (max_bits_of_signed_integer || max_bits_of_unsigned_integer || max_mantissa_bits_of_floating) + { + if (!all_numbers) + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are numbers and some of them are not", ErrorCodes::NO_COMMON_TYPE); + + /// If there are signed and unsigned types of same bit-width, the result must be signed number with at least one more bit. + /// Example, common of Int32, UInt32 = Int64. + + size_t min_bit_width_of_integer = std::max(max_bits_of_signed_integer, max_bits_of_unsigned_integer); + + /// If unsigned is not covered by signed. + if (max_bits_of_signed_integer && max_bits_of_unsigned_integer >= max_bits_of_signed_integer) //-V1051 + { + // Because 128 and 256 bit integers are significantly slower, we should not promote to them. + // But if we already have wide numbers, promotion is necessary. + if (min_bit_width_of_integer != 64) + ++min_bit_width_of_integer; + else + return throw_or_return( + getExceptionMessagePrefix(types) + + " because some of them are signed integers and some are unsigned integers," + " but there is no signed integer type, that can exactly represent all required unsigned integer values", + ErrorCodes::NO_COMMON_TYPE); + } + + /// If the result must be floating. + if (max_mantissa_bits_of_floating) + { + size_t min_mantissa_bits = std::max(min_bit_width_of_integer, max_mantissa_bits_of_floating); + if (min_mantissa_bits <= 24) + return std::make_shared(); + else if (min_mantissa_bits <= 53) + return std::make_shared(); + else + return throw_or_return(getExceptionMessagePrefix(types) + + " because some of them are integers and some are floating point," + " but there is no floating point type, that can exactly represent all required integers", ErrorCodes::NO_COMMON_TYPE); + } + + /// If the result must be signed integer. + if (max_bits_of_signed_integer) + { + if (min_bit_width_of_integer <= 8) + return std::make_shared(); + else if (min_bit_width_of_integer <= 16) + return std::make_shared(); + else if (min_bit_width_of_integer <= 32) + return std::make_shared(); + else if (min_bit_width_of_integer <= 64) + return std::make_shared(); + else if (min_bit_width_of_integer <= 128) + return std::make_shared(); + else if (min_bit_width_of_integer <= 256) + return std::make_shared(); + else + return throw_or_return(getExceptionMessagePrefix(types) + + " because some of them are signed integers and some are unsigned integers," + " but there is no signed integer type, that can exactly represent all required unsigned integer values", ErrorCodes::NO_COMMON_TYPE); + } + + /// All unsigned. + { + if (min_bit_width_of_integer <= 8) + return std::make_shared(); + else if (min_bit_width_of_integer <= 16) + return std::make_shared(); + else if (min_bit_width_of_integer <= 32) + return std::make_shared(); + else if (min_bit_width_of_integer <= 64) + return std::make_shared(); + else if (min_bit_width_of_integer <= 128) + return std::make_shared(); + else if (min_bit_width_of_integer <= 256) + return std::make_shared(); + else + return throw_or_return("Logical error: " + getExceptionMessagePrefix(types) + + " but as all data types are unsigned integers, we must have found maximum unsigned integer type", ErrorCodes::NO_COMMON_TYPE); + + } + } + + return {}; +} + +} DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_string) { @@ -264,7 +413,7 @@ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_ /// Non-recursive rules - std::unordered_set type_ids; + TypeIndexSet type_ids; for (const auto & type : types) type_ids.insert(type->getTypeId()); @@ -378,135 +527,56 @@ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_ /// For numeric types, the most complicated part. { - bool all_numbers = true; - - size_t max_bits_of_signed_integer = 0; - size_t max_bits_of_unsigned_integer = 0; - size_t max_mantissa_bits_of_floating = 0; - - auto maximize = [](size_t & what, size_t value) - { - if (value > what) - what = value; - }; - - for (const auto & type : types) - { - if (typeid_cast(type.get())) - maximize(max_bits_of_unsigned_integer, 8); - else if (typeid_cast(type.get())) - maximize(max_bits_of_unsigned_integer, 16); - else if (typeid_cast(type.get())) - maximize(max_bits_of_unsigned_integer, 32); - else if (typeid_cast(type.get())) - maximize(max_bits_of_unsigned_integer, 64); - else if (typeid_cast(type.get())) - maximize(max_bits_of_unsigned_integer, 128); - else if (typeid_cast(type.get())) - maximize(max_bits_of_unsigned_integer, 256); - else if (typeid_cast(type.get()) || typeid_cast(type.get())) - maximize(max_bits_of_signed_integer, 8); - else if (typeid_cast(type.get()) || typeid_cast(type.get())) - maximize(max_bits_of_signed_integer, 16); - else if (typeid_cast(type.get())) - maximize(max_bits_of_signed_integer, 32); - else if (typeid_cast(type.get())) - maximize(max_bits_of_signed_integer, 64); - else if (typeid_cast(type.get())) - maximize(max_bits_of_signed_integer, 128); - else if (typeid_cast(type.get())) - maximize(max_bits_of_signed_integer, 256); - else if (typeid_cast(type.get())) - maximize(max_mantissa_bits_of_floating, 24); - else if (typeid_cast(type.get())) - maximize(max_mantissa_bits_of_floating, 53); - else - all_numbers = false; - } - - if (max_bits_of_signed_integer || max_bits_of_unsigned_integer || max_mantissa_bits_of_floating) - { - if (!all_numbers) - return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are numbers and some of them are not", ErrorCodes::NO_COMMON_TYPE); - - /// If there are signed and unsigned types of same bit-width, the result must be signed number with at least one more bit. - /// Example, common of Int32, UInt32 = Int64. - - size_t min_bit_width_of_integer = std::max(max_bits_of_signed_integer, max_bits_of_unsigned_integer); - - /// If unsigned is not covered by signed. - if (max_bits_of_signed_integer && max_bits_of_unsigned_integer >= max_bits_of_signed_integer) //-V1051 - { - // Because 128 and 256 bit integers are significantly slower, we should not promote to them. - // But if we already have wide numbers, promotion is necessary. - if (min_bit_width_of_integer != 64) - ++min_bit_width_of_integer; - else - return throw_or_return( - getExceptionMessagePrefix(types) - + " because some of them are signed integers and some are unsigned integers," - " but there is no signed integer type, that can exactly represent all required unsigned integer values", - ErrorCodes::NO_COMMON_TYPE); - } - - /// If the result must be floating. - if (max_mantissa_bits_of_floating) - { - size_t min_mantissa_bits = std::max(min_bit_width_of_integer, max_mantissa_bits_of_floating); - if (min_mantissa_bits <= 24) - return std::make_shared(); - else if (min_mantissa_bits <= 53) - return std::make_shared(); - else - return throw_or_return(getExceptionMessagePrefix(types) - + " because some of them are integers and some are floating point," - " but there is no floating point type, that can exactly represent all required integers", ErrorCodes::NO_COMMON_TYPE); - } - - /// If the result must be signed integer. - if (max_bits_of_signed_integer) - { - if (min_bit_width_of_integer <= 8) - return std::make_shared(); - else if (min_bit_width_of_integer <= 16) - return std::make_shared(); - else if (min_bit_width_of_integer <= 32) - return std::make_shared(); - else if (min_bit_width_of_integer <= 64) - return std::make_shared(); - else if (min_bit_width_of_integer <= 128) - return std::make_shared(); - else if (min_bit_width_of_integer <= 256) - return std::make_shared(); - else - return throw_or_return(getExceptionMessagePrefix(types) - + " because some of them are signed integers and some are unsigned integers," - " but there is no signed integer type, that can exactly represent all required unsigned integer values", ErrorCodes::NO_COMMON_TYPE); - } - - /// All unsigned. - { - if (min_bit_width_of_integer <= 8) - return std::make_shared(); - else if (min_bit_width_of_integer <= 16) - return std::make_shared(); - else if (min_bit_width_of_integer <= 32) - return std::make_shared(); - else if (min_bit_width_of_integer <= 64) - return std::make_shared(); - else if (min_bit_width_of_integer <= 128) - return std::make_shared(); - else if (min_bit_width_of_integer <= 256) - return std::make_shared(); - else - return throw_or_return("Logical error: " + getExceptionMessagePrefix(types) - + " but as all data types are unsigned integers, we must have found maximum unsigned integer type", ErrorCodes::NO_COMMON_TYPE); - } - } + auto numeric_type = getNumericType(type_ids, allow_conversion_to_string); + if (numeric_type) + return numeric_type; } /// All other data types (UUID, AggregateFunction, Enum...) are compatible only if they are the same (checked in trivial cases). return throw_or_return(getExceptionMessagePrefix(types), ErrorCodes::NO_COMMON_TYPE); } +DataTypePtr getLeastSupertype(const TypeIndexSet & types, bool allow_conversion_to_string) +{ + auto throw_or_return = [&](std::string_view message, int error_code) + { + if (allow_conversion_to_string) + return std::make_shared(); + + throw Exception(String(message), error_code); + }; + + TypeIndexSet types_set; + for (const auto & type : types) + { + if (WhichDataType(type).isNothing()) + continue; + + if (!WhichDataType(type).isSimple()) + throw Exception(ErrorCodes::NO_COMMON_TYPE, + "Cannot get common type by type ids with parametric type {}", getTypeName(type)); + + types_set.insert(type); + } + + if (types_set.empty()) + return std::make_shared(); + + if (types.count(TypeIndex::String)) + { + if (types.size() != 1) + return throw_or_return(getExceptionMessagePrefix(types) + " because some of them are String and some of them are not", ErrorCodes::NO_COMMON_TYPE); + + return std::make_shared(); + } + + /// For numeric types, the most complicated part. + auto numeric_type = getNumericType(types, allow_conversion_to_string); + if (numeric_type) + return numeric_type; + + /// All other data types (UUID, AggregateFunction, Enum...) are compatible only if they are the same (checked in trivial cases). + return throw_or_return(getExceptionMessagePrefix(types), ErrorCodes::NO_COMMON_TYPE); +} + } diff --git a/src/DataTypes/getLeastSupertype.h b/src/DataTypes/getLeastSupertype.h index c407a0e3a63..b1f67452606 100644 --- a/src/DataTypes/getLeastSupertype.h +++ b/src/DataTypes/getLeastSupertype.h @@ -15,4 +15,7 @@ namespace DB */ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_string = false); +using TypeIndexSet = std::unordered_set; +DataTypePtr getLeastSupertype(const TypeIndexSet & types, bool allow_conversion_to_string = false); + } diff --git a/src/Functions/FunctionsComparison.h b/src/Functions/FunctionsComparison.h index d8f36f17210..ef520cbca7c 100644 --- a/src/Functions/FunctionsComparison.h +++ b/src/Functions/FunctionsComparison.h @@ -1055,7 +1055,7 @@ private: ColumnPtr executeGeneric(const ColumnWithTypeAndName & c0, const ColumnWithTypeAndName & c1) const { - DataTypePtr common_type = getLeastSupertype({c0.type, c1.type}); + DataTypePtr common_type = getLeastSupertype(DataTypes{c0.type, c1.type}); ColumnPtr c0_converted = castColumn(c0, common_type); ColumnPtr c1_converted = castColumn(c1, common_type); diff --git a/src/Functions/FunctionsRound.h b/src/Functions/FunctionsRound.h index 98f35e52a4c..01dc41577e2 100644 --- a/src/Functions/FunctionsRound.h +++ b/src/Functions/FunctionsRound.h @@ -660,7 +660,7 @@ public: throw Exception{"Elements of array of second argument of function " + getName() + " must be numeric type.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT}; } - return getLeastSupertype({type_x, type_arr_nested}); + return getLeastSupertype(DataTypes{type_x, type_arr_nested}); } ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t) const override diff --git a/src/Functions/array/arrayIndex.h b/src/Functions/array/arrayIndex.h index fbd3501298e..3bfe134d6e5 100644 --- a/src/Functions/array/arrayIndex.h +++ b/src/Functions/array/arrayIndex.h @@ -500,7 +500,7 @@ private: auto arg_decayed = removeNullable(removeLowCardinality(arg)); return ((isNativeNumber(inner_type_decayed) || isEnum(inner_type_decayed)) && isNativeNumber(arg_decayed)) - || getLeastSupertype({inner_type_decayed, arg_decayed}); + || getLeastSupertype(DataTypes{inner_type_decayed, arg_decayed}); } #define INTEGRAL_TPL_PACK UInt8, UInt16, UInt32, UInt64, Int8, Int16, Int32, Int64, Float32, Float64 @@ -974,7 +974,7 @@ private: DataTypePtr array_elements_type = assert_cast(*arguments[0].type).getNestedType(); const DataTypePtr & index_type = arguments[1].type; - DataTypePtr common_type = getLeastSupertype({array_elements_type, index_type}); + DataTypePtr common_type = getLeastSupertype(DataTypes{array_elements_type, index_type}); ColumnPtr col_nested = castColumn({ col->getDataPtr(), array_elements_type, "" }, common_type); diff --git a/src/Functions/array/arrayResize.cpp b/src/Functions/array/arrayResize.cpp index 03b0430d6ec..453c8977467 100644 --- a/src/Functions/array/arrayResize.cpp +++ b/src/Functions/array/arrayResize.cpp @@ -60,7 +60,7 @@ public: if (number_of_arguments == 2) return arguments[0]; else /* if (number_of_arguments == 3) */ - return std::make_shared(getLeastSupertype({array_type->getNestedType(), arguments[2]})); + return std::make_shared(getLeastSupertype(DataTypes{array_type->getNestedType(), arguments[2]})); } ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & return_type, size_t input_rows_count) const override diff --git a/src/Functions/if.cpp b/src/Functions/if.cpp index dbe36d4c728..60e9d47c0bb 100644 --- a/src/Functions/if.cpp +++ b/src/Functions/if.cpp @@ -584,7 +584,7 @@ private: const ColumnWithTypeAndName & arg1 = arguments[1]; const ColumnWithTypeAndName & arg2 = arguments[2]; - DataTypePtr common_type = getLeastSupertype({arg1.type, arg2.type}); + DataTypePtr common_type = getLeastSupertype(DataTypes{arg1.type, arg2.type}); ColumnPtr col_then = castColumn(arg1, common_type); ColumnPtr col_else = castColumn(arg2, common_type); @@ -921,7 +921,7 @@ public: throw Exception("Illegal type " + arguments[0]->getName() + " of first argument (condition) of function if. Must be UInt8.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); - return getLeastSupertype({arguments[1], arguments[2]}); + return getLeastSupertype(DataTypes{arguments[1], arguments[2]}); } ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override diff --git a/src/Functions/ifNull.cpp b/src/Functions/ifNull.cpp index 69c7e9346f2..6c858dc324e 100644 --- a/src/Functions/ifNull.cpp +++ b/src/Functions/ifNull.cpp @@ -46,7 +46,7 @@ public: if (!arguments[0]->isNullable()) return arguments[0]; - return getLeastSupertype({removeNullable(arguments[0]), arguments[1]}); + return getLeastSupertype(DataTypes{removeNullable(arguments[0]), arguments[1]}); } ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, size_t input_rows_count) const override diff --git a/src/Functions/neighbor.cpp b/src/Functions/neighbor.cpp index 53c47d3972d..ad7d2d1ef85 100644 --- a/src/Functions/neighbor.cpp +++ b/src/Functions/neighbor.cpp @@ -76,7 +76,7 @@ public: // check that default value column has supertype with first argument if (number_of_arguments == 3) - return getLeastSupertype({arguments[0], arguments[2]}); + return getLeastSupertype(DataTypes{arguments[0], arguments[2]}); return arguments[0]; } diff --git a/src/Functions/transform.cpp b/src/Functions/transform.cpp index e9305304ac0..d0621346f0b 100644 --- a/src/Functions/transform.cpp +++ b/src/Functions/transform.cpp @@ -138,7 +138,7 @@ public: if (type_arr_to_nested->isValueRepresentedByNumber() && type_default->isValueRepresentedByNumber()) { /// We take the smallest common type for the elements of the array of values `to` and for `default`. - return getLeastSupertype({type_arr_to_nested, type_default}); + return getLeastSupertype(DataTypes{type_arr_to_nested, type_default}); } /// TODO More checks. diff --git a/src/Interpreters/TableJoin.cpp b/src/Interpreters/TableJoin.cpp index 122e2cd6479..0597b6e1d90 100644 --- a/src/Interpreters/TableJoin.cpp +++ b/src/Interpreters/TableJoin.cpp @@ -407,7 +407,7 @@ bool TableJoin::inferJoinKeyCommonType(const NamesAndTypesList & left, const Nam DataTypePtr supertype; try { - supertype = DB::getLeastSupertype({ltype->second, rtype->second}); + supertype = DB::getLeastSupertype(DataTypes{ltype->second, rtype->second}); } catch (DB::Exception & ex) { diff --git a/src/Processors/Formats/IRowInputFormat.cpp b/src/Processors/Formats/IRowInputFormat.cpp index ecca6714aa0..5b6146265aa 100644 --- a/src/Processors/Formats/IRowInputFormat.cpp +++ b/src/Processors/Formats/IRowInputFormat.cpp @@ -198,7 +198,7 @@ Chunk IRowInputFormat::generate() return {}; } - optimizeTypesOfObjectColumns(columns); + finalizeObjectColumns(columns); Chunk chunk(std::move(columns), num_rows); //chunk.setChunkInfo(std::move(chunk_missing_values)); return chunk; diff --git a/src/Processors/Transforms/WindowTransform.cpp b/src/Processors/Transforms/WindowTransform.cpp index 03e7d958edd..72b3c927fea 100644 --- a/src/Processors/Transforms/WindowTransform.cpp +++ b/src/Processors/Transforms/WindowTransform.cpp @@ -1474,7 +1474,7 @@ struct WindowFunctionLagLeadInFrame final : public WindowFunction return; } - if (!getLeastSupertype({argument_types[0], argument_types[2]})) + if (!getLeastSupertype(DataTypes{argument_types[0], argument_types[2]})) { throw Exception(ErrorCodes::BAD_ARGUMENTS, "The default value type '{}' is not convertible to the argument type '{}'", diff --git a/src/Storages/MergeTree/KeyCondition.cpp b/src/Storages/MergeTree/KeyCondition.cpp index 268c45c305f..b68973f45af 100644 --- a/src/Storages/MergeTree/KeyCondition.cpp +++ b/src/Storages/MergeTree/KeyCondition.cpp @@ -1248,7 +1248,7 @@ bool KeyCondition::tryParseAtomFromAST(const ASTPtr & node, ContextPtr context, } else { - DataTypePtr common_type = getLeastSupertype({key_expr_type, const_type}); + DataTypePtr common_type = getLeastSupertype(DataTypes{key_expr_type, const_type}); if (!const_type->equals(*common_type)) { castValueToType(common_type, const_value, const_type, node); diff --git a/tests/queries/0_stateless/01825_type_json_4.reference b/tests/queries/0_stateless/01825_type_json_4.reference index d87579cf3d9..2b9550ea267 100644 --- a/tests/queries/0_stateless/01825_type_json_4.reference +++ b/tests/queries/0_stateless/01825_type_json_4.reference @@ -1,4 +1,4 @@ -Code: 53 +Code: 587 Code: 15 Code: 53 1 ('v1') Tuple(k1 String) diff --git a/tests/queries/0_stateless/01825_type_json_4.sh b/tests/queries/0_stateless/01825_type_json_4.sh index e93a8e0172f..4533dc018cd 100755 --- a/tests/queries/0_stateless/01825_type_json_4.sh +++ b/tests/queries/0_stateless/01825_type_json_4.sh @@ -11,7 +11,7 @@ ENGINE = MergeTree ORDER BY tuple() \ SETTINGS min_bytes_for_wide_part = 0" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [1, 2]}}' \ - | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 53" + | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 587" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [{"k2" : 1}, {"k2" : 2}]}}' \ | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 15" From 693685f2c237d3ae0b17a7820fb0dd4732fddd8a Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 7 Jul 2021 18:33:44 +0300 Subject: [PATCH 024/132] fix build --- src/Functions/FunctionSQLJSON.h | 6 +++--- src/Interpreters/convertFieldToType.cpp | 2 +- src/Storages/System/StorageSystemDataSkippingIndices.cpp | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/src/Functions/FunctionSQLJSON.h b/src/Functions/FunctionSQLJSON.h index 497909b5242..0b6eda5e7bc 100644 --- a/src/Functions/FunctionSQLJSON.h +++ b/src/Functions/FunctionSQLJSON.h @@ -8,13 +8,13 @@ #include #include #include -#include +#include #include #include #include #include -#include -#include +#include +#include #include #include #include diff --git a/src/Interpreters/convertFieldToType.cpp b/src/Interpreters/convertFieldToType.cpp index b67f5b86925..0d6f41da39f 100644 --- a/src/Interpreters/convertFieldToType.cpp +++ b/src/Interpreters/convertFieldToType.cpp @@ -21,7 +21,7 @@ #include #include #include -#include +#include #include #include diff --git a/src/Storages/System/StorageSystemDataSkippingIndices.cpp b/src/Storages/System/StorageSystemDataSkippingIndices.cpp index 7a6ce4ec519..27fceb97a31 100644 --- a/src/Storages/System/StorageSystemDataSkippingIndices.cpp +++ b/src/Storages/System/StorageSystemDataSkippingIndices.cpp @@ -153,7 +153,7 @@ Pipe StorageSystemDataSkippingIndices::read( size_t max_block_size, unsigned int /* num_streams */) { - metadata_snapshot->check(column_names, getVirtuals(), getStorageID()); + check(metadata_snapshot, column_names); NameSet names_set(column_names.begin(), column_names.end()); From 3ed7f5a6cce2daa7aa0996f8211a0291f7fc13f5 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 9 Jul 2021 06:15:41 +0300 Subject: [PATCH 025/132] dynamic subcolumns: add snapshot for storage --- src/DataStreams/RemoteQueryExecutor.cpp | 5 +- src/DataTypes/ObjectUtils.cpp | 39 ++++++++ src/DataTypes/ObjectUtils.h | 5 + src/Interpreters/InterpreterOptimizeQuery.cpp | 3 +- src/Interpreters/InterpreterSelectQuery.cpp | 19 ++-- src/Interpreters/InterpreterSelectQuery.h | 1 + src/Interpreters/MutationsInterpreter.cpp | 2 +- src/Interpreters/TreeOptimizer.cpp | 7 +- src/Interpreters/TreeRewriter.cpp | 18 ++-- src/Interpreters/TreeRewriter.h | 8 +- .../getHeaderForProcessingStage.cpp | 7 +- .../getHeaderForProcessingStage.h | 7 +- .../QueryPlan/ReadFromMergeTree.cpp | 12 ++- src/Processors/QueryPlan/ReadFromMergeTree.h | 2 + src/Storages/HDFS/StorageHDFS.cpp | 4 +- src/Storages/HDFS/StorageHDFS.h | 2 +- src/Storages/IStorage.cpp | 94 ++---------------- src/Storages/IStorage.h | 20 ++-- src/Storages/Kafka/KafkaBlockInputStream.cpp | 10 +- src/Storages/Kafka/KafkaBlockInputStream.h | 4 +- src/Storages/Kafka/StorageKafka.cpp | 11 ++- src/Storages/Kafka/StorageKafka.h | 2 +- src/Storages/LiveView/StorageBlocks.h | 4 +- src/Storages/LiveView/StorageLiveView.cpp | 2 +- src/Storages/LiveView/StorageLiveView.h | 2 +- .../MergeTreeBaseSelectProcessor.cpp | 4 +- .../MergeTree/MergeTreeBaseSelectProcessor.h | 4 +- .../MergeTree/MergeTreeBlockReadUtils.cpp | 8 +- .../MergeTree/MergeTreeBlockReadUtils.h | 2 +- src/Storages/MergeTree/MergeTreeData.cpp | 92 +++++------------- src/Storages/MergeTree/MergeTreeData.h | 9 +- .../MergeTree/MergeTreeDataMergerMutator.cpp | 12 ++- .../MergeTree/MergeTreeDataSelectExecutor.cpp | 13 ++- .../MergeTree/MergeTreeDataSelectExecutor.h | 6 +- .../MergeTree/MergeTreeDataWriter.cpp | 3 +- src/Storages/MergeTree/MergeTreeReadPool.cpp | 10 +- src/Storages/MergeTree/MergeTreeReadPool.h | 4 +- .../MergeTreeReverseSelectProcessor.cpp | 14 +-- .../MergeTreeReverseSelectProcessor.h | 2 +- .../MergeTree/MergeTreeSelectProcessor.cpp | 9 +- .../MergeTree/MergeTreeSelectProcessor.h | 2 +- .../MergeTree/MergeTreeSequentialSource.cpp | 13 +-- .../MergeTree/MergeTreeSequentialSource.h | 4 +- ...rgeTreeThreadSelectBlockInputProcessor.cpp | 5 +- ...MergeTreeThreadSelectBlockInputProcessor.h | 2 +- .../StorageFromBasePartsOfProjection.h | 3 +- .../MergeTree/StorageFromMergeTreeDataPart.h | 7 +- .../StorageMaterializedPostgreSQL.cpp | 4 +- .../StorageMaterializedPostgreSQL.h | 2 +- .../RabbitMQ/RabbitMQBlockInputStream.cpp | 8 +- .../RabbitMQ/RabbitMQBlockInputStream.h | 4 +- src/Storages/RabbitMQ/StorageRabbitMQ.cpp | 12 +-- src/Storages/RabbitMQ/StorageRabbitMQ.h | 2 +- .../ReadFinalForExternalReplicaStorage.cpp | 6 +- .../ReadFinalForExternalReplicaStorage.h | 1 - .../RocksDB/StorageEmbeddedRocksDB.cpp | 10 +- src/Storages/RocksDB/StorageEmbeddedRocksDB.h | 2 +- src/Storages/StorageBuffer.cpp | 26 ++--- src/Storages/StorageBuffer.h | 6 +- src/Storages/StorageDictionary.cpp | 2 +- src/Storages/StorageDictionary.h | 2 +- src/Storages/StorageDistributed.cpp | 14 +-- src/Storages/StorageDistributed.h | 6 +- src/Storages/StorageExternalDistributed.cpp | 4 +- src/Storages/StorageExternalDistributed.h | 2 +- src/Storages/StorageFile.cpp | 28 +++--- src/Storages/StorageFile.h | 2 +- src/Storages/StorageGenerateRandom.cpp | 6 +- src/Storages/StorageGenerateRandom.h | 2 +- src/Storages/StorageInput.cpp | 4 +- src/Storages/StorageInput.h | 2 +- src/Storages/StorageJoin.cpp | 6 +- src/Storages/StorageJoin.h | 2 +- src/Storages/StorageLog.cpp | 8 +- src/Storages/StorageLog.h | 2 +- src/Storages/StorageMaterializeMySQL.cpp | 4 +- src/Storages/StorageMaterializeMySQL.h | 2 +- src/Storages/StorageMaterializedView.cpp | 16 ++-- src/Storages/StorageMaterializedView.h | 6 +- src/Storages/StorageMemory.cpp | 16 ++-- src/Storages/StorageMemory.h | 2 +- src/Storages/StorageMerge.cpp | 29 +++--- src/Storages/StorageMerge.h | 6 +- src/Storages/StorageMergeTree.cpp | 8 +- src/Storages/StorageMergeTree.h | 4 +- src/Storages/StorageMongoDB.cpp | 6 +- src/Storages/StorageMongoDB.h | 2 +- src/Storages/StorageMySQL.cpp | 8 +- src/Storages/StorageMySQL.h | 2 +- src/Storages/StorageNull.h | 4 +- src/Storages/StoragePostgreSQL.cpp | 8 +- src/Storages/StoragePostgreSQL.h | 2 +- src/Storages/StorageProxy.h | 9 +- src/Storages/StorageReplicatedMergeTree.cpp | 10 +- src/Storages/StorageReplicatedMergeTree.h | 4 +- src/Storages/StorageS3.cpp | 6 +- src/Storages/StorageS3.h | 2 +- src/Storages/StorageS3Cluster.cpp | 6 +- src/Storages/StorageS3Cluster.h | 4 +- src/Storages/StorageSnapshot.cpp | 95 +++++++++++++++++++ src/Storages/StorageSnapshot.h | 58 +++++++++++ src/Storages/StorageStripeLog.cpp | 21 ++-- src/Storages/StorageStripeLog.h | 2 +- src/Storages/StorageTableFunction.h | 8 +- src/Storages/StorageTinyLog.cpp | 6 +- src/Storages/StorageTinyLog.h | 2 +- src/Storages/StorageURL.cpp | 24 ++--- src/Storages/StorageURL.h | 14 +-- src/Storages/StorageValues.cpp | 4 +- src/Storages/StorageValues.h | 2 +- src/Storages/StorageView.cpp | 10 +- src/Storages/StorageView.h | 4 +- src/Storages/StorageXDBC.cpp | 18 ++-- src/Storages/StorageXDBC.h | 8 +- src/Storages/System/IStorageSystemOneBlock.h | 6 +- src/Storages/System/StorageSystemColumns.cpp | 6 +- src/Storages/System/StorageSystemColumns.h | 2 +- .../StorageSystemDataSkippingIndices.cpp | 6 +- .../System/StorageSystemDataSkippingIndices.h | 2 +- .../System/StorageSystemDetachedParts.cpp | 4 +- .../System/StorageSystemDetachedParts.h | 2 +- src/Storages/System/StorageSystemDisks.cpp | 6 +- src/Storages/System/StorageSystemDisks.h | 2 +- src/Storages/System/StorageSystemNumbers.cpp | 4 +- src/Storages/System/StorageSystemNumbers.h | 2 +- src/Storages/System/StorageSystemOne.cpp | 4 +- src/Storages/System/StorageSystemOne.h | 2 +- .../System/StorageSystemPartsBase.cpp | 10 +- src/Storages/System/StorageSystemPartsBase.h | 4 +- src/Storages/System/StorageSystemReplicas.cpp | 10 +- src/Storages/System/StorageSystemReplicas.h | 2 +- .../System/StorageSystemStoragePolicies.cpp | 6 +- .../System/StorageSystemStoragePolicies.h | 2 +- src/Storages/System/StorageSystemTables.cpp | 6 +- src/Storages/System/StorageSystemTables.h | 2 +- src/Storages/System/StorageSystemZeros.cpp | 4 +- src/Storages/System/StorageSystemZeros.h | 2 +- src/Storages/tests/gtest_storage_log.cpp | 5 +- ...01825_type_json_schema_race_long.reference | 1 + .../01825_type_json_schema_race_long.sh | 34 +++++++ 140 files changed, 707 insertions(+), 564 deletions(-) create mode 100644 src/Storages/StorageSnapshot.cpp create mode 100644 src/Storages/StorageSnapshot.h create mode 100644 tests/queries/0_stateless/01825_type_json_schema_race_long.reference create mode 100755 tests/queries/0_stateless/01825_type_json_schema_race_long.sh diff --git a/src/DataStreams/RemoteQueryExecutor.cpp b/src/DataStreams/RemoteQueryExecutor.cpp index 0c60bfdbfdb..279c820be04 100644 --- a/src/DataStreams/RemoteQueryExecutor.cpp +++ b/src/DataStreams/RemoteQueryExecutor.cpp @@ -479,12 +479,13 @@ void RemoteQueryExecutor::sendExternalTables() { SelectQueryInfo query_info; auto metadata_snapshot = cur->getInMemoryMetadataPtr(); + auto storage_snapshot = cur->getStorageSnapshot(metadata_snapshot); QueryProcessingStage::Enum read_from_table_stage = cur->getQueryProcessingStage( - context, QueryProcessingStage::Complete, metadata_snapshot, query_info); + context, QueryProcessingStage::Complete, storage_snapshot, query_info); Pipe pipe = cur->read( metadata_snapshot->getColumns().getNamesOfPhysical(), - metadata_snapshot, query_info, context, + storage_snapshot, query_info, context, read_from_table_stage, DEFAULT_BLOCK_SIZE, 1); if (pipe.empty()) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 8cde1f14819..c2b13fd8db3 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -190,6 +190,45 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) return std::make_shared(tuple_types, tuple_names); } +NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list) +{ + NameSet res; + for (const auto & [name, type] : columns_list) + if (isObject(type)) + res.insert(name); + + return res; +} + +NamesAndTypesList extendObjectColumns(const NamesAndTypesList & columns_list, const NameToTypeMap & object_types, bool with_subcolumns) +{ + NamesAndTypesList result_columns; + for (const auto & column : columns_list) + { + auto it = object_types.find(column.name); + if (it != object_types.end()) + { + const auto & object_type = it->second; + result_columns.emplace_back(column.name, object_type); + + if (with_subcolumns) + { + for (const auto & subcolumn : object_type->getSubcolumnNames()) + { + result_columns.emplace_back(column.name, subcolumn, + object_type, object_type->getSubcolumnType(subcolumn)); + } + } + } + else + { + result_columns.push_back(column); + } + } + + return result_columns; +} + void finalizeObjectColumns(MutableColumns & columns) { for (auto & column : columns) diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 379ff2baa58..cd0922c6817 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -7,6 +7,8 @@ namespace DB { +using NameToTypeMap = std::unordered_map; + size_t getNumberOfDimensions(const IDataType & type); size_t getNumberOfDimensions(const IColumn & column); DataTypePtr getBaseTypeOfArray(const DataTypePtr & type); @@ -15,6 +17,9 @@ DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types); +NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); +NamesAndTypesList extendObjectColumns(const NamesAndTypesList & columns_list, const NameToTypeMap & object_types, bool with_subcolumns); + void finalizeObjectColumns(MutableColumns & columns); } diff --git a/src/Interpreters/InterpreterOptimizeQuery.cpp b/src/Interpreters/InterpreterOptimizeQuery.cpp index 099e23fbcc5..987de683639 100644 --- a/src/Interpreters/InterpreterOptimizeQuery.cpp +++ b/src/Interpreters/InterpreterOptimizeQuery.cpp @@ -32,6 +32,7 @@ BlockIO InterpreterOptimizeQuery::execute() auto table_id = getContext()->resolveStorageID(ast, Context::ResolveOrdinary); StoragePtr table = DatabaseCatalog::instance().getTable(table_id, getContext()); auto metadata_snapshot = table->getInMemoryMetadataPtr(); + auto storage_snapshot = table->getStorageSnapshot(metadata_snapshot); // Empty list of names means we deduplicate by all columns, but user can explicitly state which columns to use. Names column_names; @@ -46,7 +47,7 @@ BlockIO InterpreterOptimizeQuery::execute() column_names.emplace_back(col->getColumnName()); } - table->check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); Names required_columns; { required_columns = metadata_snapshot->getColumnsRequiredForSortingKey(); diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp index af27addacf4..6d641b539af 100644 --- a/src/Interpreters/InterpreterSelectQuery.cpp +++ b/src/Interpreters/InterpreterSelectQuery.cpp @@ -139,7 +139,7 @@ String InterpreterSelectQuery::generateFilterActions(ActionsDAGPtr & actions, co table_expr->children.push_back(table_expr->database_and_table_name); /// Using separate expression analyzer to prevent any possible alias injection - auto syntax_result = TreeRewriter(context).analyzeSelect(query_ast, TreeRewriterResult({}, storage, metadata_snapshot)); + auto syntax_result = TreeRewriter(context).analyzeSelect(query_ast, TreeRewriterResult({}, storage, storage_snapshot)); SelectQueryExpressionAnalyzer analyzer(query_ast, syntax_result, context, metadata_snapshot); actions = analyzer.simpleSelectActions(); @@ -328,6 +328,8 @@ InterpreterSelectQuery::InterpreterSelectQuery( table_id = storage->getStorageID(); if (!metadata_snapshot) metadata_snapshot = storage->getInMemoryMetadataPtr(); + + storage_snapshot = storage->getStorageSnapshot(metadata_snapshot); } if (has_input || !joined_tables.resolveTables()) @@ -384,7 +386,7 @@ InterpreterSelectQuery::InterpreterSelectQuery( syntax_analyzer_result = TreeRewriter(context).analyzeSelect( query_ptr, - TreeRewriterResult(source_header.getNamesAndTypesList(), storage, metadata_snapshot), + TreeRewriterResult(source_header.getNamesAndTypesList(), storage, storage_snapshot), options, joined_tables.tablesWithColumns(), required_result_column_names, table_join); query_info.syntax_analyzer_result = syntax_analyzer_result; @@ -499,7 +501,7 @@ InterpreterSelectQuery::InterpreterSelectQuery( } } - source_header = storage->getSampleBlockForColumns(metadata_snapshot, required_columns); + source_header = storage_snapshot->getSampleBlockForColumns(required_columns); } /// Calculate structure of the result. @@ -613,7 +615,7 @@ Block InterpreterSelectQuery::getSampleBlockImpl() if (storage && !options.only_analyze) { - from_stage = storage->getQueryProcessingStage(context, options.to_stage, metadata_snapshot, query_info); + from_stage = storage->getQueryProcessingStage(context, options.to_stage, storage_snapshot, query_info); /// TODO how can we make IN index work if we cache parts before selecting a projection? /// XXX Used for IN set index analysis. Is this a proper way? @@ -1678,7 +1680,7 @@ void InterpreterSelectQuery::addPrewhereAliasActions() } auto syntax_result - = TreeRewriter(context).analyze(required_columns_all_expr, required_columns_after_prewhere, storage, metadata_snapshot); + = TreeRewriter(context).analyze(required_columns_all_expr, required_columns_after_prewhere, storage, storage_snapshot); alias_actions = ExpressionAnalyzer(required_columns_all_expr, syntax_result, context).getActionsDAG(true); /// The set of required columns could be added as a result of adding an action to calculate ALIAS. @@ -1948,7 +1950,7 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc if (!options.ignore_quota && (options.to_stage == QueryProcessingStage::Complete)) quota = context->getQuota(); - storage->read(query_plan, required_columns, metadata_snapshot, query_info, context, processing_stage, max_block_size, max_streams); + storage->read(query_plan, required_columns, storage_snapshot, query_info, context, processing_stage, max_block_size, max_streams); if (context->hasQueryContext() && !options.is_internal) { @@ -1963,8 +1965,9 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc /// Create step which reads from empty source if storage has no data. if (!query_plan.isInitialized()) { - const auto & metadata = query_info.projection ? query_info.projection->desc->metadata : metadata_snapshot; - auto header = storage->getSampleBlockForColumns(metadata, required_columns); + /// TODO: fix. + // const auto & metadata = query_info.projection ? query_info.projection->desc->metadata : metadata_snapshot; + auto header = storage_snapshot->getSampleBlockForColumns(required_columns); addEmptySourceToQueryPlan(query_plan, header, query_info, context); } diff --git a/src/Interpreters/InterpreterSelectQuery.h b/src/Interpreters/InterpreterSelectQuery.h index aec3b0b8bd3..d8a866f00f8 100644 --- a/src/Interpreters/InterpreterSelectQuery.h +++ b/src/Interpreters/InterpreterSelectQuery.h @@ -203,6 +203,7 @@ private: Poco::Logger * log; StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; }; } diff --git a/src/Interpreters/MutationsInterpreter.cpp b/src/Interpreters/MutationsInterpreter.cpp index 03a2a4da1d1..0d5d03b676a 100644 --- a/src/Interpreters/MutationsInterpreter.cpp +++ b/src/Interpreters/MutationsInterpreter.cpp @@ -732,7 +732,7 @@ ASTPtr MutationsInterpreter::prepareInterpreterSelectQuery(std::vector & for (const String & column : stage.output_columns) all_asts->children.push_back(std::make_shared(column)); - auto syntax_result = TreeRewriter(context).analyze(all_asts, all_columns, storage, metadata_snapshot); + auto syntax_result = TreeRewriter(context).analyze(all_asts, all_columns, storage, storage->getStorageSnapshot(metadata_snapshot)); if (context->hasQueryContext()) for (const auto & it : syntax_result->getScalars()) context->getQueryContext()->addScalar(it.first, it.second); diff --git a/src/Interpreters/TreeOptimizer.cpp b/src/Interpreters/TreeOptimizer.cpp index c1a265d9a06..8724ac55802 100644 --- a/src/Interpreters/TreeOptimizer.cpp +++ b/src/Interpreters/TreeOptimizer.cpp @@ -607,9 +607,8 @@ void TreeOptimizer::apply(ASTPtr & query, TreeRewriterResult & result, if (!select_query) throw Exception("Select analyze for not select asts.", ErrorCodes::LOGICAL_ERROR); - if (settings.optimize_functions_to_subcolumns && result.storage - && result.storage->supportsSubcolumns() && result.metadata_snapshot) - optimizeFunctionsToSubcolumns(query, result.metadata_snapshot); + if (settings.optimize_functions_to_subcolumns && result.storage_snapshot && result.storage->supportsSubcolumns()) + optimizeFunctionsToSubcolumns(query, result.storage_snapshot->metadata); optimizeIf(query, result.aliases, settings.optimize_if_chain_to_multiif); @@ -668,7 +667,7 @@ void TreeOptimizer::apply(ASTPtr & query, TreeRewriterResult & result, /// Replace monotonous functions with its argument if (settings.optimize_monotonous_functions_in_order_by) optimizeMonotonousFunctionsInOrderBy(select_query, context, tables_with_columns, - result.metadata_snapshot ? result.metadata_snapshot->getSortingKeyColumns() : Names{}); + result.storage_snapshot ? result.storage_snapshot->metadata->getSortingKeyColumns() : Names{}); /// Remove duplicate items from ORDER BY. /// Execute it after all order by optimizations, diff --git a/src/Interpreters/TreeRewriter.cpp b/src/Interpreters/TreeRewriter.cpp index 7f0f53d5b26..2e9ddaf5c54 100644 --- a/src/Interpreters/TreeRewriter.cpp +++ b/src/Interpreters/TreeRewriter.cpp @@ -617,10 +617,10 @@ std::vector getWindowFunctions(ASTPtr & query, const ASTSel TreeRewriterResult::TreeRewriterResult( const NamesAndTypesList & source_columns_, ConstStoragePtr storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, bool add_special) : storage(storage_) - , metadata_snapshot(metadata_snapshot_) + , storage_snapshot(storage_snapshot_) , source_columns(source_columns_) { collectSourceColumns(add_special); @@ -638,7 +638,7 @@ void TreeRewriterResult::collectSourceColumns(bool add_special) if (storage->supportsSubcolumns()) options.withSubcolumns(); - auto columns_from_storage = storage->getColumns(metadata_snapshot, options); + auto columns_from_storage = storage_snapshot->getColumns(options); if (source_columns.empty()) source_columns.swap(columns_from_storage); @@ -745,9 +745,9 @@ void TreeRewriterResult::collectUsedColumns(const ASTPtr & query, bool is_select /// If we have no information about columns sizes, choose a column of minimum size of its data type. required.insert(ExpressionActions::getSmallestColumn(source_columns)); } - else if (is_select && metadata_snapshot && !columns_context.has_array_join) + else if (is_select && storage_snapshot && !columns_context.has_array_join) { - const auto & partition_desc = metadata_snapshot->getPartitionKey(); + const auto & partition_desc = storage_snapshot->metadata->getPartitionKey(); if (partition_desc.expression) { auto partition_source_columns = partition_desc.expression->getRequiredColumns(); @@ -939,9 +939,9 @@ TreeRewriterResultPtr TreeRewriter::analyzeSelect( result.required_source_columns_before_expanding_alias_columns = result.required_source_columns.getNames(); /// rewrite filters for select query, must go after getArrayJoinedColumns - if (settings.optimize_respect_aliases && result.metadata_snapshot) + if (settings.optimize_respect_aliases && result.storage_snapshot) { - replaceAliasColumnsInQuery(query, result.metadata_snapshot->getColumns(), result.array_join_result_to_source, getContext()); + replaceAliasColumnsInQuery(query, result.storage_snapshot->metadata->getColumns(), result.array_join_result_to_source, getContext()); result.collectUsedColumns(query, true); } @@ -960,7 +960,7 @@ TreeRewriterResultPtr TreeRewriter::analyze( ASTPtr & query, const NamesAndTypesList & source_columns, ConstStoragePtr storage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, bool allow_aggregations, bool allow_self_aliases) const { @@ -969,7 +969,7 @@ TreeRewriterResultPtr TreeRewriter::analyze( const auto & settings = getContext()->getSettingsRef(); - TreeRewriterResult result(source_columns, storage, metadata_snapshot, false); + TreeRewriterResult result(source_columns, storage, storage_snapshot, false); normalize(query, result.aliases, result.source_columns_set, false, settings, allow_self_aliases); diff --git a/src/Interpreters/TreeRewriter.h b/src/Interpreters/TreeRewriter.h index 0dca00c285e..e5d69f41811 100644 --- a/src/Interpreters/TreeRewriter.h +++ b/src/Interpreters/TreeRewriter.h @@ -19,11 +19,13 @@ struct SelectQueryOptions; using Scalars = std::map; struct StorageInMemoryMetadata; using StorageMetadataPtr = std::shared_ptr; +struct StorageSnapshot; +using StorageSnapshotPtr = std::shared_ptr; struct TreeRewriterResult { ConstStoragePtr storage; - StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; std::shared_ptr analyzed_join; const ASTTablesInSelectQueryElement * ast_join = nullptr; @@ -76,7 +78,7 @@ struct TreeRewriterResult TreeRewriterResult( const NamesAndTypesList & source_columns_, ConstStoragePtr storage_ = {}, - const StorageMetadataPtr & metadata_snapshot_ = {}, + const StorageSnapshotPtr & storage_snapshot_ = {}, bool add_special = true); void collectSourceColumns(bool add_special); @@ -109,7 +111,7 @@ public: ASTPtr & query, const NamesAndTypesList & source_columns_, ConstStoragePtr storage = {}, - const StorageMetadataPtr & metadata_snapshot = {}, + const StorageSnapshotPtr & storage_snapshot = {}, bool allow_aggregations = false, bool allow_self_aliases = true) const; diff --git a/src/Interpreters/getHeaderForProcessingStage.cpp b/src/Interpreters/getHeaderForProcessingStage.cpp index a98ce9eec0a..3cf5c977e8b 100644 --- a/src/Interpreters/getHeaderForProcessingStage.cpp +++ b/src/Interpreters/getHeaderForProcessingStage.cpp @@ -80,9 +80,8 @@ bool removeJoin(ASTSelectQuery & select, TreeRewriterResult & rewriter_result, C } Block getHeaderForProcessingStage( - const IStorage & storage, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage) @@ -91,7 +90,7 @@ Block getHeaderForProcessingStage( { case QueryProcessingStage::FetchColumns: { - Block header = storage.getSampleBlockForColumns(metadata_snapshot, column_names); + Block header = storage_snapshot->getSampleBlockForColumns(column_names); if (query_info.prewhere_info) { @@ -122,7 +121,7 @@ Block getHeaderForProcessingStage( removeJoin(*query->as(), new_rewriter_result, context); auto stream = std::make_shared( - storage.getSampleBlockForColumns(metadata_snapshot, column_names)); + storage_snapshot->getSampleBlockForColumns(column_names)); return InterpreterSelectQuery(query, context, stream, SelectQueryOptions(processed_stage).analyze()).getSampleBlock(); } } diff --git a/src/Interpreters/getHeaderForProcessingStage.h b/src/Interpreters/getHeaderForProcessingStage.h index 54a1126a3df..6ada136030e 100644 --- a/src/Interpreters/getHeaderForProcessingStage.h +++ b/src/Interpreters/getHeaderForProcessingStage.h @@ -10,8 +10,8 @@ namespace DB { class IStorage; -struct StorageInMemoryMetadata; -using StorageMetadataPtr = std::shared_ptr; +struct StorageSnapshot; +using StorageSnapshotPtr = std::shared_ptr; struct SelectQueryInfo; struct TreeRewriterResult; class ASTSelectQuery; @@ -20,9 +20,8 @@ bool hasJoin(const ASTSelectQuery & select); bool removeJoin(ASTSelectQuery & select, TreeRewriterResult & rewriter_result, ContextPtr context); Block getHeaderForProcessingStage( - const IStorage & storage, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage); diff --git a/src/Processors/QueryPlan/ReadFromMergeTree.cpp b/src/Processors/QueryPlan/ReadFromMergeTree.cpp index b772662c29e..a3c4067000b 100644 --- a/src/Processors/QueryPlan/ReadFromMergeTree.cpp +++ b/src/Processors/QueryPlan/ReadFromMergeTree.cpp @@ -74,6 +74,7 @@ ReadFromMergeTree::ReadFromMergeTree( Names virt_column_names_, const MergeTreeData & data_, const SelectQueryInfo & query_info_, + StorageSnapshotPtr storage_snapshot_, StorageMetadataPtr metadata_snapshot_, StorageMetadataPtr metadata_snapshot_base_, ContextPtr context_, @@ -83,7 +84,7 @@ ReadFromMergeTree::ReadFromMergeTree( std::shared_ptr max_block_numbers_to_read_, Poco::Logger * log_) : ISourceStep(DataStream{.header = MergeTreeBaseSelectProcessor::transformHeader( - data_.getSampleBlockForColumns(metadata_snapshot_, real_column_names_), + storage_snapshot_->getSampleBlockForColumns(real_column_names_), getPrewhereInfo(query_info_), data_.getPartitionValueType(), virt_column_names_)}) @@ -95,6 +96,7 @@ ReadFromMergeTree::ReadFromMergeTree( , query_info(query_info_) , prewhere_info(getPrewhereInfo(query_info)) , actions_settings(ExpressionActionsSettings::fromContext(context_)) + , storage_snapshot(std::move(storage_snapshot_)) , metadata_snapshot(std::move(metadata_snapshot_)) , metadata_snapshot_base(std::move(metadata_snapshot_base_)) , context(std::move(context_)) @@ -141,7 +143,7 @@ Pipe ReadFromMergeTree::readFromPool( min_marks_for_concurrent_read, std::move(parts_with_range), data, - metadata_snapshot, + storage_snapshot, prewhere_info, true, required_columns, @@ -157,7 +159,7 @@ Pipe ReadFromMergeTree::readFromPool( auto source = std::make_shared( i, pool, min_marks_for_concurrent_read, max_block_size, settings.preferred_block_size_bytes, settings.preferred_max_column_in_block_size_bytes, - data, metadata_snapshot, use_uncompressed_cache, + data, storage_snapshot, use_uncompressed_cache, prewhere_info, actions_settings, reader_settings, virt_column_names); if (i == 0) @@ -179,7 +181,7 @@ ProcessorPtr ReadFromMergeTree::createSource( bool use_uncompressed_cache) { return std::make_shared( - data, metadata_snapshot, part.data_part, max_block_size, preferred_block_size_bytes, + data, storage_snapshot, part.data_part, max_block_size, preferred_block_size_bytes, preferred_max_column_in_block_size_bytes, required_columns, part.ranges, use_uncompressed_cache, prewhere_info, actions_settings, true, reader_settings, virt_column_names, part.part_index_in_query); } @@ -784,7 +786,7 @@ ReadFromMergeTree::AnalysisResult ReadFromMergeTree::selectRangesToRead(MergeTre result.column_names_to_read.push_back(ExpressionActions::getSmallestColumn(available_real_columns)); } - data.check(metadata_snapshot, result.column_names_to_read); + storage_snapshot->check(result.column_names_to_read); // Build and check if primary key is used when necessary const auto & primary_key = metadata_snapshot->getPrimaryKey(); diff --git a/src/Processors/QueryPlan/ReadFromMergeTree.h b/src/Processors/QueryPlan/ReadFromMergeTree.h index a5184d28593..764227ef304 100644 --- a/src/Processors/QueryPlan/ReadFromMergeTree.h +++ b/src/Processors/QueryPlan/ReadFromMergeTree.h @@ -60,6 +60,7 @@ public: Names virt_column_names_, const MergeTreeData & data_, const SelectQueryInfo & query_info_, + StorageSnapshotPtr storage_snapshot, StorageMetadataPtr metadata_snapshot_, StorageMetadataPtr metadata_snapshot_base_, ContextPtr context_, @@ -92,6 +93,7 @@ private: PrewhereInfoPtr prewhere_info; ExpressionActionsSettings actions_settings; + StorageSnapshotPtr storage_snapshot; StorageMetadataPtr metadata_snapshot; StorageMetadataPtr metadata_snapshot_base; diff --git a/src/Storages/HDFS/StorageHDFS.cpp b/src/Storages/HDFS/StorageHDFS.cpp index 578da239c20..a8ab5c00ba2 100644 --- a/src/Storages/HDFS/StorageHDFS.cpp +++ b/src/Storages/HDFS/StorageHDFS.cpp @@ -274,7 +274,7 @@ Strings LSWithRegexpMatching(const String & path_for_ls, const HDFSFSPtr & fs, c Pipe StorageHDFS::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context_, QueryProcessingStage::Enum /*processed_stage*/, @@ -309,7 +309,7 @@ Pipe StorageHDFS::read( for (size_t i = 0; i < num_streams; ++i) pipes.emplace_back(std::make_shared( - sources_info, uri_without_path, format_name, compression_method, metadata_snapshot->getSampleBlock(), context_, max_block_size)); + sources_info, uri_without_path, format_name, compression_method, storage_snapshot->metadata->getSampleBlock(), context_, max_block_size)); return Pipe::unitePipes(std::move(pipes)); } diff --git a/src/Storages/HDFS/StorageHDFS.h b/src/Storages/HDFS/StorageHDFS.h index 4a6614be2e0..f24992ba412 100644 --- a/src/Storages/HDFS/StorageHDFS.h +++ b/src/Storages/HDFS/StorageHDFS.h @@ -25,7 +25,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp index 8a9a2f5f76f..2ccaf9b2c1c 100644 --- a/src/Storages/IStorage.cpp +++ b/src/Storages/IStorage.cpp @@ -90,7 +90,7 @@ TableExclusiveLockHolder IStorage::lockExclusively(const String & query_id, cons Pipe IStorage::read( const Names & /*column_names*/, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, @@ -103,18 +103,19 @@ Pipe IStorage::read( void IStorage::read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, unsigned num_streams) { - auto pipe = read(column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams); + auto pipe = read(column_names, storage_snapshot, query_info, context, processed_stage, max_block_size, num_streams); if (pipe.empty()) { - const auto & metadata_for_query = query_info.projection ? query_info.projection->desc->metadata : metadata_snapshot; - auto header = getSampleBlockForColumns(metadata_for_query, column_names); + /// TODO: fix + // const auto & metadata_for_query = query_info.projection ? query_info.projection->desc->metadata : storage_snapshot->metadata; + auto header = storage_snapshot->getSampleBlockForColumns(column_names); InterpreterSelectQuery::addEmptySourceToQueryPlan(query_plan, header, query_info, context); } else @@ -206,90 +207,11 @@ NameDependencies IStorage::getDependentViewsByColumn(ContextPtr context) const return name_deps; } -NamesAndTypesList IStorage::getColumns(const StorageMetadataPtr & metadata_snapshot, const GetColumnsOptions & options) const +StorageSnapshotPtr IStorage::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const { - auto all_columns = metadata_snapshot->getColumns().get(options); - - if (options.with_virtuals) - { - /// Virtual columns must be appended after ordinary, - /// because user can override them. - auto virtuals = getVirtuals(); - if (!virtuals.empty()) - { - NameSet column_names; - for (const auto & column : all_columns) - column_names.insert(column.name); - for (auto && column : virtuals) - if (!column_names.count(column.name)) - all_columns.push_back(std::move(column)); - } - } - - if (options.with_extended_objects) - all_columns = extendObjectColumns(all_columns, options.with_subcolumns); - - return all_columns; + return std::make_shared(*this, metadata_snapshot); } -Block IStorage::getSampleBlockForColumns(const StorageMetadataPtr & metadata_snapshot, const Names & column_names) const -{ - Block res; - - auto all_columns = getColumns( - metadata_snapshot, - GetColumnsOptions(GetColumnsOptions::All) - .withSubcolumns().withVirtuals().withExtendedObjects()); - - std::unordered_map columns_map; - columns_map.reserve(all_columns.size()); - - for (const auto & elem : all_columns) - columns_map.emplace(elem.name, elem.type); - - for (const auto & name : column_names) - { - auto it = columns_map.find(name); - if (it != columns_map.end()) - res.insert({it->second->createColumn(), it->second, it->first}); - else - throw Exception(ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK, - "Column {} not found in table {}", backQuote(name), getStorageID().getNameForLogs()); - } - - return res; -} - -void IStorage::check(const StorageMetadataPtr & metadata_snapshot, const Names & column_names) const -{ - auto available_columns = getColumns( - metadata_snapshot, - GetColumnsOptions(GetColumnsOptions::AllPhysical) - .withSubcolumns().withVirtuals().withExtendedObjects()).getNames(); - - if (column_names.empty()) - throw Exception(ErrorCodes::EMPTY_LIST_OF_COLUMNS_QUERIED, - "Empty list of columns queried. There are columns: {}", - boost::algorithm::join(available_columns, ",")); - - std::unordered_set columns_set(available_columns.begin(), available_columns.end()); - std::unordered_set unique_names; - - for (const auto & name : column_names) - { - if (columns_set.end() == columns_set.find(name)) - throw Exception(ErrorCodes::NO_SUCH_COLUMN_IN_TABLE, - "There is no column with name {} in table {}. There are columns: ", - backQuote(name), getStorageID().getNameForLogs(), boost::algorithm::join(available_columns, ",")); - - if (unique_names.end() != unique_names.find(name)) - throw Exception(ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE, "Column {} queried more than once", name); - - unique_names.insert(name); - } -} - - std::string PrewhereInfo::dump() const { WriteBufferFromOwnString ss; diff --git a/src/Storages/IStorage.h b/src/Storages/IStorage.h index 8dc1277cc33..fa7e58b6d0b 100644 --- a/src/Storages/IStorage.h +++ b/src/Storages/IStorage.h @@ -14,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -160,16 +161,6 @@ public: /// used without any locks. StorageMetadataPtr getInMemoryMetadataPtr() const { return metadata.get(); } - NamesAndTypesList getColumns(const StorageMetadataPtr & metadata_snapshot, const GetColumnsOptions & options) const; - - /// Block with ordinary + materialized + aliases + virtuals + subcolumns. - /// message. - Block getSampleBlockForColumns(const StorageMetadataPtr & metadata_snapshot, const Names & column_names) const; - - /// Verify that all the requested names are in the table and are set correctly: - /// list of names is not empty and the names do not repeat. - void check(const StorageMetadataPtr & metadata_snapshot, const Names & column_names) const; - /// Update storage metadata. Used in ALTER or initialization of Storage. /// Metadata object is multiversion, so this method can be called without /// any locks. @@ -246,8 +237,7 @@ public: * QueryProcessingStage::Enum required for Distributed over Distributed, * since it cannot return Complete for intermediate queries never. */ - virtual QueryProcessingStage::Enum - getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageMetadataPtr &, SelectQueryInfo &) const + virtual QueryProcessingStage::Enum getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const { return QueryProcessingStage::FetchColumns; } @@ -304,7 +294,7 @@ public: */ virtual Pipe read( const Names & /*column_names*/, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, @@ -316,7 +306,7 @@ public: virtual void read( QueryPlan & query_plan, const Names & /*column_names*/, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, @@ -564,6 +554,8 @@ public: virtual NamesAndTypesList extendObjectColumns(const NamesAndTypesList & columns_list, bool /*with_subcolumns*/) const { return columns_list; } + virtual StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const; + private: /// Lock required for alter queries (lockForAlter). Always taken for write /// (actually can be replaced with std::mutex, but for consistency we use diff --git a/src/Storages/Kafka/KafkaBlockInputStream.cpp b/src/Storages/Kafka/KafkaBlockInputStream.cpp index b75f7a4e5be..b4146b634e5 100644 --- a/src/Storages/Kafka/KafkaBlockInputStream.cpp +++ b/src/Storages/Kafka/KafkaBlockInputStream.cpp @@ -21,21 +21,21 @@ const auto MAX_FAILED_POLL_ATTEMPTS = 10; KafkaBlockInputStream::KafkaBlockInputStream( StorageKafka & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const std::shared_ptr & context_, const Names & columns, Poco::Logger * log_, size_t max_block_size_, bool commit_in_suffix_) : storage(storage_) - , metadata_snapshot(metadata_snapshot_) + , storage_snapshot(storage_snapshot_) , context(context_) , column_names(columns) , log(log_) , max_block_size(max_block_size_) , commit_in_suffix(commit_in_suffix_) - , non_virtual_header(metadata_snapshot->getSampleBlockNonMaterialized()) - , virtual_header(storage.getSampleBlockForColumns(metadata_snapshot, storage.getVirtualColumnNames())) + , non_virtual_header(storage_snapshot->metadata->getSampleBlockNonMaterialized()) + , virtual_header(storage_snapshot->getSampleBlockForColumns(storage.getVirtualColumnNames())) , handle_error_mode(storage.getHandleKafkaErrorMode()) { } @@ -53,7 +53,7 @@ KafkaBlockInputStream::~KafkaBlockInputStream() Block KafkaBlockInputStream::getHeader() const { - return storage.getSampleBlockForColumns(metadata_snapshot, column_names); + return storage_snapshot->getSampleBlockForColumns(column_names); } void KafkaBlockInputStream::readPrefixImpl() diff --git a/src/Storages/Kafka/KafkaBlockInputStream.h b/src/Storages/Kafka/KafkaBlockInputStream.h index 98e4b8982e0..88b757bd2ef 100644 --- a/src/Storages/Kafka/KafkaBlockInputStream.h +++ b/src/Storages/Kafka/KafkaBlockInputStream.h @@ -18,7 +18,7 @@ class KafkaBlockInputStream : public IBlockInputStream public: KafkaBlockInputStream( StorageKafka & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const std::shared_ptr & context_, const Names & columns, Poco::Logger * log_, @@ -38,7 +38,7 @@ public: private: StorageKafka & storage; - StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; ContextPtr context; Names column_names; Poco::Logger * log; diff --git a/src/Storages/Kafka/StorageKafka.cpp b/src/Storages/Kafka/StorageKafka.cpp index 15dd5b553b0..af006abd249 100644 --- a/src/Storages/Kafka/StorageKafka.cpp +++ b/src/Storages/Kafka/StorageKafka.cpp @@ -258,7 +258,7 @@ String StorageKafka::getDefaultClientId(const StorageID & table_id_) Pipe StorageKafka::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /* query_info */, ContextPtr local_context, QueryProcessingStage::Enum /* processed_stage */, @@ -281,7 +281,8 @@ Pipe StorageKafka::read( /// TODO: probably that leads to awful performance. /// FIXME: seems that doesn't help with extra reading and committing unprocessed messages. /// TODO: rewrite KafkaBlockInputStream to KafkaSource. Now it is used in other place. - pipes.emplace_back(std::make_shared(std::make_shared(*this, metadata_snapshot, modified_context, column_names, log, 1))); + pipes.emplace_back(std::make_shared(std::make_shared( + *this, storage_snapshot, modified_context, column_names, log, 1))); } LOG_DEBUG(log, "Starting reading {} streams", pipes.size()); @@ -592,7 +593,8 @@ bool StorageKafka::streamToViews() auto table = DatabaseCatalog::instance().getTable(table_id, getContext()); if (!table) throw Exception("Engine table " + table_id.getNameForLogs() + " doesn't exist.", ErrorCodes::LOGICAL_ERROR); - auto metadata_snapshot = getInMemoryMetadataPtr(); + + auto storage_snapshot = getStorageSnapshot(getInMemoryMetadataPtr()); // Create an INSERT query for streaming data auto insert = std::make_shared(); @@ -616,7 +618,8 @@ bool StorageKafka::streamToViews() streams.reserve(stream_count); for (size_t i = 0; i < stream_count; ++i) { - auto stream = std::make_shared(*this, metadata_snapshot, kafka_context, block_io.out->getHeader().getNames(), log, block_size, false); + auto stream = std::make_shared( + *this, storage_snapshot, kafka_context, block_io.out->getHeader().getNames(), log, block_size, false); streams.emplace_back(stream); // Limit read batch to maximum block size to allow DDL diff --git a/src/Storages/Kafka/StorageKafka.h b/src/Storages/Kafka/StorageKafka.h index 805fa9d510c..9ba190611ec 100644 --- a/src/Storages/Kafka/StorageKafka.h +++ b/src/Storages/Kafka/StorageKafka.h @@ -43,7 +43,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/LiveView/StorageBlocks.h b/src/Storages/LiveView/StorageBlocks.h index 6cf7ce59fa2..388a94462ee 100644 --- a/src/Storages/LiveView/StorageBlocks.h +++ b/src/Storages/LiveView/StorageBlocks.h @@ -34,14 +34,14 @@ public: bool supportsFinal() const override { return true; } QueryProcessingStage::Enum - getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageMetadataPtr &, SelectQueryInfo &) const override + getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const override { return to_stage; } Pipe read( const Names & /*column_names*/, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, diff --git a/src/Storages/LiveView/StorageLiveView.cpp b/src/Storages/LiveView/StorageLiveView.cpp index f54abda6d7f..f7022cf6d5b 100644 --- a/src/Storages/LiveView/StorageLiveView.cpp +++ b/src/Storages/LiveView/StorageLiveView.cpp @@ -497,7 +497,7 @@ void StorageLiveView::refresh(bool grab_lock) Pipe StorageLiveView::read( const Names & /*column_names*/, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, diff --git a/src/Storages/LiveView/StorageLiveView.h b/src/Storages/LiveView/StorageLiveView.h index 23a9c84cb9e..deaf74bed41 100644 --- a/src/Storages/LiveView/StorageLiveView.h +++ b/src/Storages/LiveView/StorageLiveView.h @@ -146,7 +146,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp index 549a8a4f772..a756618dc67 100644 --- a/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp +++ b/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.cpp @@ -25,7 +25,7 @@ namespace ErrorCodes MergeTreeBaseSelectProcessor::MergeTreeBaseSelectProcessor( Block header, const MergeTreeData & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const PrewhereInfoPtr & prewhere_info_, ExpressionActionsSettings actions_settings, UInt64 max_block_size_rows_, @@ -36,7 +36,7 @@ MergeTreeBaseSelectProcessor::MergeTreeBaseSelectProcessor( const Names & virt_column_names_) : SourceWithProgress(transformHeader(std::move(header), prewhere_info_, storage_.getPartitionValueType(), virt_column_names_)) , storage(storage_) - , metadata_snapshot(metadata_snapshot_) + , storage_snapshot(storage_snapshot_) , prewhere_info(prewhere_info_) , max_block_size_rows(max_block_size_rows_) , preferred_block_size_bytes(preferred_block_size_bytes_) diff --git a/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.h b/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.h index 8da9b002e16..d8127e041d5 100644 --- a/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.h +++ b/src/Storages/MergeTree/MergeTreeBaseSelectProcessor.h @@ -22,7 +22,7 @@ public: MergeTreeBaseSelectProcessor( Block header, const MergeTreeData & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const PrewhereInfoPtr & prewhere_info_, ExpressionActionsSettings actions_settings, UInt64 max_block_size_rows_, @@ -57,7 +57,7 @@ protected: protected: const MergeTreeData & storage; - StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; PrewhereInfoPtr prewhere_info; std::unique_ptr prewhere_actions; diff --git a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp index 12c96f3eb02..88a596dd1ae 100644 --- a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp +++ b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp @@ -265,7 +265,7 @@ void MergeTreeBlockSizePredictor::update(const Block & sample_block, const Colum MergeTreeReadTaskColumns getReadTaskColumns( const MergeTreeData & storage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const MergeTreeData::DataPartPtr & data_part, const Names & required_columns, const PrewhereInfoPtr & prewhere_info, @@ -275,7 +275,7 @@ MergeTreeReadTaskColumns getReadTaskColumns( Names pre_column_names; /// inject columns required for defaults evaluation - bool should_reorder = !injectRequiredColumns(storage, metadata_snapshot, data_part, column_names).empty(); + bool should_reorder = !injectRequiredColumns(storage, storage_snapshot->metadata, data_part, column_names).empty(); if (prewhere_info) { @@ -300,7 +300,7 @@ MergeTreeReadTaskColumns getReadTaskColumns( if (pre_column_names.empty()) pre_column_names.push_back(column_names[0]); - const auto injected_pre_columns = injectRequiredColumns(storage, metadata_snapshot, data_part, pre_column_names); + const auto injected_pre_columns = injectRequiredColumns(storage, storage_snapshot->metadata, data_part, pre_column_names); if (!injected_pre_columns.empty()) should_reorder = true; @@ -318,7 +318,7 @@ MergeTreeReadTaskColumns getReadTaskColumns( if (check_columns) { - auto all_columns = storage.getColumns(metadata_snapshot, + auto all_columns = storage_snapshot->getColumns( GetColumnsOptions(GetColumnsOptions::All).withSubcolumns().withExtendedObjects()); result.pre_columns = all_columns.addTypes(pre_column_names); diff --git a/src/Storages/MergeTree/MergeTreeBlockReadUtils.h b/src/Storages/MergeTree/MergeTreeBlockReadUtils.h index 31d609e4242..4eee4ccd8d0 100644 --- a/src/Storages/MergeTree/MergeTreeBlockReadUtils.h +++ b/src/Storages/MergeTree/MergeTreeBlockReadUtils.h @@ -75,7 +75,7 @@ struct MergeTreeReadTaskColumns MergeTreeReadTaskColumns getReadTaskColumns( const MergeTreeData & storage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const MergeTreeData::DataPartPtr & data_part, const Names & required_columns, const PrewhereInfoPtr & prewhere_info, diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index 730626ba8e5..74976c057ef 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -3861,7 +3861,7 @@ using PartitionIdToMaxBlock = std::unordered_map; static void selectBestProjection( const MergeTreeDataSelectExecutor & reader, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, const Names & required_columns, ProjectionCandidate & candidate, @@ -3890,7 +3890,8 @@ static void selectBestProjection( auto sum_marks = reader.estimateNumMarksToRead( projection_parts, candidate.required_columns, - metadata_snapshot, + storage_snapshot, + storage_snapshot->metadata, candidate.desc->metadata, query_info, // TODO syntax_analysis_result set in index query_context, @@ -3908,8 +3909,9 @@ static void selectBestProjection( sum_marks += reader.estimateNumMarksToRead( normal_parts, required_columns, - metadata_snapshot, - metadata_snapshot, + storage_snapshot, + storage_snapshot->metadata, + storage_snapshot->metadata, query_info, // TODO syntax_analysis_result set in index query_context, settings.max_threads, @@ -3926,8 +3928,9 @@ static void selectBestProjection( bool MergeTreeData::getQueryProcessingStageWithAggregateProjection( - ContextPtr query_context, const StorageMetadataPtr & metadata_snapshot, SelectQueryInfo & query_info) const + ContextPtr query_context, const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info) const { + const auto & metadata_snapshot = storage_snapshot->metadata; const auto & settings = query_context->getSettingsRef(); if (!settings.allow_experimental_projection_optimization || query_info.ignore_projections) return false; @@ -4160,7 +4163,7 @@ bool MergeTreeData::getQueryProcessingStageWithAggregateProjection( { selectBestProjection( reader, - metadata_snapshot, + storage_snapshot, query_info, analysis_result.required_columns, candidate, @@ -4181,6 +4184,7 @@ bool MergeTreeData::getQueryProcessingStageWithAggregateProjection( min_sum_marks = reader.estimateNumMarksToRead( parts, analysis_result.required_columns, + storage_snapshot, metadata_snapshot, metadata_snapshot, query_info, // TODO syntax_analysis_result set in index @@ -4198,7 +4202,7 @@ bool MergeTreeData::getQueryProcessingStageWithAggregateProjection( { selectBestProjection( reader, - metadata_snapshot, + storage_snapshot, query_info, analysis_result.required_columns, candidate, @@ -4232,12 +4236,12 @@ bool MergeTreeData::getQueryProcessingStageWithAggregateProjection( QueryProcessingStage::Enum MergeTreeData::getQueryProcessingStage( ContextPtr query_context, QueryProcessingStage::Enum to_stage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info) const { if (to_stage >= QueryProcessingStage::Enum::WithMergeableState) { - if (getQueryProcessingStageWithAggregateProjection(query_context, metadata_snapshot, query_info)) + if (getQueryProcessingStageWithAggregateProjection(query_context, storage_snapshot, query_info)) { if (query_info.projection->desc->type == ProjectionDescription::Type::Aggregate) return QueryProcessingStage::Enum::WithMergeableState; @@ -5101,27 +5105,13 @@ ReservationPtr MergeTreeData::balancedReservation( return reserved_space; } -static NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list) -{ - NameSet res; - for (const auto & [name, type] : columns_list) - if (isObject(type)) - res.insert(name); - - return res; -} - -static NamesAndTypesList extendObjectColumnsImpl( - const MergeTreeData::DataPartsVector & parts, - const NamesAndTypesList & columns_list, - const NameSet & requested_to_extend, - bool with_subcolumns) +StorageSnapshot::NameToTypeMap MergeTreeData::getObjectTypes(const DataPartsVector & parts, const NameSet & object_names) { std::unordered_map types_in_parts; if (parts.empty()) { - for (const auto & name : requested_to_extend) + for (const auto & name : object_names) types_in_parts[name].push_back(std::make_shared( DataTypes{std::make_shared()}, Names{ColumnObject::COLUMN_NAME_DUMMY})); @@ -5133,57 +5123,27 @@ static NamesAndTypesList extendObjectColumnsImpl( const auto & part_columns = part->getColumns(); for (const auto & [name, type] : part_columns) { - if (requested_to_extend.count(name)) + if (object_names.count(name)) types_in_parts[name].push_back(type); } } } - NamesAndTypesList result_columns; - for (const auto & column : columns_list) - { - auto it = types_in_parts.find(column.name); - if (it != types_in_parts.end()) - { - auto expanded_type = getLeastCommonTypeForObject(it->second); - result_columns.emplace_back(column.name, expanded_type); + StorageSnapshot::NameToTypeMap object_types; + for (const auto & [name, types] : types_in_parts) + object_types.emplace(name, getLeastCommonTypeForObject(types)); - if (with_subcolumns) - { - for (const auto & subcolumn : expanded_type->getSubcolumnNames()) - { - result_columns.emplace_back(column.name, subcolumn, - expanded_type, expanded_type->getSubcolumnType(subcolumn)); - } - } - } - else - { - result_columns.push_back(column); - } - } - - return result_columns; + return object_types; } -NamesAndTypesList MergeTreeData::extendObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns) +StorageSnapshotPtr MergeTreeData::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const { - /// Firstly fast check without locking parts, if there are any Object columns. - NameSet requested_to_extend = getNamesOfObjectColumns(columns_list); - if (requested_to_extend.empty()) - return columns_list; + auto parts = getDataPartsVector(); + auto object_types = getObjectTypes( + parts, + getNamesOfObjectColumns(metadata_snapshot->getColumns().getAll())); - return extendObjectColumnsImpl(parts, columns_list, requested_to_extend, with_subcolumns); -} - -NamesAndTypesList MergeTreeData::extendObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const -{ - /// Firstly fast check without locking parts, if there are any Object columns. - NameSet requested_to_extend = getNamesOfObjectColumns(columns_list); - if (requested_to_extend.empty()) - return columns_list; - - return extendObjectColumnsImpl(getDataPartsVector(), columns_list, requested_to_extend, with_subcolumns); + return std::make_shared(*this, metadata_snapshot, object_types, parts); } CurrentlySubmergingEmergingTagger::~CurrentlySubmergingEmergingTagger() diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index 0c24e16b10e..79f1ebaa6d0 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -363,12 +363,12 @@ public: BrokenPartCallback broken_part_callback_ = [](const String &){}); bool getQueryProcessingStageWithAggregateProjection( - ContextPtr query_context, const StorageMetadataPtr & metadata_snapshot, SelectQueryInfo & query_info) const; + ContextPtr query_context, const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info) const; QueryProcessingStage::Enum getQueryProcessingStage( ContextPtr query_context, QueryProcessingStage::Enum to_stage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & info) const override; ReservationPtr reserveSpace(UInt64 expected_size, VolumePtr & volume) const; @@ -394,6 +394,8 @@ public: bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr, const StorageMetadataPtr & metadata_snapshot) const override; + StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const override; + /// Load the set of data parts from disk. Call once - immediately after the object is created. void loadDataParts(bool skip_sanity_checks); @@ -635,8 +637,7 @@ public: return column_sizes; } - NamesAndTypesList extendObjectColumns(const NamesAndTypesList & columns_list, bool with_subcolumns) const override; - static NamesAndTypesList extendObjectColumns(const DataPartsVector & parts, const NamesAndTypesList & columns_list, bool with_subcolumns); + static StorageSnapshot::NameToTypeMap getObjectTypes(const DataPartsVector & parts, const NameSet & object_names); /// For ATTACH/DETACH/DROP PARTITION. String getPartitionIDFromQuery(const ASTPtr & ast, ContextPtr context) const; diff --git a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp index 45c3027c638..708b8c10c08 100644 --- a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp +++ b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp @@ -15,6 +15,7 @@ #include #include #include +#include #include #include #include @@ -718,7 +719,11 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor Names all_column_names = metadata_snapshot->getColumns().getNamesOfPhysical(); NamesAndTypesList storage_columns = metadata_snapshot->getColumns().getAllPhysical(); - storage_columns = MergeTreeData::extendObjectColumns(parts, storage_columns, false); + + auto object_types = MergeTreeData::getObjectTypes(parts, getNamesOfObjectColumns(storage_columns)); + auto storage_snapshot = std::make_shared(data, metadata_snapshot, object_types, parts); + storage_columns = extendObjectColumns(storage_columns, object_types, false); + const auto data_settings = data.getSettings(); NamesAndTypesList gathering_columns; @@ -858,8 +863,9 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor for (const auto & part : parts) { + /// TODO: Fix auto input = std::make_unique( - data, metadata_snapshot, part, merging_column_names, read_with_direct_io, true); + data, storage_snapshot, part, merging_column_names, read_with_direct_io, true); input->setProgressCallback( MergeProgressCallback(merge_entry, watch_prev_elapsed, horizontal_stage_progress)); @@ -1061,7 +1067,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor for (size_t part_num = 0; part_num < parts.size(); ++part_num) { auto column_part_source = std::make_shared( - data, metadata_snapshot, parts[part_num], column_names, read_with_direct_io, true); + data, storage_snapshot, parts[part_num], column_names, read_with_direct_io, true); column_part_source->setProgressCallback( MergeProgressCallback(merge_entry, watch_prev_elapsed, column_progress)); diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp index bd3153034b3..6c2bb157c4f 100644 --- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp +++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp @@ -124,7 +124,7 @@ static RelativeSize convertAbsoluteSampleSizeToRelative(const ASTPtr & node, siz QueryPlanPtr MergeTreeDataSelectExecutor::read( const Names & column_names_to_return, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, ContextPtr context, const UInt64 max_block_size, @@ -133,12 +133,15 @@ QueryPlanPtr MergeTreeDataSelectExecutor::read( std::shared_ptr max_block_numbers_to_read) const { const auto & settings = context->getSettingsRef(); - auto parts = data.getDataPartsVector(); + const auto & parts = storage_snapshot->parts; + const auto & metadata_snapshot = storage_snapshot->metadata; + if (!query_info.projection) { auto plan = readFromParts( parts, column_names_to_return, + storage_snapshot, metadata_snapshot, metadata_snapshot, query_info, @@ -185,6 +188,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::read( auto plan = readFromParts( projection_parts, query_info.projection->required_columns, + storage_snapshot, metadata_snapshot, query_info.projection->desc->metadata, query_info, @@ -1086,6 +1090,7 @@ static void selectColumnNames( size_t MergeTreeDataSelectExecutor::estimateNumMarksToRead( MergeTreeData::DataPartsVector parts, const Names & column_names_to_return, + const StorageSnapshotPtr & storage_snapshot, const StorageMetadataPtr & metadata_snapshot_base, const StorageMetadataPtr & metadata_snapshot, const SelectQueryInfo & query_info, @@ -1116,7 +1121,7 @@ size_t MergeTreeDataSelectExecutor::estimateNumMarksToRead( real_column_names.push_back(ExpressionActions::getSmallestColumn(available_real_columns)); } - data.check(metadata_snapshot, real_column_names); + storage_snapshot->check(real_column_names); const auto & primary_key = metadata_snapshot->getPrimaryKey(); Names primary_key_columns = primary_key.column_names; @@ -1166,6 +1171,7 @@ size_t MergeTreeDataSelectExecutor::estimateNumMarksToRead( QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts( MergeTreeData::DataPartsVector parts, const Names & column_names_to_return, + const StorageSnapshotPtr & storage_snapshot, const StorageMetadataPtr & metadata_snapshot_base, const StorageMetadataPtr & metadata_snapshot, const SelectQueryInfo & query_info, @@ -1192,6 +1198,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts( virt_column_names, data, query_info, + storage_snapshot, metadata_snapshot, metadata_snapshot_base, context, diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h index bd2a79f0aee..88443c0febc 100644 --- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h +++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h @@ -37,7 +37,7 @@ public: QueryPlanPtr read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, ContextPtr context, UInt64 max_block_size, @@ -49,6 +49,7 @@ public: QueryPlanPtr readFromParts( MergeTreeData::DataPartsVector parts, const Names & column_names, + const StorageSnapshotPtr & storage_snapshot, const StorageMetadataPtr & metadata_snapshot_base, const StorageMetadataPtr & metadata_snapshot, const SelectQueryInfo & query_info, @@ -63,7 +64,8 @@ public: size_t estimateNumMarksToRead( MergeTreeData::DataPartsVector parts, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot_base, + const StorageSnapshotPtr & storage_snapshot, + const StorageMetadataPtr & storage_snapshot_base, const StorageMetadataPtr & metadata_snapshot, const SelectQueryInfo & query_info, ContextPtr context, diff --git a/src/Storages/MergeTree/MergeTreeDataWriter.cpp b/src/Storages/MergeTree/MergeTreeDataWriter.cpp index a36d3ab144d..f6c5fa40580 100644 --- a/src/Storages/MergeTree/MergeTreeDataWriter.cpp +++ b/src/Storages/MergeTree/MergeTreeDataWriter.cpp @@ -273,7 +273,8 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataWriter::writeTempPart( { Block & block = block_with_partition.block; auto columns = metadata_snapshot->getColumns().getAllPhysical().filter(block.getNames()); - auto extended_storage_columns = data.getColumns(metadata_snapshot, + auto storage_snapshot = data.getStorageSnapshot(metadata_snapshot); + auto extended_storage_columns = storage_snapshot->getColumns( GetColumnsOptions(GetColumnsOptions::AllPhysical).withExtendedObjects()); convertObjectsToTuples(columns, block, extended_storage_columns); diff --git a/src/Storages/MergeTree/MergeTreeReadPool.cpp b/src/Storages/MergeTree/MergeTreeReadPool.cpp index 2c525f506ce..1e26d6abe1b 100644 --- a/src/Storages/MergeTree/MergeTreeReadPool.cpp +++ b/src/Storages/MergeTree/MergeTreeReadPool.cpp @@ -23,7 +23,7 @@ MergeTreeReadPool::MergeTreeReadPool( const size_t min_marks_for_concurrent_read_, RangesInDataParts && parts_, const MergeTreeData & data_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const PrewhereInfoPtr & prewhere_info_, const bool check_columns_, const Names & column_names_, @@ -33,7 +33,7 @@ MergeTreeReadPool::MergeTreeReadPool( : backoff_settings{backoff_settings_} , backoff_state{threads_} , data{data_} - , metadata_snapshot{metadata_snapshot_} + , storage_snapshot{storage_snapshot_} , column_names{column_names_} , do_not_steal_tasks{do_not_steal_tasks_} , predict_block_size_bytes{preferred_block_size_bytes_ > 0} @@ -168,7 +168,7 @@ MarkRanges MergeTreeReadPool::getRestMarks(const IMergeTreeDataPart & part, cons Block MergeTreeReadPool::getHeader() const { - return data.getSampleBlockForColumns(metadata_snapshot, column_names); + return storage_snapshot->getSampleBlockForColumns(column_names); } void MergeTreeReadPool::profileFeedback(const ReadBufferFromFileBase::ProfileInfo info) @@ -215,7 +215,7 @@ std::vector MergeTreeReadPool::fillPerPartInfo( const RangesInDataParts & parts, const bool check_columns) { std::vector per_part_sum_marks; - Block sample_block = metadata_snapshot->getSampleBlock(); + Block sample_block = storage_snapshot->metadata->getSampleBlock(); for (const auto i : collections::range(0, parts.size())) { @@ -229,7 +229,7 @@ std::vector MergeTreeReadPool::fillPerPartInfo( per_part_sum_marks.push_back(sum_marks); auto [required_columns, required_pre_columns, should_reorder] = - getReadTaskColumns(data, metadata_snapshot, part.data_part, column_names, prewhere_info, check_columns); + getReadTaskColumns(data, storage_snapshot, part.data_part, column_names, prewhere_info, check_columns); /// will be used to distinguish between PREWHERE and WHERE columns when applying filter const auto & required_column_names = required_columns.getNames(); diff --git a/src/Storages/MergeTree/MergeTreeReadPool.h b/src/Storages/MergeTree/MergeTreeReadPool.h index 9949bdf86f8..8fefcdeffaf 100644 --- a/src/Storages/MergeTree/MergeTreeReadPool.h +++ b/src/Storages/MergeTree/MergeTreeReadPool.h @@ -71,7 +71,7 @@ private: public: MergeTreeReadPool( const size_t threads_, const size_t sum_marks_, const size_t min_marks_for_concurrent_read_, - RangesInDataParts && parts_, const MergeTreeData & data_, const StorageMetadataPtr & metadata_snapshot_, + RangesInDataParts && parts_, const MergeTreeData & data_, const StorageSnapshotPtr & storage_snapshot_, const PrewhereInfoPtr & prewhere_info_, const bool check_columns_, const Names & column_names_, const BackoffSettings & backoff_settings_, size_t preferred_block_size_bytes_, @@ -99,7 +99,7 @@ private: const RangesInDataParts & parts, const size_t min_marks_for_concurrent_read); const MergeTreeData & data; - StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; const Names column_names; bool do_not_steal_tasks; bool predict_block_size_bytes; diff --git a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp index b4abf7de222..b537c1286e1 100644 --- a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp +++ b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.cpp @@ -14,7 +14,7 @@ namespace ErrorCodes MergeTreeReverseSelectProcessor::MergeTreeReverseSelectProcessor( const MergeTreeData & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const MergeTreeData::DataPartPtr & owned_data_part_, UInt64 max_block_size_rows_, size_t preferred_block_size_bytes_, @@ -31,8 +31,8 @@ MergeTreeReverseSelectProcessor::MergeTreeReverseSelectProcessor( bool quiet) : MergeTreeBaseSelectProcessor{ - storage_.getSampleBlockForColumns(metadata_snapshot_, required_columns_), - storage_, metadata_snapshot_, prewhere_info_, std::move(actions_settings), max_block_size_rows_, + storage_snapshot_->getSampleBlockForColumns(required_columns_), + storage_, storage_snapshot_, prewhere_info_, std::move(actions_settings), max_block_size_rows_, preferred_block_size_bytes_, preferred_max_column_in_block_size_bytes_, reader_settings_, use_uncompressed_cache_, virt_column_names_}, required_columns{std::move(required_columns_)}, @@ -56,7 +56,7 @@ MergeTreeReverseSelectProcessor::MergeTreeReverseSelectProcessor( ordered_names = header_without_virtual_columns.getNames(); - task_columns = getReadTaskColumns(storage, metadata_snapshot, data_part, required_columns, prewhere_info, check_columns); + task_columns = getReadTaskColumns(storage, storage_snapshot_, data_part, required_columns, prewhere_info, check_columns); /// will be used to distinguish between PREWHERE and WHERE columns when applying filter const auto & column_names = task_columns.columns.getNames(); @@ -67,12 +67,12 @@ MergeTreeReverseSelectProcessor::MergeTreeReverseSelectProcessor( owned_mark_cache = storage.getContext()->getMarkCache(); - reader = data_part->getReader(task_columns.columns, metadata_snapshot, + reader = data_part->getReader(task_columns.columns, storage_snapshot_->metadata, all_mark_ranges, owned_uncompressed_cache.get(), owned_mark_cache.get(), reader_settings); if (prewhere_info) - pre_reader = data_part->getReader(task_columns.pre_columns, metadata_snapshot, all_mark_ranges, + pre_reader = data_part->getReader(task_columns.pre_columns, storage_snapshot_->metadata, all_mark_ranges, owned_uncompressed_cache.get(), owned_mark_cache.get(), reader_settings); } @@ -96,7 +96,7 @@ try auto size_predictor = (preferred_block_size_bytes == 0) ? nullptr - : std::make_unique(data_part, ordered_names, metadata_snapshot->getSampleBlock()); + : std::make_unique(data_part, ordered_names, storage_snapshot->metadata->getSampleBlock()); task = std::make_unique( data_part, mark_ranges_for_task, part_index_in_query, ordered_names, column_name_set, diff --git a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.h b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.h index b807c2d912c..53138450629 100644 --- a/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.h +++ b/src/Storages/MergeTree/MergeTreeReverseSelectProcessor.h @@ -18,7 +18,7 @@ class MergeTreeReverseSelectProcessor : public MergeTreeBaseSelectProcessor public: MergeTreeReverseSelectProcessor( const MergeTreeData & storage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot_, const MergeTreeData::DataPartPtr & owned_data_part, UInt64 max_block_size_rows, size_t preferred_block_size_bytes, diff --git a/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp b/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp index b663ab5220f..09b863d3808 100644 --- a/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp +++ b/src/Storages/MergeTree/MergeTreeSelectProcessor.cpp @@ -14,7 +14,7 @@ namespace ErrorCodes MergeTreeSelectProcessor::MergeTreeSelectProcessor( const MergeTreeData & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const MergeTreeData::DataPartPtr & owned_data_part_, UInt64 max_block_size_rows_, size_t preferred_block_size_bytes_, @@ -31,8 +31,8 @@ MergeTreeSelectProcessor::MergeTreeSelectProcessor( bool quiet) : MergeTreeBaseSelectProcessor{ - storage_.getSampleBlockForColumns(metadata_snapshot_, required_columns_), - storage_, metadata_snapshot_, prewhere_info_, std::move(actions_settings), max_block_size_rows_, + storage_snapshot_->getSampleBlockForColumns(required_columns_), + storage_, storage_snapshot_, prewhere_info_, std::move(actions_settings), max_block_size_rows_, preferred_block_size_bytes_, preferred_max_column_in_block_size_bytes_, reader_settings_, use_uncompressed_cache_, virt_column_names_}, required_columns{std::move(required_columns_)}, @@ -69,9 +69,10 @@ try is_first_task = false; task_columns = getReadTaskColumns( - storage, metadata_snapshot, data_part, + storage, storage_snapshot, data_part, required_columns, prewhere_info, check_columns); + const auto & metadata_snapshot = storage_snapshot->metadata; auto size_predictor = (preferred_block_size_bytes == 0) ? nullptr : std::make_unique(data_part, ordered_names, metadata_snapshot->getSampleBlock()); diff --git a/src/Storages/MergeTree/MergeTreeSelectProcessor.h b/src/Storages/MergeTree/MergeTreeSelectProcessor.h index b63107b6dbf..15df4d067fa 100644 --- a/src/Storages/MergeTree/MergeTreeSelectProcessor.h +++ b/src/Storages/MergeTree/MergeTreeSelectProcessor.h @@ -18,7 +18,7 @@ class MergeTreeSelectProcessor : public MergeTreeBaseSelectProcessor public: MergeTreeSelectProcessor( const MergeTreeData & storage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot_, const MergeTreeData::DataPartPtr & owned_data_part, UInt64 max_block_size_rows, size_t preferred_block_size_bytes, diff --git a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp index 9d27adac6d2..e2c70d191d3 100644 --- a/src/Storages/MergeTree/MergeTreeSequentialSource.cpp +++ b/src/Storages/MergeTree/MergeTreeSequentialSource.cpp @@ -11,15 +11,15 @@ namespace ErrorCodes MergeTreeSequentialSource::MergeTreeSequentialSource( const MergeTreeData & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, MergeTreeData::DataPartPtr data_part_, Names columns_to_read_, bool read_with_direct_io_, bool take_column_types_from_storage, bool quiet) - : SourceWithProgress(storage_.getSampleBlockForColumns(metadata_snapshot_, columns_to_read_)) + : SourceWithProgress(storage_snapshot_->getSampleBlockForColumns(columns_to_read_)) , storage(storage_) - , metadata_snapshot(metadata_snapshot_) + , storage_snapshot(storage_snapshot_) , data_part(std::move(data_part_)) , columns_to_read(std::move(columns_to_read_)) , read_with_direct_io(read_with_direct_io_) @@ -39,12 +39,13 @@ MergeTreeSequentialSource::MergeTreeSequentialSource( addTotalRowsApprox(data_part->rows_count); /// Add columns because we don't want to read empty blocks - injectRequiredColumns(storage, metadata_snapshot, data_part, columns_to_read); + injectRequiredColumns(storage, storage_snapshot->metadata, data_part, columns_to_read); NamesAndTypesList columns_for_reader; if (take_column_types_from_storage) { - auto physical_columns = storage.getColumns(metadata_snapshot, + auto physical_columns = storage_snapshot->getColumns( GetColumnsOptions(GetColumnsOptions::AllPhysical).withExtendedObjects()); + columns_for_reader = physical_columns.addTypes(columns_to_read); } else @@ -61,7 +62,7 @@ MergeTreeSequentialSource::MergeTreeSequentialSource( .save_marks_in_cache = false }; - reader = data_part->getReader(columns_for_reader, metadata_snapshot, + reader = data_part->getReader(columns_for_reader, storage_snapshot->metadata, MarkRanges{MarkRange(0, data_part->getMarksCount())}, /* uncompressed_cache = */ nullptr, mark_cache.get(), reader_settings); } diff --git a/src/Storages/MergeTree/MergeTreeSequentialSource.h b/src/Storages/MergeTree/MergeTreeSequentialSource.h index 7eefdd9335b..8e2b3b81c7c 100644 --- a/src/Storages/MergeTree/MergeTreeSequentialSource.h +++ b/src/Storages/MergeTree/MergeTreeSequentialSource.h @@ -14,7 +14,7 @@ class MergeTreeSequentialSource : public SourceWithProgress public: MergeTreeSequentialSource( const MergeTreeData & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, MergeTreeData::DataPartPtr data_part_, Names columns_to_read_, bool read_with_direct_io_, @@ -35,7 +35,7 @@ protected: private: const MergeTreeData & storage; - StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; /// Data part will not be removed if the pointer owns it MergeTreeData::DataPartPtr data_part; diff --git a/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.cpp b/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.cpp index daefb17038a..af01a22f80d 100644 --- a/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.cpp +++ b/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.cpp @@ -16,7 +16,7 @@ MergeTreeThreadSelectBlockInputProcessor::MergeTreeThreadSelectBlockInputProcess size_t preferred_block_size_bytes_, size_t preferred_max_column_in_block_size_bytes_, const MergeTreeData & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const bool use_uncompressed_cache_, const PrewhereInfoPtr & prewhere_info_, ExpressionActionsSettings actions_settings, @@ -24,7 +24,7 @@ MergeTreeThreadSelectBlockInputProcessor::MergeTreeThreadSelectBlockInputProcess const Names & virt_column_names_) : MergeTreeBaseSelectProcessor{ - pool_->getHeader(), storage_, metadata_snapshot_, prewhere_info_, std::move(actions_settings), max_block_size_rows_, + pool_->getHeader(), storage_, storage_snapshot_, prewhere_info_, std::move(actions_settings), max_block_size_rows_, preferred_block_size_bytes_, preferred_max_column_in_block_size_bytes_, reader_settings_, use_uncompressed_cache_, virt_column_names_}, thread{thread_}, @@ -65,6 +65,7 @@ bool MergeTreeThreadSelectBlockInputProcessor::getNewTask() /// Allows pool to reduce number of threads in case of too slow reads. auto profile_callback = [this](ReadBufferFromFileBase::ProfileInfo info_) { pool->profileFeedback(info_); }; + const auto & metadata_snapshot = storage_snapshot->metadata; if (!reader) { diff --git a/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.h b/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.h index 30c551eede0..38bd544ca22 100644 --- a/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.h +++ b/src/Storages/MergeTree/MergeTreeThreadSelectBlockInputProcessor.h @@ -22,7 +22,7 @@ public: size_t preferred_block_size_bytes_, size_t preferred_max_column_in_block_size_bytes_, const MergeTreeData & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const bool use_uncompressed_cache_, const PrewhereInfoPtr & prewhere_info_, ExpressionActionsSettings actions_settings, diff --git a/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h b/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h index 5d82716af11..9664af21541 100644 --- a/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h +++ b/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h @@ -24,7 +24,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, @@ -35,6 +35,7 @@ public: QueryPlan query_plan = std::move(*MergeTreeDataSelectExecutor(storage).readFromParts( {}, column_names, + storage_snapshot, metadata_snapshot, metadata_snapshot, query_info, diff --git a/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h b/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h index 9cc2787697d..c14964c9e23 100644 --- a/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h +++ b/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h @@ -24,7 +24,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, @@ -36,8 +36,9 @@ public: .readFromParts( parts, column_names, - metadata_snapshot, - metadata_snapshot, + storage_snapshot, + storage_snapshot->metadata, + storage_snapshot->metadata, query_info, context, max_block_size, diff --git a/src/Storages/PostgreSQL/StorageMaterializedPostgreSQL.cpp b/src/Storages/PostgreSQL/StorageMaterializedPostgreSQL.cpp index 70251a940cc..341d654216e 100644 --- a/src/Storages/PostgreSQL/StorageMaterializedPostgreSQL.cpp +++ b/src/Storages/PostgreSQL/StorageMaterializedPostgreSQL.cpp @@ -258,7 +258,7 @@ NamesAndTypesList StorageMaterializedPostgreSQL::getVirtuals() const Pipe StorageMaterializedPostgreSQL::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & query_info, ContextPtr context_, QueryProcessingStage::Enum processed_stage, @@ -267,7 +267,7 @@ Pipe StorageMaterializedPostgreSQL::read( { auto materialized_table_lock = lockForShare(String(), context_->getSettingsRef().lock_acquire_timeout); auto nested_table = getNested(); - return readFinalFromNestedStorage(nested_table, column_names, metadata_snapshot, + return readFinalFromNestedStorage(nested_table, column_names, query_info, context_, processed_stage, max_block_size, num_streams); } diff --git a/src/Storages/PostgreSQL/StorageMaterializedPostgreSQL.h b/src/Storages/PostgreSQL/StorageMaterializedPostgreSQL.h index 5d18a0b16b7..051de71ed5e 100644 --- a/src/Storages/PostgreSQL/StorageMaterializedPostgreSQL.h +++ b/src/Storages/PostgreSQL/StorageMaterializedPostgreSQL.h @@ -84,7 +84,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context_, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp index ec12f84c341..5657fc4c041 100644 --- a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp +++ b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.cpp @@ -15,20 +15,20 @@ namespace DB RabbitMQBlockInputStream::RabbitMQBlockInputStream( StorageRabbitMQ & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, ContextPtr context_, const Names & columns, size_t max_block_size_, bool ack_in_suffix_) : storage(storage_) - , metadata_snapshot(metadata_snapshot_) + , storage_snapshot(storage_snapshot_) , context(context_) , column_names(columns) , max_block_size(max_block_size_) , ack_in_suffix(ack_in_suffix_) - , non_virtual_header(metadata_snapshot->getSampleBlockNonMaterialized()) + , non_virtual_header(storage_snapshot->metadata->getSampleBlockNonMaterialized()) , sample_block(non_virtual_header) - , virtual_header(storage.getSampleBlockForColumns(metadata_snapshot, + , virtual_header(storage_snapshot->getSampleBlockForColumns( {"_exchange_name", "_channel_id", "_delivery_tag", "_redelivered", "_message_id", "_timestamp"})) { for (const auto & column : virtual_header) diff --git a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.h b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.h index 5ce1c96bf33..e6a7d16572f 100644 --- a/src/Storages/RabbitMQ/RabbitMQBlockInputStream.h +++ b/src/Storages/RabbitMQ/RabbitMQBlockInputStream.h @@ -14,7 +14,7 @@ class RabbitMQBlockInputStream : public IBlockInputStream public: RabbitMQBlockInputStream( StorageRabbitMQ & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, ContextPtr context_, const Names & columns, size_t max_block_size_, @@ -37,7 +37,7 @@ public: private: StorageRabbitMQ & storage; - StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; ContextPtr context; Names column_names; const size_t max_block_size; diff --git a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp index 293edb0711a..b6263f398c6 100644 --- a/src/Storages/RabbitMQ/StorageRabbitMQ.cpp +++ b/src/Storages/RabbitMQ/StorageRabbitMQ.cpp @@ -595,7 +595,7 @@ void StorageRabbitMQ::unbindExchange() Pipe StorageRabbitMQ::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /* query_info */, ContextPtr local_context, QueryProcessingStage::Enum /* processed_stage */, @@ -608,7 +608,7 @@ Pipe StorageRabbitMQ::read( if (num_created_consumers == 0) return {}; - auto sample_block = getSampleBlockForColumns(metadata_snapshot, column_names); + auto sample_block = storage_snapshot->getSampleBlockForColumns(column_names); auto modified_context = addSettings(local_context); auto block_size = getMaxBlockSize(); @@ -625,7 +625,7 @@ Pipe StorageRabbitMQ::read( for (size_t i = 0; i < num_created_consumers; ++i) { auto rabbit_stream = std::make_shared( - *this, metadata_snapshot, modified_context, column_names, block_size); + *this, storage_snapshot, modified_context, column_names, block_size); auto converting_stream = std::make_shared( rabbit_stream, sample_block, ConvertingBlockInputStream::MatchColumnsMode::Name); @@ -903,9 +903,9 @@ bool StorageRabbitMQ::streamToViews() InterpreterInsertQuery interpreter(insert, rabbitmq_context, false, true, true); auto block_io = interpreter.execute(); - auto metadata_snapshot = getInMemoryMetadataPtr(); + auto storage_snapshot = getStorageSnapshot(getInMemoryMetadataPtr()); auto column_names = block_io.out->getHeader().getNames(); - auto sample_block = getSampleBlockForColumns(metadata_snapshot, column_names); + auto sample_block = storage_snapshot->getSampleBlockForColumns(column_names); auto block_size = getMaxBlockSize(); @@ -916,7 +916,7 @@ bool StorageRabbitMQ::streamToViews() for (size_t i = 0; i < num_created_consumers; ++i) { auto stream = std::make_shared( - *this, metadata_snapshot, rabbitmq_context, column_names, block_size, false); + *this, storage_snapshot, rabbitmq_context, column_names, block_size, false); streams.emplace_back(stream); // Limit read batch to maximum block size to allow DDL diff --git a/src/Storages/RabbitMQ/StorageRabbitMQ.h b/src/Storages/RabbitMQ/StorageRabbitMQ.h index 1935dcaee0e..09dc46d004b 100644 --- a/src/Storages/RabbitMQ/StorageRabbitMQ.h +++ b/src/Storages/RabbitMQ/StorageRabbitMQ.h @@ -43,7 +43,7 @@ public: /// Always return virtual columns in addition to required columns Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/ReadFinalForExternalReplicaStorage.cpp b/src/Storages/ReadFinalForExternalReplicaStorage.cpp index fb96bb01936..9a66bb25630 100644 --- a/src/Storages/ReadFinalForExternalReplicaStorage.cpp +++ b/src/Storages/ReadFinalForExternalReplicaStorage.cpp @@ -19,7 +19,6 @@ namespace DB Pipe readFinalFromNestedStorage( StoragePtr nested_storage, const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -28,7 +27,7 @@ Pipe readFinalFromNestedStorage( { NameSet column_names_set = NameSet(column_names.begin(), column_names.end()); auto lock = nested_storage->lockForShare(context->getCurrentQueryId(), context->getSettingsRef().lock_acquire_timeout); - const StorageMetadataPtr & nested_metadata = nested_storage->getInMemoryMetadataPtr(); + const auto & nested_metadata = nested_storage->getInMemoryMetadataPtr(); Block nested_header = nested_metadata->getSampleBlock(); ColumnWithTypeAndName & sign_column = nested_header.getByPosition(nested_header.columns() - 2); @@ -64,7 +63,8 @@ Pipe readFinalFromNestedStorage( expressions->children.emplace_back(std::make_shared(column_name)); } - Pipe pipe = nested_storage->read(require_columns_name, nested_metadata, query_info, context, processed_stage, max_block_size, num_streams); + auto nested_snapshot = nested_storage->getStorageSnapshot(nested_metadata); + Pipe pipe = nested_storage->read(require_columns_name, nested_snapshot, query_info, context, processed_stage, max_block_size, num_streams); pipe.addTableLock(lock); if (!expressions->children.empty() && !pipe.empty()) diff --git a/src/Storages/ReadFinalForExternalReplicaStorage.h b/src/Storages/ReadFinalForExternalReplicaStorage.h index b54592159ef..0870149c719 100644 --- a/src/Storages/ReadFinalForExternalReplicaStorage.h +++ b/src/Storages/ReadFinalForExternalReplicaStorage.h @@ -16,7 +16,6 @@ namespace DB Pipe readFinalFromNestedStorage( StoragePtr nested_storage, const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp index c29f74893ef..808d80d25dd 100644 --- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp +++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.cpp @@ -285,24 +285,24 @@ void StorageEmbeddedRocksDB::initDb() Pipe StorageEmbeddedRocksDB::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, size_t max_block_size, unsigned num_streams) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); FieldVectorPtr keys; bool all_scan = false; - auto primary_key_data_type = metadata_snapshot->getSampleBlock().getByName(primary_key).type; + auto primary_key_data_type = storage_snapshot->metadata->getSampleBlock().getByName(primary_key).type; std::tie(keys, all_scan) = getFilterKeys(primary_key, primary_key_data_type, query_info); if (all_scan) { auto reader = std::make_shared( - *this, metadata_snapshot, max_block_size); + *this, storage_snapshot->metadata, max_block_size); return Pipe(std::make_shared(reader)); } else @@ -327,7 +327,7 @@ Pipe StorageEmbeddedRocksDB::read( size_t end = num_keys * (thread_idx + 1) / num_threads; pipes.emplace_back(std::make_shared( - *this, metadata_snapshot, keys, keys->begin() + begin, keys->begin() + end, max_block_size)); + *this, storage_snapshot->metadata, keys, keys->begin() + begin, keys->begin() + end, max_block_size)); } return Pipe::unitePipes(std::move(pipes)); } diff --git a/src/Storages/RocksDB/StorageEmbeddedRocksDB.h b/src/Storages/RocksDB/StorageEmbeddedRocksDB.h index aa81bc4d35f..ff6ffad3b31 100644 --- a/src/Storages/RocksDB/StorageEmbeddedRocksDB.h +++ b/src/Storages/RocksDB/StorageEmbeddedRocksDB.h @@ -27,7 +27,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageBuffer.cpp b/src/Storages/StorageBuffer.cpp index a63eef282d3..42f2d4dd80e 100644 --- a/src/Storages/StorageBuffer.cpp +++ b/src/Storages/StorageBuffer.cpp @@ -134,9 +134,9 @@ StorageBuffer::StorageBuffer( class BufferSource : public SourceWithProgress { public: - BufferSource(const Names & column_names_, StorageBuffer::Buffer & buffer_, const StorageBuffer & storage, const StorageMetadataPtr & metadata_snapshot) - : SourceWithProgress(storage.getSampleBlockForColumns(metadata_snapshot, column_names_)) - , column_names_and_types(metadata_snapshot->getColumns().getAllWithSubcolumns().addTypes(column_names_)) + BufferSource(const Names & column_names_, StorageBuffer::Buffer & buffer_, const StorageSnapshotPtr & storage_snapshot) + : SourceWithProgress(storage_snapshot->getSampleBlockForColumns(column_names_)) + , column_names_and_types(storage_snapshot->metadata->getColumns().getAllWithSubcolumns().addTypes(column_names_)) , buffer(buffer_) {} String getName() const override { return "Buffer"; } @@ -183,7 +183,7 @@ private: QueryProcessingStage::Enum StorageBuffer::getQueryProcessingStage( ContextPtr local_context, QueryProcessingStage::Enum to_stage, - const StorageMetadataPtr &, + const StorageSnapshotPtr &, SelectQueryInfo & query_info) const { if (destination_id) @@ -193,7 +193,8 @@ QueryProcessingStage::Enum StorageBuffer::getQueryProcessingStage( if (destination.get() == this) throw Exception("Destination table is myself. Read will cause infinite loop.", ErrorCodes::INFINITE_LOOP); - return destination->getQueryProcessingStage(local_context, to_stage, destination->getInMemoryMetadataPtr(), query_info); + const auto & destination_metadata = destination->getInMemoryMetadataPtr(); + return destination->getQueryProcessingStage(local_context, to_stage, destination->getStorageSnapshot(destination_metadata), query_info); } return QueryProcessingStage::FetchColumns; @@ -202,7 +203,7 @@ QueryProcessingStage::Enum StorageBuffer::getQueryProcessingStage( Pipe StorageBuffer::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -210,7 +211,7 @@ Pipe StorageBuffer::read( const unsigned num_streams) { QueryPlan plan; - read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); + read(plan, column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); return plan.convertToPipe( QueryPlanOptimizationSettings::fromContext(local_context), BuildQueryPipelineSettings::fromContext(local_context)); @@ -219,13 +220,15 @@ Pipe StorageBuffer::read( void StorageBuffer::read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, unsigned num_streams) { + const auto & metadata_snapshot = storage_snapshot->metadata; + if (destination_id) { auto destination = DatabaseCatalog::instance().getTable(destination_id, local_context); @@ -236,6 +239,7 @@ void StorageBuffer::read( auto destination_lock = destination->lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout); auto destination_metadata_snapshot = destination->getInMemoryMetadataPtr(); + auto destination_snapshot = destination->getStorageSnapshot(destination_metadata_snapshot); const bool dst_has_same_structure = std::all_of(column_names.begin(), column_names.end(), [metadata_snapshot, destination_metadata_snapshot](const String& column_name) { @@ -252,7 +256,7 @@ void StorageBuffer::read( /// The destination table has the same structure of the requested columns and we can simply read blocks from there. destination->read( - query_plan, column_names, destination_metadata_snapshot, query_info, + query_plan, column_names, destination_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); } else @@ -287,7 +291,7 @@ void StorageBuffer::read( else { destination->read( - query_plan, columns_intersection, destination_metadata_snapshot, query_info, + query_plan, columns_intersection, destination_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); if (query_plan.isInitialized()) @@ -344,7 +348,7 @@ void StorageBuffer::read( Pipes pipes_from_buffers; pipes_from_buffers.reserve(num_shards); for (auto & buf : buffers) - pipes_from_buffers.emplace_back(std::make_shared(column_names, buf, *this, metadata_snapshot)); + pipes_from_buffers.emplace_back(std::make_shared(column_names, buf, storage_snapshot)); pipe_from_buffers = Pipe::unitePipes(std::move(pipes_from_buffers)); } diff --git a/src/Storages/StorageBuffer.h b/src/Storages/StorageBuffer.h index b4fcdf6cbc9..884efe68d9d 100644 --- a/src/Storages/StorageBuffer.h +++ b/src/Storages/StorageBuffer.h @@ -59,11 +59,11 @@ public: std::string getName() const override { return "Buffer"; } QueryProcessingStage::Enum - getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageMetadataPtr &, SelectQueryInfo &) const override; + getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const override; Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -73,7 +73,7 @@ public: void read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageDictionary.cpp b/src/Storages/StorageDictionary.cpp index 4c31f62b21f..e28964eeeaa 100644 --- a/src/Storages/StorageDictionary.cpp +++ b/src/Storages/StorageDictionary.cpp @@ -160,7 +160,7 @@ void StorageDictionary::checkTableCanBeDetached() const Pipe StorageDictionary::read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & /*query_info*/, ContextPtr local_context, QueryProcessingStage::Enum /*processed_stage*/, diff --git a/src/Storages/StorageDictionary.h b/src/Storages/StorageDictionary.h index d074dec2c34..1f0b337222f 100644 --- a/src/Storages/StorageDictionary.h +++ b/src/Storages/StorageDictionary.h @@ -26,7 +26,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index f4d6ec5c6f7..c1983993d96 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -276,7 +276,7 @@ void replaceConstantExpressions( ConstStoragePtr storage, const StorageMetadataPtr & metadata_snapshot) { - auto syntax_result = TreeRewriter(context).analyze(node, columns, storage, metadata_snapshot); + auto syntax_result = TreeRewriter(context).analyze(node, columns, storage, storage->getStorageSnapshot(metadata_snapshot)); Block block_with_constants = KeyCondition::getBlockWithConstants(node, syntax_result, context); InDepthNodeVisitor visitor(block_with_constants); @@ -485,7 +485,7 @@ StorageDistributed::StorageDistributed( QueryProcessingStage::Enum StorageDistributed::getQueryProcessingStage( ContextPtr local_context, QueryProcessingStage::Enum to_stage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info) const { const auto & settings = local_context->getSettingsRef(); @@ -497,7 +497,7 @@ QueryProcessingStage::Enum StorageDistributed::getQueryProcessingStage( /// (Anyway it will be calculated in the read()) if (getClusterQueriedNodes(settings, cluster) > 1 && settings.optimize_skip_unused_shards) { - ClusterPtr optimized_cluster = getOptimizedCluster(local_context, metadata_snapshot, query_info.query); + ClusterPtr optimized_cluster = getOptimizedCluster(local_context, storage_snapshot->metadata, query_info.query); if (optimized_cluster) { LOG_DEBUG(log, "Skipping irrelevant shards - the query will be sent to the following shards of the cluster (shard numbers): {}", @@ -561,7 +561,7 @@ QueryProcessingStage::Enum StorageDistributed::getQueryProcessingStage( Pipe StorageDistributed::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -569,7 +569,7 @@ Pipe StorageDistributed::read( const unsigned num_streams) { QueryPlan plan; - read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); + read(plan, column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); return plan.convertToPipe( QueryPlanOptimizationSettings::fromContext(local_context), BuildQueryPipelineSettings::fromContext(local_context)); @@ -578,7 +578,7 @@ Pipe StorageDistributed::read( void StorageDistributed::read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -605,7 +605,7 @@ void StorageDistributed::read( const Scalars & scalars = local_context->hasQueryContext() ? local_context->getQueryContext()->getScalars() : Scalars{}; bool has_virtual_shard_num_column = std::find(column_names.begin(), column_names.end(), "_shard_num") != column_names.end(); - if (has_virtual_shard_num_column && !isVirtualColumn("_shard_num", metadata_snapshot)) + if (has_virtual_shard_num_column && !isVirtualColumn("_shard_num", storage_snapshot->metadata)) has_virtual_shard_num_column = false; ClusterProxy::SelectStreamFactory select_stream_factory = remote_table_function_ptr diff --git a/src/Storages/StorageDistributed.h b/src/Storages/StorageDistributed.h index c63abbc6aa4..6cd1115e9a9 100644 --- a/src/Storages/StorageDistributed.h +++ b/src/Storages/StorageDistributed.h @@ -57,11 +57,11 @@ public: bool isRemote() const override { return true; } QueryProcessingStage::Enum - getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageMetadataPtr &, SelectQueryInfo &) const override; + getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const override; Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -71,7 +71,7 @@ public: void read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageExternalDistributed.cpp b/src/Storages/StorageExternalDistributed.cpp index 32b9c7e9245..12bd809ac8f 100644 --- a/src/Storages/StorageExternalDistributed.cpp +++ b/src/Storages/StorageExternalDistributed.cpp @@ -177,7 +177,7 @@ StorageExternalDistributed::StorageExternalDistributed( Pipe StorageExternalDistributed::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -189,7 +189,7 @@ Pipe StorageExternalDistributed::read( { pipes.emplace_back(shard->read( column_names, - metadata_snapshot, + storage_snapshot, query_info, context, processed_stage, diff --git a/src/Storages/StorageExternalDistributed.h b/src/Storages/StorageExternalDistributed.h index c85276c09dd..1e0947d43b5 100644 --- a/src/Storages/StorageExternalDistributed.h +++ b/src/Storages/StorageExternalDistributed.h @@ -32,7 +32,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageFile.cpp b/src/Storages/StorageFile.cpp index ea64f46919e..01d26ec1f42 100644 --- a/src/Storages/StorageFile.cpp +++ b/src/Storages/StorageFile.cpp @@ -271,26 +271,26 @@ public: static Block getBlockForSource( const StorageFilePtr & storage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const ColumnsDescription & columns_description, const FilesInfoPtr & files_info) { if (storage->isColumnOriented()) - return storage->getSampleBlockForColumns(metadata_snapshot, columns_description.getNamesOfPhysical()); + return storage_snapshot->getSampleBlockForColumns(columns_description.getNamesOfPhysical()); else - return getHeader(metadata_snapshot, files_info->need_path_column, files_info->need_file_column); + return getHeader(storage_snapshot->metadata, files_info->need_path_column, files_info->need_file_column); } StorageFileSource( std::shared_ptr storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, ContextPtr context_, UInt64 max_block_size_, FilesInfoPtr files_info_, ColumnsDescription columns_description_) - : SourceWithProgress(getBlockForSource(storage_, metadata_snapshot_, columns_description_, files_info_)) + : SourceWithProgress(getBlockForSource(storage_, storage_snapshot_, columns_description_, files_info_)) , storage(std::move(storage_)) - , metadata_snapshot(metadata_snapshot_) + , storage_snapshot(storage_snapshot_) , files_info(std::move(files_info_)) , columns_description(std::move(columns_description_)) , context(context_) @@ -379,8 +379,8 @@ public: auto get_block_for_format = [&]() -> Block { if (storage->isColumnOriented()) - return storage->getSampleBlockForColumns(metadata_snapshot, columns_description.getNamesOfPhysical()); - return metadata_snapshot->getSampleBlock(); + return storage_snapshot->getSampleBlockForColumns(columns_description.getNamesOfPhysical()); + return storage_snapshot->metadata->getSampleBlock(); }; auto format = FormatFactory::instance().getInput( @@ -434,7 +434,7 @@ public: private: std::shared_ptr storage; - StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; FilesInfoPtr files_info; String current_path; Block sample_block; @@ -454,7 +454,7 @@ private: Pipe StorageFile::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, @@ -469,7 +469,7 @@ Pipe StorageFile::read( if (paths.size() == 1 && !fs::exists(paths[0])) { if (context->getSettingsRef().engine_file_empty_if_not_exists) - return Pipe(std::make_shared(getSampleBlockForColumns(metadata_snapshot, column_names))); + return Pipe(std::make_shared(storage_snapshot->getSampleBlockForColumns(column_names))); else throw Exception("File " + paths[0] + " doesn't exist", ErrorCodes::FILE_DOESNT_EXIST); } @@ -505,12 +505,12 @@ Pipe StorageFile::read( { if (isColumnOriented()) return ColumnsDescription{ - getSampleBlockForColumns(metadata_snapshot, column_names).getNamesAndTypesList()}; + storage_snapshot->getSampleBlockForColumns(column_names).getNamesAndTypesList()}; else - return metadata_snapshot->getColumns(); + return storage_snapshot->metadata->getColumns(); }; pipes.emplace_back(std::make_shared( - this_ptr, metadata_snapshot, context, max_block_size, files_info, get_columns_for_format())); + this_ptr, storage_snapshot, context, max_block_size, files_info, get_columns_for_format())); } return Pipe::unitePipes(std::move(pipes)); diff --git a/src/Storages/StorageFile.h b/src/Storages/StorageFile.h index 843cd405828..cbd4169562b 100644 --- a/src/Storages/StorageFile.h +++ b/src/Storages/StorageFile.h @@ -22,7 +22,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageGenerateRandom.cpp b/src/Storages/StorageGenerateRandom.cpp index 702eaa59c3e..982e194da87 100644 --- a/src/Storages/StorageGenerateRandom.cpp +++ b/src/Storages/StorageGenerateRandom.cpp @@ -479,19 +479,19 @@ void registerStorageGenerateRandom(StorageFactory & factory) Pipe StorageGenerateRandom::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, size_t max_block_size, unsigned num_streams) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); Pipes pipes; pipes.reserve(num_streams); - const ColumnsDescription & our_columns = metadata_snapshot->getColumns(); + const ColumnsDescription & our_columns = storage_snapshot->metadata->getColumns(); Block block_header; for (const auto & name : column_names) { diff --git a/src/Storages/StorageGenerateRandom.h b/src/Storages/StorageGenerateRandom.h index 61fd68cb80c..390b2cef46a 100644 --- a/src/Storages/StorageGenerateRandom.h +++ b/src/Storages/StorageGenerateRandom.h @@ -17,7 +17,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageInput.cpp b/src/Storages/StorageInput.cpp index 63b440aff08..e779de731b5 100644 --- a/src/Storages/StorageInput.cpp +++ b/src/Storages/StorageInput.cpp @@ -54,7 +54,7 @@ void StorageInput::setInputStream(BlockInputStreamPtr input_stream_) Pipe StorageInput::read( const Names & /*column_names*/, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, @@ -68,7 +68,7 @@ Pipe StorageInput::read( { /// Send structure to the client. query_context->initializeInput(shared_from_this()); - return Pipe(std::make_shared(query_context, metadata_snapshot->getSampleBlock())); + return Pipe(std::make_shared(query_context, storage_snapshot->metadata->getSampleBlock())); } if (!input_stream) diff --git a/src/Storages/StorageInput.h b/src/Storages/StorageInput.h index 4b04907bea2..c780edd36b9 100644 --- a/src/Storages/StorageInput.h +++ b/src/Storages/StorageInput.h @@ -19,7 +19,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageJoin.cpp b/src/Storages/StorageJoin.cpp index 48464d611ba..7fc814104b7 100644 --- a/src/Storages/StorageJoin.cpp +++ b/src/Storages/StorageJoin.cpp @@ -567,16 +567,16 @@ private: // TODO: multiple stream read and index read Pipe StorageJoin::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, size_t max_block_size, unsigned /*num_streams*/) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); - Block source_sample_block = getSampleBlockForColumns(metadata_snapshot, column_names); + Block source_sample_block = storage_snapshot->getSampleBlockForColumns(column_names); return Pipe(std::make_shared(join, rwlock, max_block_size, source_sample_block)); } diff --git a/src/Storages/StorageJoin.h b/src/Storages/StorageJoin.h index cf28e9d4dd0..402e8af3f73 100644 --- a/src/Storages/StorageJoin.h +++ b/src/Storages/StorageJoin.h @@ -49,7 +49,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageLog.cpp b/src/Storages/StorageLog.cpp index 8b146a8568c..2d7560cba2c 100644 --- a/src/Storages/StorageLog.cpp +++ b/src/Storages/StorageLog.cpp @@ -648,19 +648,19 @@ static std::chrono::seconds getLockTimeout(ContextPtr context) Pipe StorageLog::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, size_t max_block_size, unsigned num_streams) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); auto lock_timeout = getLockTimeout(context); loadMarks(lock_timeout); - auto all_columns = metadata_snapshot->getColumns().getAllWithSubcolumns().addTypes(column_names); + auto all_columns = storage_snapshot->metadata->getColumns().getAllWithSubcolumns().addTypes(column_names); all_columns = Nested::convertToSubcolumns(all_columns); std::shared_lock lock(rwlock, lock_timeout); @@ -669,7 +669,7 @@ Pipe StorageLog::read( Pipes pipes; - const Marks & marks = getMarksWithRealRowCount(metadata_snapshot); + const Marks & marks = getMarksWithRealRowCount(storage_snapshot->metadata); size_t marks_size = marks.size(); if (num_streams > marks_size) diff --git a/src/Storages/StorageLog.h b/src/Storages/StorageLog.h index 6fea00edefd..87ac5376955 100644 --- a/src/Storages/StorageLog.h +++ b/src/Storages/StorageLog.h @@ -27,7 +27,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageMaterializeMySQL.cpp b/src/Storages/StorageMaterializeMySQL.cpp index 5b371fe3fb8..a05c0c5dd2b 100644 --- a/src/Storages/StorageMaterializeMySQL.cpp +++ b/src/Storages/StorageMaterializeMySQL.cpp @@ -38,7 +38,7 @@ StorageMaterializeMySQL::StorageMaterializeMySQL(const StoragePtr & nested_stora Pipe StorageMaterializeMySQL::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -47,7 +47,7 @@ Pipe StorageMaterializeMySQL::read( { /// If the background synchronization thread has exception. rethrowSyncExceptionIfNeed(database); - return readFinalFromNestedStorage(nested_storage, column_names, metadata_snapshot, + return readFinalFromNestedStorage(nested_storage, column_names, query_info, context, processed_stage, max_block_size, num_streams); } diff --git a/src/Storages/StorageMaterializeMySQL.h b/src/Storages/StorageMaterializeMySQL.h index 45221ed5b76..aa5fe393c98 100644 --- a/src/Storages/StorageMaterializeMySQL.h +++ b/src/Storages/StorageMaterializeMySQL.h @@ -25,7 +25,7 @@ public: StorageMaterializeMySQL(const StoragePtr & nested_storage_, const IDatabase * database_); Pipe read( - const Names & column_names, const StorageMetadataPtr & metadata_snapshot, SelectQueryInfo & query_info, + const Names & column_names, const StorageSnapshotPtr & metadata_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, unsigned num_streams) override; BlockOutputStreamPtr write(const ASTPtr &, const StorageMetadataPtr &, ContextPtr) override { throwNotAllowed(); } diff --git a/src/Storages/StorageMaterializedView.cpp b/src/Storages/StorageMaterializedView.cpp index 76fa4b8e20b..74a6e4c679d 100644 --- a/src/Storages/StorageMaterializedView.cpp +++ b/src/Storages/StorageMaterializedView.cpp @@ -131,15 +131,16 @@ StorageMaterializedView::StorageMaterializedView( QueryProcessingStage::Enum StorageMaterializedView::getQueryProcessingStage( ContextPtr local_context, QueryProcessingStage::Enum to_stage, - const StorageMetadataPtr &, + const StorageSnapshotPtr &, SelectQueryInfo & query_info) const { - return getTargetTable()->getQueryProcessingStage(local_context, to_stage, getTargetTable()->getInMemoryMetadataPtr(), query_info); + auto target_metadata = getTargetTable()->getInMemoryMetadataPtr(); + return getTargetTable()->getQueryProcessingStage(local_context, to_stage, getTargetTable()->getStorageSnapshot(target_metadata), query_info); } Pipe StorageMaterializedView::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -147,7 +148,7 @@ Pipe StorageMaterializedView::read( const unsigned num_streams) { QueryPlan plan; - read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); + read(plan, column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); return plan.convertToPipe( QueryPlanOptimizationSettings::fromContext(local_context), BuildQueryPipelineSettings::fromContext(local_context)); @@ -156,7 +157,7 @@ Pipe StorageMaterializedView::read( void StorageMaterializedView::read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -166,15 +167,16 @@ void StorageMaterializedView::read( auto storage = getTargetTable(); auto lock = storage->lockForShare(local_context->getCurrentQueryId(), local_context->getSettingsRef().lock_acquire_timeout); auto target_metadata_snapshot = storage->getInMemoryMetadataPtr(); + auto target_storage_snapshot = storage->getStorageSnapshot(target_metadata_snapshot); if (query_info.order_optimizer) query_info.input_order_info = query_info.order_optimizer->getInputOrder(target_metadata_snapshot, local_context); - storage->read(query_plan, column_names, target_metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); + storage->read(query_plan, column_names, target_storage_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); if (query_plan.isInitialized()) { - auto mv_header = getHeaderForProcessingStage(*this, column_names, metadata_snapshot, query_info, local_context, processed_stage); + auto mv_header = getHeaderForProcessingStage(column_names, storage_snapshot, query_info, local_context, processed_stage); auto target_header = query_plan.getCurrentDataStream().header; /// No need to convert columns that does not exists in MV diff --git a/src/Storages/StorageMaterializedView.h b/src/Storages/StorageMaterializedView.h index 1f1729b05f7..69d06ce1063 100644 --- a/src/Storages/StorageMaterializedView.h +++ b/src/Storages/StorageMaterializedView.h @@ -67,7 +67,7 @@ public: void shutdown() override; QueryProcessingStage::Enum - getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageMetadataPtr &, SelectQueryInfo &) const override; + getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const override; StoragePtr getTargetTable() const; StoragePtr tryGetTargetTable() const; @@ -76,7 +76,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -86,7 +86,7 @@ public: void read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp index a8f563d69ca..fd09898e28c 100644 --- a/src/Storages/StorageMemory.cpp +++ b/src/Storages/StorageMemory.cpp @@ -29,13 +29,12 @@ public: MemorySource( Names column_names_, - const StorageMemory & storage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, std::shared_ptr data_, std::shared_ptr> parallel_execution_index_, InitializerFunc initializer_func_ = {}) - : SourceWithProgress(storage.getSampleBlockForColumns(metadata_snapshot, column_names_)) - , column_names_and_types(metadata_snapshot->getColumns().getAllWithSubcolumns().addTypes(std::move(column_names_))) + : SourceWithProgress(storage_snapshot->getSampleBlockForColumns(column_names_)) + , column_names_and_types(storage_snapshot->metadata->getColumns().getAllWithSubcolumns().addTypes(std::move(column_names_))) , data(data_) , parallel_execution_index(parallel_execution_index_) , initializer_func(std::move(initializer_func_)) @@ -178,14 +177,14 @@ StorageMemory::StorageMemory( Pipe StorageMemory::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, size_t /*max_block_size*/, unsigned num_streams) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); if (delay_read_for_global_subqueries) { @@ -199,8 +198,7 @@ Pipe StorageMemory::read( return Pipe(std::make_shared( column_names, - *this, - metadata_snapshot, + storage_snapshot, nullptr /* data */, nullptr /* parallel execution index */, [this](std::shared_ptr & data_to_initialize) @@ -221,7 +219,7 @@ Pipe StorageMemory::read( for (size_t stream = 0; stream < num_streams; ++stream) { - pipes.emplace_back(std::make_shared(column_names, *this, metadata_snapshot, current_data, parallel_execution_index)); + pipes.emplace_back(std::make_shared(column_names, storage_snapshot, current_data, parallel_execution_index)); } return Pipe::unitePipes(std::move(pipes)); diff --git a/src/Storages/StorageMemory.h b/src/Storages/StorageMemory.h index 47f9a942b82..7910c419374 100644 --- a/src/Storages/StorageMemory.h +++ b/src/Storages/StorageMemory.h @@ -32,7 +32,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageMerge.cpp b/src/Storages/StorageMerge.cpp index 2d5bbfc712d..12b2e69e7a1 100644 --- a/src/Storages/StorageMerge.cpp +++ b/src/Storages/StorageMerge.cpp @@ -139,7 +139,7 @@ bool StorageMerge::mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, Cont QueryProcessingStage::Enum StorageMerge::getQueryProcessingStage( ContextPtr local_context, QueryProcessingStage::Enum to_stage, - const StorageMetadataPtr &, + const StorageSnapshotPtr &, SelectQueryInfo & query_info) const { /// In case of JOIN the first stage (which includes JOIN) @@ -168,7 +168,8 @@ QueryProcessingStage::Enum StorageMerge::getQueryProcessingStage( ++selected_table_size; stage_in_source_tables = std::max( stage_in_source_tables, - table->getQueryProcessingStage(local_context, to_stage, table->getInMemoryMetadataPtr(), query_info)); + table->getQueryProcessingStage(local_context, to_stage, + table->getStorageSnapshot(table->getInMemoryMetadataPtr()), query_info)); } iterator->next(); @@ -181,7 +182,7 @@ QueryProcessingStage::Enum StorageMerge::getQueryProcessingStage( Pipe StorageMerge::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -197,9 +198,9 @@ Pipe StorageMerge::read( for (const auto & column_name : column_names) { - if (column_name == "_database" && isVirtualColumn(column_name, metadata_snapshot)) + if (column_name == "_database" && isVirtualColumn(column_name, storage_snapshot->metadata)) has_database_virtual_column = true; - else if (column_name == "_table" && isVirtualColumn(column_name, metadata_snapshot)) + else if (column_name == "_table" && isVirtualColumn(column_name, storage_snapshot->metadata)) has_table_virtual_column = true; else real_column_names.push_back(column_name); @@ -212,7 +213,7 @@ Pipe StorageMerge::read( modified_context->setSetting("optimize_move_to_prewhere", Field{false}); /// What will be result structure depending on query processed stage in source tables? - Block header = getHeaderForProcessingStage(*this, column_names, metadata_snapshot, query_info, local_context, processed_stage); + Block header = getHeaderForProcessingStage(column_names, storage_snapshot, query_info, local_context, processed_stage); /** First we make list of selected tables to find out its size. * This is necessary to correctly pass the recommended number of threads to each table. @@ -284,7 +285,7 @@ Pipe StorageMerge::read( if (processed_stage == QueryProcessingStage::FetchColumns && !storage_columns.getAliases().empty()) { - auto syntax_result = TreeRewriter(local_context).analyzeSelect(query_info.query, TreeRewriterResult({}, storage, storage_metadata_snapshot)); + auto syntax_result = TreeRewriter(local_context).analyzeSelect(query_info.query, TreeRewriterResult({}, storage, storage->getStorageSnapshot(storage_metadata_snapshot))); ASTPtr required_columns_expr_list = std::make_shared(); ASTPtr column_expr; @@ -314,13 +315,13 @@ Pipe StorageMerge::read( } syntax_result = TreeRewriter(local_context).analyze(required_columns_expr_list, storage_columns.getAllPhysical(), - storage, storage_metadata_snapshot); + storage, storage->getStorageSnapshot(storage_metadata_snapshot)); auto alias_actions = ExpressionAnalyzer(required_columns_expr_list, syntax_result, local_context).getActionsDAG(true); required_columns = alias_actions->getRequiredColumns().getNames(); } auto source_pipe = createSources( - storage_metadata_snapshot, + storage_snapshot, query_info, processed_stage, max_block_size, @@ -347,7 +348,7 @@ Pipe StorageMerge::read( } Pipe StorageMerge::createSources( - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, const QueryProcessingStage::Enum & processed_stage, const UInt64 max_block_size, @@ -389,16 +390,16 @@ Pipe StorageMerge::createSources( } auto storage_stage - = storage->getQueryProcessingStage(modified_context, QueryProcessingStage::Complete, metadata_snapshot, modified_query_info); + = storage->getQueryProcessingStage(modified_context, QueryProcessingStage::Complete, storage_snapshot, modified_query_info); if (processed_stage <= storage_stage) { /// If there are only virtual columns in query, you must request at least one other column. if (real_column_names.empty()) - real_column_names.push_back(ExpressionActions::getSmallestColumn(metadata_snapshot->getColumns().getAllPhysical())); + real_column_names.push_back(ExpressionActions::getSmallestColumn(storage_snapshot->metadata->getColumns().getAllPhysical())); pipe = storage->read( real_column_names, - metadata_snapshot, + storage_snapshot, modified_query_info, modified_context, processed_stage, @@ -470,7 +471,7 @@ Pipe StorageMerge::createSources( /// Subordinary tables could have different but convertible types, like numeric types of different width. /// We must return streams with structure equals to structure of Merge table. - convertingSourceStream(header, metadata_snapshot, aliases, modified_context, modified_query_info.query, pipe, processed_stage); + convertingSourceStream(header, storage_snapshot->metadata, aliases, modified_context, modified_query_info.query, pipe, processed_stage); pipe.addTableLock(struct_lock); pipe.addStorageHolder(storage); diff --git a/src/Storages/StorageMerge.h b/src/Storages/StorageMerge.h index 20460e95156..5d9863515c4 100644 --- a/src/Storages/StorageMerge.h +++ b/src/Storages/StorageMerge.h @@ -28,11 +28,11 @@ public: bool supportsSubcolumns() const override { return true; } QueryProcessingStage::Enum - getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageMetadataPtr &, SelectQueryInfo &) const override; + getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const override; Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -108,7 +108,7 @@ protected: using Aliases = std::vector; Pipe createSources( - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, const QueryProcessingStage::Enum & processed_stage, UInt64 max_block_size, diff --git a/src/Storages/StorageMergeTree.cpp b/src/Storages/StorageMergeTree.cpp index 55ccd60ea38..66c959d2cc5 100644 --- a/src/Storages/StorageMergeTree.cpp +++ b/src/Storages/StorageMergeTree.cpp @@ -180,20 +180,20 @@ StorageMergeTree::~StorageMergeTree() void StorageMergeTree::read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, unsigned num_streams) { - if (auto plan = reader.read(column_names, metadata_snapshot, query_info, local_context, max_block_size, num_streams, processed_stage)) + if (auto plan = reader.read(column_names, storage_snapshot, query_info, local_context, max_block_size, num_streams, processed_stage)) query_plan = std::move(*plan); } Pipe StorageMergeTree::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -201,7 +201,7 @@ Pipe StorageMergeTree::read( const unsigned num_streams) { QueryPlan plan; - read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); + read(plan, column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); return plan.convertToPipe( QueryPlanOptimizationSettings::fromContext(local_context), BuildQueryPipelineSettings::fromContext(local_context)); diff --git a/src/Storages/StorageMergeTree.h b/src/Storages/StorageMergeTree.h index fa2b2e9f08b..f39f842a858 100644 --- a/src/Storages/StorageMergeTree.h +++ b/src/Storages/StorageMergeTree.h @@ -40,7 +40,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -50,7 +50,7 @@ public: void read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageMongoDB.cpp b/src/Storages/StorageMongoDB.cpp index fc3da2343c5..61bc5dd4b5f 100644 --- a/src/Storages/StorageMongoDB.cpp +++ b/src/Storages/StorageMongoDB.cpp @@ -74,7 +74,7 @@ void StorageMongoDB::connectIfNotConnected() Pipe StorageMongoDB::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, @@ -83,12 +83,12 @@ Pipe StorageMongoDB::read( { connectIfNotConnected(); - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); Block sample_block; for (const String & column_name : column_names) { - auto column_data = metadata_snapshot->getColumns().getPhysical(column_name); + auto column_data = storage_snapshot->metadata->getColumns().getPhysical(column_name); sample_block.insert({ column_data.type, column_data.name }); } diff --git a/src/Storages/StorageMongoDB.h b/src/Storages/StorageMongoDB.h index 2553acdd40c..4572bc13074 100644 --- a/src/Storages/StorageMongoDB.h +++ b/src/Storages/StorageMongoDB.h @@ -34,7 +34,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageMySQL.cpp b/src/Storages/StorageMySQL.cpp index 116e713a8c9..4afcc492055 100644 --- a/src/Storages/StorageMySQL.cpp +++ b/src/Storages/StorageMySQL.cpp @@ -72,17 +72,17 @@ StorageMySQL::StorageMySQL( Pipe StorageMySQL::read( const Names & column_names_, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info_, ContextPtr context_, QueryProcessingStage::Enum /*processed_stage*/, size_t /*max_block_size*/, unsigned) { - check(metadata_snapshot, column_names_); + storage_snapshot->check(column_names_); String query = transformQueryForExternalDatabase( query_info_, - metadata_snapshot->getColumns().getOrdinary(), + storage_snapshot->metadata->getColumns().getOrdinary(), IdentifierQuotingStyle::BackticksMySQL, remote_database_name, remote_table_name, @@ -91,7 +91,7 @@ Pipe StorageMySQL::read( Block sample_block; for (const String & column_name : column_names_) { - auto column_data = metadata_snapshot->getColumns().getPhysical(column_name); + auto column_data = storage_snapshot->metadata->getColumns().getPhysical(column_name); WhichDataType which(column_data.type); /// Convert enum to string. diff --git a/src/Storages/StorageMySQL.h b/src/Storages/StorageMySQL.h index 2bcc7af5f2b..7bfccc1db94 100644 --- a/src/Storages/StorageMySQL.h +++ b/src/Storages/StorageMySQL.h @@ -41,7 +41,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageNull.h b/src/Storages/StorageNull.h index 2f1d9cfb4e5..d4fbe6f581d 100644 --- a/src/Storages/StorageNull.h +++ b/src/Storages/StorageNull.h @@ -23,7 +23,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo &, ContextPtr /*context*/, QueryProcessingStage::Enum /*processing_stage*/, @@ -31,7 +31,7 @@ public: unsigned) override { return Pipe( - std::make_shared(getSampleBlockForColumns(metadata_snapshot, column_names))); + std::make_shared(storage_snapshot->getSampleBlockForColumns(column_names))); } bool supportsParallelInsert() const override { return true; } diff --git a/src/Storages/StoragePostgreSQL.cpp b/src/Storages/StoragePostgreSQL.cpp index 79f9452b206..67b7dc6f372 100644 --- a/src/Storages/StoragePostgreSQL.cpp +++ b/src/Storages/StoragePostgreSQL.cpp @@ -64,25 +64,25 @@ StoragePostgreSQL::StoragePostgreSQL( Pipe StoragePostgreSQL::read( const Names & column_names_, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info_, ContextPtr context_, QueryProcessingStage::Enum /*processed_stage*/, size_t max_block_size_, unsigned) { - check(metadata_snapshot, column_names_); + storage_snapshot->check(column_names_); /// Connection is already made to the needed database, so it should not be present in the query; /// remote_table_schema is empty if it is not specified, will access only table_name. String query = transformQueryForExternalDatabase( - query_info_, metadata_snapshot->getColumns().getOrdinary(), + query_info_, storage_snapshot->metadata->getColumns().getOrdinary(), IdentifierQuotingStyle::DoubleQuotes, remote_table_schema, remote_table_name, context_); Block sample_block; for (const String & column_name : column_names_) { - auto column_data = metadata_snapshot->getColumns().getPhysical(column_name); + auto column_data = storage_snapshot->metadata->getColumns().getPhysical(column_name); WhichDataType which(column_data.type); if (which.isEnum()) column_data.type = std::make_shared(); diff --git a/src/Storages/StoragePostgreSQL.h b/src/Storages/StoragePostgreSQL.h index 5a8ecf5598f..13d74977ab5 100644 --- a/src/Storages/StoragePostgreSQL.h +++ b/src/Storages/StoragePostgreSQL.h @@ -34,7 +34,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageProxy.h b/src/Storages/StorageProxy.h index 60e7bf24046..94a9a1cb7d6 100644 --- a/src/Storages/StorageProxy.h +++ b/src/Storages/StorageProxy.h @@ -34,10 +34,11 @@ public: QueryProcessingStage::Enum getQueryProcessingStage( ContextPtr context, QueryProcessingStage::Enum to_stage, - const StorageMetadataPtr &, + const StorageSnapshotPtr &, SelectQueryInfo & info) const override { - return getNested()->getQueryProcessingStage(context, to_stage, getNested()->getInMemoryMetadataPtr(), info); + const auto & nested_metadata = getNested()->getInMemoryMetadataPtr(); + return getNested()->getQueryProcessingStage(context, to_stage, getNested()->getStorageSnapshot(nested_metadata), info); } BlockInputStreams watch( @@ -53,14 +54,14 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, unsigned num_streams) override { - return getNested()->read(column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams); + return getNested()->read(column_names, storage_snapshot, query_info, context, processed_stage, max_block_size, num_streams); } BlockOutputStreamPtr write(const ASTPtr & query, const StorageMetadataPtr & metadata_snapshot, ContextPtr context) override diff --git a/src/Storages/StorageReplicatedMergeTree.cpp b/src/Storages/StorageReplicatedMergeTree.cpp index 87befd2c407..e4a6f79ad87 100644 --- a/src/Storages/StorageReplicatedMergeTree.cpp +++ b/src/Storages/StorageReplicatedMergeTree.cpp @@ -4447,7 +4447,7 @@ ReplicatedMergeTreeQuorumAddedParts::PartitionIdToMaxBlock StorageReplicatedMerg void StorageReplicatedMergeTree::read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -4463,18 +4463,18 @@ void StorageReplicatedMergeTree::read( { auto max_added_blocks = std::make_shared(getMaxAddedBlocks()); if (auto plan = reader.read( - column_names, metadata_snapshot, query_info, local_context, max_block_size, num_streams, processed_stage, std::move(max_added_blocks))) + column_names, storage_snapshot, query_info, local_context, max_block_size, num_streams, processed_stage, std::move(max_added_blocks))) query_plan = std::move(*plan); return; } - if (auto plan = reader.read(column_names, metadata_snapshot, query_info, local_context, max_block_size, num_streams, processed_stage)) + if (auto plan = reader.read(column_names, storage_snapshot, query_info, local_context, max_block_size, num_streams, processed_stage)) query_plan = std::move(*plan); } Pipe StorageReplicatedMergeTree::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -4482,7 +4482,7 @@ Pipe StorageReplicatedMergeTree::read( const unsigned num_streams) { QueryPlan plan; - read(plan, column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); + read(plan, column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); return plan.convertToPipe( QueryPlanOptimizationSettings::fromContext(local_context), BuildQueryPipelineSettings::fromContext(local_context)); diff --git a/src/Storages/StorageReplicatedMergeTree.h b/src/Storages/StorageReplicatedMergeTree.h index 28dd3c760a8..8c79f0eb6f4 100644 --- a/src/Storages/StorageReplicatedMergeTree.h +++ b/src/Storages/StorageReplicatedMergeTree.h @@ -95,7 +95,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -105,7 +105,7 @@ public: void read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageS3.cpp b/src/Storages/StorageS3.cpp index b4fec69e075..88f7558d38f 100644 --- a/src/Storages/StorageS3.cpp +++ b/src/Storages/StorageS3.cpp @@ -360,7 +360,7 @@ StorageS3::StorageS3( Pipe StorageS3::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr local_context, QueryProcessingStage::Enum /*processed_stage*/, @@ -405,9 +405,9 @@ Pipe StorageS3::read( need_file_column, format_name, getName(), - metadata_snapshot->getSampleBlock(), + storage_snapshot->metadata->getSampleBlock(), local_context, - metadata_snapshot->getColumns(), + storage_snapshot->metadata->getColumns(), max_block_size, max_single_read_retries, compression_method, diff --git a/src/Storages/StorageS3.h b/src/Storages/StorageS3.h index 37ada9e8eb7..8ade1f0b533 100644 --- a/src/Storages/StorageS3.h +++ b/src/Storages/StorageS3.h @@ -121,7 +121,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageS3Cluster.cpp b/src/Storages/StorageS3Cluster.cpp index 8985ff314f6..311910a8b28 100644 --- a/src/Storages/StorageS3Cluster.cpp +++ b/src/Storages/StorageS3Cluster.cpp @@ -80,7 +80,7 @@ StorageS3Cluster::StorageS3Cluster( /// The code executes on initiator Pipe StorageS3Cluster::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -133,12 +133,12 @@ Pipe StorageS3Cluster::read( } } - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); return Pipe::unitePipes(std::move(pipes)); } QueryProcessingStage::Enum StorageS3Cluster::getQueryProcessingStage( - ContextPtr context, QueryProcessingStage::Enum to_stage, const StorageMetadataPtr &, SelectQueryInfo &) const + ContextPtr context, QueryProcessingStage::Enum to_stage, const StorageSnapshotPtr &, SelectQueryInfo &) const { /// Initiator executes query on remote node. if (context->getClientInfo().query_kind == ClientInfo::QueryKind::INITIAL_QUERY) diff --git a/src/Storages/StorageS3Cluster.h b/src/Storages/StorageS3Cluster.h index 821765a3780..a40edf34e27 100644 --- a/src/Storages/StorageS3Cluster.h +++ b/src/Storages/StorageS3Cluster.h @@ -27,11 +27,11 @@ class StorageS3Cluster : public shared_ptr_helper, public ISto public: std::string getName() const override { return "S3Cluster"; } - Pipe read(const Names &, const StorageMetadataPtr &, SelectQueryInfo &, + Pipe read(const Names &, const StorageSnapshotPtr &, SelectQueryInfo &, ContextPtr, QueryProcessingStage::Enum, size_t /*max_block_size*/, unsigned /*num_streams*/) override; QueryProcessingStage::Enum - getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageMetadataPtr &, SelectQueryInfo &) const override; + getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const override; NamesAndTypesList getVirtuals() const override; diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp new file mode 100644 index 00000000000..cd1e516c7fe --- /dev/null +++ b/src/Storages/StorageSnapshot.cpp @@ -0,0 +1,95 @@ +#include +#include +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int NOT_FOUND_COLUMN_IN_BLOCK; + extern const int EMPTY_LIST_OF_COLUMNS_QUERIED; + extern const int NO_SUCH_COLUMN_IN_TABLE; + extern const int COLUMN_QUERIED_MORE_THAN_ONCE; +} + +NamesAndTypesList StorageSnapshot::getColumns(const GetColumnsOptions & options) const +{ + auto all_columns = metadata->getColumns().get(options); + + if (options.with_virtuals) + { + /// Virtual columns must be appended after ordinary, + /// because user can override them. + auto virtuals = storage.getVirtuals(); + if (!virtuals.empty()) + { + NameSet column_names; + for (const auto & column : all_columns) + column_names.insert(column.name); + for (auto && column : virtuals) + if (!column_names.count(column.name)) + all_columns.push_back(std::move(column)); + } + } + + if (options.with_extended_objects) + all_columns = extendObjectColumns(all_columns, object_types, options.with_subcolumns); + + return all_columns; +} + +Block StorageSnapshot::getSampleBlockForColumns(const Names & column_names) const +{ + Block res; + + auto all_columns = getColumns(GetColumnsOptions(GetColumnsOptions::All) + .withSubcolumns().withVirtuals().withExtendedObjects()); + + std::unordered_map columns_map; + columns_map.reserve(all_columns.size()); + + for (const auto & elem : all_columns) + columns_map.emplace(elem.name, elem.type); + + for (const auto & name : column_names) + { + auto it = columns_map.find(name); + if (it != columns_map.end()) + res.insert({it->second->createColumn(), it->second, it->first}); + else + throw Exception(ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK, + "Column {} not found in table {}", backQuote(name), storage.getStorageID().getNameForLogs()); + } + + return res; +} + +void StorageSnapshot::check(const Names & column_names) const +{ + auto available_columns = getColumns(GetColumnsOptions(GetColumnsOptions::AllPhysical) + .withSubcolumns().withVirtuals().withExtendedObjects()).getNames(); + + if (column_names.empty()) + throw Exception(ErrorCodes::EMPTY_LIST_OF_COLUMNS_QUERIED, + "Empty list of columns queried. There are columns: {}", + boost::algorithm::join(available_columns, ",")); + + std::unordered_set columns_set(available_columns.begin(), available_columns.end()); + std::unordered_set unique_names; + + for (const auto & name : column_names) + { + if (columns_set.end() == columns_set.find(name)) + throw Exception(ErrorCodes::NO_SUCH_COLUMN_IN_TABLE, + "There is no column with name {} in table {}. There are columns: ", + backQuote(name), storage.getStorageID().getNameForLogs(), boost::algorithm::join(available_columns, ",")); + + if (unique_names.end() != unique_names.find(name)) + throw Exception(ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE, "Column {} queried more than once", name); + + unique_names.insert(name); + } +} + +} diff --git a/src/Storages/StorageSnapshot.h b/src/Storages/StorageSnapshot.h new file mode 100644 index 00000000000..a34eef8116a --- /dev/null +++ b/src/Storages/StorageSnapshot.h @@ -0,0 +1,58 @@ +#pragma once +#include + +namespace DB +{ + +class IStorage; + +class IMergeTreeDataPart; +using DataPartPtr = std::shared_ptr; +using DataPartsVector = std::vector; + +struct StorageSnapshot +{ + using NameToTypeMap = std::unordered_map; + + const IStorage & storage; + const StorageMetadataPtr metadata; + const NameToTypeMap object_types; + const DataPartsVector parts; + + StorageSnapshot( + const IStorage & storage_, + const StorageMetadataPtr & metadata_) + : storage(storage_), metadata(metadata_) + { + } + + StorageSnapshot( + const IStorage & storage_, + const StorageMetadataPtr & metadata_, + const NameToTypeMap & object_types_) + : storage(storage_), metadata(metadata_), object_types(object_types_) + { + } + + StorageSnapshot( + const IStorage & storage_, + const StorageMetadataPtr & metadata_, + const NameToTypeMap & object_types_, + const DataPartsVector & parts_) + : storage(storage_), metadata(metadata_), object_types(object_types_), parts(parts_) + { + } + + NamesAndTypesList getColumns(const GetColumnsOptions & options) const; + + /// Block with ordinary + materialized + aliases + virtuals + subcolumns. + Block getSampleBlockForColumns(const Names & column_names) const; + + /// Verify that all the requested names are in the table and are set correctly: + /// list of names is not empty and the names do not repeat. + void check(const Names & column_names) const; +}; + +using StorageSnapshotPtr = std::shared_ptr; + +} diff --git a/src/Storages/StorageStripeLog.cpp b/src/Storages/StorageStripeLog.cpp index b0f4bbe484e..2ffd2d40870 100644 --- a/src/Storages/StorageStripeLog.cpp +++ b/src/Storages/StorageStripeLog.cpp @@ -52,14 +52,13 @@ class StripeLogSource final : public SourceWithProgress { public: static Block getHeader( - StorageStripeLog & storage, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const Names & column_names, IndexForNativeFormat::Blocks::const_iterator index_begin, IndexForNativeFormat::Blocks::const_iterator index_end) { if (index_begin == index_end) - return storage.getSampleBlockForColumns(metadata_snapshot, column_names); + return storage_snapshot->getSampleBlockForColumns(column_names); /// TODO: check if possible to always return storage.getSampleBlock() @@ -76,16 +75,16 @@ public: StripeLogSource( StorageStripeLog & storage_, - const StorageMetadataPtr & metadata_snapshot_, + const StorageSnapshotPtr & storage_snapshot_, const Names & column_names, size_t max_read_buffer_size_, std::shared_ptr & index_, IndexForNativeFormat::Blocks::const_iterator index_begin_, IndexForNativeFormat::Blocks::const_iterator index_end_) : SourceWithProgress( - getHeader(storage_, metadata_snapshot_, column_names, index_begin_, index_end_)) + getHeader(storage_snapshot_, column_names, index_begin_, index_end_)) , storage(storage_) - , metadata_snapshot(metadata_snapshot_) + , storage_snapshot(storage_snapshot_) , max_read_buffer_size(max_read_buffer_size_) , index(index_) , index_begin(index_begin_) @@ -122,7 +121,7 @@ protected: private: StorageStripeLog & storage; - StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; size_t max_read_buffer_size; std::shared_ptr index; @@ -321,7 +320,7 @@ static std::chrono::seconds getLockTimeout(ContextPtr context) Pipe StorageStripeLog::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, @@ -332,7 +331,7 @@ Pipe StorageStripeLog::read( if (!lock) throw Exception("Lock timeout exceeded", ErrorCodes::TIMEOUT_EXCEEDED); - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); NameSet column_names_set(column_names.begin(), column_names.end()); @@ -341,7 +340,7 @@ Pipe StorageStripeLog::read( String index_file = table_path + "index.mrk"; if (!disk->exists(index_file)) { - return Pipe(std::make_shared(getSampleBlockForColumns(metadata_snapshot, column_names))); + return Pipe(std::make_shared(storage_snapshot->getSampleBlockForColumns(column_names))); } CompressedReadBufferFromFile index_in(disk->readFile(index_file, 4096)); @@ -360,7 +359,7 @@ Pipe StorageStripeLog::read( std::advance(end, (stream + 1) * size / num_streams); pipes.emplace_back(std::make_shared( - *this, metadata_snapshot, column_names, context->getSettingsRef().max_read_buffer_size, index, begin, end)); + *this, storage_snapshot, column_names, context->getSettingsRef().max_read_buffer_size, index, begin, end)); } /// We do not keep read lock directly at the time of reading, because we read ranges of data that do not change. diff --git a/src/Storages/StorageStripeLog.h b/src/Storages/StorageStripeLog.h index 0749273043f..8ae8dda41b2 100644 --- a/src/Storages/StorageStripeLog.h +++ b/src/Storages/StorageStripeLog.h @@ -27,7 +27,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageTableFunction.h b/src/Storages/StorageTableFunction.h index 859735fec5b..dd886b700a8 100644 --- a/src/Storages/StorageTableFunction.h +++ b/src/Storages/StorageTableFunction.h @@ -78,7 +78,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -89,12 +89,12 @@ public: for (const auto & c : column_names) cnames += c + " "; auto storage = getNested(); - auto nested_metadata = storage->getInMemoryMetadataPtr(); - auto pipe = storage->read(column_names, nested_metadata, query_info, context, + auto nested_snapshot = storage->getStorageSnapshot(storage->getInMemoryMetadataPtr()); + auto pipe = storage->read(column_names, nested_snapshot, query_info, context, processed_stage, max_block_size, num_streams); if (!pipe.empty() && add_conversion) { - auto to_header = getHeaderForProcessingStage(*this, column_names, metadata_snapshot, + auto to_header = getHeaderForProcessingStage(column_names, storage_snapshot, query_info, context, processed_stage); auto convert_actions_dag = ActionsDAG::makeConvertingActions( diff --git a/src/Storages/StorageTinyLog.cpp b/src/Storages/StorageTinyLog.cpp index f02a2610db2..e69c485c119 100644 --- a/src/Storages/StorageTinyLog.cpp +++ b/src/Storages/StorageTinyLog.cpp @@ -480,16 +480,16 @@ static std::chrono::seconds getLockTimeout(ContextPtr context) Pipe StorageTinyLog::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, const size_t max_block_size, const unsigned /*num_streams*/) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); - auto all_columns = metadata_snapshot->getColumns().getAllWithSubcolumns().addTypes(column_names); + auto all_columns = storage_snapshot->metadata->getColumns().getAllWithSubcolumns().addTypes(column_names); // When reading, we lock the entire storage, because we only have one file // per column and can't modify it concurrently. diff --git a/src/Storages/StorageTinyLog.h b/src/Storages/StorageTinyLog.h index 71763a6403e..96955d7119f 100644 --- a/src/Storages/StorageTinyLog.h +++ b/src/Storages/StorageTinyLog.h @@ -26,7 +26,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageURL.cpp b/src/Storages/StorageURL.cpp index fd9453e632c..f154b83673d 100644 --- a/src/Storages/StorageURL.cpp +++ b/src/Storages/StorageURL.cpp @@ -182,7 +182,7 @@ std::string IStorageURLBase::getReadMethod() const std::vector> IStorageURLBase::getReadURIParams( const Names & /*column_names*/, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, const SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum & /*processed_stage*/, @@ -193,7 +193,7 @@ std::vector> IStorageURLBase::getReadURIPara std::function IStorageURLBase::getReadPOSTDataCallback( const Names & /*column_names*/, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, const SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum & /*processed_stage*/, @@ -205,7 +205,7 @@ std::function IStorageURLBase::getReadPOSTDataCallback( Pipe IStorageURLBase::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, @@ -213,7 +213,7 @@ Pipe IStorageURLBase::read( unsigned /*num_streams*/) { auto request_uri = uri; - auto params = getReadURIParams(column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size); + auto params = getReadURIParams(column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size); for (const auto & [param, value] : params) request_uri.addQueryParameter(param, value); @@ -221,14 +221,14 @@ Pipe IStorageURLBase::read( request_uri, getReadMethod(), getReadPOSTDataCallback( - column_names, metadata_snapshot, query_info, + column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size), format_name, format_settings, getName(), - getHeaderBlock(column_names, metadata_snapshot), + getHeaderBlock(column_names, storage_snapshot), local_context, - metadata_snapshot->getColumns(), + storage_snapshot->metadata->getColumns(), max_block_size, ConnectionTimeouts::getHTTPTimeouts(local_context), chooseCompressionMethod(request_uri.getPath(), compression_method))); @@ -237,14 +237,14 @@ Pipe IStorageURLBase::read( Pipe StorageURLWithFailover::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, unsigned /*num_streams*/) { - auto params = getReadURIParams(column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size); + auto params = getReadURIParams(column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size); WriteBufferFromOwnString error_message; error_message << "Detailed description:"; @@ -260,14 +260,14 @@ Pipe StorageURLWithFailover::read( request_uri, getReadMethod(), getReadPOSTDataCallback( - column_names, metadata_snapshot, query_info, + column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size), format_name, format_settings, getName(), - getHeaderBlock(column_names, metadata_snapshot), + getHeaderBlock(column_names, storage_snapshot), local_context, - metadata_snapshot->getColumns(), + storage_snapshot->metadata->getColumns(), max_block_size, ConnectionTimeouts::getHTTPTimeouts(local_context), chooseCompressionMethod(request_uri.getPath(), compression_method)); diff --git a/src/Storages/StorageURL.h b/src/Storages/StorageURL.h index 78306292044..c86f57cb269 100644 --- a/src/Storages/StorageURL.h +++ b/src/Storages/StorageURL.h @@ -25,7 +25,7 @@ class IStorageURLBase : public IStorage public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -59,7 +59,7 @@ protected: virtual std::vector> getReadURIParams( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum & processed_stage, @@ -67,14 +67,14 @@ protected: virtual std::function getReadPOSTDataCallback( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum & processed_stage, size_t max_block_size) const; private: - virtual Block getHeaderBlock(const Names & column_names, const StorageMetadataPtr & metadata_snapshot) const = 0; + virtual Block getHeaderBlock(const Names & column_names, const StorageSnapshotPtr & storage_snapshot) const = 0; }; class StorageURLBlockOutputStream : public IBlockOutputStream @@ -124,9 +124,9 @@ public: return "URL"; } - Block getHeaderBlock(const Names & /*column_names*/, const StorageMetadataPtr & metadata_snapshot) const override + Block getHeaderBlock(const Names & /*column_names*/, const StorageSnapshotPtr & storage_snapshot) const override { - return metadata_snapshot->getSampleBlock(); + return storage_snapshot->metadata->getSampleBlock(); } static FormatSettings getFormatSettingsFromArgs(const StorageFactory::Arguments & args); @@ -149,7 +149,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageValues.cpp b/src/Storages/StorageValues.cpp index 0c9de61783a..d0acb191e8d 100644 --- a/src/Storages/StorageValues.cpp +++ b/src/Storages/StorageValues.cpp @@ -22,14 +22,14 @@ StorageValues::StorageValues( Pipe StorageValues::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, size_t /*max_block_size*/, unsigned /*num_streams*/) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); /// Get only required columns. Block block; diff --git a/src/Storages/StorageValues.h b/src/Storages/StorageValues.h index 4d6d168441c..c74f8eae3ed 100644 --- a/src/Storages/StorageValues.h +++ b/src/Storages/StorageValues.h @@ -17,7 +17,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageView.cpp b/src/Storages/StorageView.cpp index 26996e4da6e..d89a9499e60 100644 --- a/src/Storages/StorageView.cpp +++ b/src/Storages/StorageView.cpp @@ -53,7 +53,7 @@ StorageView::StorageView( Pipe StorageView::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -61,7 +61,7 @@ Pipe StorageView::read( const unsigned num_streams) { QueryPlan plan; - read(plan, column_names, metadata_snapshot, query_info, context, processed_stage, max_block_size, num_streams); + read(plan, column_names, storage_snapshot, query_info, context, processed_stage, max_block_size, num_streams); return plan.convertToPipe( QueryPlanOptimizationSettings::fromContext(context), BuildQueryPipelineSettings::fromContext(context)); @@ -70,14 +70,14 @@ Pipe StorageView::read( void StorageView::read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - ASTPtr current_inner_query = metadata_snapshot->getSelectQuery().inner_query; + ASTPtr current_inner_query = storage_snapshot->metadata->getSelectQuery().inner_query; if (query_info.view_query) { @@ -104,7 +104,7 @@ void StorageView::read( query_plan.addStep(std::move(materializing)); /// And also convert to expected structure. - auto header = getSampleBlockForColumns(metadata_snapshot, column_names); + auto header = storage_snapshot->getSampleBlockForColumns(column_names); auto convert_actions_dag = ActionsDAG::makeConvertingActions( query_plan.getCurrentDataStream().header.getColumnsWithTypeAndName(), header.getColumnsWithTypeAndName(), diff --git a/src/Storages/StorageView.h b/src/Storages/StorageView.h index a59328cd471..f55472c4bf7 100644 --- a/src/Storages/StorageView.h +++ b/src/Storages/StorageView.h @@ -23,7 +23,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -33,7 +33,7 @@ public: void read( QueryPlan & query_plan, const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/StorageXDBC.cpp b/src/Storages/StorageXDBC.cpp index 9a8b419a16c..313ab36182a 100644 --- a/src/Storages/StorageXDBC.cpp +++ b/src/Storages/StorageXDBC.cpp @@ -58,7 +58,7 @@ std::string StorageXDBC::getReadMethod() const std::vector> StorageXDBC::getReadURIParams( const Names & /* column_names */, - const StorageMetadataPtr & /* metadata_snapshot */, + const StorageSnapshotPtr & /*storage_snapshot*/, const SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum & /*processed_stage*/, @@ -69,14 +69,14 @@ std::vector> StorageXDBC::getReadURIParams( std::function StorageXDBC::getReadPOSTDataCallback( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum & /*processed_stage*/, size_t /*max_block_size*/) const { String query = transformQueryForExternalDatabase(query_info, - metadata_snapshot->getColumns().getOrdinary(), + storage_snapshot->metadata->getColumns().getOrdinary(), bridge_helper->getIdentifierQuotingStyle(), remote_database_name, remote_table_name, @@ -85,7 +85,7 @@ std::function StorageXDBC::getReadPOSTDataCallback( NamesAndTypesList cols; for (const String & name : column_names) { - auto column_data = metadata_snapshot->getColumns().getPhysical(name); + auto column_data = storage_snapshot->metadata->getColumns().getPhysical(name); cols.emplace_back(column_data.name, column_data.type); } @@ -101,17 +101,17 @@ std::function StorageXDBC::getReadPOSTDataCallback( Pipe StorageXDBC::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr local_context, QueryProcessingStage::Enum processed_stage, size_t max_block_size, unsigned num_streams) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); bridge_helper->startBridgeSync(); - return IStorageURLBase::read(column_names, metadata_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); + return IStorageURLBase::read(column_names, storage_snapshot, query_info, local_context, processed_stage, max_block_size, num_streams); } BlockOutputStreamPtr StorageXDBC::write(const ASTPtr & /*query*/, const StorageMetadataPtr & metadata_snapshot, ContextPtr local_context) @@ -140,9 +140,9 @@ BlockOutputStreamPtr StorageXDBC::write(const ASTPtr & /*query*/, const StorageM chooseCompressionMethod(uri.toString(), compression_method)); } -Block StorageXDBC::getHeaderBlock(const Names & column_names, const StorageMetadataPtr & metadata_snapshot) const +Block StorageXDBC::getHeaderBlock(const Names & column_names, const StorageSnapshotPtr & storage_snapshot) const { - return getSampleBlockForColumns(metadata_snapshot, column_names); + return storage_snapshot->getSampleBlockForColumns(column_names); } std::string StorageXDBC::getName() const diff --git a/src/Storages/StorageXDBC.h b/src/Storages/StorageXDBC.h index db0b506546d..cd13c09a169 100644 --- a/src/Storages/StorageXDBC.h +++ b/src/Storages/StorageXDBC.h @@ -17,7 +17,7 @@ class StorageXDBC : public IStorageURLBase public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -48,7 +48,7 @@ private: std::vector> getReadURIParams( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum & processed_stage, @@ -56,13 +56,13 @@ private: std::function getReadPOSTDataCallback( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, const SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum & processed_stage, size_t max_block_size) const override; - Block getHeaderBlock(const Names & column_names, const StorageMetadataPtr & metadata_snapshot) const override; + Block getHeaderBlock(const Names & column_names, const StorageSnapshotPtr & storage_snapshot) const override; }; } diff --git a/src/Storages/System/IStorageSystemOneBlock.h b/src/Storages/System/IStorageSystemOneBlock.h index 752265e7c40..f9c74d8ec29 100644 --- a/src/Storages/System/IStorageSystemOneBlock.h +++ b/src/Storages/System/IStorageSystemOneBlock.h @@ -46,16 +46,16 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, size_t /*max_block_size*/, unsigned /*num_streams*/) override { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); - Block sample_block = metadata_snapshot->getSampleBlockWithVirtuals(getVirtuals()); + Block sample_block = storage_snapshot->metadata->getSampleBlockWithVirtuals(getVirtuals()); MutableColumns res_columns = sample_block.cloneEmptyColumns(); fillData(res_columns, context, query_info); diff --git a/src/Storages/System/StorageSystemColumns.cpp b/src/Storages/System/StorageSystemColumns.cpp index 424ba6347c2..05db859e0aa 100644 --- a/src/Storages/System/StorageSystemColumns.cpp +++ b/src/Storages/System/StorageSystemColumns.cpp @@ -241,20 +241,20 @@ private: Pipe StorageSystemColumns::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, const size_t max_block_size, const unsigned /*num_streams*/) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); /// Create a mask of what columns are needed in the result. NameSet names_set(column_names.begin(), column_names.end()); - Block sample_block = metadata_snapshot->getSampleBlock(); + Block sample_block = storage_snapshot->metadata->getSampleBlock(); Block header; std::vector columns_mask(sample_block.columns()); diff --git a/src/Storages/System/StorageSystemColumns.h b/src/Storages/System/StorageSystemColumns.h index 015b8627c4b..d8565193a4f 100644 --- a/src/Storages/System/StorageSystemColumns.h +++ b/src/Storages/System/StorageSystemColumns.h @@ -19,7 +19,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/System/StorageSystemDataSkippingIndices.cpp b/src/Storages/System/StorageSystemDataSkippingIndices.cpp index 27fceb97a31..8e995e1f0e6 100644 --- a/src/Storages/System/StorageSystemDataSkippingIndices.cpp +++ b/src/Storages/System/StorageSystemDataSkippingIndices.cpp @@ -146,18 +146,18 @@ private: Pipe StorageSystemDataSkippingIndices::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /* processed_stage */, size_t max_block_size, unsigned int /* num_streams */) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); NameSet names_set(column_names.begin(), column_names.end()); - Block sample_block = metadata_snapshot->getSampleBlock(); + Block sample_block = storage_snapshot->metadata->getSampleBlock(); Block header; std::vector columns_mask(sample_block.columns()); diff --git a/src/Storages/System/StorageSystemDataSkippingIndices.h b/src/Storages/System/StorageSystemDataSkippingIndices.h index 8497f16606f..3a67cc9bd11 100644 --- a/src/Storages/System/StorageSystemDataSkippingIndices.h +++ b/src/Storages/System/StorageSystemDataSkippingIndices.h @@ -16,7 +16,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/System/StorageSystemDetachedParts.cpp b/src/Storages/System/StorageSystemDetachedParts.cpp index 1a9418485e5..1021f31d04a 100644 --- a/src/Storages/System/StorageSystemDetachedParts.cpp +++ b/src/Storages/System/StorageSystemDetachedParts.cpp @@ -31,7 +31,7 @@ StorageSystemDetachedParts::StorageSystemDetachedParts(const StorageID & table_i Pipe StorageSystemDetachedParts::read( const Names & /* column_names */, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, @@ -41,7 +41,7 @@ Pipe StorageSystemDetachedParts::read( StoragesInfoStream stream(query_info, context); /// Create the result. - Block block = metadata_snapshot->getSampleBlock(); + Block block = storage_snapshot->metadata->getSampleBlock(); MutableColumns new_columns = block.cloneEmptyColumns(); while (StoragesInfo info = stream.next()) diff --git a/src/Storages/System/StorageSystemDetachedParts.h b/src/Storages/System/StorageSystemDetachedParts.h index 9350e758d93..9d4fb76f597 100644 --- a/src/Storages/System/StorageSystemDetachedParts.h +++ b/src/Storages/System/StorageSystemDetachedParts.h @@ -24,7 +24,7 @@ protected: Pipe read( const Names & /* column_names */, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, diff --git a/src/Storages/System/StorageSystemDisks.cpp b/src/Storages/System/StorageSystemDisks.cpp index 51c62a1614d..bcd99237d67 100644 --- a/src/Storages/System/StorageSystemDisks.cpp +++ b/src/Storages/System/StorageSystemDisks.cpp @@ -28,14 +28,14 @@ StorageSystemDisks::StorageSystemDisks(const StorageID & table_id_) Pipe StorageSystemDisks::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); MutableColumnPtr col_name = ColumnString::create(); MutableColumnPtr col_path = ColumnString::create(); @@ -65,7 +65,7 @@ Pipe StorageSystemDisks::read( UInt64 num_rows = res_columns.at(0)->size(); Chunk chunk(std::move(res_columns), num_rows); - return Pipe(std::make_shared(metadata_snapshot->getSampleBlock(), std::move(chunk))); + return Pipe(std::make_shared(storage_snapshot->metadata->getSampleBlock(), std::move(chunk))); } } diff --git a/src/Storages/System/StorageSystemDisks.h b/src/Storages/System/StorageSystemDisks.h index 1274903ff00..3eb757f7547 100644 --- a/src/Storages/System/StorageSystemDisks.h +++ b/src/Storages/System/StorageSystemDisks.h @@ -22,7 +22,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/System/StorageSystemNumbers.cpp b/src/Storages/System/StorageSystemNumbers.cpp index 4edda96d2ff..bfdfafd57ab 100644 --- a/src/Storages/System/StorageSystemNumbers.cpp +++ b/src/Storages/System/StorageSystemNumbers.cpp @@ -124,14 +124,14 @@ StorageSystemNumbers::StorageSystemNumbers(const StorageID & table_id, bool mult Pipe StorageSystemNumbers::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo &, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, size_t max_block_size, unsigned num_streams) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); if (limit && *limit < max_block_size) { diff --git a/src/Storages/System/StorageSystemNumbers.h b/src/Storages/System/StorageSystemNumbers.h index 960c354fda2..95a7d2b7a4f 100644 --- a/src/Storages/System/StorageSystemNumbers.h +++ b/src/Storages/System/StorageSystemNumbers.h @@ -31,7 +31,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/System/StorageSystemOne.cpp b/src/Storages/System/StorageSystemOne.cpp index 09b4c438422..d0c7072b070 100644 --- a/src/Storages/System/StorageSystemOne.cpp +++ b/src/Storages/System/StorageSystemOne.cpp @@ -22,14 +22,14 @@ StorageSystemOne::StorageSystemOne(const StorageID & table_id_) Pipe StorageSystemOne::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo &, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); Block header{ColumnWithTypeAndName( DataTypeUInt8().createColumn(), diff --git a/src/Storages/System/StorageSystemOne.h b/src/Storages/System/StorageSystemOne.h index 71a29847919..7ae00bed263 100644 --- a/src/Storages/System/StorageSystemOne.h +++ b/src/Storages/System/StorageSystemOne.h @@ -23,7 +23,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/System/StorageSystemPartsBase.cpp b/src/Storages/System/StorageSystemPartsBase.cpp index 5676adb49be..dc5ebe6be22 100644 --- a/src/Storages/System/StorageSystemPartsBase.cpp +++ b/src/Storages/System/StorageSystemPartsBase.cpp @@ -26,7 +26,7 @@ namespace ErrorCodes extern const int TABLE_IS_DROPPED; } -bool StorageSystemPartsBase::hasStateColumn(const Names & column_names, const StorageMetadataPtr & metadata_snapshot) const +bool StorageSystemPartsBase::hasStateColumn(const Names & column_names, const StorageSnapshotPtr & storage_snapshot) const { bool has_state_column = false; Names real_column_names; @@ -41,7 +41,7 @@ bool StorageSystemPartsBase::hasStateColumn(const Names & column_names, const St /// Do not check if only _state column is requested if (!(has_state_column && real_column_names.empty())) - check(metadata_snapshot, real_column_names); + storage_snapshot->check(real_column_names); return has_state_column; } @@ -235,14 +235,14 @@ StoragesInfo StoragesInfoStream::next() Pipe StorageSystemPartsBase::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - bool has_state_column = hasStateColumn(column_names, metadata_snapshot); + bool has_state_column = hasStateColumn(column_names, storage_snapshot); StoragesInfoStream stream(query_info, context); @@ -250,7 +250,7 @@ Pipe StorageSystemPartsBase::read( NameSet names_set(column_names.begin(), column_names.end()); - Block sample = metadata_snapshot->getSampleBlock(); + Block sample = storage_snapshot->metadata->getSampleBlock(); Block header; std::vector columns_mask(sample.columns()); diff --git a/src/Storages/System/StorageSystemPartsBase.h b/src/Storages/System/StorageSystemPartsBase.h index 86f62e37fad..b16d5c46c72 100644 --- a/src/Storages/System/StorageSystemPartsBase.h +++ b/src/Storages/System/StorageSystemPartsBase.h @@ -58,7 +58,7 @@ class StorageSystemPartsBase : public IStorage public: Pipe read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, @@ -68,7 +68,7 @@ public: NamesAndTypesList getVirtuals() const override; private: - bool hasStateColumn(const Names & column_names, const StorageMetadataPtr & metadata_snapshot) const; + bool hasStateColumn(const Names & column_names, const StorageSnapshotPtr & storage_snapshot) const; protected: const FormatSettings format_settings; diff --git a/src/Storages/System/StorageSystemReplicas.cpp b/src/Storages/System/StorageSystemReplicas.cpp index 2d4c90b5954..28e70743b68 100644 --- a/src/Storages/System/StorageSystemReplicas.cpp +++ b/src/Storages/System/StorageSystemReplicas.cpp @@ -58,14 +58,14 @@ StorageSystemReplicas::StorageSystemReplicas(const StorageID & table_id_) Pipe StorageSystemReplicas::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); const auto access = context->getAccess(); const bool check_access_for_databases = !access->isGranted(AccessType::SHOW_TABLES); @@ -145,7 +145,7 @@ Pipe StorageSystemReplicas::read( col_engine = filtered_block.getByName("engine").column; } - MutableColumns res_columns = metadata_snapshot->getSampleBlock().cloneEmptyColumns(); + MutableColumns res_columns = storage_snapshot->metadata->getSampleBlock().cloneEmptyColumns(); for (size_t i = 0, size = col_database->size(); i < size; ++i) { @@ -186,8 +186,6 @@ Pipe StorageSystemReplicas::read( res_columns[col_num++]->insert(status.zookeeper_exception); } - Block header = metadata_snapshot->getSampleBlock(); - Columns fin_columns; fin_columns.reserve(res_columns.size()); @@ -201,7 +199,7 @@ Pipe StorageSystemReplicas::read( UInt64 num_rows = fin_columns.at(0)->size(); Chunk chunk(std::move(fin_columns), num_rows); - return Pipe(std::make_shared(metadata_snapshot->getSampleBlock(), std::move(chunk))); + return Pipe(std::make_shared(storage_snapshot->metadata->getSampleBlock(), std::move(chunk))); } diff --git a/src/Storages/System/StorageSystemReplicas.h b/src/Storages/System/StorageSystemReplicas.h index 1454628f363..74b93274f1c 100644 --- a/src/Storages/System/StorageSystemReplicas.h +++ b/src/Storages/System/StorageSystemReplicas.h @@ -20,7 +20,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/System/StorageSystemStoragePolicies.cpp b/src/Storages/System/StorageSystemStoragePolicies.cpp index 8f20ab63f25..2333f8cf0f9 100644 --- a/src/Storages/System/StorageSystemStoragePolicies.cpp +++ b/src/Storages/System/StorageSystemStoragePolicies.cpp @@ -37,14 +37,14 @@ StorageSystemStoragePolicies::StorageSystemStoragePolicies(const StorageID & tab Pipe StorageSystemStoragePolicies::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, const size_t /*max_block_size*/, const unsigned /*num_streams*/) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); MutableColumnPtr col_policy_name = ColumnString::create(); MutableColumnPtr col_volume_name = ColumnString::create(); @@ -88,7 +88,7 @@ Pipe StorageSystemStoragePolicies::read( UInt64 num_rows = res_columns.at(0)->size(); Chunk chunk(std::move(res_columns), num_rows); - return Pipe(std::make_shared(metadata_snapshot->getSampleBlock(), std::move(chunk))); + return Pipe(std::make_shared(storage_snapshot->metadata->getSampleBlock(), std::move(chunk))); } } diff --git a/src/Storages/System/StorageSystemStoragePolicies.h b/src/Storages/System/StorageSystemStoragePolicies.h index 25afd4166c8..1bd671a40e7 100644 --- a/src/Storages/System/StorageSystemStoragePolicies.h +++ b/src/Storages/System/StorageSystemStoragePolicies.h @@ -22,7 +22,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/System/StorageSystemTables.cpp b/src/Storages/System/StorageSystemTables.cpp index 6c924e04fce..a0d078096d0 100644 --- a/src/Storages/System/StorageSystemTables.cpp +++ b/src/Storages/System/StorageSystemTables.cpp @@ -504,20 +504,20 @@ private: Pipe StorageSystemTables::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, const size_t max_block_size, const unsigned /*num_streams*/) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); /// Create a mask of what columns are needed in the result. NameSet names_set(column_names.begin(), column_names.end()); - Block sample_block = metadata_snapshot->getSampleBlock(); + Block sample_block = storage_snapshot->metadata->getSampleBlock(); Block res_block; std::vector columns_mask(sample_block.columns()); diff --git a/src/Storages/System/StorageSystemTables.h b/src/Storages/System/StorageSystemTables.h index b196a87b093..36443651451 100644 --- a/src/Storages/System/StorageSystemTables.h +++ b/src/Storages/System/StorageSystemTables.h @@ -20,7 +20,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/System/StorageSystemZeros.cpp b/src/Storages/System/StorageSystemZeros.cpp index 6292ff4d414..93f00d62e70 100644 --- a/src/Storages/System/StorageSystemZeros.cpp +++ b/src/Storages/System/StorageSystemZeros.cpp @@ -92,14 +92,14 @@ StorageSystemZeros::StorageSystemZeros(const StorageID & table_id_, bool multith Pipe StorageSystemZeros::read( const Names & column_names, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo &, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, size_t max_block_size, unsigned num_streams) { - check(metadata_snapshot, column_names); + storage_snapshot->check(column_names); bool use_multiple_streams = multithreaded; diff --git a/src/Storages/System/StorageSystemZeros.h b/src/Storages/System/StorageSystemZeros.h index d33d9b4b099..283f4c49ded 100644 --- a/src/Storages/System/StorageSystemZeros.h +++ b/src/Storages/System/StorageSystemZeros.h @@ -22,7 +22,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, diff --git a/src/Storages/tests/gtest_storage_log.cpp b/src/Storages/tests/gtest_storage_log.cpp index e8057c54a0f..974988a691c 100644 --- a/src/Storages/tests/gtest_storage_log.cpp +++ b/src/Storages/tests/gtest_storage_log.cpp @@ -112,16 +112,17 @@ std::string readData(DB::StoragePtr & table, const DB::ContextPtr context) { using namespace DB; auto metadata_snapshot = table->getInMemoryMetadataPtr(); + auto storage_snapshot = table->getStorageSnapshot(metadata_snapshot); Names column_names; column_names.push_back("a"); SelectQueryInfo query_info; QueryProcessingStage::Enum stage = table->getQueryProcessingStage( - context, QueryProcessingStage::Complete, metadata_snapshot, query_info); + context, QueryProcessingStage::Complete, storage_snapshot, query_info); QueryPipeline pipeline; - pipeline.init(table->read(column_names, metadata_snapshot, query_info, context, stage, 8192, 1)); + pipeline.init(table->read(column_names, storage_snapshot, query_info, context, stage, 8192, 1)); BlockInputStreamPtr in = std::make_shared(std::move(pipeline)); Block sample; diff --git a/tests/queries/0_stateless/01825_type_json_schema_race_long.reference b/tests/queries/0_stateless/01825_type_json_schema_race_long.reference new file mode 100644 index 00000000000..d86bac9de59 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_schema_race_long.reference @@ -0,0 +1 @@ +OK diff --git a/tests/queries/0_stateless/01825_type_json_schema_race_long.sh b/tests/queries/0_stateless/01825_type_json_schema_race_long.sh new file mode 100755 index 00000000000..70da8b52d61 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_schema_race_long.sh @@ -0,0 +1,34 @@ +#!/usr/bin/env bash + +set -e + +CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +# shellcheck source=../shell_config.sh +. "$CURDIR"/../shell_config.sh + +$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_race" +$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_race (data JSON) ENGINE = MergeTree ORDER BY tuple()" + +function test_case() +{ + $CLICKHOUSE_CLIENT -q "TRUNCATE TABLE t_json_race" + + echo '{"data": {"k1": 1, "k2": 2}}' | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_race FORMAT JSONEachRow" + + pids=() + for _ in {1..5}; do + $CLICKHOUSE_CLIENT -q "SELECT * FROM t_json_race WHERE 0 IN (SELECT sleep(0.05)) FORMAT Null" & + pids+=($!) + done + + echo '{"data": {"k1": "str", "k2": "str1"}}' | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_race FORMAT JSONEachRow" & + + for pid in "${pids[@]}"; do + wait "$pid" || exit 1 + done +} + +for i in {1..30}; do test_case; done + +$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_race" +echo OK From cd05df90f149d0b4d0b2807c295367638620694b Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 9 Jul 2021 17:11:44 +0300 Subject: [PATCH 026/132] fix snapshot for storage Merge --- src/Storages/StorageMerge.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/Storages/StorageMerge.cpp b/src/Storages/StorageMerge.cpp index 12b2e69e7a1..c779b1f11d8 100644 --- a/src/Storages/StorageMerge.cpp +++ b/src/Storages/StorageMerge.cpp @@ -282,10 +282,11 @@ Pipe StorageMerge::read( Aliases aliases; auto storage_metadata_snapshot = storage->getInMemoryMetadataPtr(); auto storage_columns = storage_metadata_snapshot->getColumns(); + auto nested_storage_snaphsot = storage->getStorageSnapshot(storage_metadata_snapshot); if (processed_stage == QueryProcessingStage::FetchColumns && !storage_columns.getAliases().empty()) { - auto syntax_result = TreeRewriter(local_context).analyzeSelect(query_info.query, TreeRewriterResult({}, storage, storage->getStorageSnapshot(storage_metadata_snapshot))); + auto syntax_result = TreeRewriter(local_context).analyzeSelect(query_info.query, TreeRewriterResult({}, storage, nested_storage_snaphsot)); ASTPtr required_columns_expr_list = std::make_shared(); ASTPtr column_expr; @@ -321,7 +322,7 @@ Pipe StorageMerge::read( } auto source_pipe = createSources( - storage_snapshot, + nested_storage_snaphsot, query_info, processed_stage, max_block_size, From e1afdc1f1e9c2aa75bb8608f038f9c7201c2b444 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 9 Jul 2021 17:54:53 +0300 Subject: [PATCH 027/132] dynamic subcolumns: add mode for DESCRIBE query to show deduced object types --- src/Core/Settings.h | 1 + src/Interpreters/InterpreterDescribeQuery.cpp | 26 +++++++++++++------ src/Storages/StorageSnapshot.cpp | 9 +++++++ src/Storages/StorageSnapshot.h | 2 ++ .../01825_type_json_describe.reference | 3 +++ .../0_stateless/01825_type_json_describe.sql | 16 ++++++++++++ 6 files changed, 49 insertions(+), 8 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_describe.reference create mode 100644 tests/queries/0_stateless/01825_type_json_describe.sql diff --git a/src/Core/Settings.h b/src/Core/Settings.h index 28e46160a98..5013366101e 100644 --- a/src/Core/Settings.h +++ b/src/Core/Settings.h @@ -451,6 +451,7 @@ class IColumn; M(Bool, force_optimize_projection, false, "If projection optimization is enabled, SELECT queries need to use projection", 0) \ M(Bool, async_socket_for_remote, true, "Asynchronously read from socket executing remote query", 0) \ M(Bool, insert_null_as_default, true, "Insert DEFAULT values instead of NULL in INSERT SELECT (UNION ALL)", 0) \ + M(Bool, describe_extend_object_type, false, "Deduce concrete type of columns of type Object in DESCRIBE query", 0) \ \ M(Bool, optimize_rewrite_sum_if_to_count_if, true, "Rewrite sumIf() and sum(if()) function countIf() function when logically equivalent", 0) \ M(UInt64, insert_shard_id, 0, "If non zero, when insert into a distributed table, the data will be inserted into the shard `insert_shard_id` synchronously. Possible values range from 1 to `shards_number` of corresponding distributed table", 0) \ diff --git a/src/Interpreters/InterpreterDescribeQuery.cpp b/src/Interpreters/InterpreterDescribeQuery.cpp index 705e52da72c..72cf2dc18ab 100644 --- a/src/Interpreters/InterpreterDescribeQuery.cpp +++ b/src/Interpreters/InterpreterDescribeQuery.cpp @@ -63,27 +63,33 @@ Block InterpreterDescribeQuery::getSampleBlock() BlockInputStreamPtr InterpreterDescribeQuery::executeImpl() { ColumnsDescription columns; + StorageSnapshotPtr storage_snapshot; const auto & ast = query_ptr->as(); const auto & table_expression = ast.table_expression->as(); + auto context = getContext(); + const auto & settings = context->getSettingsRef(); + if (table_expression.subquery) { auto names_and_types = InterpreterSelectWithUnionQuery::getSampleBlock( - table_expression.subquery->children.at(0), getContext()).getNamesAndTypesList(); + table_expression.subquery->children.at(0), context).getNamesAndTypesList(); columns = ColumnsDescription(std::move(names_and_types)); } else if (table_expression.table_function) { - TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().get(table_expression.table_function, getContext()); - columns = table_function_ptr->getActualTableStructure(getContext()); + TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().get(table_expression.table_function, context); + columns = table_function_ptr->getActualTableStructure(context); } else { - auto table_id = getContext()->resolveStorageID(table_expression.database_and_table_name); - getContext()->checkAccess(AccessType::SHOW_COLUMNS, table_id); - auto table = DatabaseCatalog::instance().getTable(table_id, getContext()); - auto table_lock = table->lockForShare(getContext()->getInitialQueryId(), getContext()->getSettingsRef().lock_acquire_timeout); + auto table_id = context->resolveStorageID(table_expression.database_and_table_name); + context->checkAccess(AccessType::SHOW_COLUMNS, table_id); + auto table = DatabaseCatalog::instance().getTable(table_id, context); + auto table_lock = table->lockForShare(context->getInitialQueryId(), settings.lock_acquire_timeout); + auto metadata_snapshot = table->getInMemoryMetadataPtr(); + storage_snapshot = table->getStorageSnapshot(metadata_snapshot); columns = metadata_snapshot->getColumns(); } @@ -93,7 +99,11 @@ BlockInputStreamPtr InterpreterDescribeQuery::executeImpl() for (const auto & column : columns) { res_columns[0]->insert(column.name); - res_columns[1]->insert(column.type->getName()); + + if (settings.describe_extend_object_type && storage_snapshot) + res_columns[1]->insert(storage_snapshot->getConcreteType(column.name)->getName()); + else + res_columns[1]->insert(column.type->getName()); if (column.default_desc.expression) { diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp index cd1e516c7fe..ffff2ce47c4 100644 --- a/src/Storages/StorageSnapshot.cpp +++ b/src/Storages/StorageSnapshot.cpp @@ -92,4 +92,13 @@ void StorageSnapshot::check(const Names & column_names) const } } +DataTypePtr StorageSnapshot::getConcreteType(const String & column_name) const +{ + auto it = object_types.find(column_name); + if (it != object_types.end()) + return it->second; + + return metadata->getColumns().get(column_name).type; +} + } diff --git a/src/Storages/StorageSnapshot.h b/src/Storages/StorageSnapshot.h index a34eef8116a..a1bed1fc253 100644 --- a/src/Storages/StorageSnapshot.h +++ b/src/Storages/StorageSnapshot.h @@ -51,6 +51,8 @@ struct StorageSnapshot /// Verify that all the requested names are in the table and are set correctly: /// list of names is not empty and the names do not repeat. void check(const Names & column_names) const; + + DataTypePtr getConcreteType(const String & column_name) const; }; using StorageSnapshotPtr = std::shared_ptr; diff --git a/tests/queries/0_stateless/01825_type_json_describe.reference b/tests/queries/0_stateless/01825_type_json_describe.reference new file mode 100644 index 00000000000..629b60cb629 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_describe.reference @@ -0,0 +1,3 @@ +data Object(\'json\') +data Tuple(k1 Int8) +data Tuple(k1 String, k2 Array(Int8)) diff --git a/tests/queries/0_stateless/01825_type_json_describe.sql b/tests/queries/0_stateless/01825_type_json_describe.sql new file mode 100644 index 00000000000..4a99ebd3336 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_describe.sql @@ -0,0 +1,16 @@ +DROP TABLE IF EXISTS t_json_desc; + +CREATE TABLE t_json_desc (data JSON) ENGINE = MergeTree ORDER BY tuple(); + +INSERT INTO t_json_desc FORMAT JSONAsObject {"k1": 10} +; + +DESC TABLE t_json_desc; +DESC TABLE t_json_desc SETTINGS describe_extend_object_type = 1; + +INSERT INTO t_json_desc FORMAT JSONAsObject {"k1": "q", "k2": [1, 2, 3]} +; + +DESC TABLE t_json_desc SETTINGS describe_extend_object_type = 1; + +DROP TABLE IF EXISTS t_json_desc; From 6ba41dc265e183a87e4cd1535c9952f144e57203 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Mon, 12 Jul 2021 16:45:35 +0300 Subject: [PATCH 028/132] fix projections with storage snapshot --- src/Interpreters/InterpreterSelectQuery.cpp | 5 +-- .../QueryPlan/ReadFromMergeTree.cpp | 33 +++++++++---------- src/Processors/QueryPlan/ReadFromMergeTree.h | 5 +-- src/Storages/IStorage.cpp | 2 -- .../MergeTree/MergeTreeBlockReadUtils.cpp | 4 +-- src/Storages/MergeTree/MergeTreeData.cpp | 6 ---- .../MergeTree/MergeTreeDataSelectExecutor.cpp | 26 +++++---------- .../MergeTree/MergeTreeDataSelectExecutor.h | 4 --- .../MergeTree/StorageFromMergeTreeDataPart.h | 2 -- src/Storages/StorageSnapshot.cpp | 2 +- src/Storages/StorageSnapshot.h | 7 ++++ 11 files changed, 37 insertions(+), 59 deletions(-) diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp index 6d641b539af..7d6b55d758a 100644 --- a/src/Interpreters/InterpreterSelectQuery.cpp +++ b/src/Interpreters/InterpreterSelectQuery.cpp @@ -620,7 +620,10 @@ Block InterpreterSelectQuery::getSampleBlockImpl() /// TODO how can we make IN index work if we cache parts before selecting a projection? /// XXX Used for IN set index analysis. Is this a proper way? if (query_info.projection) + { metadata_snapshot->selected_projection = query_info.projection->desc; + storage_snapshot->addProjection(query_info.projection->desc); + } } /// Do I need to perform the first part of the pipeline? @@ -1965,8 +1968,6 @@ void InterpreterSelectQuery::executeFetchColumns(QueryProcessingStage::Enum proc /// Create step which reads from empty source if storage has no data. if (!query_plan.isInitialized()) { - /// TODO: fix. - // const auto & metadata = query_info.projection ? query_info.projection->desc->metadata : metadata_snapshot; auto header = storage_snapshot->getSampleBlockForColumns(required_columns); addEmptySourceToQueryPlan(query_plan, header, query_info, context); } diff --git a/src/Processors/QueryPlan/ReadFromMergeTree.cpp b/src/Processors/QueryPlan/ReadFromMergeTree.cpp index a3c4067000b..db5af2f3d26 100644 --- a/src/Processors/QueryPlan/ReadFromMergeTree.cpp +++ b/src/Processors/QueryPlan/ReadFromMergeTree.cpp @@ -75,8 +75,6 @@ ReadFromMergeTree::ReadFromMergeTree( const MergeTreeData & data_, const SelectQueryInfo & query_info_, StorageSnapshotPtr storage_snapshot_, - StorageMetadataPtr metadata_snapshot_, - StorageMetadataPtr metadata_snapshot_base_, ContextPtr context_, size_t max_block_size_, size_t num_streams_, @@ -97,8 +95,7 @@ ReadFromMergeTree::ReadFromMergeTree( , prewhere_info(getPrewhereInfo(query_info)) , actions_settings(ExpressionActionsSettings::fromContext(context_)) , storage_snapshot(std::move(storage_snapshot_)) - , metadata_snapshot(std::move(metadata_snapshot_)) - , metadata_snapshot_base(std::move(metadata_snapshot_base_)) + , metadata_for_reading(storage_snapshot->getMetadataForQuery()) , context(std::move(context_)) , max_block_size(max_block_size_) , requested_num_streams(num_streams_) @@ -464,7 +461,7 @@ Pipe ReadFromMergeTree::spreadMarkRangesAmongStreamsWithOrder( { SortDescription sort_description; for (size_t j = 0; j < input_order_info->order_key_prefix_descr.size(); ++j) - sort_description.emplace_back(metadata_snapshot->getSortingKey().column_names[j], + sort_description.emplace_back(metadata_for_reading->getSortingKey().column_names[j], input_order_info->direction, 1); auto sorting_key_expr = std::make_shared(sorting_key_prefix_expr); @@ -691,7 +688,7 @@ Pipe ReadFromMergeTree::spreadMarkRangesAmongStreamsFinal( } auto sorting_expr = std::make_shared( - metadata_snapshot->getSortingKey().expression->getActionsDAG().clone()); + metadata_for_reading->getSortingKey().expression->getActionsDAG().clone()); pipe.addSimpleTransform([sorting_expr](const Block & header) { @@ -708,12 +705,12 @@ Pipe ReadFromMergeTree::spreadMarkRangesAmongStreamsFinal( continue; } - Names sort_columns = metadata_snapshot->getSortingKeyColumns(); + Names sort_columns = metadata_for_reading->getSortingKeyColumns(); SortDescription sort_description; size_t sort_columns_size = sort_columns.size(); sort_description.reserve(sort_columns_size); - Names partition_key_columns = metadata_snapshot->getPartitionKey().column_names; + Names partition_key_columns = metadata_for_reading->getPartitionKey().column_names; const auto & header = pipe.getHeader(); for (size_t i = 0; i < sort_columns_size; ++i) @@ -753,7 +750,7 @@ Pipe ReadFromMergeTree::spreadMarkRangesAmongStreamsFinal( out_projection = createProjection(pipe.getHeader()); auto sorting_expr = std::make_shared( - metadata_snapshot->getSortingKey().expression->getActionsDAG().clone()); + metadata_for_reading->getSortingKey().expression->getActionsDAG().clone()); pipe.addSimpleTransform([sorting_expr](const Block & header) { @@ -782,14 +779,14 @@ ReadFromMergeTree::AnalysisResult ReadFromMergeTree::selectRangesToRead(MergeTre /// If there are only virtual columns in the query, you must request at least one non-virtual one. if (result.column_names_to_read.empty()) { - NamesAndTypesList available_real_columns = metadata_snapshot->getColumns().getAllPhysical(); + NamesAndTypesList available_real_columns = metadata_for_reading->getColumns().getAllPhysical(); result.column_names_to_read.push_back(ExpressionActions::getSmallestColumn(available_real_columns)); } storage_snapshot->check(result.column_names_to_read); // Build and check if primary key is used when necessary - const auto & primary_key = metadata_snapshot->getPrimaryKey(); + const auto & primary_key = metadata_for_reading->getPrimaryKey(); Names primary_key_columns = primary_key.column_names; KeyCondition key_condition(query_info, context, primary_key_columns, primary_key.expression); @@ -805,12 +802,12 @@ ReadFromMergeTree::AnalysisResult ReadFromMergeTree::selectRangesToRead(MergeTre const auto & select = query_info.query->as(); MergeTreeDataSelectExecutor::filterPartsByPartition( - parts, part_values, metadata_snapshot_base, data, query_info, context, + parts, part_values, storage_snapshot->metadata, data, query_info, context, max_block_numbers_to_read.get(), log, result.index_stats); result.sampling = MergeTreeDataSelectExecutor::getSampling( - select, metadata_snapshot->getColumns().getAllPhysical(), parts, key_condition, - data, metadata_snapshot, context, sample_factor_column_queried, log); + select, metadata_for_reading->getColumns().getAllPhysical(), parts, key_condition, + data, metadata_for_reading, context, sample_factor_column_queried, log); if (result.sampling.read_nothing) return result; @@ -823,7 +820,7 @@ ReadFromMergeTree::AnalysisResult ReadFromMergeTree::selectRangesToRead(MergeTre result.parts_with_ranges = MergeTreeDataSelectExecutor::filterPartsByPrimaryKeyAndSkipIndexes( std::move(parts), - metadata_snapshot, + metadata_for_reading, query_info, context, key_condition, @@ -913,7 +910,7 @@ void ReadFromMergeTree::initializePipeline(QueryPipeline & pipeline, const Build if (select.final()) { /// Add columns needed to calculate the sorting expression and the sign. - std::vector add_columns = metadata_snapshot->getColumnsRequiredForSortingKey(); + std::vector add_columns = metadata_for_reading->getColumnsRequiredForSortingKey(); column_names_to_read.insert(column_names_to_read.end(), add_columns.begin(), add_columns.end()); if (!data.merging_params.sign_column.empty()) @@ -932,10 +929,10 @@ void ReadFromMergeTree::initializePipeline(QueryPipeline & pipeline, const Build else if ((settings.optimize_read_in_order || settings.optimize_aggregation_in_order) && input_order_info) { size_t prefix_size = input_order_info->order_key_prefix_descr.size(); - auto order_key_prefix_ast = metadata_snapshot->getSortingKey().expression_list_ast->clone(); + auto order_key_prefix_ast = metadata_for_reading->getSortingKey().expression_list_ast->clone(); order_key_prefix_ast->children.resize(prefix_size); - auto syntax_result = TreeRewriter(context).analyze(order_key_prefix_ast, metadata_snapshot->getColumns().getAllPhysical()); + auto syntax_result = TreeRewriter(context).analyze(order_key_prefix_ast, metadata_for_reading->getColumns().getAllPhysical()); auto sorting_key_prefix_expr = ExpressionAnalyzer(order_key_prefix_ast, syntax_result, context).getActionsDAG(false); pipe = spreadMarkRangesAmongStreamsWithOrder( diff --git a/src/Processors/QueryPlan/ReadFromMergeTree.h b/src/Processors/QueryPlan/ReadFromMergeTree.h index 764227ef304..be844ef0cc0 100644 --- a/src/Processors/QueryPlan/ReadFromMergeTree.h +++ b/src/Processors/QueryPlan/ReadFromMergeTree.h @@ -61,8 +61,6 @@ public: const MergeTreeData & data_, const SelectQueryInfo & query_info_, StorageSnapshotPtr storage_snapshot, - StorageMetadataPtr metadata_snapshot_, - StorageMetadataPtr metadata_snapshot_base_, ContextPtr context_, size_t max_block_size_, size_t num_streams_, @@ -94,8 +92,7 @@ private: ExpressionActionsSettings actions_settings; StorageSnapshotPtr storage_snapshot; - StorageMetadataPtr metadata_snapshot; - StorageMetadataPtr metadata_snapshot_base; + StorageMetadataPtr metadata_for_reading; ContextPtr context; diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp index 2ccaf9b2c1c..80e5b52ec28 100644 --- a/src/Storages/IStorage.cpp +++ b/src/Storages/IStorage.cpp @@ -113,8 +113,6 @@ void IStorage::read( auto pipe = read(column_names, storage_snapshot, query_info, context, processed_stage, max_block_size, num_streams); if (pipe.empty()) { - /// TODO: fix - // const auto & metadata_for_query = query_info.projection ? query_info.projection->desc->metadata : storage_snapshot->metadata; auto header = storage_snapshot->getSampleBlockForColumns(column_names); InterpreterSelectQuery::addEmptySourceToQueryPlan(query_plan, header, query_info, context); } diff --git a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp index 88a596dd1ae..7eeb9189599 100644 --- a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp +++ b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp @@ -275,7 +275,7 @@ MergeTreeReadTaskColumns getReadTaskColumns( Names pre_column_names; /// inject columns required for defaults evaluation - bool should_reorder = !injectRequiredColumns(storage, storage_snapshot->metadata, data_part, column_names).empty(); + bool should_reorder = !injectRequiredColumns(storage, storage_snapshot->getMetadataForQuery(), data_part, column_names).empty(); if (prewhere_info) { @@ -300,7 +300,7 @@ MergeTreeReadTaskColumns getReadTaskColumns( if (pre_column_names.empty()) pre_column_names.push_back(column_names[0]); - const auto injected_pre_columns = injectRequiredColumns(storage, storage_snapshot->metadata, data_part, pre_column_names); + const auto injected_pre_columns = injectRequiredColumns(storage, storage_snapshot->getMetadataForQuery(), data_part, pre_column_names); if (!injected_pre_columns.empty()) should_reorder = true; diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index 74976c057ef..49f9eba5b0f 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -3890,8 +3890,6 @@ static void selectBestProjection( auto sum_marks = reader.estimateNumMarksToRead( projection_parts, candidate.required_columns, - storage_snapshot, - storage_snapshot->metadata, candidate.desc->metadata, query_info, // TODO syntax_analysis_result set in index query_context, @@ -3909,8 +3907,6 @@ static void selectBestProjection( sum_marks += reader.estimateNumMarksToRead( normal_parts, required_columns, - storage_snapshot, - storage_snapshot->metadata, storage_snapshot->metadata, query_info, // TODO syntax_analysis_result set in index query_context, @@ -4184,8 +4180,6 @@ bool MergeTreeData::getQueryProcessingStageWithAggregateProjection( min_sum_marks = reader.estimateNumMarksToRead( parts, analysis_result.required_columns, - storage_snapshot, - metadata_snapshot, metadata_snapshot, query_info, // TODO syntax_analysis_result set in index query_context, diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp index 6c2bb157c4f..b762ecc167b 100644 --- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp +++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp @@ -134,7 +134,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::read( { const auto & settings = context->getSettingsRef(); const auto & parts = storage_snapshot->parts; - const auto & metadata_snapshot = storage_snapshot->metadata; + const auto & metadata_for_reading = storage_snapshot->getMetadataForQuery(); if (!query_info.projection) { @@ -142,8 +142,6 @@ QueryPlanPtr MergeTreeDataSelectExecutor::read( parts, column_names_to_return, storage_snapshot, - metadata_snapshot, - metadata_snapshot, query_info, context, max_block_size, @@ -151,7 +149,7 @@ QueryPlanPtr MergeTreeDataSelectExecutor::read( max_block_numbers_to_read); if (plan->isInitialized() && settings.allow_experimental_projection_optimization && settings.force_optimize_projection - && !metadata_snapshot->projections.empty()) + && !metadata_for_reading->projections.empty()) throw Exception( "No projection is used when allow_experimental_projection_optimization = 1 and force_optimize_projection = 1", ErrorCodes::PROJECTION_NOT_USED); @@ -189,8 +187,6 @@ QueryPlanPtr MergeTreeDataSelectExecutor::read( projection_parts, query_info.projection->required_columns, storage_snapshot, - metadata_snapshot, - query_info.projection->desc->metadata, query_info, context, max_block_size, @@ -1090,8 +1086,6 @@ static void selectColumnNames( size_t MergeTreeDataSelectExecutor::estimateNumMarksToRead( MergeTreeData::DataPartsVector parts, const Names & column_names_to_return, - const StorageSnapshotPtr & storage_snapshot, - const StorageMetadataPtr & metadata_snapshot_base, const StorageMetadataPtr & metadata_snapshot, const SelectQueryInfo & query_info, ContextPtr context, @@ -1114,14 +1108,14 @@ size_t MergeTreeDataSelectExecutor::estimateNumMarksToRead( if (part_values && part_values->empty()) return 0; + auto physical_columns = metadata_snapshot->getColumns().getAllPhysical(); + /// If there are only virtual columns in the query, you must request at least one non-virtual one. if (real_column_names.empty()) - { - NamesAndTypesList available_real_columns = metadata_snapshot->getColumns().getAllPhysical(); - real_column_names.push_back(ExpressionActions::getSmallestColumn(available_real_columns)); - } + real_column_names.push_back(ExpressionActions::getSmallestColumn(physical_columns)); - storage_snapshot->check(real_column_names); + /// TODO: do we support dynamic columns here? + metadata_snapshot->check(physical_columns.addTypes(real_column_names)); const auto & primary_key = metadata_snapshot->getPrimaryKey(); Names primary_key_columns = primary_key.column_names; @@ -1140,7 +1134,7 @@ size_t MergeTreeDataSelectExecutor::estimateNumMarksToRead( ReadFromMergeTree::IndexStats index_stats; filterPartsByPartition( - parts, part_values, metadata_snapshot_base, data, query_info, + parts, part_values, metadata_snapshot, data, query_info, context, max_block_numbers_to_read.get(), log, index_stats); auto sampling = MergeTreeDataSelectExecutor::getSampling( @@ -1172,8 +1166,6 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts( MergeTreeData::DataPartsVector parts, const Names & column_names_to_return, const StorageSnapshotPtr & storage_snapshot, - const StorageMetadataPtr & metadata_snapshot_base, - const StorageMetadataPtr & metadata_snapshot, const SelectQueryInfo & query_info, ContextPtr context, const UInt64 max_block_size, @@ -1199,8 +1191,6 @@ QueryPlanPtr MergeTreeDataSelectExecutor::readFromParts( data, query_info, storage_snapshot, - metadata_snapshot, - metadata_snapshot_base, context, max_block_size, num_streams, diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h index 88443c0febc..d2e26d870ae 100644 --- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h +++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.h @@ -50,8 +50,6 @@ public: MergeTreeData::DataPartsVector parts, const Names & column_names, const StorageSnapshotPtr & storage_snapshot, - const StorageMetadataPtr & metadata_snapshot_base, - const StorageMetadataPtr & metadata_snapshot, const SelectQueryInfo & query_info, ContextPtr context, UInt64 max_block_size, @@ -64,8 +62,6 @@ public: size_t estimateNumMarksToRead( MergeTreeData::DataPartsVector parts, const Names & column_names, - const StorageSnapshotPtr & storage_snapshot, - const StorageMetadataPtr & storage_snapshot_base, const StorageMetadataPtr & metadata_snapshot, const SelectQueryInfo & query_info, ContextPtr context, diff --git a/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h b/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h index c14964c9e23..a938fb3f573 100644 --- a/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h +++ b/src/Storages/MergeTree/StorageFromMergeTreeDataPart.h @@ -37,8 +37,6 @@ public: parts, column_names, storage_snapshot, - storage_snapshot->metadata, - storage_snapshot->metadata, query_info, context, max_block_size, diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp index ffff2ce47c4..982057bf72c 100644 --- a/src/Storages/StorageSnapshot.cpp +++ b/src/Storages/StorageSnapshot.cpp @@ -15,7 +15,7 @@ namespace ErrorCodes NamesAndTypesList StorageSnapshot::getColumns(const GetColumnsOptions & options) const { - auto all_columns = metadata->getColumns().get(options); + auto all_columns = getMetadataForQuery()->getColumns().get(options); if (options.with_virtuals) { diff --git a/src/Storages/StorageSnapshot.h b/src/Storages/StorageSnapshot.h index a1bed1fc253..1ee61c059a0 100644 --- a/src/Storages/StorageSnapshot.h +++ b/src/Storages/StorageSnapshot.h @@ -19,6 +19,9 @@ struct StorageSnapshot const NameToTypeMap object_types; const DataPartsVector parts; + /// TODO: fix + mutable const ProjectionDescription * projection = nullptr; + StorageSnapshot( const IStorage & storage_, const StorageMetadataPtr & metadata_) @@ -53,6 +56,10 @@ struct StorageSnapshot void check(const Names & column_names) const; DataTypePtr getConcreteType(const String & column_name) const; + + void addProjection(const ProjectionDescription * projection_) const { projection = projection_; } + + StorageMetadataPtr getMetadataForQuery() const { return (projection ? projection->metadata : metadata); } }; using StorageSnapshotPtr = std::shared_ptr; From 5d175bf557bc46c540d2da76258a24fc0f0bb94b Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Mon, 12 Jul 2021 17:54:02 +0300 Subject: [PATCH 029/132] dynamic columns: support distributed tables --- src/Core/Settings.h | 2 +- src/Interpreters/InterpreterDescribeQuery.cpp | 2 +- src/Storages/StorageDistributed.cpp | 28 ++++++++ src/Storages/StorageDistributed.h | 2 + src/Storages/getStructureOfRemoteTable.cpp | 64 +++++++++++++++++++ src/Storages/getStructureOfRemoteTable.h | 6 ++ .../01825_type_json_distributed.reference | 4 ++ .../01825_type_json_distributed.sql | 14 ++++ 8 files changed, 120 insertions(+), 2 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_distributed.reference create mode 100644 tests/queries/0_stateless/01825_type_json_distributed.sql diff --git a/src/Core/Settings.h b/src/Core/Settings.h index 5013366101e..ff4ef241bd3 100644 --- a/src/Core/Settings.h +++ b/src/Core/Settings.h @@ -451,7 +451,7 @@ class IColumn; M(Bool, force_optimize_projection, false, "If projection optimization is enabled, SELECT queries need to use projection", 0) \ M(Bool, async_socket_for_remote, true, "Asynchronously read from socket executing remote query", 0) \ M(Bool, insert_null_as_default, true, "Insert DEFAULT values instead of NULL in INSERT SELECT (UNION ALL)", 0) \ - M(Bool, describe_extend_object_type, false, "Deduce concrete type of columns of type Object in DESCRIBE query", 0) \ + M(Bool, describe_extend_object_types, false, "Deduce concrete type of columns of type Object in DESCRIBE query", 0) \ \ M(Bool, optimize_rewrite_sum_if_to_count_if, true, "Rewrite sumIf() and sum(if()) function countIf() function when logically equivalent", 0) \ M(UInt64, insert_shard_id, 0, "If non zero, when insert into a distributed table, the data will be inserted into the shard `insert_shard_id` synchronously. Possible values range from 1 to `shards_number` of corresponding distributed table", 0) \ diff --git a/src/Interpreters/InterpreterDescribeQuery.cpp b/src/Interpreters/InterpreterDescribeQuery.cpp index 72cf2dc18ab..5c976c1cd23 100644 --- a/src/Interpreters/InterpreterDescribeQuery.cpp +++ b/src/Interpreters/InterpreterDescribeQuery.cpp @@ -100,7 +100,7 @@ BlockInputStreamPtr InterpreterDescribeQuery::executeImpl() { res_columns[0]->insert(column.name); - if (settings.describe_extend_object_type && storage_snapshot) + if (settings.describe_extend_object_types && storage_snapshot) res_columns[1]->insert(storage_snapshot->getConcreteType(column.name)->getName()); else res_columns[1]->insert(column.type->getName()); diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index c1983993d96..946513988df 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -9,10 +9,12 @@ #include #include #include +#include #include #include #include +#include #include @@ -559,6 +561,32 @@ QueryProcessingStage::Enum StorageDistributed::getQueryProcessingStage( return QueryProcessingStage::WithMergeableState; } +StorageSnapshotPtr StorageDistributed::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const +{ + auto names_of_objects = getNamesOfObjectColumns(metadata_snapshot->getColumns().getAllPhysical()); + if (names_of_objects.empty()) + return std::make_shared(*this, metadata_snapshot); + + auto columns_in_tables = getExtendedColumnsOfRemoteTables(*getCluster(), StorageID{remote_database, remote_table}, getContext()); + assert(!columns_in_tables.empty()); + + std::unordered_map types_in_tables; + for (const auto & columns : columns_in_tables) + { + for (const auto & [name, type] : columns) + { + if (names_of_objects.count(name)) + types_in_tables[name].push_back(type); + } + } + + StorageSnapshot::NameToTypeMap object_types; + for (const auto & [name, types] : types_in_tables) + object_types.emplace(name, getLeastCommonTypeForObject(types)); + + return std::make_shared(*this, metadata_snapshot, object_types); +} + Pipe StorageDistributed::read( const Names & column_names, const StorageSnapshotPtr & storage_snapshot, diff --git a/src/Storages/StorageDistributed.h b/src/Storages/StorageDistributed.h index 6cd1115e9a9..e1932543a5e 100644 --- a/src/Storages/StorageDistributed.h +++ b/src/Storages/StorageDistributed.h @@ -56,6 +56,8 @@ public: bool isRemote() const override { return true; } + StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const override; + QueryProcessingStage::Enum getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const override; diff --git a/src/Storages/getStructureOfRemoteTable.cpp b/src/Storages/getStructureOfRemoteTable.cpp index fb828b8f744..247f9a23c56 100644 --- a/src/Storages/getStructureOfRemoteTable.cpp +++ b/src/Storages/getStructureOfRemoteTable.cpp @@ -60,6 +60,7 @@ ColumnsDescription getStructureOfRemoteTableInShard( ColumnsDescription res; auto new_context = ClusterProxy::updateSettingsForCluster(cluster, context, context->getSettingsRef()); + new_context->setSetting("describe_extend_object_types", true); /// Expect only needed columns from the result of DESC TABLE. NOTE 'comment' column is ignored for compatibility reasons. Block sample_block @@ -150,4 +151,67 @@ ColumnsDescription getStructureOfRemoteTable( ErrorCodes::NO_REMOTE_SHARD_AVAILABLE); } +std::vector getExtendedColumnsOfRemoteTables( + const Cluster & cluster, + const StorageID & remote_table_id, + ContextPtr context) +{ + const auto & shards_info = cluster.getShardsInfo(); + auto query = "DESC TABLE " + remote_table_id.getFullTableName(); + + auto new_context = ClusterProxy::updateSettingsForCluster(cluster, context, context->getSettingsRef()); + new_context->setSetting("describe_extend_object_types", true); + + /// Expect only needed columns from the result of DESC TABLE. + Block sample_block + { + { ColumnString::create(), std::make_shared(), "name" }, + { ColumnString::create(), std::make_shared(), "type" }, + }; + + auto execute_query_on_shard = [&](const auto & shard_info) + { + /// Execute remote query without restrictions (because it's not real user query, but part of implementation) + auto input = std::make_shared(shard_info.pool, query, sample_block, new_context); + + input->setPoolMode(PoolMode::GET_ONE); + input->setMainTable(remote_table_id); + input->readPrefix(); + + NamesAndTypesList res; + while (auto block = input->read()) + { + const auto & name_col = *block.getByName("name").column; + const auto & type_col = *block.getByName("type").column; + + size_t size = name_col.size(); + for (size_t i = 0; i < size; ++i) + { + auto name = name_col[i].template get(); + auto type_name = type_col[i].template get(); + + res.emplace_back(std::move(name), DataTypeFactory::instance().get(type_name)); + } + } + + return res; + }; + + std::vector columns; + for (const auto & shard_info : shards_info) + { + auto res = execute_query_on_shard(shard_info); + + /// Expect at least some columns. + /// This is a hack to handle the empty block case returned by Connection when skip_unavailable_shards is set. + if (!res.empty()) + columns.emplace_back(std::move(res)); + } + + if (columns.empty()) + throw NetException("All attempts to get table structure failed", ErrorCodes::NO_REMOTE_SHARD_AVAILABLE); + + return columns; +} + } diff --git a/src/Storages/getStructureOfRemoteTable.h b/src/Storages/getStructureOfRemoteTable.h index 3f77236c756..5ca15055b8f 100644 --- a/src/Storages/getStructureOfRemoteTable.h +++ b/src/Storages/getStructureOfRemoteTable.h @@ -8,6 +8,7 @@ namespace DB { + class Context; struct StorageID; @@ -19,4 +20,9 @@ ColumnsDescription getStructureOfRemoteTable( ContextPtr context, const ASTPtr & table_func_ptr = nullptr); +std::vector getExtendedColumnsOfRemoteTables( + const Cluster & cluster, + const StorageID & remote_table_id, + ContextPtr context); + } diff --git a/tests/queries/0_stateless/01825_type_json_distributed.reference b/tests/queries/0_stateless/01825_type_json_distributed.reference new file mode 100644 index 00000000000..21308748ef3 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_distributed.reference @@ -0,0 +1,4 @@ +(2,'qqq',[44,55]) Tuple(k1 Int8, `k2.k3` String, `k2.k4` Array(Int8)) +(2,'qqq',[44,55]) Tuple(k1 Int8, `k2.k3` String, `k2.k4` Array(Int8)) +2 qqq [44,55] +2 qqq [44,55] diff --git a/tests/queries/0_stateless/01825_type_json_distributed.sql b/tests/queries/0_stateless/01825_type_json_distributed.sql new file mode 100644 index 00000000000..faa0717e21e --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_distributed.sql @@ -0,0 +1,14 @@ +DROP TABLE IF EXISTS t_json_local; +DROP TABLE IF EXISTS t_json_dist; + +CREATE TABLE t_json_local(data JSON) ENGINE = MergeTree ORDER BY tuple(); +CREATE TABLE t_json_dist AS t_json_local ENGINE = Distributed(test_cluster_two_shards, currentDatabase(), t_json_local); + +INSERT INTO t_json_local FORMAT JSONAsObject {"k1": 2, "k2": {"k3": "qqq", "k4": [44, 55]}} +; + +SELECT data, toTypeName(data) FROM t_json_dist; +SELECT data.k1, data.k2.k3, data.k2.k4 FROM t_json_dist; + +DROP TABLE IF EXISTS t_json_local; +DROP TABLE IF EXISTS t_json_dist; From c7214cd42c5ec1fffe48612435188721d54ffbbb Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Tue, 13 Jul 2021 15:39:12 +0300 Subject: [PATCH 030/132] dynamic columns: add integration test for distributed --- .../test_distributed_type_object/__init__.py | 0 .../configs/remote_servers.xml | 18 ++++++++++ .../test_distributed_type_object/test.py | 36 +++++++++++++++++++ 3 files changed, 54 insertions(+) create mode 100644 tests/integration/test_distributed_type_object/__init__.py create mode 100644 tests/integration/test_distributed_type_object/configs/remote_servers.xml create mode 100644 tests/integration/test_distributed_type_object/test.py diff --git a/tests/integration/test_distributed_type_object/__init__.py b/tests/integration/test_distributed_type_object/__init__.py new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/integration/test_distributed_type_object/configs/remote_servers.xml b/tests/integration/test_distributed_type_object/configs/remote_servers.xml new file mode 100644 index 00000000000..ebce4697529 --- /dev/null +++ b/tests/integration/test_distributed_type_object/configs/remote_servers.xml @@ -0,0 +1,18 @@ + + + + + + node1 + 9000 + + + + + node2 + 9000 + + + + + diff --git a/tests/integration/test_distributed_type_object/test.py b/tests/integration/test_distributed_type_object/test.py new file mode 100644 index 00000000000..7ceb538cf45 --- /dev/null +++ b/tests/integration/test_distributed_type_object/test.py @@ -0,0 +1,36 @@ +import pytest + +from helpers.cluster import ClickHouseCluster +from helpers.test_tools import TSV + +cluster = ClickHouseCluster(__file__) + +node1 = cluster.add_instance('node1', main_configs=['configs/remote_servers.xml']) +node2 = cluster.add_instance('node2', main_configs=['configs/remote_servers.xml']) + +@pytest.fixture(scope="module") +def started_cluster(): + try: + cluster.start() + + for node in (node1, node2): + node.query("CREATE TABLE local_table(id UInt32, data JSON) ENGINE = MergeTree ORDER BY id") + node.query("CREATE TABLE dist_table AS local_table ENGINE = Distributed(test_cluster, default, local_table)") + + yield cluster + + finally: + cluster.shutdown() + + +def test_distributed_type_object(started_cluster): + node1.query('INSERT INTO local_table FORMAT JSONEachRow {"id": 1, "data": {"k1": 10}}') + node2.query('INSERT INTO local_table FORMAT JSONEachRow {"id": 2, "data": {"k1": 20}}') + + expected = TSV("10\n20\n") + assert TSV(node1.query("SELECT data.k1 FROM dist_table ORDER BY id")) == expected + + node1.query('INSERT INTO local_table FORMAT JSONEachRow {"id": 3, "data": {"k1": "str1"}}') + + expected = TSV("10\n20\nstr1\n") + assert TSV(node1.query("SELECT data.k1 FROM dist_table ORDER BY id")) == expected From 1685ca482639073fde83e67fb823b1ee6e8a47f2 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Tue, 20 Jul 2021 15:19:58 +0300 Subject: [PATCH 031/132] dynamic columns: fix with compact parts --- src/Storages/MergeTree/IMergeTreeReader.cpp | 2 +- src/Storages/getStructureOfRemoteTable.cpp | 2 -- tests/queries/0_stateless/01825_type_json.sql | 3 +-- tests/queries/0_stateless/01825_type_json_2.sql | 3 +-- tests/queries/0_stateless/01825_type_json_3.sql | 3 +-- tests/queries/0_stateless/01825_type_json_4.sh | 3 +-- tests/queries/0_stateless/01825_type_json_describe.sql | 4 ++-- 7 files changed, 7 insertions(+), 13 deletions(-) diff --git a/src/Storages/MergeTree/IMergeTreeReader.cpp b/src/Storages/MergeTree/IMergeTreeReader.cpp index 14187564536..bfc015b80c6 100644 --- a/src/Storages/MergeTree/IMergeTreeReader.cpp +++ b/src/Storages/MergeTree/IMergeTreeReader.cpp @@ -232,7 +232,7 @@ NameAndTypePair IMergeTreeReader::getColumnFromPart(const NameAndTypePair & requ auto subcolumn_type = it->second->tryGetSubcolumnType(subcolumn_name); if (!subcolumn_type) - return required_column; + return {required_column.name, required_column.type}; return {it->first, subcolumn_name, it->second, subcolumn_type}; } diff --git a/src/Storages/getStructureOfRemoteTable.cpp b/src/Storages/getStructureOfRemoteTable.cpp index 247f9a23c56..e2cd2b492e7 100644 --- a/src/Storages/getStructureOfRemoteTable.cpp +++ b/src/Storages/getStructureOfRemoteTable.cpp @@ -58,9 +58,7 @@ ColumnsDescription getStructureOfRemoteTableInShard( } ColumnsDescription res; - auto new_context = ClusterProxy::updateSettingsForCluster(cluster, context, context->getSettingsRef()); - new_context->setSetting("describe_extend_object_types", true); /// Expect only needed columns from the result of DESC TABLE. NOTE 'comment' column is ignored for compatibility reasons. Block sample_block diff --git a/tests/queries/0_stateless/01825_type_json.sql b/tests/queries/0_stateless/01825_type_json.sql index 668b39db70f..73110cd866d 100644 --- a/tests/queries/0_stateless/01825_type_json.sql +++ b/tests/queries/0_stateless/01825_type_json.sql @@ -1,8 +1,7 @@ DROP TABLE IF EXISTS t_json; CREATE TABLE t_json(id UInt64, data Object('JSON')) -ENGINE = MergeTree ORDER BY tuple() -SETTINGS min_bytes_for_wide_part = 0; +ENGINE = MergeTree ORDER BY tuple(); SYSTEM STOP MERGES t_json; diff --git a/tests/queries/0_stateless/01825_type_json_2.sql b/tests/queries/0_stateless/01825_type_json_2.sql index fbea36978c6..fa87aacae29 100644 --- a/tests/queries/0_stateless/01825_type_json_2.sql +++ b/tests/queries/0_stateless/01825_type_json_2.sql @@ -1,8 +1,7 @@ DROP TABLE IF EXISTS t_json_2; CREATE TABLE t_json_2(id UInt64, data Object('JSON')) -ENGINE = MergeTree ORDER BY tuple() -SETTINGS min_bytes_for_wide_part = 0; +ENGINE = MergeTree ORDER BY tuple(); INSERT INTO t_json_2 FORMAT JSONEachRow {"id": 1, "data": {"k1": 1, "k2" : 2}} {"id": 2, "data": {"k2": 3, "k3" : 4}}; diff --git a/tests/queries/0_stateless/01825_type_json_3.sql b/tests/queries/0_stateless/01825_type_json_3.sql index cb30f1002fd..a90ec162609 100644 --- a/tests/queries/0_stateless/01825_type_json_3.sql +++ b/tests/queries/0_stateless/01825_type_json_3.sql @@ -1,8 +1,7 @@ DROP TABLE IF EXISTS t_json_3; CREATE TABLE t_json_3(id UInt64, data JSON) -ENGINE = MergeTree ORDER BY tuple() -SETTINGS min_bytes_for_wide_part = 0; +ENGINE = MergeTree ORDER BY tuple(); SYSTEM STOP MERGES t_json_3; diff --git a/tests/queries/0_stateless/01825_type_json_4.sh b/tests/queries/0_stateless/01825_type_json_4.sh index 1b54ea6c1ef..96609e82e60 100755 --- a/tests/queries/0_stateless/01825_type_json_4.sh +++ b/tests/queries/0_stateless/01825_type_json_4.sh @@ -7,8 +7,7 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) $CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_4" $CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_4(id UInt64, data JSON) \ -ENGINE = MergeTree ORDER BY tuple() \ -SETTINGS min_bytes_for_wide_part = 0" +ENGINE = MergeTree ORDER BY tuple()" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [1, 2]}}' \ | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 591" diff --git a/tests/queries/0_stateless/01825_type_json_describe.sql b/tests/queries/0_stateless/01825_type_json_describe.sql index 4a99ebd3336..fa002e9cbff 100644 --- a/tests/queries/0_stateless/01825_type_json_describe.sql +++ b/tests/queries/0_stateless/01825_type_json_describe.sql @@ -6,11 +6,11 @@ INSERT INTO t_json_desc FORMAT JSONAsObject {"k1": 10} ; DESC TABLE t_json_desc; -DESC TABLE t_json_desc SETTINGS describe_extend_object_type = 1; +DESC TABLE t_json_desc SETTINGS describe_extend_object_types = 1; INSERT INTO t_json_desc FORMAT JSONAsObject {"k1": "q", "k2": [1, 2, 3]} ; -DESC TABLE t_json_desc SETTINGS describe_extend_object_type = 1; +DESC TABLE t_json_desc SETTINGS describe_extend_object_types = 1; DROP TABLE IF EXISTS t_json_desc; From af65637ca256ea5cacb7487965bc5ea614774cb1 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 21 Jul 2021 17:45:19 +0300 Subject: [PATCH 032/132] fix subcolumns of object --- src/DataTypes/ObjectUtils.cpp | 16 +-- src/DataTypes/ObjectUtils.h | 2 +- src/Storages/ColumnsDescription.cpp | 16 +++ src/Storages/ColumnsDescription.h | 2 + .../MergeTree/MergeTreeDataMergerMutator.cpp | 2 +- src/Storages/StorageSnapshot.cpp | 103 ++++++++++++++---- src/Storages/StorageSnapshot.h | 15 ++- 7 files changed, 121 insertions(+), 35 deletions(-) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index c2b13fd8db3..f0fe9ee8f3b 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -200,33 +200,29 @@ NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list) return res; } -NamesAndTypesList extendObjectColumns(const NamesAndTypesList & columns_list, const NameToTypeMap & object_types, bool with_subcolumns) +void extendObjectColumns(NamesAndTypesList & columns_list, const NameToTypeMap & object_types, bool with_subcolumns) { - NamesAndTypesList result_columns; - for (const auto & column : columns_list) + NamesAndTypesList subcolumns_list; + for (auto & column : columns_list) { auto it = object_types.find(column.name); if (it != object_types.end()) { const auto & object_type = it->second; - result_columns.emplace_back(column.name, object_type); + column.type = object_type; if (with_subcolumns) { for (const auto & subcolumn : object_type->getSubcolumnNames()) { - result_columns.emplace_back(column.name, subcolumn, + subcolumns_list.emplace_back(column.name, subcolumn, object_type, object_type->getSubcolumnType(subcolumn)); } } } - else - { - result_columns.push_back(column); - } } - return result_columns; + columns_list.splice(columns_list.end(), std::move(subcolumns_list)); } void finalizeObjectColumns(MutableColumns & columns) diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index cd0922c6817..bb79b818c8e 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -18,7 +18,7 @@ DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types); NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); -NamesAndTypesList extendObjectColumns(const NamesAndTypesList & columns_list, const NameToTypeMap & object_types, bool with_subcolumns); +void extendObjectColumns(NamesAndTypesList & columns_list, const NameToTypeMap & object_types, bool with_subcolumns); void finalizeObjectColumns(MutableColumns & columns); diff --git a/src/Storages/ColumnsDescription.cpp b/src/Storages/ColumnsDescription.cpp index 4efaf99bbdc..6bf7d23d4f6 100644 --- a/src/Storages/ColumnsDescription.cpp +++ b/src/Storages/ColumnsDescription.cpp @@ -489,6 +489,22 @@ Names ColumnsDescription::getNamesOfPhysical() const return ret; } +std::optional ColumnsDescription::tryGetColumn(const GetColumnsOptions & options, const String & column_name) const +{ + auto it = columns.get<1>().find(column_name); + if (it != columns.get<1>().end() && (defaultKindToGetKind(it->default_desc.kind) & options.kind)) + return NameAndTypePair(it->name, it->type); + + if (options.with_subcolumns) + { + auto jt = subcolumns.get<0>().find(column_name); + if (jt != subcolumns.get<0>().end()) + return *jt; + } + + return {}; +} + std::optional ColumnsDescription::tryGetColumnOrSubcolumn(GetColumnsOptions::Kind kind, const String & column_name) const { auto it = columns.get<1>().find(column_name); diff --git a/src/Storages/ColumnsDescription.h b/src/Storages/ColumnsDescription.h index 9b765b80763..ff3e4bdfd24 100644 --- a/src/Storages/ColumnsDescription.h +++ b/src/Storages/ColumnsDescription.h @@ -164,6 +164,8 @@ public: std::optional tryGetPhysical(const String & column_name) const; std::optional tryGetColumnOrSubcolumn(GetColumnsOptions::Kind kind, const String & column_name) const; + std::optional tryGetColumn(const GetColumnsOptions & options, const String & column_name) const; + ColumnDefaults getDefaults() const; /// TODO: remove bool hasDefault(const String & column_name) const; bool hasDefaults() const; diff --git a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp index cd7311b231e..3ecf8dc4341 100644 --- a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp +++ b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp @@ -722,7 +722,7 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor auto object_types = MergeTreeData::getObjectTypes(parts, getNamesOfObjectColumns(storage_columns)); auto storage_snapshot = std::make_shared(data, metadata_snapshot, object_types, parts); - storage_columns = extendObjectColumns(storage_columns, object_types, false); + extendObjectColumns(storage_columns, object_types, false); const auto data_settings = data.getSettings(); diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp index 19982e779d2..68b76e8508e 100644 --- a/src/Storages/StorageSnapshot.cpp +++ b/src/Storages/StorageSnapshot.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include @@ -45,20 +46,28 @@ namespace } } +void StorageSnapshot::init() +{ + for (const auto & [name, type] : storage.getVirtuals()) + virtual_columns[name] = type; + + for (const auto & [name, type] : object_types) + { + for (const auto & subcolumn : type->getSubcolumnNames()) + { + auto full_name = Nested::concatenateName(name, subcolumn); + object_subcolumns[full_name] = {name, subcolumn, type, type->getSubcolumnType(subcolumn)}; + } + } +} + NamesAndTypesList StorageSnapshot::getColumns(const GetColumnsOptions & options) const { auto all_columns = getMetadataForQuery()->getColumns().get(options); - return addVirtualsAndObjects(options, std::move(all_columns)); -} -NamesAndTypesList StorageSnapshot::getColumnsByNames(const GetColumnsOptions & options, const Names & names) const -{ - auto all_columns = getMetadataForQuery()->getColumns().getByNames(options, names); - return addVirtualsAndObjects(options, std::move(all_columns)); -} + if (options.with_extended_objects) + extendObjectColumns(all_columns, object_types, options.with_subcolumns); -NamesAndTypesList StorageSnapshot::addVirtualsAndObjects(const GetColumnsOptions & options, NamesAndTypesList columns_list) const -{ if (options.with_virtuals) { /// Virtual columns must be appended after ordinary, @@ -67,33 +76,75 @@ NamesAndTypesList StorageSnapshot::addVirtualsAndObjects(const GetColumnsOptions if (!virtuals.empty()) { NameSet column_names; - for (const auto & column : columns_list) + for (const auto & column : all_columns) column_names.insert(column.name); for (auto && column : virtuals) if (!column_names.count(column.name)) - columns_list.push_back(std::move(column)); + all_columns.push_back(std::move(column)); } } - if (options.with_extended_objects) - columns_list = extendObjectColumns(columns_list, object_types, options.with_subcolumns); + return all_columns; +} - return columns_list; +NamesAndTypesList StorageSnapshot::getColumnsByNames(const GetColumnsOptions & options, const Names & names) const +{ + NamesAndTypesList res; + const auto & columns = getMetadataForQuery()->getColumns(); + for (const auto & name : names) + { + auto column = columns.tryGetColumn(options, name); + if (column && !isObject(column->type)) + { + res.emplace_back(std::move(*column)); + continue; + } + + if (options.with_extended_objects) + { + auto it = object_types.find(name); + if (it != object_types.end()) + { + res.emplace_back(name, it->second); + continue; + } + + if (options.with_subcolumns) + { + auto jt = object_subcolumns.find(name); + if (jt != object_subcolumns.end()) + { + res.emplace_back(jt->second); + continue; + } + } + } + + if (options.with_virtuals) + { + auto it = virtual_columns.find(name); + if (it != virtual_columns.end()) + { + res.emplace_back(name, it->second); + continue; + } + } + + throw Exception(ErrorCodes::NO_SUCH_COLUMN_IN_TABLE, "There is no column {} in table", name); + } + + return res; } Block StorageSnapshot::getSampleBlockForColumns(const Names & column_names) const { Block res; - /// Virtual columns must be appended after ordinary, because user can - /// override them. - const auto virtuals_map = getColumnsMap(storage.getVirtuals()); const auto & columns = getMetadataForQuery()->getColumns(); - for (const auto & name : column_names) { auto column = columns.tryGetColumnOrSubcolumn(GetColumnsOptions::All, name); - if (column) + if (column && !isObject(column->type)) { res.insert({column->type->createColumn(), column->type, column->name}); } @@ -102,9 +153,16 @@ Block StorageSnapshot::getSampleBlockForColumns(const Names & column_names) cons const auto & type = it->second; res.insert({type->createColumn(), type, name}); } - else if (auto jt = virtuals_map.find(name); jt != virtuals_map.end()) + else if (auto jt = object_subcolumns.find(name); jt != object_subcolumns.end()) { - const auto & type = *jt->second; + const auto & type = jt->second.type; + res.insert({type->createColumn(), type, name}); + } + else if (auto kt = virtual_columns.find(name); kt != virtual_columns.end()) + { + /// Virtual columns must be appended after ordinary, because user can + /// override them. + const auto & type = kt->second; res.insert({type->createColumn(), type, name}); } else @@ -131,7 +189,8 @@ void StorageSnapshot::check(const Names & column_names) const for (const auto & name : column_names) { - bool has_column = columns.hasColumnOrSubcolumn(GetColumnsOptions::AllPhysical, name) || virtuals_map.count(name); + bool has_column = columns.hasColumnOrSubcolumn(GetColumnsOptions::AllPhysical, name) + || object_subcolumns.count(name) || virtuals_map.count(name); if (!has_column) { diff --git a/src/Storages/StorageSnapshot.h b/src/Storages/StorageSnapshot.h index 8793963fa0d..293357c3f83 100644 --- a/src/Storages/StorageSnapshot.h +++ b/src/Storages/StorageSnapshot.h @@ -1,5 +1,6 @@ #pragma once #include +// #include namespace DB { @@ -10,6 +11,12 @@ class IMergeTreeDataPart; using DataPartPtr = std::shared_ptr; using DataPartsVector = std::vector; +// #if !defined(ARCADIA_BUILD) +// using NamesAndTypesMap = google::dense_hash_map; +// #else +// using NamesAndTypesMap = google::sparsehash::dense_hash_map; +// #endif + struct StorageSnapshot { using NameToTypeMap = std::unordered_map; @@ -27,6 +34,7 @@ struct StorageSnapshot const StorageMetadataPtr & metadata_) : storage(storage_), metadata(metadata_) { + init(); } StorageSnapshot( @@ -35,6 +43,7 @@ struct StorageSnapshot const NameToTypeMap & object_types_) : storage(storage_), metadata(metadata_), object_types(object_types_) { + init(); } StorageSnapshot( @@ -44,6 +53,7 @@ struct StorageSnapshot const DataPartsVector & parts_) : storage(storage_), metadata(metadata_), object_types(object_types_), parts(parts_) { + init(); } NamesAndTypesList getColumns(const GetColumnsOptions & options) const; @@ -63,7 +73,10 @@ struct StorageSnapshot StorageMetadataPtr getMetadataForQuery() const { return (projection ? projection->metadata : metadata); } private: - NamesAndTypesList addVirtualsAndObjects(const GetColumnsOptions & options, NamesAndTypesList columns_list) const; + void init(); + + std::unordered_map object_subcolumns; + NameToTypeMap virtual_columns; }; using StorageSnapshotPtr = std::shared_ptr; From 2b58f39c10e7b2e935b01de9807e3e79fd4667c7 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 23 Jul 2021 19:30:18 +0300 Subject: [PATCH 033/132] dynamic columns: support missed columns in distributed --- src/DataTypes/ObjectUtils.cpp | 76 ++++++++++-- src/DataTypes/ObjectUtils.h | 10 +- .../ClusterProxy/SelectStreamFactory.cpp | 11 +- .../ClusterProxy/SelectStreamFactory.h | 7 ++ .../ClusterProxy/executeQuery.cpp | 2 +- src/Storages/ColumnsDescription.cpp | 70 ++++------- src/Storages/ColumnsDescription.h | 5 +- .../MergeTree/MergeTreeBlockReadUtils.cpp | 2 +- src/Storages/MergeTree/MergeTreeData.cpp | 18 +-- src/Storages/MergeTree/MergeTreeData.h | 7 +- .../MergeTree/MergeTreeDataMergerMutator.cpp | 6 +- .../MergeTree/MergeTreeDataSelectExecutor.cpp | 4 +- src/Storages/StorageDistributed.cpp | 28 +++-- src/Storages/StorageDistributed.h | 6 + src/Storages/StorageSnapshot.cpp | 112 +++++++----------- src/Storages/StorageSnapshot.h | 29 +++-- src/Storages/getStructureOfRemoteTable.cpp | 14 ++- src/Storages/getStructureOfRemoteTable.h | 6 +- .../test_distributed_type_object/test.py | 8 ++ 19 files changed, 242 insertions(+), 179 deletions(-) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index f0fe9ee8f3b..bee738f8e60 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -8,12 +8,17 @@ #include #include #include +#include #include #include #include #include #include #include +#include +#include +#include +#include namespace DB { @@ -79,7 +84,7 @@ DataTypePtr getDataTypeByColumn(const IColumn & column) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot get data type of column {}", column.getFamilyName()); } -template +template static auto extractVector(const std::vector & vec) { static_assert(I < std::tuple_size_v); @@ -200,29 +205,80 @@ NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list) return res; } -void extendObjectColumns(NamesAndTypesList & columns_list, const NameToTypeMap & object_types, bool with_subcolumns) +void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescription & object_columns, bool with_subcolumns) { NamesAndTypesList subcolumns_list; for (auto & column : columns_list) { - auto it = object_types.find(column.name); - if (it != object_types.end()) + auto object_column = object_columns.tryGetColumn(GetColumnsOptions::All, column.name); + if (object_column) { - const auto & object_type = it->second; - column.type = object_type; + column.type = object_column->type; if (with_subcolumns) + subcolumns_list.splice(subcolumns_list.end(), object_columns.getSubcolumns(column.name)); + } + } + + columns_list.splice(columns_list.end(), std::move(subcolumns_list)); +} + +static void addConstantToWithClause(const ASTPtr & query, const String & column_name, const DataTypePtr & data_type) +{ + auto & select = query->as(); + if (!select.with()) + select.setExpression(ASTSelectQuery::Expression::WITH, std::make_shared()); + + auto literal = std::make_shared(data_type->getDefault()); + auto node = makeASTFunction("CAST", std::move(literal), std::make_shared(data_type->getName())); + + node->alias = column_name; + node->prefer_alias_to_column_name = true; + select.with()->children.push_back(std::move(node)); +} + +void replaceMissedSubcolumnsByConstants( + const ColumnsDescription & expected_columns, + const ColumnsDescription & available_columns, + ASTPtr query) +{ + NamesAndTypesList missed; + for (const auto & column : available_columns) + { + const auto * type_tuple = typeid_cast(column.type.get()); + assert(type_tuple); + + auto expected_column = expected_columns.getColumn(GetColumnsOptions::All, column.name); + const auto * expected_type_tuple = typeid_cast(expected_column.type.get()); + assert(expected_type_tuple); + + if (!type_tuple->equals(*expected_type_tuple)) + { + const auto & names = type_tuple->getElementNames(); + const auto & expected_names = expected_type_tuple->getElementNames(); + const auto & expected_types = expected_type_tuple->getElements(); + + NameSet names_set(names.begin(), names.end()); + + for (size_t i = 0; i < expected_names.size(); ++i) { - for (const auto & subcolumn : object_type->getSubcolumnNames()) + if (!names_set.count(expected_names[i])) { - subcolumns_list.emplace_back(column.name, subcolumn, - object_type, object_type->getSubcolumnType(subcolumn)); + auto full_name = Nested::concatenateName(column.name, expected_names[i]); + missed.emplace_back(std::move(full_name), expected_types[i]); } } } } - columns_list.splice(columns_list.end(), std::move(subcolumns_list)); + if (missed.empty()) + return; + + IdentifierNameSet identifiers; + query->collectIdentifierNames(identifiers); + for (const auto & [name, type] : missed) + if (identifiers.count(name)) + addConstantToWithClause(query, name, type); } void finalizeObjectColumns(MutableColumns & columns) diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index bb79b818c8e..345db6fdf36 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -3,12 +3,11 @@ #include #include #include +#include namespace DB { -using NameToTypeMap = std::unordered_map; - size_t getNumberOfDimensions(const IDataType & type); size_t getNumberOfDimensions(const IColumn & column); DataTypePtr getBaseTypeOfArray(const DataTypePtr & type); @@ -18,7 +17,12 @@ DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types); NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); -void extendObjectColumns(NamesAndTypesList & columns_list, const NameToTypeMap & object_types, bool with_subcolumns); +void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescription & object_columns, bool with_subcolumns); + +void replaceMissedSubcolumnsByConstants( + const ColumnsDescription & expected_columns, + const ColumnsDescription & available_columns, + ASTPtr query); void finalizeObjectColumns(MutableColumns & columns); diff --git a/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp b/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp index efad9f899d4..39b5c912e76 100644 --- a/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp +++ b/src/Interpreters/ClusterProxy/SelectStreamFactory.cpp @@ -8,6 +8,7 @@ #include #include #include +#include #include #include @@ -35,10 +36,14 @@ namespace ClusterProxy SelectStreamFactory::SelectStreamFactory( const Block & header_, + const ColumnsDescriptionByShardNum & objects_by_shard_, + const StorageSnapshotPtr & storage_snapshot_, QueryProcessingStage::Enum processed_stage_, bool has_virtual_shard_num_column_) : header(header_), - processed_stage{processed_stage_}, + objects_by_shard(objects_by_shard_), + storage_snapshot(storage_snapshot_), + processed_stage(processed_stage_), has_virtual_shard_num_column(has_virtual_shard_num_column_) { } @@ -169,6 +174,10 @@ void SelectStreamFactory::createForShard( } } + auto it = objects_by_shard.find(shard_info.shard_num); + if (it != objects_by_shard.end()) + replaceMissedSubcolumnsByConstants(storage_snapshot->object_columns, it->second, modified_query_ast); + auto emplace_local_stream = [&]() { local_plans.emplace_back(createLocalPlan(modified_query_ast, modified_header, context, processed_stage)); diff --git a/src/Interpreters/ClusterProxy/SelectStreamFactory.h b/src/Interpreters/ClusterProxy/SelectStreamFactory.h index d041ac8ea5f..30faf5f509a 100644 --- a/src/Interpreters/ClusterProxy/SelectStreamFactory.h +++ b/src/Interpreters/ClusterProxy/SelectStreamFactory.h @@ -4,6 +4,7 @@ #include #include #include +#include namespace DB { @@ -11,11 +12,15 @@ namespace DB namespace ClusterProxy { +using ColumnsDescriptionByShardNum = std::unordered_map; + class SelectStreamFactory final : public IStreamFactory { public: SelectStreamFactory( const Block & header_, + const ColumnsDescriptionByShardNum & objects_by_shard_, + const StorageSnapshotPtr & storage_snapshot_, QueryProcessingStage::Enum processed_stage_, bool has_virtual_shard_num_column_); @@ -30,6 +35,8 @@ public: private: const Block header; + const ColumnsDescriptionByShardNum objects_by_shard; + const StorageSnapshotPtr storage_snapshot; QueryProcessingStage::Enum processed_stage; bool has_virtual_shard_num_column = false; diff --git a/src/Interpreters/ClusterProxy/executeQuery.cpp b/src/Interpreters/ClusterProxy/executeQuery.cpp index d3a1b40a8e3..b8d32405be7 100644 --- a/src/Interpreters/ClusterProxy/executeQuery.cpp +++ b/src/Interpreters/ClusterProxy/executeQuery.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include #include diff --git a/src/Storages/ColumnsDescription.cpp b/src/Storages/ColumnsDescription.cpp index 6bf7d23d4f6..af2c6b86921 100644 --- a/src/Storages/ColumnsDescription.cpp +++ b/src/Storages/ColumnsDescription.cpp @@ -359,17 +359,23 @@ NamesAndTypesList ColumnsDescription::getAll() const return ret; } -static NamesAndTypesList getWithSubcolumns(NamesAndTypesList && source_list) +NamesAndTypesList ColumnsDescription::getSubcolumns(const String & name_in_storage) const { - NamesAndTypesList ret; + auto range = subcolumns.get<1>().equal_range(name_in_storage); + return NamesAndTypesList(range.first, range.second); +} + +void ColumnsDescription::addSubcolumnsToList(NamesAndTypesList & source_list) const +{ + NamesAndTypesList subcolumns_list; for (const auto & col : source_list) { - ret.emplace_back(col.name, col.type); - for (const auto & subcolumn : col.type->getSubcolumnNames()) - ret.emplace_back(col.name, subcolumn, col.type, col.type->getSubcolumnType(subcolumn)); + auto range = subcolumns.get<1>().equal_range(col.name); + if (range.first != range.second) + subcolumns_list.insert(subcolumns_list.end(), range.first, range.second); } - return ret; + source_list.splice(source_list.end(), std::move(subcolumns_list)); } NamesAndTypesList ColumnsDescription::get(const GetColumnsOptions & options) const @@ -395,7 +401,7 @@ NamesAndTypesList ColumnsDescription::get(const GetColumnsOptions & options) con } if (options.with_subcolumns) - res = getWithSubcolumns(std::move(res)); + addSubcolumnsToList(res); return res; } @@ -505,17 +511,19 @@ std::optional ColumnsDescription::tryGetColumn(const GetColumns return {}; } +NameAndTypePair ColumnsDescription::getColumn(const GetColumnsOptions & options, const String & column_name) const +{ + auto column = tryGetColumn(options, column_name); + if (!column) + throw Exception(ErrorCodes::NO_SUCH_COLUMN_IN_TABLE, + "There is no column {} in table.", column_name); + + return *column; +} + std::optional ColumnsDescription::tryGetColumnOrSubcolumn(GetColumnsOptions::Kind kind, const String & column_name) const { - auto it = columns.get<1>().find(column_name); - if (it != columns.get<1>().end() && (defaultKindToGetKind(it->default_desc.kind) & kind)) - return NameAndTypePair(it->name, it->type); - - auto jt = subcolumns.get<0>().find(column_name); - if (jt != subcolumns.get<0>().end()) - return *jt; - - return {}; + return tryGetColumn(GetColumnsOptions(kind).withSubcolumns(), column_name); } NameAndTypePair ColumnsDescription::getColumnOrSubcolumn(GetColumnsOptions::Kind kind, const String & column_name) const @@ -530,11 +538,7 @@ NameAndTypePair ColumnsDescription::getColumnOrSubcolumn(GetColumnsOptions::Kind std::optional ColumnsDescription::tryGetPhysical(const String & column_name) const { - auto it = columns.get<1>().find(column_name); - if (it == columns.get<1>().end() || it->default_desc.kind == ColumnDefaultKind::Alias) - return {}; - - return NameAndTypePair(it->name, it->type); + return tryGetColumn(GetColumnsOptions::AllPhysical, column_name); } NameAndTypePair ColumnsDescription::getPhysical(const String & column_name) const @@ -561,30 +565,6 @@ bool ColumnsDescription::hasColumnOrSubcolumn(GetColumnsOptions::Kind kind, cons || hasSubcolumn(column_name); } -void ColumnsDescription::addSubcolumnsToList(NamesAndTypesList & source_list) const -{ - for (const auto & col : source_list) - { - auto range = subcolumns.get<1>().equal_range(col.name); - if (range.first != range.second) - source_list.insert(source_list.end(), range.first, range.second); - } -} - -NamesAndTypesList ColumnsDescription::getAllWithSubcolumns() const -{ - auto columns_list = getAll(); - addSubcolumnsToList(columns_list); - return columns_list; -} - -NamesAndTypesList ColumnsDescription::getAllPhysicalWithSubcolumns() const -{ - auto columns_list = getAllPhysical(); - addSubcolumnsToList(columns_list); - return columns_list; -} - bool ColumnsDescription::hasDefaults() const { for (const auto & column : columns) diff --git a/src/Storages/ColumnsDescription.h b/src/Storages/ColumnsDescription.h index ff3e4bdfd24..cc405f7afa1 100644 --- a/src/Storages/ColumnsDescription.h +++ b/src/Storages/ColumnsDescription.h @@ -124,8 +124,7 @@ public: NamesAndTypesList getAliases() const; NamesAndTypesList getAllPhysical() const; /// ordinary + materialized. NamesAndTypesList getAll() const; /// ordinary + materialized + aliases - NamesAndTypesList getAllWithSubcolumns() const; - NamesAndTypesList getAllPhysicalWithSubcolumns() const; + NamesAndTypesList getSubcolumns(const String & name_in_storage) const; using ColumnTTLs = std::unordered_map; ColumnTTLs getColumnTTLs() const; @@ -160,10 +159,10 @@ public: NameAndTypePair getPhysical(const String & column_name) const; NameAndTypePair getColumnOrSubcolumn(GetColumnsOptions::Kind kind, const String & column_name) const; + NameAndTypePair getColumn(const GetColumnsOptions & options, const String & column_name) const; std::optional tryGetPhysical(const String & column_name) const; std::optional tryGetColumnOrSubcolumn(GetColumnsOptions::Kind kind, const String & column_name) const; - std::optional tryGetColumn(const GetColumnsOptions & options, const String & column_name) const; ColumnDefaults getDefaults() const; /// TODO: remove diff --git a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp index 5fa65f54f74..89b6eb2635c 100644 --- a/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp +++ b/src/Storages/MergeTree/MergeTreeBlockReadUtils.cpp @@ -315,6 +315,7 @@ MergeTreeReadTaskColumns getReadTaskColumns( } MergeTreeReadTaskColumns result; + NamesAndTypesList all_columns; if (check_columns) { @@ -329,7 +330,6 @@ MergeTreeReadTaskColumns getReadTaskColumns( } result.should_reorder = should_reorder; - return result; } diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index d1ed3e63457..b33f20a7f4d 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -5115,7 +5115,7 @@ ReservationPtr MergeTreeData::balancedReservation( return reserved_space; } -StorageSnapshot::NameToTypeMap MergeTreeData::getObjectTypes(const DataPartsVector & parts, const NameSet & object_names) +ColumnsDescription MergeTreeData::getObjectsDescription(const DataPartsVector & parts, const NameSet & object_names) { std::unordered_map types_in_parts; @@ -5139,21 +5139,23 @@ StorageSnapshot::NameToTypeMap MergeTreeData::getObjectTypes(const DataPartsVect } } - StorageSnapshot::NameToTypeMap object_types; + ColumnsDescription object_columns; for (const auto & [name, types] : types_in_parts) - object_types.emplace(name, getLeastCommonTypeForObject(types)); + object_columns.add(ColumnDescription{name, getLeastCommonTypeForObject(types)}); - return object_types; + return object_columns; } StorageSnapshotPtr MergeTreeData::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const { - auto parts = getDataPartsVector(); - auto object_types = getObjectTypes( - parts, + auto snapshot_data = std::make_unique(); + snapshot_data->parts = getDataPartsVector(); + + auto object_columns = getObjectsDescription( + snapshot_data->parts, getNamesOfObjectColumns(metadata_snapshot->getColumns().getAll())); - return std::make_shared(*this, metadata_snapshot, object_types, parts); + return std::make_shared(*this, metadata_snapshot, object_columns, std::move(snapshot_data)); } CurrentlySubmergingEmergingTagger::~CurrentlySubmergingEmergingTagger() diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index 10317b26526..1e39610ab46 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -394,6 +394,11 @@ public: bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr, const StorageMetadataPtr & metadata_snapshot) const override; + struct SnapshotData : public StorageSnapshot::Data + { + DataPartsVector parts; + }; + StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const override; /// Load the set of data parts from disk. Call once - immediately after the object is created. @@ -636,7 +641,7 @@ public: return column_sizes; } - static StorageSnapshot::NameToTypeMap getObjectTypes(const DataPartsVector & parts, const NameSet & object_names); + static ColumnsDescription getObjectsDescription(const DataPartsVector & parts, const NameSet & object_names); /// For ATTACH/DETACH/DROP PARTITION. String getPartitionIDFromQuery(const ASTPtr & ast, ContextPtr context) const; diff --git a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp index 3ecf8dc4341..dfcc22da655 100644 --- a/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp +++ b/src/Storages/MergeTree/MergeTreeDataMergerMutator.cpp @@ -720,9 +720,9 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataMergerMutator::mergePartsToTempor Names all_column_names = metadata_snapshot->getColumns().getNamesOfPhysical(); NamesAndTypesList storage_columns = metadata_snapshot->getColumns().getAllPhysical(); - auto object_types = MergeTreeData::getObjectTypes(parts, getNamesOfObjectColumns(storage_columns)); - auto storage_snapshot = std::make_shared(data, metadata_snapshot, object_types, parts); - extendObjectColumns(storage_columns, object_types, false); + auto object_columns = MergeTreeData::getObjectsDescription(parts, getNamesOfObjectColumns(storage_columns)); + auto storage_snapshot = std::make_shared(data, metadata_snapshot, object_columns); + extendObjectColumns(storage_columns, object_columns, false); const auto data_settings = data.getSettings(); diff --git a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp index 1338284bbb6..03d554d35e5 100644 --- a/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp +++ b/src/Storages/MergeTree/MergeTreeDataSelectExecutor.cpp @@ -133,9 +133,11 @@ QueryPlanPtr MergeTreeDataSelectExecutor::read( std::shared_ptr max_block_numbers_to_read) const { const auto & settings = context->getSettingsRef(); - const auto & parts = storage_snapshot->parts; const auto & metadata_for_reading = storage_snapshot->getMetadataForQuery(); + const auto & snapshot_data = assert_cast(*storage_snapshot->data); + const auto & parts = snapshot_data.parts; + if (!query_info.projection) { auto plan = readFromParts( diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index 7abc5286479..2fc91331510 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -567,24 +567,30 @@ StorageSnapshotPtr StorageDistributed::getStorageSnapshot(const StorageMetadataP if (names_of_objects.empty()) return std::make_shared(*this, metadata_snapshot); - auto columns_in_tables = getExtendedColumnsOfRemoteTables(*getCluster(), StorageID{remote_database, remote_table}, getContext()); - assert(!columns_in_tables.empty()); + auto snapshot_data = std::make_unique(); + snapshot_data->objects_by_shard = getExtendedObjectsOfRemoteTables( + *getCluster(), + StorageID{remote_database, remote_table}, + names_of_objects, + getContext()); + + assert(!snapshot_data->objects_by_shard.empty()); std::unordered_map types_in_tables; - for (const auto & columns : columns_in_tables) + for (const auto & [_, columns] : snapshot_data->objects_by_shard) { - for (const auto & [name, type] : columns) + for (const auto & column : columns) { - if (names_of_objects.count(name)) - types_in_tables[name].push_back(type); + assert(names_of_objects.count(column.name)); + types_in_tables[column.name].push_back(column.type); } } - StorageSnapshot::NameToTypeMap object_types; + ColumnsDescription object_columns; for (const auto & [name, types] : types_in_tables) - object_types.emplace(name, getLeastCommonTypeForObject(types)); + object_columns.add(ColumnDescription(name, getLeastCommonTypeForObject(types))); - return std::make_shared(*this, metadata_snapshot, object_types); + return std::make_shared(*this, metadata_snapshot, object_columns, std::move(snapshot_data)); } Pipe StorageDistributed::read( @@ -638,9 +644,12 @@ void StorageDistributed::read( if (!remote_table_function_ptr) main_table = StorageID{remote_database, remote_table}; + const auto & snapshot_data = assert_cast(*storage_snapshot->data); ClusterProxy::SelectStreamFactory select_stream_factory = ClusterProxy::SelectStreamFactory( header, + snapshot_data.objects_by_shard, + storage_snapshot, processed_stage, has_virtual_shard_num_column); @@ -1399,3 +1408,4 @@ void registerStorageDistributed(StorageFactory & factory) } } + diff --git a/src/Storages/StorageDistributed.h b/src/Storages/StorageDistributed.h index e1932543a5e..9ecdb3e0fa8 100644 --- a/src/Storages/StorageDistributed.h +++ b/src/Storages/StorageDistributed.h @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include @@ -56,6 +57,11 @@ public: bool isRemote() const override { return true; } + struct SnapshotData : public StorageSnapshot::Data + { + ColumnsDescriptionByShardNum objects_by_shard; + }; + StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const override; QueryProcessingStage::Enum diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp index 68b76e8508e..e1fad3432a2 100644 --- a/src/Storages/StorageSnapshot.cpp +++ b/src/Storages/StorageSnapshot.cpp @@ -4,6 +4,7 @@ #include #include #include +#include namespace DB { @@ -16,49 +17,10 @@ namespace ErrorCodes extern const int COLUMN_QUERIED_MORE_THAN_ONCE; } -namespace -{ - -#if !defined(ARCADIA_BUILD) - using NamesAndTypesMap = google::dense_hash_map; - using UniqueStrings = google::dense_hash_set; -#else - using NamesAndTypesMap = google::sparsehash::dense_hash_map; - using UniqueStrings = google::sparsehash::dense_hash_set; -#endif - - NamesAndTypesMap getColumnsMap(const NamesAndTypesList & columns) - { - NamesAndTypesMap res; - res.set_empty_key(StringRef()); - - for (const auto & column : columns) - res.insert({column.name, &column.type}); - - return res; - } - - UniqueStrings initUniqueStrings() - { - UniqueStrings strings; - strings.set_empty_key(StringRef()); - return strings; - } -} - void StorageSnapshot::init() { for (const auto & [name, type] : storage.getVirtuals()) virtual_columns[name] = type; - - for (const auto & [name, type] : object_types) - { - for (const auto & subcolumn : type->getSubcolumnNames()) - { - auto full_name = Nested::concatenateName(name, subcolumn); - object_subcolumns[full_name] = {name, subcolumn, type, type->getSubcolumnType(subcolumn)}; - } - } } NamesAndTypesList StorageSnapshot::getColumns(const GetColumnsOptions & options) const @@ -66,7 +28,7 @@ NamesAndTypesList StorageSnapshot::getColumns(const GetColumnsOptions & options) auto all_columns = getMetadataForQuery()->getColumns().get(options); if (options.with_extended_objects) - extendObjectColumns(all_columns, object_types, options.with_subcolumns); + extendObjectColumns(all_columns, object_columns, options.with_subcolumns); if (options.with_virtuals) { @@ -102,22 +64,12 @@ NamesAndTypesList StorageSnapshot::getColumnsByNames(const GetColumnsOptions & o if (options.with_extended_objects) { - auto it = object_types.find(name); - if (it != object_types.end()) + auto object_column = object_columns.tryGetColumn(options, name); + if (object_column) { - res.emplace_back(name, it->second); + res.emplace_back(std::move(*object_column)); continue; } - - if (options.with_subcolumns) - { - auto jt = object_subcolumns.find(name); - if (jt != object_subcolumns.end()) - { - res.emplace_back(jt->second); - continue; - } - } } if (options.with_virtuals) @@ -148,59 +100,68 @@ Block StorageSnapshot::getSampleBlockForColumns(const Names & column_names) cons { res.insert({column->type->createColumn(), column->type, column->name}); } - else if (auto it = object_types.find(name); it != object_types.end()) + else if (auto object_column = object_columns.tryGetColumnOrSubcolumn(GetColumnsOptions::All, name)) { - const auto & type = it->second; - res.insert({type->createColumn(), type, name}); + res.insert({object_column->type->createColumn(), object_column->type, object_column->name}); } - else if (auto jt = object_subcolumns.find(name); jt != object_subcolumns.end()) - { - const auto & type = jt->second.type; - res.insert({type->createColumn(), type, name}); - } - else if (auto kt = virtual_columns.find(name); kt != virtual_columns.end()) + else if (auto it = virtual_columns.find(name); it != virtual_columns.end()) { /// Virtual columns must be appended after ordinary, because user can /// override them. - const auto & type = kt->second; + const auto & type = it->second; res.insert({type->createColumn(), type, name}); } else + { throw Exception(ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK, "Column {} not found in table {}", backQuote(name), storage.getStorageID().getNameForLogs()); + } } return res; } +namespace +{ + +#if !defined(ARCADIA_BUILD) + using DenseHashSet = google::dense_hash_set; +#else + using DenseHashSet = google::sparsehash::dense_hash_set; +#endif + +} + void StorageSnapshot::check(const Names & column_names) const { const auto & columns = getMetadataForQuery()->getColumns(); + auto options = GetColumnsOptions(GetColumnsOptions::AllPhysical).withSubcolumns(); if (column_names.empty()) { - auto list_of_columns = listOfColumns(columns.getAllPhysicalWithSubcolumns()); + auto list_of_columns = listOfColumns(columns.get(options)); throw Exception(ErrorCodes::EMPTY_LIST_OF_COLUMNS_QUERIED, "Empty list of columns queried. There are columns: {}", list_of_columns); } - const auto virtuals_map = getColumnsMap(storage.getVirtuals()); - auto unique_names = initUniqueStrings(); + DenseHashSet unique_names; + unique_names.set_empty_key(StringRef()); for (const auto & name : column_names) { bool has_column = columns.hasColumnOrSubcolumn(GetColumnsOptions::AllPhysical, name) - || object_subcolumns.count(name) || virtuals_map.count(name); + || object_columns.hasColumnOrSubcolumn(GetColumnsOptions::AllPhysical, name) + || virtual_columns.count(name); if (!has_column) { - auto list_of_columns = listOfColumns(columns.getAllPhysicalWithSubcolumns()); + auto list_of_columns = listOfColumns(columns.get(options)); throw Exception(ErrorCodes::NO_SUCH_COLUMN_IN_TABLE, "There is no column with name {} in table {}. There are columns: {}", backQuote(name), storage.getStorageID().getNameForLogs(), list_of_columns); } - if (unique_names.end() != unique_names.find(name)) + if (unique_names.count(name)) throw Exception(ErrorCodes::COLUMN_QUERIED_MORE_THAN_ONCE, "Column {} queried more than once", name); unique_names.insert(name); @@ -209,11 +170,18 @@ void StorageSnapshot::check(const Names & column_names) const DataTypePtr StorageSnapshot::getConcreteType(const String & column_name) const { - auto it = object_types.find(column_name); - if (it != object_types.end()) - return it->second; + auto object_column = object_columns.tryGetColumnOrSubcolumn(GetColumnsOptions::All, column_name); + if (object_column) + return object_column->type; return metadata->getColumns().get(column_name).type; } +bool StorageSnapshot::isSubcolumnOfObject(const String & name) const +{ + auto split = Nested::splitName(name); + return !split.second.empty() + && object_columns.tryGetColumn(GetColumnsOptions::All, split.first); +} + } diff --git a/src/Storages/StorageSnapshot.h b/src/Storages/StorageSnapshot.h index 293357c3f83..1d5af7e8f88 100644 --- a/src/Storages/StorageSnapshot.h +++ b/src/Storages/StorageSnapshot.h @@ -7,10 +7,6 @@ namespace DB class IStorage; -class IMergeTreeDataPart; -using DataPartPtr = std::shared_ptr; -using DataPartsVector = std::vector; - // #if !defined(ARCADIA_BUILD) // using NamesAndTypesMap = google::dense_hash_map; // #else @@ -19,12 +15,14 @@ using DataPartsVector = std::vector; struct StorageSnapshot { - using NameToTypeMap = std::unordered_map; - const IStorage & storage; const StorageMetadataPtr metadata; - const NameToTypeMap object_types; - const DataPartsVector parts; + const ColumnsDescription object_columns; + + struct Data{}; + using DataPtr = std::unique_ptr; + + const DataPtr data; /// TODO: fix mutable const ProjectionDescription * projection = nullptr; @@ -40,8 +38,8 @@ struct StorageSnapshot StorageSnapshot( const IStorage & storage_, const StorageMetadataPtr & metadata_, - const NameToTypeMap & object_types_) - : storage(storage_), metadata(metadata_), object_types(object_types_) + const ColumnsDescription & object_columns_) + : storage(storage_), metadata(metadata_), object_columns(object_columns_) { init(); } @@ -49,9 +47,9 @@ struct StorageSnapshot StorageSnapshot( const IStorage & storage_, const StorageMetadataPtr & metadata_, - const NameToTypeMap & object_types_, - const DataPartsVector & parts_) - : storage(storage_), metadata(metadata_), object_types(object_types_), parts(parts_) + const ColumnsDescription & object_columns_, + DataPtr data_) + : storage(storage_), metadata(metadata_), object_columns(object_columns_), data(std::move(data_)) { init(); } @@ -72,11 +70,12 @@ struct StorageSnapshot StorageMetadataPtr getMetadataForQuery() const { return (projection ? projection->metadata : metadata); } + bool isSubcolumnOfObject(const String & name) const; + private: void init(); - std::unordered_map object_subcolumns; - NameToTypeMap virtual_columns; + std::unordered_map virtual_columns; }; using StorageSnapshotPtr = std::shared_ptr; diff --git a/src/Storages/getStructureOfRemoteTable.cpp b/src/Storages/getStructureOfRemoteTable.cpp index e2cd2b492e7..db7461317d6 100644 --- a/src/Storages/getStructureOfRemoteTable.cpp +++ b/src/Storages/getStructureOfRemoteTable.cpp @@ -149,9 +149,10 @@ ColumnsDescription getStructureOfRemoteTable( ErrorCodes::NO_REMOTE_SHARD_AVAILABLE); } -std::vector getExtendedColumnsOfRemoteTables( +ColumnsDescriptionByShardNum getExtendedObjectsOfRemoteTables( const Cluster & cluster, const StorageID & remote_table_id, + const NameSet & names_of_objects, ContextPtr context) { const auto & shards_info = cluster.getShardsInfo(); @@ -176,7 +177,7 @@ std::vector getExtendedColumnsOfRemoteTables( input->setMainTable(remote_table_id); input->readPrefix(); - NamesAndTypesList res; + ColumnsDescription res; while (auto block = input->read()) { const auto & name_col = *block.getByName("name").column; @@ -188,14 +189,17 @@ std::vector getExtendedColumnsOfRemoteTables( auto name = name_col[i].template get(); auto type_name = type_col[i].template get(); - res.emplace_back(std::move(name), DataTypeFactory::instance().get(type_name)); + if (!names_of_objects.count(name)) + continue; + + res.add(ColumnDescription(std::move(name), DataTypeFactory::instance().get(type_name))); } } return res; }; - std::vector columns; + ColumnsDescriptionByShardNum columns; for (const auto & shard_info : shards_info) { auto res = execute_query_on_shard(shard_info); @@ -203,7 +207,7 @@ std::vector getExtendedColumnsOfRemoteTables( /// Expect at least some columns. /// This is a hack to handle the empty block case returned by Connection when skip_unavailable_shards is set. if (!res.empty()) - columns.emplace_back(std::move(res)); + columns.emplace(shard_info.shard_num, std::move(res)); } if (columns.empty()) diff --git a/src/Storages/getStructureOfRemoteTable.h b/src/Storages/getStructureOfRemoteTable.h index 5ca15055b8f..2c346b25c2b 100644 --- a/src/Storages/getStructureOfRemoteTable.h +++ b/src/Storages/getStructureOfRemoteTable.h @@ -20,9 +20,13 @@ ColumnsDescription getStructureOfRemoteTable( ContextPtr context, const ASTPtr & table_func_ptr = nullptr); -std::vector getExtendedColumnsOfRemoteTables( + +using ColumnsDescriptionByShardNum = std::unordered_map; + +ColumnsDescriptionByShardNum getExtendedObjectsOfRemoteTables( const Cluster & cluster, const StorageID & remote_table_id, + const NameSet & names_of_objects, ContextPtr context); } diff --git a/tests/integration/test_distributed_type_object/test.py b/tests/integration/test_distributed_type_object/test.py index 7ceb538cf45..476e26a9d1d 100644 --- a/tests/integration/test_distributed_type_object/test.py +++ b/tests/integration/test_distributed_type_object/test.py @@ -34,3 +34,11 @@ def test_distributed_type_object(started_cluster): expected = TSV("10\n20\nstr1\n") assert TSV(node1.query("SELECT data.k1 FROM dist_table ORDER BY id")) == expected + + node1.query('INSERT INTO local_table FORMAT JSONEachRow {"id": 4, "data": {"k2": 30}}') + + expected = TSV("10\t0\n20\t0\nstr1\t0\n\t30") + assert TSV(node1.query("SELECT data.k1, data.k2 FROM dist_table ORDER BY id")) == expected + + expected = TSV("120\n") + assert TSV(node1.query("SELECT sum(data.k2 * id) FROM dist_table SETTINGS optimize_arithmetic_operations_in_aggregate_functions = 0")) == expected From f867995b9447e0efff4b9db45f0ac54503dba143 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 23 Jul 2021 19:47:43 +0300 Subject: [PATCH 034/132] remove excessive creation of storage snapshot --- src/Storages/StorageDistributed.cpp | 14 +++++++------- src/Storages/StorageDistributed.h | 4 ++-- 2 files changed, 9 insertions(+), 9 deletions(-) diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index 2fc91331510..cf9354325dd 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -276,9 +276,9 @@ void replaceConstantExpressions( ContextPtr context, const NamesAndTypesList & columns, ConstStoragePtr storage, - const StorageMetadataPtr & metadata_snapshot) + const StorageSnapshotPtr & storage_snapshot) { - auto syntax_result = TreeRewriter(context).analyze(node, columns, storage, storage->getStorageSnapshot(metadata_snapshot)); + auto syntax_result = TreeRewriter(context).analyze(node, columns, storage, storage_snapshot); Block block_with_constants = KeyCondition::getBlockWithConstants(node, syntax_result, context); InDepthNodeVisitor visitor(block_with_constants); @@ -500,7 +500,7 @@ QueryProcessingStage::Enum StorageDistributed::getQueryProcessingStage( /// (Anyway it will be calculated in the read()) if (getClusterQueriedNodes(settings, cluster) > 1 && settings.optimize_skip_unused_shards) { - ClusterPtr optimized_cluster = getOptimizedCluster(local_context, storage_snapshot->metadata, query_info.query); + ClusterPtr optimized_cluster = getOptimizedCluster(local_context, storage_snapshot, query_info.query); if (optimized_cluster) { LOG_DEBUG(log, "Skipping irrelevant shards - the query will be sent to the following shards of the cluster (shard numbers): {}", @@ -1040,7 +1040,7 @@ ClusterPtr StorageDistributed::getCluster() const } ClusterPtr StorageDistributed::getOptimizedCluster( - ContextPtr local_context, const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query_ptr) const + ContextPtr local_context, const StorageSnapshotPtr & storage_snapshot, const ASTPtr & query_ptr) const { ClusterPtr cluster = getCluster(); const Settings & settings = local_context->getSettingsRef(); @@ -1049,7 +1049,7 @@ ClusterPtr StorageDistributed::getOptimizedCluster( if (has_sharding_key && sharding_key_is_usable) { - ClusterPtr optimized = skipUnusedShards(cluster, query_ptr, metadata_snapshot, local_context); + ClusterPtr optimized = skipUnusedShards(cluster, query_ptr, storage_snapshot, local_context); if (optimized) return optimized; } @@ -1105,7 +1105,7 @@ IColumn::Selector StorageDistributed::createSelector(const ClusterPtr cluster, c ClusterPtr StorageDistributed::skipUnusedShards( ClusterPtr cluster, const ASTPtr & query_ptr, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, ContextPtr local_context) const { const auto & select = query_ptr->as(); @@ -1125,7 +1125,7 @@ ClusterPtr StorageDistributed::skipUnusedShards( condition_ast = select.prewhere() ? select.prewhere()->clone() : select.where()->clone(); } - replaceConstantExpressions(condition_ast, local_context, metadata_snapshot->getColumns().getAll(), shared_from_this(), metadata_snapshot); + replaceConstantExpressions(condition_ast, local_context, storage_snapshot->metadata->getColumns().getAll(), shared_from_this(), storage_snapshot); size_t limit = local_context->getSettingsRef().optimize_skip_unused_shards_limit; if (!limit || limit > SSIZE_MAX) diff --git a/src/Storages/StorageDistributed.h b/src/Storages/StorageDistributed.h index 9ecdb3e0fa8..bc4dff62a90 100644 --- a/src/Storages/StorageDistributed.h +++ b/src/Storages/StorageDistributed.h @@ -180,9 +180,9 @@ private: /// Apply the following settings: /// - optimize_skip_unused_shards /// - force_optimize_skip_unused_shards - ClusterPtr getOptimizedCluster(ContextPtr, const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query_ptr) const; + ClusterPtr getOptimizedCluster(ContextPtr, const StorageSnapshotPtr & storage_snapshot, const ASTPtr & query_ptr) const; ClusterPtr - skipUnusedShards(ClusterPtr cluster, const ASTPtr & query_ptr, const StorageMetadataPtr & metadata_snapshot, ContextPtr context) const; + skipUnusedShards(ClusterPtr cluster, const ASTPtr & query_ptr, const StorageSnapshotPtr & storage_snapshot, ContextPtr context) const; size_t getRandomShardIndex(const Cluster::ShardsInfo & shards); From 5b3c9dc5decd2b006434d020af7724ed128092f6 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 24 Jul 2021 02:15:44 +0300 Subject: [PATCH 035/132] dynamic columns: allow nullable subcolumns --- src/Columns/ColumnNullable.cpp | 19 ++++++-- src/Columns/ColumnNullable.h | 4 +- src/Columns/ColumnObject.cpp | 30 +++++++----- src/Columns/ColumnObject.h | 8 ++-- src/DataTypes/DataTypeObject.cpp | 47 ++++++++++++++----- src/DataTypes/DataTypeObject.h | 5 +- .../01825_type_json_nullable.reference | 17 +++++++ .../0_stateless/01825_type_json_nullable.sql | 24 ++++++++++ 8 files changed, 122 insertions(+), 32 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_nullable.reference create mode 100644 tests/queries/0_stateless/01825_type_json_nullable.sql diff --git a/src/Columns/ColumnNullable.cpp b/src/Columns/ColumnNullable.cpp index c1745e9bed7..1fdb560efc0 100644 --- a/src/Columns/ColumnNullable.cpp +++ b/src/Columns/ColumnNullable.cpp @@ -644,9 +644,22 @@ void ColumnNullable::checkConsistency() const ColumnPtr ColumnNullable::createWithOffsets(const IColumn::Offsets & offsets, const Field & default_field, size_t total_rows, size_t shift) const { - /// TODO: check if default_field is null. - auto new_values = nested_column->createWithOffsets(offsets, default_field, total_rows, shift); - auto new_null_map = null_map->createWithOffsets(offsets, Field(1), total_rows, shift); + ColumnPtr new_values; + ColumnPtr new_null_map; + + if (default_field.getType() == Field::Types::Null) + { + auto default_column = nested_column->cloneEmpty(); + default_column->insertDefault(); + + new_values = nested_column->createWithOffsets(offsets, (*default_column)[0], total_rows, shift); + new_null_map = null_map->createWithOffsets(offsets, Field(1u), total_rows, shift); + } + else + { + new_values = nested_column->createWithOffsets(offsets, default_field, total_rows, shift); + new_null_map = null_map->createWithOffsets(offsets, Field(0u), total_rows, shift); + } return ColumnNullable::create(new_values, new_null_map); } diff --git a/src/Columns/ColumnNullable.h b/src/Columns/ColumnNullable.h index 39246ad654a..570e6d4137f 100644 --- a/src/Columns/ColumnNullable.h +++ b/src/Columns/ColumnNullable.h @@ -139,12 +139,12 @@ public: double getRatioOfDefaultRows(double sample_ratio) const override { - return null_map->getRatioOfDefaultRows(sample_ratio); + return getRatioOfDefaultRowsImpl(sample_ratio); } void getIndicesOfNonDefaultRows(Offsets & indices, size_t from, size_t limit) const override { - null_map->getIndicesOfNonDefaultRows(indices, from, limit); + getIndicesOfNonDefaultRowsImpl(indices, from, limit); } ColumnPtr createWithOffsets(const Offsets & offsets, const Field & default_field, size_t total_rows, size_t shift) const override; diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 5e31d296d97..a328cbbedd8 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -157,6 +157,7 @@ private: ColumnObject::Subcolumn::Subcolumn(const Subcolumn & other) : least_common_type(other.least_common_type) + , is_nullable(other.is_nullable) , data(other.data) , num_of_defaults_in_prefix(other.num_of_defaults_in_prefix) { @@ -164,12 +165,14 @@ ColumnObject::Subcolumn::Subcolumn(const Subcolumn & other) ColumnObject::Subcolumn::Subcolumn(MutableColumnPtr && data_) : least_common_type(getDataTypeByColumn(*data_)) + , is_nullable(least_common_type->isNullable()) { data.push_back(std::move(data_)); } -ColumnObject::Subcolumn::Subcolumn(size_t size_) +ColumnObject::Subcolumn::Subcolumn(size_t size_, bool is_nullable_) : least_common_type(std::make_shared()) + , is_nullable(is_nullable_) , num_of_defaults_in_prefix(size_) { } @@ -235,8 +238,10 @@ void ColumnObject::Subcolumn::insert(Field && field) return; } - DataTypePtr value_type; - if (base_type->isNullable()) + if (is_nullable && !base_type->isNullable()) + base_type = makeNullable(base_type); + + if (!is_nullable && base_type->isNullable()) { base_type = removeNullable(base_type); if (isNothing(base_type)) @@ -246,14 +251,11 @@ void ColumnObject::Subcolumn::insert(Field && field) } field = applyVisitor(FieldVisitorReplaceNull(base_type->getDefault()), std::move(field)); - value_type = createArrayOfType(base_type, value_dim); - } - else - { - value_type = createArrayOfType(base_type, value_dim); } + auto value_type = createArrayOfType(base_type, value_dim); bool type_changed = false; + if (data.empty()) { data.push_back(value_type->createColumn()); @@ -347,8 +349,14 @@ const ColumnPtr & ColumnObject::Subcolumn::getFinalizedColumnPtr() const return data[0]; } -ColumnObject::ColumnObject(SubcolumnsMap && subcolumns_) +ColumnObject::ColumnObject(bool is_nullable_) + : is_nullable(is_nullable_) +{ +} + +ColumnObject::ColumnObject(SubcolumnsMap && subcolumns_, bool is_nullable_) : subcolumns(std::move(subcolumns_)) + , is_nullable(is_nullable_) { checkConsistency(); } @@ -384,7 +392,7 @@ MutableColumnPtr ColumnObject::cloneResized(size_t new_size) const throw Exception(ErrorCodes::NOT_IMPLEMENTED, "ColumnObject doesn't support resize to non-zero length"); - return ColumnObject::create(); + return ColumnObject::create(is_nullable); } size_t ColumnObject::byteSize() const @@ -442,7 +450,7 @@ void ColumnObject::addSubcolumn(const String & key, size_t new_size, bool check_ "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", key, new_size, size()); - subcolumns[key] = Subcolumn(new_size); + subcolumns[key] = Subcolumn(new_size, is_nullable); } void ColumnObject::addSubcolumn(const String & key, Subcolumn && subcolumn, bool check_size) diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index a54b9fcbdb5..822e25cad32 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -23,7 +23,7 @@ public: { public: Subcolumn() = default; - Subcolumn(size_t size_); + Subcolumn(size_t size_, bool is_nullable); Subcolumn(MutableColumnPtr && data_); Subcolumn(const Subcolumn & other); Subcolumn & operator=(Subcolumn && other) = default; @@ -46,6 +46,7 @@ public: private: DataTypePtr least_common_type; + bool is_nullable = false; std::vector data; size_t num_of_defaults_in_prefix = 0; }; @@ -54,12 +55,13 @@ public: private: SubcolumnsMap subcolumns; + bool is_nullable; public: static constexpr auto COLUMN_NAME_DUMMY = "_dummy"; - ColumnObject() = default; - ColumnObject(SubcolumnsMap && subcolumns_); + ColumnObject(bool is_nullable); + ColumnObject(SubcolumnsMap && subcolumns_, bool is_nullable_); void checkConsistency() const; diff --git a/src/DataTypes/DataTypeObject.cpp b/src/DataTypes/DataTypeObject.cpp index 5f07d9905f4..3ed4c79af07 100644 --- a/src/DataTypes/DataTypeObject.cpp +++ b/src/DataTypes/DataTypeObject.cpp @@ -13,10 +13,12 @@ namespace ErrorCodes { extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH; extern const int UNEXPECTED_AST_STRUCTURE; + extern const int BAD_ARGUMENTS; } -DataTypeObject::DataTypeObject(const String & schema_format_) +DataTypeObject::DataTypeObject(const String & schema_format_, bool is_nullable_) : schema_format(Poco::toLower(schema_format_)) + , is_nullable(is_nullable_) , default_serialization(getObjectSerialization(schema_format)) { } @@ -33,33 +35,56 @@ SerializationPtr DataTypeObject::doGetDefaultSerialization() const return default_serialization; } +static constexpr auto NAME_DEFAULT = "Default"; +static constexpr auto NAME_NULL = "Null"; + String DataTypeObject::doGetName() const { WriteBufferFromOwnString out; - out << "Object(" << quote << schema_format << ")"; + out << "Object(" << quote << schema_format; + if (is_nullable) + out << ", " << quote << NAME_NULL; + out << ")"; return out.str(); } - static DataTypePtr create(const ASTPtr & arguments) { - if (!arguments || arguments->children.size() != 1) - throw Exception("Object data type family must have exactly one argument - name of schema format", + if (!arguments || arguments->children.size() < 1 || arguments->children.size() > 2) + throw Exception("Object data type family must have one or two arguments -" + " name of schema format and type of default value", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH); - const auto * argument = arguments->children[0]->as(); - if (!argument || argument->value.getType() != Field::Types::String) - throw Exception("Object data type family must have a string as its argument", - ErrorCodes::UNEXPECTED_AST_STRUCTURE); + const auto * literal = arguments->children[0]->as(); + if (!literal || literal->value.getType() != Field::Types::String) + throw Exception(ErrorCodes::UNEXPECTED_AST_STRUCTURE, + "Object data type family must have a const string as its first argument"); - return std::make_shared(argument->value.get()); + bool is_nullable = false; + if (arguments->children.size() == 2) + { + const auto * default_literal = arguments->children[1]->as(); + if (!default_literal || default_literal->value.getType() != Field::Types::String) + throw Exception(ErrorCodes::UNEXPECTED_AST_STRUCTURE, + "Object data type family must have a const string as its second argument"); + + const auto & default_kind = default_literal->value.get(); + if (default_kind == NAME_NULL) + is_nullable = true; + else if (default_kind != NAME_DEFAULT) + throw Exception(ErrorCodes::BAD_ARGUMENTS, + "Unexpected type of default value '{}'. Should be {} or {}", + default_kind, NAME_DEFAULT, NAME_NULL); + } + + return std::make_shared(literal->value.get(), is_nullable); } void registerDataTypeObject(DataTypeFactory & factory) { factory.registerDataType("Object", create); factory.registerSimpleDataType("JSON", - [] { return std::make_shared("JSON"); }, + [] { return std::make_shared("JSON", false); }, DataTypeFactory::CaseInsensitive); } diff --git a/src/DataTypes/DataTypeObject.h b/src/DataTypes/DataTypeObject.h index 6ba666adf3f..991991124a7 100644 --- a/src/DataTypes/DataTypeObject.h +++ b/src/DataTypes/DataTypeObject.h @@ -17,16 +17,17 @@ class DataTypeObject : public IDataType { private: String schema_format; + bool is_nullable; SerializationPtr default_serialization; public: - DataTypeObject(const String & schema_format_); + DataTypeObject(const String & schema_format_, bool is_nullable_); const char * getFamilyName() const override { return "Object"; } String doGetName() const override; TypeIndex getTypeId() const override { return TypeIndex::Object; } - MutableColumnPtr createColumn() const override { return ColumnObject::create(); } + MutableColumnPtr createColumn() const override { return ColumnObject::create(is_nullable); } Field getDefault() const override { diff --git a/tests/queries/0_stateless/01825_type_json_nullable.reference b/tests/queries/0_stateless/01825_type_json_nullable.reference new file mode 100644 index 00000000000..7f1691a6469 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_nullable.reference @@ -0,0 +1,17 @@ +1 (1,2,NULL) Tuple(k1 Nullable(Int8), k2 Nullable(Int8), k3 Nullable(Int8)) +2 (NULL,3,4) Tuple(k1 Nullable(Int8), k2 Nullable(Int8), k3 Nullable(Int8)) +1 1 2 \N +2 \N 3 4 +1 (1,2,NULL) Tuple(k1 Nullable(Int8), k2 Nullable(Int8), k3 Nullable(String)) +2 (NULL,3,'4') Tuple(k1 Nullable(Int8), k2 Nullable(Int8), k3 Nullable(String)) +3 (NULL,NULL,'10') Tuple(k1 Nullable(Int8), k2 Nullable(Int8), k3 Nullable(String)) +4 (NULL,5,'str') Tuple(k1 Nullable(Int8), k2 Nullable(Int8), k3 Nullable(String)) +1 1 2 \N +2 \N 3 4 +3 \N \N 10 +4 \N 5 str +============ +1 ([11,NULL],[NULL,22],[]) Tuple(`k1.k2` Array(Nullable(Int8)), `k1.k3` Array(Nullable(Int8)), `k1.k4` Array(Nullable(Int8))) +2 ([],[33,NULL,55],[NULL,44,66]) Tuple(`k1.k2` Array(Nullable(Int8)), `k1.k3` Array(Nullable(Int8)), `k1.k4` Array(Nullable(Int8))) +1 [11,NULL] [NULL,22] [] +2 [] [33,NULL,55] [NULL,44,66] diff --git a/tests/queries/0_stateless/01825_type_json_nullable.sql b/tests/queries/0_stateless/01825_type_json_nullable.sql new file mode 100644 index 00000000000..a89bebe82c2 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_nullable.sql @@ -0,0 +1,24 @@ +DROP TABLE IF EXISTS t_json_null; + +CREATE TABLE t_json_null(id UInt64, data Object('JSON', 'Null')) +ENGINE = MergeTree ORDER BY tuple(); + +INSERT INTO t_json_null FORMAT JSONEachRow {"id": 1, "data": {"k1": 1, "k2" : 2}} {"id": 2, "data": {"k2": 3, "k3" : 4}}; + +SELECT id, data, toTypeName(data) FROM t_json_null ORDER BY id; +SELECT id, data.k1, data.k2, data.k3 FROM t_json_null ORDER BY id; + +INSERT INTO t_json_null FORMAT JSONEachRow {"id": 3, "data": {"k3" : 10}} {"id": 4, "data": {"k2": 5, "k3" : "str"}}; + +SELECT id, data, toTypeName(data) FROM t_json_null ORDER BY id; +SELECT id, data.k1, data.k2, data.k3 FROM t_json_null ORDER BY id; + +SELECT '============'; +TRUNCATE TABLE t_json_null; + +INSERT INTO TABLE t_json_null FORMAT JSONEachRow {"id": 1, "data": {"k1" : [{"k2" : 11}, {"k3" : 22}]}} {"id": 2, "data": {"k1" : [{"k3" : 33}, {"k4" : 44}, {"k3" : 55, "k4" : 66}]}}; + +SELECT id, data, toTypeName(data) FROM t_json_null ORDER BY id; +SELECT id, data.k1.k2, data.k1.k3, data.k1.k4 FROM t_json_null ORDER BY id; + +DROP TABLE t_json_null; From 90b6a591e536fb4c0cdb991482a7b961df18e61c Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 24 Jul 2021 03:55:50 +0300 Subject: [PATCH 036/132] fix reading from distributed --- src/Storages/StorageDistributed.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index cf9354325dd..018f40f6389 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -563,11 +563,11 @@ QueryProcessingStage::Enum StorageDistributed::getQueryProcessingStage( StorageSnapshotPtr StorageDistributed::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const { + auto snapshot_data = std::make_unique(); auto names_of_objects = getNamesOfObjectColumns(metadata_snapshot->getColumns().getAllPhysical()); if (names_of_objects.empty()) - return std::make_shared(*this, metadata_snapshot); + return std::make_shared(*this, metadata_snapshot, ColumnsDescription{}, std::move(snapshot_data)); - auto snapshot_data = std::make_unique(); snapshot_data->objects_by_shard = getExtendedObjectsOfRemoteTables( *getCluster(), StorageID{remote_database, remote_table}, From 75c81f189aa3155ac36be339400b4825361ab197 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Mon, 2 Aug 2021 22:49:52 +0300 Subject: [PATCH 037/132] fix destruction of snapshot data --- src/DataTypes/ObjectUtils.cpp | 7 +++++-- src/Storages/StorageSnapshot.h | 7 +++++-- tests/integration/test_distributed_type_object/test.py | 2 +- 3 files changed, 11 insertions(+), 5 deletions(-) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index bee738f8e60..81a658ee689 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -229,8 +229,11 @@ static void addConstantToWithClause(const ASTPtr & query, const String & column_ if (!select.with()) select.setExpression(ASTSelectQuery::Expression::WITH, std::make_shared()); - auto literal = std::make_shared(data_type->getDefault()); - auto node = makeASTFunction("CAST", std::move(literal), std::make_shared(data_type->getName())); + /// TODO: avoid materialize + auto node = makeASTFunction("materialize", + makeASTFunction("CAST", + std::make_shared(data_type->getDefault()), + std::make_shared(data_type->getName()))); node->alias = column_name; node->prefer_alias_to_column_name = true; diff --git a/src/Storages/StorageSnapshot.h b/src/Storages/StorageSnapshot.h index 1d5af7e8f88..fece121cd6f 100644 --- a/src/Storages/StorageSnapshot.h +++ b/src/Storages/StorageSnapshot.h @@ -19,9 +19,12 @@ struct StorageSnapshot const StorageMetadataPtr metadata; const ColumnsDescription object_columns; - struct Data{}; - using DataPtr = std::unique_ptr; + struct Data + { + virtual ~Data() = default; + }; + using DataPtr = std::unique_ptr; const DataPtr data; /// TODO: fix diff --git a/tests/integration/test_distributed_type_object/test.py b/tests/integration/test_distributed_type_object/test.py index 476e26a9d1d..02cb17ded86 100644 --- a/tests/integration/test_distributed_type_object/test.py +++ b/tests/integration/test_distributed_type_object/test.py @@ -41,4 +41,4 @@ def test_distributed_type_object(started_cluster): assert TSV(node1.query("SELECT data.k1, data.k2 FROM dist_table ORDER BY id")) == expected expected = TSV("120\n") - assert TSV(node1.query("SELECT sum(data.k2 * id) FROM dist_table SETTINGS optimize_arithmetic_operations_in_aggregate_functions = 0")) == expected + assert TSV(node1.query("SELECT sum(data.k2 * id) FROM dist_table")) == expected From 5a2daae63a5997e5df8d4acc1990070adfdb3893 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Tue, 10 Aug 2021 04:33:57 +0300 Subject: [PATCH 038/132] add conversion from tuple to object --- src/Columns/ColumnObject.cpp | 90 +++++++++++++------ src/Columns/ColumnObject.h | 6 +- src/DataTypes/DataTypeObject.h | 2 + src/DataTypes/ObjectUtils.cpp | 38 ++++++++ src/DataTypes/ObjectUtils.h | 1 + src/Functions/FunctionsConversion.h | 55 ++++++++++++ .../Formats/Impl/ValuesBlockInputFormat.cpp | 2 + .../01825_type_json_insert_select.reference | 12 +++ .../01825_type_json_insert_select.sql | 32 +++++++ 9 files changed, 210 insertions(+), 28 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_insert_select.reference create mode 100644 tests/queries/0_stateless/01825_type_json_insert_select.sql diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index a328cbbedd8..431db916afc 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -12,9 +12,6 @@ #include #include -#include -#include - namespace DB { @@ -281,9 +278,41 @@ void ColumnObject::Subcolumn::insert(Field && field) data.back()->insert(std::move(field)); } +void ColumnObject::Subcolumn::insertRangeFrom(const Subcolumn & src, size_t start, size_t length) +{ + assert(src.isFinalized()); + + const auto & src_column = src.data.back(); + const auto & src_type = src.least_common_type; + + if (data.empty()) + { + least_common_type = src_type; + data.push_back(src_type->createColumn()); + data.back()->insertRangeFrom(*src_column, start, length); + } + else if (least_common_type->equals(*src_type)) + { + data.back()->insertRangeFrom(*src_column, start, length); + } + else + { + auto new_least_common_type = getLeastSupertype(DataTypes{least_common_type, src_type}); + auto casted_column = castColumn({src_column, src_type, ""}, new_least_common_type); + + if (!least_common_type->equals(*new_least_common_type)) + { + least_common_type = new_least_common_type; + data.push_back(least_common_type->createColumn()); + } + + data.back()->insertRangeFrom(*casted_column, start, length); + } +} + void ColumnObject::Subcolumn::finalize() { - if (isFinalized()) + if (isFinalized() || data.empty()) return; const auto & to_type = least_common_type; @@ -331,6 +360,14 @@ void ColumnObject::Subcolumn::insertDefault() data.back()->insertDefault(); } +void ColumnObject::Subcolumn::insertManyDefaults(size_t length) +{ + if (data.empty()) + num_of_defaults_in_prefix += length; + else + data.back()->insertManyDefaults(length); +} + IColumn & ColumnObject::Subcolumn::getFinalizedColumn() { assert(isFinalized()); @@ -417,6 +454,21 @@ void ColumnObject::forEachSubcolumn(ColumnCallback) // callback(column.data); } +void ColumnObject::insertRangeFrom(const IColumn & src, size_t start, size_t length) +{ + const auto & src_object = assert_cast(src); + + for (auto & [name, subcolumn] : subcolumns) + { + if (src_object.hasSubcolumn(name)) + subcolumn.insertRangeFrom(src_object.getSubcolumn(name), start, length); + else + subcolumn.insertManyDefaults(length); + } + + finalize(); +} + const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const String & key) const { auto it = subcolumns.find(key); @@ -466,15 +518,13 @@ void ColumnObject::addSubcolumn(const String & key, Subcolumn && subcolumn, bool subcolumns[key] = std::move(subcolumn); } -static bool isPrefix(const Strings & prefix, const Strings & strings) +Strings ColumnObject::getKeys() const { - if (prefix.size() > strings.size()) - return false; - - for (size_t i = 0; i < prefix.size(); ++i) - if (prefix[i] != strings[i]) - return false; - return true; + Strings keys; + keys.reserve(subcolumns.size()); + for (const auto & [key, _] : subcolumns) + keys.emplace_back(key); + return keys; } bool ColumnObject::isFinalized() const @@ -493,21 +543,6 @@ void ColumnObject::finalize() if (isNothing(getBaseTypeOfArray(least_common_type))) continue; - Strings name_parts; - boost::split(name_parts, name, boost::is_any_of(".")); - - for (const auto & [other_name, _] : subcolumns) - { - if (other_name.size() > name.size()) - { - Strings other_name_parts; - boost::split(other_name_parts, other_name, boost::is_any_of(".")); - - if (isPrefix(name_parts, other_name_parts)) - throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Data in Object has ambiguous paths: '{}' and '{}", name, other_name); - } - } - subcolumn.finalize(); new_subcolumns[name] = std::move(subcolumn); } @@ -516,6 +551,7 @@ void ColumnObject::finalize() new_subcolumns[COLUMN_NAME_DUMMY] = Subcolumn{ColumnUInt8::create(old_size)}; std::swap(subcolumns, new_subcolumns); + checkObjectHasNoAmbiguosPaths(getKeys()); } } diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 822e25cad32..c12e88a0d4a 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -38,6 +38,9 @@ public: void insert(Field && field); void insertDefault(); + void insertManyDefaults(size_t length); + void insertRangeFrom(const Subcolumn & src, size_t start, size_t length); + void finalize(); IColumn & getFinalizedColumn(); @@ -75,6 +78,7 @@ public: const SubcolumnsMap & getSubcolumns() const { return subcolumns; } SubcolumnsMap & getSubcolumns() { return subcolumns; } + Strings getKeys() const; bool isFinalized() const; void finalize(); @@ -88,6 +92,7 @@ public: size_t byteSize() const override; size_t allocatedBytes() const override; void forEachSubcolumn(ColumnCallback callback) override; + void insertRangeFrom(const IColumn & src, size_t start, size_t length) override; /// All other methods throw exception. @@ -98,7 +103,6 @@ public: StringRef getDataAt(size_t) const override { throwMustBeConcrete(); } bool isDefaultAt(size_t) const override { throwMustBeConcrete(); } void insert(const Field &) override { throwMustBeConcrete(); } - void insertRangeFrom(const IColumn &, size_t, size_t) override { throwMustBeConcrete(); } void insertData(const char *, size_t) override { throwMustBeConcrete(); } void insertDefault() override { throwMustBeConcrete(); } void popBack(size_t) override { throwMustBeConcrete(); } diff --git a/src/DataTypes/DataTypeObject.h b/src/DataTypes/DataTypeObject.h index 991991124a7..b4b31f0b8ea 100644 --- a/src/DataTypes/DataTypeObject.h +++ b/src/DataTypes/DataTypeObject.h @@ -39,6 +39,8 @@ public: bool isParametric() const override { return true; } SerializationPtr doGetDefaultSerialization() const override; + + bool hasNullableSubcolumns() const { return is_nullable; } }; } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 81a658ee689..21b60f25707 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -20,6 +20,9 @@ #include #include +#include +#include + namespace DB { @@ -27,6 +30,7 @@ namespace ErrorCodes { extern const int TYPE_MISMATCH; extern const int LOGICAL_ERROR; + extern const int DUPLICATE_COLUMN; } static const IDataType * getTypeObject(const DataTypePtr & type) @@ -148,6 +152,38 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con } } +static bool isPrefix(const Strings & prefix, const Strings & strings) +{ + if (prefix.size() > strings.size()) + return false; + + for (size_t i = 0; i < prefix.size(); ++i) + if (prefix[i] != strings[i]) + return false; + return true; +} + +void checkObjectHasNoAmbiguosPaths(const Strings & key_names) +{ + for (const auto & name : key_names) + { + Strings name_parts; + boost::split(name_parts, name, boost::is_any_of(".")); + + for (const auto & other_name : key_names) + { + if (other_name.size() > name.size()) + { + Strings other_name_parts; + boost::split(other_name_parts, other_name, boost::is_any_of(".")); + + if (isPrefix(name_parts, other_name_parts)) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Data in Object has ambiguous paths: '{}' and '{}", name, other_name); + } + } + } +} + DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) { std::unordered_map subcolumns_types; @@ -192,6 +228,8 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) auto tuple_names = extractVector<0>(tuple_elements); auto tuple_types = extractVector<1>(tuple_elements); + checkObjectHasNoAmbiguosPaths(tuple_names); + return std::make_shared(tuple_types, tuple_names); } diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 345db6fdf36..1da7031670d 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -15,6 +15,7 @@ DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); +void checkObjectHasNoAmbiguosPaths(const Strings & key_names); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types); NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescription & object_columns, bool with_subcolumns); diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index 6aa7ea6c39c..dd9f5824880 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -24,6 +24,7 @@ #include #include #include +#include #include #include #include @@ -33,6 +34,7 @@ #include #include #include +#include #include #include #include @@ -2978,6 +2980,57 @@ private: } } + WrapperType createObjectWrapper(const DataTypePtr & from_type, const DataTypeObject * to_type) const + { + if (const auto * from_tuple = checkAndGetDataType(from_type.get())) + { + if (!from_tuple->haveExplicitNames()) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Cast to Object can be performed only from flatten Named Tuple. Got: {}", from_type->getName()); + + const auto & names = from_tuple->getElementNames(); + const auto & from_types = from_tuple->getElements(); + auto to_types = from_types; + + for (auto & type : to_types) + { + if (checkAndGetDataType(type.get())) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Cast to Object can be performed only from flatten Named Tuple. Got: {}", from_type->getName()); + + type = recursiveRemoveLowCardinality(type); + } + + return [element_wrappers = getElementWrappers(from_types, to_types), + has_nullable_subcolumns = to_type->hasNullableSubcolumns(), from_types, to_types, names] + (ColumnsWithTypeAndName & arguments, const DataTypePtr &, const ColumnNullable * nullable_source, size_t input_rows_count) -> ColumnPtr + { + size_t tuple_size = to_types.size(); + const ColumnTuple & column_tuple = assert_cast(*arguments.front().column); + + ColumnObject::SubcolumnsMap subcolumns; + for (size_t i = 0; i < tuple_size; ++i) + { + ColumnsWithTypeAndName element = {{column_tuple.getColumns()[i], from_types[i], "" }}; + auto converted_column = element_wrappers[i](element, to_types[i], nullable_source, input_rows_count); + subcolumns[names[i]] = converted_column->assumeMutable(); + } + + return ColumnObject::create(std::move(subcolumns), has_nullable_subcolumns); + }; + } + else if (checkAndGetDataType(from_type.get())) + { + return [] (ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const ColumnNullable *, size_t /*input_rows_count*/) + { + return ConvertImplGenericFromString::execute(arguments, result_type); + }; + } + + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Cast to Object can be performed only from flatten named tuple. Got: {}", from_type->getName()); + } + template WrapperType createEnumWrapper(const DataTypePtr & from_type, const DataTypeEnum * to_type) const { @@ -3353,6 +3406,8 @@ private: return createTupleWrapper(from_type, checkAndGetDataType(to_type.get())); case TypeIndex::Map: return createMapWrapper(from_type, checkAndGetDataType(to_type.get())); + case TypeIndex::Object: + return createObjectWrapper(from_type, checkAndGetDataType(to_type.get())); case TypeIndex::AggregateFunction: return createAggregateFunctionWrapper(from_type, checkAndGetDataType(to_type.get())); default: diff --git a/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp b/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp index 1eb64682fae..9d64df9f36f 100644 --- a/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp +++ b/src/Processors/Formats/Impl/ValuesBlockInputFormat.cpp @@ -16,6 +16,7 @@ #include #include #include +#include namespace DB @@ -93,6 +94,7 @@ Chunk ValuesBlockInputFormat::generate() return {}; } + finalizeObjectColumns(columns); size_t rows_in_block = columns[0]->size(); return Chunk{std::move(columns), rows_in_block}; } diff --git a/tests/queries/0_stateless/01825_type_json_insert_select.reference b/tests/queries/0_stateless/01825_type_json_insert_select.reference new file mode 100644 index 00000000000..3a7fe84af9e --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_insert_select.reference @@ -0,0 +1,12 @@ +Tuple(k1 Int8, k2 String) +1 (1,'foo') +Tuple(k1 Int8, k2 String, k3 String) +1 (1,'foo','') +2 (2,'bar','') +3 (3,'','aaa') +Tuple(`arr.k11` Array(Int8), `arr.k22` Array(String), `arr.k33` Array(Int8), k1 Int8, k2 String, k3 String) +1 ([],[],[],1,'foo','') +2 ([],[],[],2,'bar','') +3 ([],[],[],3,'','aaa') +4 ([5,7],['6','0'],[0,8],0,'','') +5 ([],['str1'],[],0,'','') diff --git a/tests/queries/0_stateless/01825_type_json_insert_select.sql b/tests/queries/0_stateless/01825_type_json_insert_select.sql new file mode 100644 index 00000000000..da0545993b2 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_insert_select.sql @@ -0,0 +1,32 @@ +DROP TABLE IF EXISTS type_json_src; +DROP TABLE IF EXISTS type_json_dst; + +CREATE TABLE type_json_src (id UInt32, data JSON) ENGINE = MergeTree ORDER BY id; +CREATE TABLE type_json_dst AS type_json_src; + +INSERT INTO type_json_src VALUES (1, '{"k1": 1, "k2": "foo"}'); +INSERT INTO type_json_dst SELECT * FROM type_json_src; + +SELECT DISTINCT toTypeName(data) FROM type_json_dst; +SELECT id, data FROM type_json_dst ORDER BY id; + +INSERT INTO type_json_src VALUES (2, '{"k1": 2, "k2": "bar"}') (3, '{"k1": 3, "k3": "aaa"}'); +INSERT INTO type_json_dst SELECT * FROM type_json_src WHERE id > 1; + +SELECT DISTINCT toTypeName(data) FROM type_json_dst; +SELECT id, data FROM type_json_dst ORDER BY id; + +INSERT INTO type_json_dst VALUES (4, '{"arr": [{"k11": 5, "k22": 6}, {"k11": 7, "k33": 8}]}'); + +INSERT INTO type_json_src VALUES (5, '{"arr": "not array"}'); +INSERT INTO type_json_dst SELECT * FROM type_json_src WHERE id = 5; -- { serverError 15 } + +TRUNCATE TABLE type_json_src; +INSERT INTO type_json_src VALUES (5, '{"arr": [{"k22": "str1"}]}') +INSERT INTO type_json_dst SELECT * FROM type_json_src WHERE id = 5; + +SELECT DISTINCT toTypeName(data) FROM type_json_dst; +SELECT id, data FROM type_json_dst ORDER BY id; + +DROP TABLE type_json_src; +DROP TABLE type_json_dst; From e9f90b2859d14dc315f0c3a314c704e1a16afdf6 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 21 Aug 2021 00:11:22 +0300 Subject: [PATCH 039/132] support fields of type object --- src/Columns/ColumnObject.cpp | 88 +++++++++++++++++-- src/Columns/ColumnObject.h | 19 ++-- src/Common/FieldVisitorConvertToNumber.h | 5 ++ src/Common/FieldVisitorDump.cpp | 17 ++++ src/Common/FieldVisitorDump.h | 1 + src/Common/FieldVisitorHash.cpp | 13 +++ src/Common/FieldVisitorHash.h | 1 + src/Common/FieldVisitorSum.cpp | 1 + src/Common/FieldVisitorSum.h | 1 + src/Common/FieldVisitorToString.cpp | 19 ++++ src/Common/FieldVisitorToString.h | 1 + src/Common/FieldVisitorWriteBinary.cpp | 14 +++ src/Common/FieldVisitorWriteBinary.h | 1 + src/Core/Field.cpp | 40 +++++++++ src/Core/Field.h | 45 ++++++++-- src/DataTypes/FieldToDataType.cpp | 8 +- src/DataTypes/FieldToDataType.h | 1 + src/DataTypes/Serializations/JSONDataParser.h | 3 + src/Interpreters/convertFieldToType.cpp | 41 +++++++++ src/Storages/MergeTree/MergeTreePartition.cpp | 12 +++ .../0_stateless/01825_type_json_4.reference | 2 +- .../queries/0_stateless/01825_type_json_4.sh | 2 +- .../01825_type_json_field.reference | 12 +++ .../0_stateless/01825_type_json_field.sql | 24 +++++ 24 files changed, 347 insertions(+), 24 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_field.reference create mode 100644 tests/queries/0_stateless/01825_type_json_field.sql diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 431db916afc..6b5610ce7d1 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -11,6 +11,7 @@ #include #include #include +#include namespace DB @@ -214,7 +215,7 @@ void ColumnObject::Subcolumn::checkTypes() const } } -void ColumnObject::Subcolumn::insert(Field && field) +void ColumnObject::Subcolumn::insert(Field field) { auto value_dim = applyVisitor(FieldVisitorToNumberOfDimensions(), field); auto column_dim = getNumberOfDimensions(*least_common_type); @@ -297,7 +298,7 @@ void ColumnObject::Subcolumn::insertRangeFrom(const Subcolumn & src, size_t star } else { - auto new_least_common_type = getLeastSupertype(DataTypes{least_common_type, src_type}); + auto new_least_common_type = getLeastSupertype(DataTypes{least_common_type, src_type}, true); auto casted_column = castColumn({src_column, src_type, ""}, new_least_common_type); if (!least_common_type->equals(*new_least_common_type)) @@ -448,10 +449,65 @@ size_t ColumnObject::allocatedBytes() const return res; } -void ColumnObject::forEachSubcolumn(ColumnCallback) +void ColumnObject::forEachSubcolumn(ColumnCallback callback) { - // for (auto & [_, column] : subcolumns) - // callback(column.data); + if (!isFinalized()) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot iterate over non-finalized ColumnObject"); + + for (auto & [_, column] : subcolumns) + callback(column.data.back()); +} + +void ColumnObject::insert(const Field & field) +{ + const auto & object = field.get(); + + HashSet inserted; + size_t old_size = size(); + for (const auto & [key, value] : object) + { + inserted.insert(key); + if (!hasSubcolumn(key)) + addSubcolumn(key, old_size); + + auto & subcolumn = getSubcolumn(key); + subcolumn.insert(value); + } + + for (auto & [key, subcolumn] : subcolumns) + if (!inserted.has(key)) + subcolumn.insertDefault(); +} + +void ColumnObject::insertDefault() +{ + for (auto & [_, subcolumn] : subcolumns) + subcolumn.insertDefault(); +} + +Field ColumnObject::operator[](size_t n) const +{ + if (!isFinalized()) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot get Field from non-finalized ColumnObject"); + + Object object; + for (const auto & [key, subcolumn] : subcolumns) + object[key] = (*subcolumn.data.back())[n]; + + return object; +} + +void ColumnObject::get(size_t n, Field & res) const +{ + if (!isFinalized()) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot get Field from non-finalized ColumnObject"); + + auto & object = res.get(); + for (const auto & [key, subcolumn] : subcolumns) + { + auto it = object.try_emplace(key).first; + subcolumn.data.back()->get(n, it->second); + } } void ColumnObject::insertRangeFrom(const IColumn & src, size_t start, size_t length) @@ -469,6 +525,27 @@ void ColumnObject::insertRangeFrom(const IColumn & src, size_t start, size_t len finalize(); } +ColumnPtr ColumnObject::replicate(const Offsets & offsets) const +{ + if (!isFinalized()) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot replicate non-finalized ColumnObject"); + + auto res_column = ColumnObject::create(is_nullable); + for (auto & [key, subcolumn] : subcolumns) + res_column->addSubcolumn(key, Subcolumn(subcolumn.data.back()->replicate(offsets)->assumeMutable())); + + return res_column; +} + +void ColumnObject::popBack(size_t length) +{ + if (!isFinalized()) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot popBack from non-finalized ColumnObject"); + + for (auto & [_, subcolumn] : subcolumns) + subcolumn.data.back()->popBack(length); +} + const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const String & key) const { auto it = subcolumns.find(key); @@ -515,6 +592,7 @@ void ColumnObject::addSubcolumn(const String & key, Subcolumn && subcolumn, bool "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", key, subcolumn.size(), size()); + subcolumn.setNullable(is_nullable); subcolumns[key] = std::move(subcolumn); } diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index f7cc8ef2ea6..26976d6afe6 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -36,17 +36,20 @@ public: const DataTypePtr & getLeastCommonType() const { return least_common_type; } void checkTypes() const; - void insert(Field && field); + void insert(Field field); void insertDefault(); void insertManyDefaults(size_t length); void insertRangeFrom(const Subcolumn & src, size_t start, size_t length); void finalize(); + void setNullable(bool value) { is_nullable = value; } IColumn & getFinalizedColumn(); const IColumn & getFinalizedColumn() const; const ColumnPtr & getFinalizedColumnPtr() const; + friend class ColumnObject; + private: DataTypePtr least_common_type; bool is_nullable = false; @@ -86,26 +89,27 @@ public: /// Part of interface const char * getFamilyName() const override { return "Object"; } + TypeIndex getDataType() const override { return TypeIndex::Object; } size_t size() const override; MutableColumnPtr cloneResized(size_t new_size) const override; size_t byteSize() const override; size_t allocatedBytes() const override; void forEachSubcolumn(ColumnCallback callback) override; + void insert(const Field & field) override; + void insertDefault() override; void insertRangeFrom(const IColumn & src, size_t start, size_t length) override; + ColumnPtr replicate(const Offsets & offsets) const override; + void popBack(size_t length) override; + Field operator[](size_t n) const override; + void get(size_t n, Field & res) const override; /// All other methods throw exception. ColumnPtr decompress() const override { throwMustBeConcrete(); } - TypeIndex getDataType() const override { throwMustBeConcrete(); } - Field operator[](size_t) const override { throwMustBeConcrete(); } - void get(size_t, Field &) const override { throwMustBeConcrete(); } StringRef getDataAt(size_t) const override { throwMustBeConcrete(); } bool isDefaultAt(size_t) const override { throwMustBeConcrete(); } - void insert(const Field &) override { throwMustBeConcrete(); } void insertData(const char *, size_t) override { throwMustBeConcrete(); } - void insertDefault() override { throwMustBeConcrete(); } - void popBack(size_t) override { throwMustBeConcrete(); } StringRef serializeValueIntoArena(size_t, Arena &, char const *&) const override { throwMustBeConcrete(); } const char * deserializeAndInsertFromArena(const char *) override { throwMustBeConcrete(); } const char * skipSerializedInArena(const char *) const override { throwMustBeConcrete(); } @@ -121,7 +125,6 @@ public: bool hasEqualValues() const override { throwMustBeConcrete(); } void getPermutation(bool, size_t, int, Permutation &) const override { throwMustBeConcrete(); } void updatePermutation(bool, size_t, int, Permutation &, EqualRanges &) const override { throwMustBeConcrete(); } - ColumnPtr replicate(const Offsets &) const override { throwMustBeConcrete(); } MutableColumns scatter(ColumnIndex, const Selector &) const override { throwMustBeConcrete(); } void gather(ColumnGathererStream &) override { throwMustBeConcrete(); } void getExtremes(Field &, Field &) const override { throwMustBeConcrete(); } diff --git a/src/Common/FieldVisitorConvertToNumber.h b/src/Common/FieldVisitorConvertToNumber.h index 82a804691d7..66e32893426 100644 --- a/src/Common/FieldVisitorConvertToNumber.h +++ b/src/Common/FieldVisitorConvertToNumber.h @@ -56,6 +56,11 @@ public: throw Exception("Cannot convert Map to " + demangle(typeid(T).name()), ErrorCodes::CANNOT_CONVERT_TYPE); } + T operator() (const Object &) const + { + throw Exception("Cannot convert Object to " + demangle(typeid(T).name()), ErrorCodes::CANNOT_CONVERT_TYPE); + } + T operator() (const UInt64 & x) const { return T(x); } T operator() (const Int64 & x) const { return T(x); } T operator() (const Int128 & x) const { return T(x); } diff --git a/src/Common/FieldVisitorDump.cpp b/src/Common/FieldVisitorDump.cpp index 660677404ad..b1bcfd8fd10 100644 --- a/src/Common/FieldVisitorDump.cpp +++ b/src/Common/FieldVisitorDump.cpp @@ -96,6 +96,23 @@ String FieldVisitorDump::operator() (const Map & x) const return wb.str(); } +String FieldVisitorDump::operator() (const Object & x) const +{ + WriteBufferFromOwnString wb; + + wb << "Object_("; + for (auto it = x.begin(); it != x.end(); ++it) + { + if (it != x.begin()) + wb << ", "; + wb << "(" << it->first << ", " << applyVisitor(*this, it->second) << ")"; + } + wb << ')'; + + return wb.str(); + +} + String FieldVisitorDump::operator() (const AggregateFunctionStateData & x) const { WriteBufferFromOwnString wb; diff --git a/src/Common/FieldVisitorDump.h b/src/Common/FieldVisitorDump.h index bc82d35f0f1..280176355aa 100644 --- a/src/Common/FieldVisitorDump.h +++ b/src/Common/FieldVisitorDump.h @@ -24,6 +24,7 @@ public: String operator() (const Array & x) const; String operator() (const Tuple & x) const; String operator() (const Map & x) const; + String operator() (const Object & x) const; String operator() (const DecimalField & x) const; String operator() (const DecimalField & x) const; String operator() (const DecimalField & x) const; diff --git a/src/Common/FieldVisitorHash.cpp b/src/Common/FieldVisitorHash.cpp index 259dd871d20..dfe96946a69 100644 --- a/src/Common/FieldVisitorHash.cpp +++ b/src/Common/FieldVisitorHash.cpp @@ -106,6 +106,19 @@ void FieldVisitorHash::operator() (const Array & x) const applyVisitor(*this, elem); } +void FieldVisitorHash::operator() (const Object & x) const +{ + UInt8 type = Field::Types::Object; + hash.update(type); + hash.update(x.size()); + + for (const auto & [key, value]: x) + { + hash.update(key); + applyVisitor(*this, value); + } +} + void FieldVisitorHash::operator() (const DecimalField & x) const { UInt8 type = Field::Types::Decimal32; diff --git a/src/Common/FieldVisitorHash.h b/src/Common/FieldVisitorHash.h index bf7c3d5004f..378b1cfa233 100644 --- a/src/Common/FieldVisitorHash.h +++ b/src/Common/FieldVisitorHash.h @@ -30,6 +30,7 @@ public: void operator() (const Array & x) const; void operator() (const Tuple & x) const; void operator() (const Map & x) const; + void operator() (const Object & x) const; void operator() (const DecimalField & x) const; void operator() (const DecimalField & x) const; void operator() (const DecimalField & x) const; diff --git a/src/Common/FieldVisitorSum.cpp b/src/Common/FieldVisitorSum.cpp index e0ffca28341..6fb437d06c8 100644 --- a/src/Common/FieldVisitorSum.cpp +++ b/src/Common/FieldVisitorSum.cpp @@ -28,6 +28,7 @@ bool FieldVisitorSum::operator() (String &) const { throw Exception("Cannot sum bool FieldVisitorSum::operator() (Array &) const { throw Exception("Cannot sum Arrays", ErrorCodes::LOGICAL_ERROR); } bool FieldVisitorSum::operator() (Tuple &) const { throw Exception("Cannot sum Tuples", ErrorCodes::LOGICAL_ERROR); } bool FieldVisitorSum::operator() (Map &) const { throw Exception("Cannot sum Maps", ErrorCodes::LOGICAL_ERROR); } +bool FieldVisitorSum::operator() (Object &) const { throw Exception("Cannot sum Objects", ErrorCodes::LOGICAL_ERROR); } bool FieldVisitorSum::operator() (UUID &) const { throw Exception("Cannot sum UUIDs", ErrorCodes::LOGICAL_ERROR); } bool FieldVisitorSum::operator() (AggregateFunctionStateData &) const diff --git a/src/Common/FieldVisitorSum.h b/src/Common/FieldVisitorSum.h index 4c34fa86455..5f96854dd02 100644 --- a/src/Common/FieldVisitorSum.h +++ b/src/Common/FieldVisitorSum.h @@ -27,6 +27,7 @@ public: bool operator() (Array &) const; bool operator() (Tuple &) const; bool operator() (Map &) const; + bool operator() (Object &) const; bool operator() (UUID &) const; bool operator() (AggregateFunctionStateData &) const; diff --git a/src/Common/FieldVisitorToString.cpp b/src/Common/FieldVisitorToString.cpp index b8750d95e5e..cad92b0cf56 100644 --- a/src/Common/FieldVisitorToString.cpp +++ b/src/Common/FieldVisitorToString.cpp @@ -128,5 +128,24 @@ String FieldVisitorToString::operator() (const Map & x) const return wb.str(); } +String FieldVisitorToString::operator() (const Object & x) const +{ + WriteBufferFromOwnString wb; + + wb << '{'; + for (auto it = x.begin(); it != x.end(); ++it) + { + if (it != x.begin()) + wb << ", "; + + writeDoubleQuoted(it->first, wb); + wb << ": " << applyVisitor(*this, it->second); + } + wb << '}'; + + return wb.str(); + +} + } diff --git a/src/Common/FieldVisitorToString.h b/src/Common/FieldVisitorToString.h index 139f011927f..77059caa6b1 100644 --- a/src/Common/FieldVisitorToString.h +++ b/src/Common/FieldVisitorToString.h @@ -24,6 +24,7 @@ public: String operator() (const Array & x) const; String operator() (const Tuple & x) const; String operator() (const Map & x) const; + String operator() (const Object & x) const; String operator() (const DecimalField & x) const; String operator() (const DecimalField & x) const; String operator() (const DecimalField & x) const; diff --git a/src/Common/FieldVisitorWriteBinary.cpp b/src/Common/FieldVisitorWriteBinary.cpp index 56df9f1e43a..adb2bb8decd 100644 --- a/src/Common/FieldVisitorWriteBinary.cpp +++ b/src/Common/FieldVisitorWriteBinary.cpp @@ -68,5 +68,19 @@ void FieldVisitorWriteBinary::operator() (const Map & x, WriteBuffer & buf) cons } } +void FieldVisitorWriteBinary::operator() (const Object & x, WriteBuffer & buf) const +{ + const size_t size = x.size(); + writeBinary(size, buf); + + for (const auto & [key, value] : x) + { + const UInt8 type = value.getType(); + writeBinary(type, buf); + writeBinary(key, buf); + Field::dispatch([&buf] (const auto & val) { FieldVisitorWriteBinary()(val, buf); }, value); + } +} + } diff --git a/src/Common/FieldVisitorWriteBinary.h b/src/Common/FieldVisitorWriteBinary.h index 5f7bf578e32..2eedb54ff12 100644 --- a/src/Common/FieldVisitorWriteBinary.h +++ b/src/Common/FieldVisitorWriteBinary.h @@ -23,6 +23,7 @@ public: void operator() (const Array & x, WriteBuffer & buf) const; void operator() (const Tuple & x, WriteBuffer & buf) const; void operator() (const Map & x, WriteBuffer & buf) const; + void operator() (const Object & x, WriteBuffer & buf) const; void operator() (const DecimalField & x, WriteBuffer & buf) const; void operator() (const DecimalField & x, WriteBuffer & buf) const; void operator() (const DecimalField & x, WriteBuffer & buf) const; diff --git a/src/Core/Field.cpp b/src/Core/Field.cpp index 8739f56d991..511b77a8f9e 100644 --- a/src/Core/Field.cpp +++ b/src/Core/Field.cpp @@ -99,6 +99,12 @@ inline Field getBinaryValue(UInt8 type, ReadBuffer & buf) readBinary(value, buf); return value; } + case Field::Types::Object: + { + Object value; + readBinary(value, buf); + return value; + } case Field::Types::AggregateFunctionState: { AggregateFunctionStateData value; @@ -202,6 +208,40 @@ void writeText(const Map & x, WriteBuffer & buf) writeFieldText(Field(x), buf); } +void readBinary(Object & x, ReadBuffer & buf) +{ + size_t size; + readBinary(size, buf); + + for (size_t index = 0; index < size; ++index) + { + UInt8 type; + String key; + readBinary(type, buf); + readBinary(key, buf); + x[key] = getBinaryValue(type, buf); + } +} + +void writeBinary(const Object & x, WriteBuffer & buf) +{ + const size_t size = x.size(); + writeBinary(size, buf); + + for (const auto & [key, value] : x) + { + const UInt8 type = value.getType(); + writeBinary(type, buf); + writeBinary(key, buf); + Field::dispatch([&buf] (const auto & val) { FieldVisitorWriteBinary()(val, buf); }, value); + } +} + +void writeText(const Object & x, WriteBuffer & buf) +{ + writeFieldText(Field(x), buf); +} + template void readQuoted(DecimalField & x, ReadBuffer & buf) { diff --git a/src/Core/Field.h b/src/Core/Field.h index 0023497e970..a548617bfc2 100644 --- a/src/Core/Field.h +++ b/src/Core/Field.h @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -52,10 +53,22 @@ DEFINE_FIELD_VECTOR(Array); DEFINE_FIELD_VECTOR(Tuple); /// An array with the following structure: [(key1, value1), (key2, value2), ...] -DEFINE_FIELD_VECTOR(Map); +DEFINE_FIELD_VECTOR(Map); /// TODO: use map instead of vector. #undef DEFINE_FIELD_VECTOR +using FieldMap = std::map, AllocatorWithMemoryTracking>>; + +#define DEFINE_FIELD_MAP(X) \ +struct X : public FieldMap \ +{ \ + using FieldMap::FieldMap; \ +} + +DEFINE_FIELD_MAP(Object); + +#undef DEFINE_FIELD_MAP + struct AggregateFunctionStateData { String name; /// Name with arguments. @@ -216,6 +229,7 @@ template <> struct NearestFieldTypeImpl { using Type = String; }; template <> struct NearestFieldTypeImpl { using Type = Array; }; template <> struct NearestFieldTypeImpl { using Type = Tuple; }; template <> struct NearestFieldTypeImpl { using Type = Map; }; +template <> struct NearestFieldTypeImpl { using Type = Object; }; template <> struct NearestFieldTypeImpl { using Type = UInt64; }; template <> struct NearestFieldTypeImpl { using Type = Null; }; template <> struct NearestFieldTypeImpl { using Type = NegativeInfinity; }; @@ -271,6 +285,7 @@ public: Int256 = 25, Map = 26, UUID = 27, + Object = 28, // Special types for index analysis NegativeInfinity = 254, @@ -296,6 +311,7 @@ public: case Array: return "Array"; case Tuple: return "Tuple"; case Map: return "Map"; + case Object: return "Object"; case Decimal32: return "Decimal32"; case Decimal64: return "Decimal64"; case Decimal128: return "Decimal128"; @@ -486,6 +502,7 @@ public: case Types::Array: return get() < rhs.get(); case Types::Tuple: return get() < rhs.get(); case Types::Map: return get() < rhs.get(); + case Types::Object: return get() < rhs.get(); case Types::Decimal32: return get>() < rhs.get>(); case Types::Decimal64: return get>() < rhs.get>(); case Types::Decimal128: return get>() < rhs.get>(); @@ -526,6 +543,7 @@ public: case Types::Array: return get() <= rhs.get(); case Types::Tuple: return get() <= rhs.get(); case Types::Map: return get() <= rhs.get(); + case Types::Object: return get() <= rhs.get(); case Types::Decimal32: return get>() <= rhs.get>(); case Types::Decimal64: return get>() <= rhs.get>(); case Types::Decimal128: return get>() <= rhs.get>(); @@ -566,6 +584,7 @@ public: case Types::Array: return get() == rhs.get(); case Types::Tuple: return get() == rhs.get(); case Types::Map: return get() == rhs.get(); + case Types::Object: return get() == rhs.get(); case Types::UInt128: return get() == rhs.get(); case Types::UInt256: return get() == rhs.get(); case Types::Int128: return get() == rhs.get(); @@ -612,6 +631,7 @@ public: case Types::Array: return f(field.template get()); case Types::Tuple: return f(field.template get()); case Types::Map: return f(field.template get()); + case Types::Object: return f(field.template get()); case Types::Decimal32: return f(field.template get>()); case Types::Decimal64: return f(field.template get>()); case Types::Decimal128: return f(field.template get>()); @@ -728,6 +748,9 @@ private: case Types::Map: destroy(); break; + case Types::Object: + destroy(); + break; case Types::AggregateFunctionState: destroy(); break; @@ -767,6 +790,7 @@ template <> struct Field::TypeToEnum { static const Types::Which value template <> struct Field::TypeToEnum { static const Types::Which value = Types::Array; }; template <> struct Field::TypeToEnum { static const Types::Which value = Types::Tuple; }; template <> struct Field::TypeToEnum { static const Types::Which value = Types::Map; }; +template <> struct Field::TypeToEnum { static const Types::Which value = Types::Object; }; template <> struct Field::TypeToEnum>{ static const Types::Which value = Types::Decimal32; }; template <> struct Field::TypeToEnum>{ static const Types::Which value = Types::Decimal64; }; template <> struct Field::TypeToEnum>{ static const Types::Which value = Types::Decimal128; }; @@ -789,6 +813,7 @@ template <> struct Field::EnumToType { using Type = Strin template <> struct Field::EnumToType { using Type = Array; }; template <> struct Field::EnumToType { using Type = Tuple; }; template <> struct Field::EnumToType { using Type = Map; }; +template <> struct Field::EnumToType { using Type = Object; }; template <> struct Field::EnumToType { using Type = DecimalField; }; template <> struct Field::EnumToType { using Type = DecimalField; }; template <> struct Field::EnumToType { using Type = DecimalField; }; @@ -872,6 +897,7 @@ T safeGet(Field & field) template <> inline constexpr const char * TypeName = "Array"; template <> inline constexpr const char * TypeName = "Tuple"; template <> inline constexpr const char * TypeName = "Map"; +template <> inline constexpr const char * TypeName = "Object"; template <> inline constexpr const char * TypeName = "AggregateFunctionState"; @@ -938,34 +964,39 @@ class WriteBuffer; /// It is assumed that all elements of the array have the same type. void readBinary(Array & x, ReadBuffer & buf); - [[noreturn]] inline void readText(Array &, ReadBuffer &) { throw Exception("Cannot read Array.", ErrorCodes::NOT_IMPLEMENTED); } [[noreturn]] inline void readQuoted(Array &, ReadBuffer &) { throw Exception("Cannot read Array.", ErrorCodes::NOT_IMPLEMENTED); } /// It is assumed that all elements of the array have the same type. /// Also write size and type into buf. UInt64 and Int64 is written in variadic size form void writeBinary(const Array & x, WriteBuffer & buf); - void writeText(const Array & x, WriteBuffer & buf); - [[noreturn]] inline void writeQuoted(const Array &, WriteBuffer &) { throw Exception("Cannot write Array quoted.", ErrorCodes::NOT_IMPLEMENTED); } void readBinary(Tuple & x, ReadBuffer & buf); - [[noreturn]] inline void readText(Tuple &, ReadBuffer &) { throw Exception("Cannot read Tuple.", ErrorCodes::NOT_IMPLEMENTED); } [[noreturn]] inline void readQuoted(Tuple &, ReadBuffer &) { throw Exception("Cannot read Tuple.", ErrorCodes::NOT_IMPLEMENTED); } void writeBinary(const Tuple & x, WriteBuffer & buf); - void writeText(const Tuple & x, WriteBuffer & buf); +[[noreturn]] inline void writeQuoted(const Tuple &, WriteBuffer &) { throw Exception("Cannot write Tuple quoted.", ErrorCodes::NOT_IMPLEMENTED); } void readBinary(Map & x, ReadBuffer & buf); [[noreturn]] inline void readText(Map &, ReadBuffer &) { throw Exception("Cannot read Map.", ErrorCodes::NOT_IMPLEMENTED); } [[noreturn]] inline void readQuoted(Map &, ReadBuffer &) { throw Exception("Cannot read Map.", ErrorCodes::NOT_IMPLEMENTED); } + void writeBinary(const Map & x, WriteBuffer & buf); void writeText(const Map & x, WriteBuffer & buf); [[noreturn]] inline void writeQuoted(const Map &, WriteBuffer &) { throw Exception("Cannot write Map quoted.", ErrorCodes::NOT_IMPLEMENTED); } +void readBinary(Object & x, ReadBuffer & buf); +[[noreturn]] inline void readText(Object &, ReadBuffer &) { throw Exception("Cannot read Object.", ErrorCodes::NOT_IMPLEMENTED); } +[[noreturn]] inline void readQuoted(Object &, ReadBuffer &) { throw Exception("Cannot read Object.", ErrorCodes::NOT_IMPLEMENTED); } + +void writeBinary(const Object & x, WriteBuffer & buf); +void writeText(const Object & x, WriteBuffer & buf); +[[noreturn]] inline void writeQuoted(const Object &, WriteBuffer &) { throw Exception("Cannot write Object quoted.", ErrorCodes::NOT_IMPLEMENTED); } + __attribute__ ((noreturn)) inline void writeText(const AggregateFunctionStateData &, WriteBuffer &) { // This probably doesn't make any sense, but we have to have it for @@ -984,8 +1015,6 @@ void readQuoted(DecimalField & x, ReadBuffer & buf); void writeFieldText(const Field & x, WriteBuffer & buf); -[[noreturn]] inline void writeQuoted(const Tuple &, WriteBuffer &) { throw Exception("Cannot write Tuple quoted.", ErrorCodes::NOT_IMPLEMENTED); } - String toString(const Field & x); } diff --git a/src/DataTypes/FieldToDataType.cpp b/src/DataTypes/FieldToDataType.cpp index 38a0968cc81..d315ed2f902 100644 --- a/src/DataTypes/FieldToDataType.cpp +++ b/src/DataTypes/FieldToDataType.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -124,7 +125,6 @@ DataTypePtr FieldToDataType::operator() (const Array & x) const return std::make_shared(getLeastSupertype(element_types, allow_convertion_to_string)); } - DataTypePtr FieldToDataType::operator() (const Tuple & tuple) const { if (tuple.empty()) @@ -159,6 +159,12 @@ DataTypePtr FieldToDataType::operator() (const Map & map) const getLeastSupertype(value_types, allow_convertion_to_string)); } +DataTypePtr FieldToDataType::operator() (const Object &) const +{ + /// TODO: Do we need different parameters for type Object? + return std::make_shared("json", false); +} + DataTypePtr FieldToDataType::operator() (const AggregateFunctionStateData & x) const { const auto & name = static_cast(x).name; diff --git a/src/DataTypes/FieldToDataType.h b/src/DataTypes/FieldToDataType.h index f7a611b90bc..47f552fdcea 100644 --- a/src/DataTypes/FieldToDataType.h +++ b/src/DataTypes/FieldToDataType.h @@ -38,6 +38,7 @@ public: DataTypePtr operator() (const Array & x) const; DataTypePtr operator() (const Tuple & tuple) const; DataTypePtr operator() (const Map & map) const; + DataTypePtr operator() (const Object & map) const; DataTypePtr operator() (const DecimalField & x) const; DataTypePtr operator() (const DecimalField & x) const; DataTypePtr operator() (const DecimalField & x) const; diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index daefb6a9b9a..ecf0107b255 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -2,6 +2,7 @@ #include #include +#include namespace DB { @@ -74,6 +75,8 @@ public: private: void traverse(const Element & element, String current_path, ParseResult & result) { + checkStackSize(); + if (element.isObject()) { auto object = element.getObject(); diff --git a/src/Interpreters/convertFieldToType.cpp b/src/Interpreters/convertFieldToType.cpp index 51ab49c5096..575efaa8d92 100644 --- a/src/Interpreters/convertFieldToType.cpp +++ b/src/Interpreters/convertFieldToType.cpp @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -358,6 +359,46 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type, const ID return src; } + else if (const auto * object_type = typeid_cast(&type)) + { + const auto * from_type_tuple = typeid_cast(from_type_hint); + if (src.getType() == Field::Types::Tuple && from_type_tuple && from_type_tuple->haveExplicitNames()) + { + const auto & names = from_type_tuple->getElementNames(); + const auto & tuple = src.get(); + + if (names.size() != tuple.size()) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Bad size of tuple in IN or VALUES section (while converting to Object). Expected size: {}, actual size: {}", + names.size(), tuple.size()); + + Object object; + for (size_t i = 0; i < names.size(); ++i) + object[names[i]] = tuple[i]; + + return object; + } + + if (src.getType() == Field::Types::Map) + { + Object object; + const auto & map = src.get(); + for (size_t i = 0; i < map.size(); ++i) + { + const auto & map_entry = map[i].get(); + const auto & key = map_entry[0]; + const auto & value = map_entry[1]; + + if (key.getType() != Field::Types::String) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Cannot convert from Map with key of type {} to Object", key.getTypeName()); + + object[key.get()] = value; + } + + return object; + } + } /// Conversion from string by parsing. if (src.getType() == Field::Types::String) diff --git a/src/Storages/MergeTree/MergeTreePartition.cpp b/src/Storages/MergeTree/MergeTreePartition.cpp index 0d457971dc6..1902c4fc180 100644 --- a/src/Storages/MergeTree/MergeTreePartition.cpp +++ b/src/Storages/MergeTree/MergeTreePartition.cpp @@ -133,6 +133,18 @@ namespace for (const auto & elem : x) applyVisitor(*this, elem); } + void operator() (const Object & x) const + { + UInt8 type = Field::Types::Object; + hash.update(type); + hash.update(x.size()); + + for (const auto & [key, value]: x) + { + hash.update(key); + applyVisitor(*this, value); + } + } void operator() (const DecimalField & x) const { UInt8 type = Field::Types::Decimal32; diff --git a/tests/queries/0_stateless/01825_type_json_4.reference b/tests/queries/0_stateless/01825_type_json_4.reference index 8c5510d8d5b..8bef8c02ee5 100644 --- a/tests/queries/0_stateless/01825_type_json_4.reference +++ b/tests/queries/0_stateless/01825_type_json_4.reference @@ -1,4 +1,4 @@ -Code: 594 +Code: 598 Code: 15 Code: 53 1 ('v1') Tuple(k1 String) diff --git a/tests/queries/0_stateless/01825_type_json_4.sh b/tests/queries/0_stateless/01825_type_json_4.sh index 711e86f474f..5d85e59cd5f 100755 --- a/tests/queries/0_stateless/01825_type_json_4.sh +++ b/tests/queries/0_stateless/01825_type_json_4.sh @@ -10,7 +10,7 @@ $CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_4(id UInt64, data JSON) \ ENGINE = MergeTree ORDER BY tuple()" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [1, 2]}}' \ - | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 594" + | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 598" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [{"k2" : 1}, {"k2" : 2}]}}' \ | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 15" diff --git a/tests/queries/0_stateless/01825_type_json_field.reference b/tests/queries/0_stateless/01825_type_json_field.reference new file mode 100644 index 00000000000..cabaf04d7ad --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_field.reference @@ -0,0 +1,12 @@ +1 10 a +Tuple(a UInt32, s String) +1 10 a 0 +2 sss b 300 +3 20 c 0 +Tuple(a String, b UInt64, s String) +1 10 a 0 +2 sss b 300 +3 20 c 0 +4 30 400 +5 0 qqq 0 foo +Tuple(a String, b UInt64, s String, t String) diff --git a/tests/queries/0_stateless/01825_type_json_field.sql b/tests/queries/0_stateless/01825_type_json_field.sql new file mode 100644 index 00000000000..b1e00b3ee96 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_field.sql @@ -0,0 +1,24 @@ +DROP TABLE IF EXISTS t_json_field; + +CREATE TABLE t_json_field (id UInt32, data JSON) +ENGINE = MergeTree ORDER BY tuple(); + +INSERT INTO t_json_field VALUES (1, (10, 'a')::Tuple(a UInt32, s String)); + +SELECT id, data.a, data.s FROM t_json_field ORDER BY id; +SELECT DISTINCT toTypeName(data) FROM t_json_field; + +INSERT INTO t_json_field VALUES (2, ('sss', 300, 'b')::Tuple(a String, b UInt64, s String)), (3, (20, 'c')::Tuple(a UInt32, s String)); + +SELECT id, data.a, data.s, data.b FROM t_json_field ORDER BY id; +SELECT DISTINCT toTypeName(data) FROM t_json_field; + +INSERT INTO t_json_field VALUES (4, map('a', 30, 'b', 400)), (5, map('s', 'qqq', 't', 'foo')); + +SELECT id, data.a, data.s, data.b, data.t FROM t_json_field ORDER BY id; +SELECT DISTINCT toTypeName(data) FROM t_json_field; + +INSERT INTO t_json_field VALUES (6, map(1, 2, 3, 4)); -- { clientError 53 } +INSERT INTO t_json_field VALUES (6, (1, 2, 3)); -- { clientError 53 } + +DROP TABLE t_json_field; From b05943f4a460f394a86871c7f1f39ee32b75064b Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 21 Aug 2021 03:31:44 +0300 Subject: [PATCH 040/132] add text serialization for type Object --- src/DataTypes/ObjectUtils.cpp | 2 +- .../Serializations/SerializationObject.cpp | 51 +++++++++++++++---- .../Serializations/SerializationObject.h | 4 +- src/Functions/FunctionsConversion.h | 5 +- .../0_stateless/01825_type_json_5.reference | 5 ++ .../queries/0_stateless/01825_type_json_5.sql | 19 +++++++ 6 files changed, 72 insertions(+), 14 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_5.reference create mode 100644 tests/queries/0_stateless/01825_type_json_5.sql diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 21b60f25707..7352dda256a 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -121,7 +121,7 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con if (!column_object.isFinalized()) throw Exception(ErrorCodes::LOGICAL_ERROR, - "Cannot convert to tuple column '{}' from type {}. Column should be finalized firts", + "Cannot convert to tuple column '{}' from type {}. Column should be finalized first", name_type.name, name_type.type->getName()); std::vector> tuple_elements; diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 6277f58bef9..1326a7b56e8 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -156,7 +156,7 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( settings.path.back() = Substream::ObjectStructure; settings.path.back().object_key_name = key; - auto type = getDataTypeByColumn(subcolumn.getFinalizedColumn()); + const auto & type = subcolumn.getLeastCommonType(); if (auto * stream = settings.getter(settings.path)) { writeStringBinary(key, *stream); @@ -264,34 +264,63 @@ void SerializationObject::deserializeBinary(IColumn &, ReadBuffer &) con throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); } +/// TODO: use format different of JSON in serializations. + template -void SerializationObject::serializeText(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const +void SerializationObject::serializeTextImpl(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const { - throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); + const auto & column_object = assert_cast(column); + const auto & subcolumns = column_object.getSubcolumns(); + + writeChar('{', ostr); + for (auto it = subcolumns.begin(); it != subcolumns.end(); ++it) + { + if (it != subcolumns.begin()) + writeCString(",", ostr); + + writeDoubleQuoted(it->first, ostr); + writeChar(':', ostr); + + auto serialization = it->second.getLeastCommonType()->getDefaultSerialization(); + serialization->serializeTextJSON(it->second.getFinalizedColumn(), row_num, ostr, settings); + } + writeChar('}', ostr); } template -void SerializationObject::serializeTextEscaped(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const +void SerializationObject::serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const { - throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); + serializeTextImpl(column, row_num, ostr, settings); } template -void SerializationObject::serializeTextQuoted(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const +void SerializationObject::serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const { - throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); + WriteBufferFromOwnString ostr_str; + serializeTextImpl(column, row_num, ostr_str, settings); + writeEscapedString(ostr_str.str(), ostr); } template -void SerializationObject::serializeTextJSON(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const +void SerializationObject::serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const { - throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); + WriteBufferFromOwnString ostr_str; + serializeTextImpl(column, row_num, ostr_str, settings); + writeQuotedString(ostr_str.str(), ostr); } template -void SerializationObject::serializeTextCSV(const IColumn &, size_t, WriteBuffer &, const FormatSettings &) const +void SerializationObject::serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const { - throw Exception(ErrorCodes::NOT_IMPLEMENTED, "Not implemented for SerializationObject"); + serializeTextImpl(column, row_num, ostr, settings); +} + +template +void SerializationObject::serializeTextCSV(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const +{ + WriteBufferFromOwnString ostr_str; + serializeTextImpl(column, row_num, ostr_str, settings); + writeCSVString(ostr_str.str(), ostr); } SerializationPtr getObjectSerialization(const String & schema_format) diff --git a/src/DataTypes/Serializations/SerializationObject.h b/src/DataTypes/Serializations/SerializationObject.h index eba013b1664..da490e6f461 100644 --- a/src/DataTypes/Serializations/SerializationObject.h +++ b/src/DataTypes/Serializations/SerializationObject.h @@ -40,7 +40,7 @@ public: void serializeBinary(const IColumn & column, size_t row_num, WriteBuffer & ostr) const override; void deserializeBinary(IColumn & column, ReadBuffer & istr) const override; - void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings &) const override; + void serializeText(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override; void serializeTextEscaped(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override; void serializeTextQuoted(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override; void serializeTextJSON(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const override; @@ -59,6 +59,8 @@ private: template void deserializeTextImpl(IColumn & column, Reader && reader) const; + void serializeTextImpl(const IColumn & column, size_t row_num, WriteBuffer & ostr, const FormatSettings & settings) const; + mutable Parser parser; }; diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index 79e0426d1db..5134e7a61ea 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -3044,7 +3044,10 @@ private: { return [] (ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const ColumnNullable *, size_t /*input_rows_count*/) { - return ConvertImplGenericFromString::execute(arguments, result_type); + auto res = ConvertImplGenericFromString::execute(arguments, result_type); + auto & res_object = assert_cast(res->assumeMutableRef()); + res_object.finalize(); + return res; }; } diff --git a/tests/queries/0_stateless/01825_type_json_5.reference b/tests/queries/0_stateless/01825_type_json_5.reference new file mode 100644 index 00000000000..8abbbe74968 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_5.reference @@ -0,0 +1,5 @@ +{"a.c":2,"a.b":1} +{"s":{"a.c":2,"a.b":1}} +1 [22,33] +2 qqq [44] +Tuple(k1 Int8, `k2.k3` String, `k2.k4` Array(Int8)) diff --git a/tests/queries/0_stateless/01825_type_json_5.sql b/tests/queries/0_stateless/01825_type_json_5.sql new file mode 100644 index 00000000000..7d9498e454b --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_5.sql @@ -0,0 +1,19 @@ +SELECT '{"a": {"b": 1, "c": 2}}'::JSON AS s; +SELECT '{"a": {"b": 1, "c": 2}}'::JSON AS s format JSONEachRow; + +DROP TABLE IF EXISTS t_json_5; +DROP TABLE IF EXISTS t_json_str_5; + +CREATE TABLE t_json_str_5 (data String) ENGINE = MergeTree ORDER BY tuple(); +CREATE TABLE t_json_5 (data JSON) ENGINE = MergeTree ORDER BY tuple(); + +INSERT INTO t_json_str_5 FORMAT JSONAsString {"k1": 1, "k2": {"k4": [22, 33]}}, {"k1": 2, "k2": {"k3": "qqq", "k4": [44]}} +; + +INSERT INTO t_json_5 SELECT data FROM t_json_str_5; + +SELECT data.k1, data.k2.k3, data.k2.k4 FROM t_json_5 ORDER BY data.k1; +SELECT DISTINCT toTypeName(data) FROM t_json_5; + +DROP TABLE t_json_5; +DROP TABLE t_json_str_5; From ee9f85686b66f6a7984ca8556d137bd571610b16 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 9 Sep 2021 14:27:10 +0300 Subject: [PATCH 041/132] fix build --- src/Core/Field.h | 4 --- src/Storages/MergeTree/MergeTreeData.cpp | 32 +++++++++++++++++++++++- src/Storages/StorageExecutable.cpp | 4 +-- src/Storages/StorageExecutable.h | 2 +- 4 files changed, 34 insertions(+), 8 deletions(-) diff --git a/src/Core/Field.h b/src/Core/Field.h index a139316e3fd..45abb10f3b9 100644 --- a/src/Core/Field.h +++ b/src/Core/Field.h @@ -297,10 +297,6 @@ public: Map = 26, UUID = 27, Object = 28, - - // Special types for index analysis - NegativeInfinity = 254, - PositiveInfinity = 255, }; static const char * toString(Which which) diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index 11b52a8bd27..28185a44512 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -4515,7 +4515,37 @@ bool MergeTreeData::getQueryProcessingStageWithAggregateProjection( } // Let's select the best projection to execute the query. - if (!candidates.empty() && !selected_candidate)src/Storages/StorageS3.cpp + if (!candidates.empty() && !selected_candidate) + { + std::shared_ptr max_added_blocks; + if (settings.select_sequential_consistency) + { + if (const StorageReplicatedMergeTree * replicated = dynamic_cast(this)) + max_added_blocks = std::make_shared(replicated->getMaxAddedBlocks()); + } + + auto parts = getDataPartsVector(); + MergeTreeDataSelectExecutor reader(*this); + query_info.merge_tree_select_result_ptr = reader.estimateNumMarksToRead( + parts, + analysis_result.required_columns, + metadata_snapshot, + metadata_snapshot, + query_info, + query_context, + settings.max_threads, + max_added_blocks); + + if (!query_info.merge_tree_select_result_ptr->error()) + { + // Add 1 to base sum_marks so that we prefer projections even when they have equal number of marks to read. + // NOTE: It is not clear if we need it. E.g. projections do not support skip index for now. + min_sum_marks = query_info.merge_tree_select_result_ptr->marks() + 1; + } + + /// Favor aggregate projections + for (auto & candidate : candidates) + { if (candidate.desc->type == ProjectionDescription::Type::Aggregate) { selectBestProjection( diff --git a/src/Storages/StorageExecutable.cpp b/src/Storages/StorageExecutable.cpp index 4b0aaf6caea..86479f8242a 100644 --- a/src/Storages/StorageExecutable.cpp +++ b/src/Storages/StorageExecutable.cpp @@ -77,7 +77,7 @@ StorageExecutable::StorageExecutable( Pipe StorageExecutable::read( const Names & /*column_names*/, - const StorageMetadataPtr & metadata_snapshot, + const StorageSnapshotPtr & storage_snapshot, SelectQueryInfo & /*query_info*/, ContextPtr context, QueryProcessingStage::Enum /*processed_stage*/, @@ -172,7 +172,7 @@ Pipe StorageExecutable::read( tasks.emplace_back(std::move(task)); } - auto sample_block = metadata_snapshot->getSampleBlock(); + auto sample_block = storage_snapshot->metadata->getSampleBlock(); ShellCommandSourceConfiguration configuration; configuration.max_block_size = max_block_size; diff --git a/src/Storages/StorageExecutable.h b/src/Storages/StorageExecutable.h index dd986ee3956..4974f845c14 100644 --- a/src/Storages/StorageExecutable.h +++ b/src/Storages/StorageExecutable.h @@ -31,7 +31,7 @@ public: Pipe read( const Names & column_names, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & query_info, ContextPtr context, QueryProcessingStage::Enum processed_stage, From 3ff89a4e292419fb06028ccf3f73678c44168f66 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 9 Sep 2021 14:31:21 +0300 Subject: [PATCH 042/132] fix tests --- tests/queries/0_stateless/01825_type_json_4.reference | 2 +- tests/queries/0_stateless/01825_type_json_4.sh | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/queries/0_stateless/01825_type_json_4.reference b/tests/queries/0_stateless/01825_type_json_4.reference index 8bef8c02ee5..37a2413598f 100644 --- a/tests/queries/0_stateless/01825_type_json_4.reference +++ b/tests/queries/0_stateless/01825_type_json_4.reference @@ -1,4 +1,4 @@ -Code: 598 +Code: 619 Code: 15 Code: 53 1 ('v1') Tuple(k1 String) diff --git a/tests/queries/0_stateless/01825_type_json_4.sh b/tests/queries/0_stateless/01825_type_json_4.sh index 5d85e59cd5f..bb563820e6d 100755 --- a/tests/queries/0_stateless/01825_type_json_4.sh +++ b/tests/queries/0_stateless/01825_type_json_4.sh @@ -10,7 +10,7 @@ $CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_4(id UInt64, data JSON) \ ENGINE = MergeTree ORDER BY tuple()" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [1, 2]}}' \ - | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 598" + | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 619" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [{"k2" : 1}, {"k2" : 2}]}}' \ | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 15" From 71bf39c69c8c2fa5f19489cfe224b4c980ea89e3 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 9 Sep 2021 21:17:54 +0300 Subject: [PATCH 043/132] fix tests --- src/Storages/StorageSnapshot.cpp | 6 ++++-- tests/queries/0_stateless/01825_type_json_field.reference | 6 +++--- 2 files changed, 7 insertions(+), 5 deletions(-) diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp index e1fad3432a2..d452f3d9137 100644 --- a/src/Storages/StorageSnapshot.cpp +++ b/src/Storages/StorageSnapshot.cpp @@ -96,11 +96,13 @@ Block StorageSnapshot::getSampleBlockForColumns(const Names & column_names) cons for (const auto & name : column_names) { auto column = columns.tryGetColumnOrSubcolumn(GetColumnsOptions::All, name); - if (column && !isObject(column->type)) + auto object_column = object_columns.tryGetColumnOrSubcolumn(GetColumnsOptions::All, name); + + if (column && !object_column) { res.insert({column->type->createColumn(), column->type, column->name}); } - else if (auto object_column = object_columns.tryGetColumnOrSubcolumn(GetColumnsOptions::All, name)) + else if (object_column) { res.insert({object_column->type->createColumn(), object_column->type, object_column->name}); } diff --git a/tests/queries/0_stateless/01825_type_json_field.reference b/tests/queries/0_stateless/01825_type_json_field.reference index cabaf04d7ad..b5637b1fbb7 100644 --- a/tests/queries/0_stateless/01825_type_json_field.reference +++ b/tests/queries/0_stateless/01825_type_json_field.reference @@ -1,12 +1,12 @@ 1 10 a -Tuple(a UInt32, s String) +Tuple(a UInt8, s String) 1 10 a 0 2 sss b 300 3 20 c 0 -Tuple(a String, b UInt64, s String) +Tuple(a String, b UInt16, s String) 1 10 a 0 2 sss b 300 3 20 c 0 4 30 400 5 0 qqq 0 foo -Tuple(a String, b UInt64, s String, t String) +Tuple(a String, b UInt16, s String, t String) From ee7c0d4cc1eec5fadf9a081db4110053b6d71c27 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 10 Sep 2021 00:16:57 +0300 Subject: [PATCH 044/132] dynamic columns: fix several cases of parsing json --- src/DataTypes/Serializations/JSONDataParser.h | 9 +- src/Formats/registerFormats.cpp | 2 + src/IO/ReadHelpers.cpp | 24 +++- .../Impl/JSONAsObjectRowInputFormat.cpp | 84 ------------ .../Impl/JSONAsStringRowInputFormat.cpp | 125 ++++++++++++------ .../Formats/Impl/JSONAsStringRowInputFormat.h | 32 ++++- 6 files changed, 134 insertions(+), 142 deletions(-) delete mode 100644 src/Processors/Formats/Impl/JSONAsObjectRowInputFormat.cpp diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index ecf0107b255..c5d6bdd2826 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -12,11 +12,8 @@ namespace ErrorCodes extern const int LOGICAL_ERROR; } -namespace -{ - template -Field getValueAsField(const Element & element) +static Field getValueAsField(const Element & element) { if (element.isBool()) return element.getBool(); if (element.isInt64()) return element.getInt64(); @@ -28,7 +25,7 @@ Field getValueAsField(const Element & element) throw Exception(ErrorCodes::LOGICAL_ERROR, "Unsupported type of JSON field"); } -String getNextPath(const String & current_path, const std::string_view & key) +static String getNextPath(const String & current_path, const std::string_view & key) { String next_path = current_path; if (!key.empty()) @@ -41,8 +38,6 @@ String getNextPath(const String & current_path, const std::string_view & key) return next_path; } -} - struct ParseResult { Strings paths; diff --git a/src/Formats/registerFormats.cpp b/src/Formats/registerFormats.cpp index 1ed5d558ef6..5a955aeccd5 100644 --- a/src/Formats/registerFormats.cpp +++ b/src/Formats/registerFormats.cpp @@ -84,6 +84,7 @@ void registerInputFormatProcessorCapnProto(FormatFactory & factory); /// Non trivial prefix and suffix checkers for disabling parallel parsing. void registerNonTrivialPrefixAndSuffixCheckerJSONEachRow(FormatFactory & factory); void registerNonTrivialPrefixAndSuffixCheckerJSONAsString(FormatFactory & factory); +void registerNonTrivialPrefixAndSuffixCheckerJSONAsObject(FormatFactory & factory); void registerFormats() { @@ -163,6 +164,7 @@ void registerFormats() registerNonTrivialPrefixAndSuffixCheckerJSONEachRow(factory); registerNonTrivialPrefixAndSuffixCheckerJSONAsString(factory); + registerNonTrivialPrefixAndSuffixCheckerJSONAsObject(factory); } } diff --git a/src/IO/ReadHelpers.cpp b/src/IO/ReadHelpers.cpp index 9bbd87629b6..cd3435f1801 100644 --- a/src/IO/ReadHelpers.cpp +++ b/src/IO/ReadHelpers.cpp @@ -771,28 +771,38 @@ ReturnType readJSONObjectPossiblyInvalid(Vector & s, ReadBuffer & buf) s.push_back(*buf.position()); ++buf.position(); + Int64 balance = 1; + bool quotes = false; + while (!buf.eof()) { - char * next_pos = find_first_symbols<'\\', '{', '}'>(buf.position(), buf.buffer().end()); + char * next_pos = find_first_symbols<'\\', '{', '}', '"'>(buf.position(), buf.buffer().end()); appendToStringOrVector(s, buf, next_pos); buf.position() = next_pos; if (!buf.hasPendingData()) continue; + s.push_back(*buf.position()); + if (*buf.position() == '\\') { - parseJSONEscapeSequence(s, buf); + ++buf.position(); + if (!buf.eof()) + { + s.push_back(*buf.position()); + ++buf.position(); + } + continue; } - if (*buf.position() == '}') - --balance; - else if (*buf.position() == '{') - ++balance; + if (*buf.position() == '"') + quotes = !quotes; + else if (!quotes) // can be only '{' or '}' + balance += *buf.position() == '{' ? 1 : -1; - s.push_back(*buf.position()); ++buf.position(); if (balance == 0) diff --git a/src/Processors/Formats/Impl/JSONAsObjectRowInputFormat.cpp b/src/Processors/Formats/Impl/JSONAsObjectRowInputFormat.cpp deleted file mode 100644 index 48550c50329..00000000000 --- a/src/Processors/Formats/Impl/JSONAsObjectRowInputFormat.cpp +++ /dev/null @@ -1,84 +0,0 @@ -#include -#include -#include -#include -#include -#include - -namespace DB -{ - -namespace ErrorCodes -{ - extern const int BAD_ARGUMENTS; -} - -namespace -{ - -class JSONAsObjectRowInputFormat : public IRowInputFormat -{ -public: - JSONAsObjectRowInputFormat(ReadBuffer & in_, const Block & header_, Params params_, const FormatSettings & format_settings_); - - bool readRow(MutableColumns & columns, RowReadExtension & ext) override; - String getName() const override { return "JSONAsObjectRowInputFormat"; } - -private: - const FormatSettings format_settings; -}; - -JSONAsObjectRowInputFormat::JSONAsObjectRowInputFormat( - ReadBuffer & in_, const Block & header_, Params params_, const FormatSettings & format_settings_) - : IRowInputFormat(header_, in_, std::move(params_)) - , format_settings(format_settings_) -{ - if (header_.columns() != 1) - throw Exception(ErrorCodes::BAD_ARGUMENTS, - "Input format JSONAsObject is only suitable for tables with a single column of type Object but the number of columns is {}", - header_.columns()); - - if (!isObject(header_.getByPosition(0).type)) - throw Exception(ErrorCodes::BAD_ARGUMENTS, - "Input format JSONAsObject is only suitable for tables with a single column of type Object but the column type is {}", - header_.getByPosition(0).type->getName()); -} - - -bool JSONAsObjectRowInputFormat::readRow(MutableColumns & columns, RowReadExtension &) -{ - assert(serializations.size() == 1); - assert(columns.size() == 1); - - skipWhitespaceIfAny(in); - if (!in.eof()) - serializations[0]->deserializeTextJSON(*columns[0], in, format_settings); - - skipWhitespaceIfAny(in); - if (!in.eof() && *in.position() == ',') - ++in.position(); - skipWhitespaceIfAny(in); - - return !in.eof(); -} - -} - -void registerInputFormatProcessorJSONAsObject(FormatFactory & factory) -{ - factory.registerInputFormatProcessor("JSONAsObject", []( - ReadBuffer & buf, - const Block & sample, - IRowInputFormat::Params params, - const FormatSettings & settings) - { - return std::make_shared(buf, sample, std::move(params), settings); - }); -} - -void registerFileSegmentationEngineJSONAsObject(FormatFactory & factory) -{ - factory.registerFileSegmentationEngine("JSONAsObject", &fileSegmentationEngineJSONEachRowImpl); -} - -} diff --git a/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.cpp b/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.cpp index e968c187bef..6e3396dd48a 100644 --- a/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.cpp +++ b/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.cpp @@ -14,27 +14,23 @@ namespace ErrorCodes extern const int INCORRECT_DATA; } -JSONAsStringRowInputFormat::JSONAsStringRowInputFormat(const Block & header_, ReadBuffer & in_, Params params_) : - IRowInputFormat(header_, in_, std::move(params_)), buf(in) +JSONAsRowInputFormat::JSONAsRowInputFormat( + const Block & header_, ReadBuffer & in_, Params params_) + : IRowInputFormat(header_, in_, std::move(params_)), buf(in) { if (header_.columns() > 1) throw Exception(ErrorCodes::BAD_ARGUMENTS, - "This input format is only suitable for tables with a single column of type String but the number of columns is {}", + "This input format is only suitable for tables with a single column of type String or Object, but the number of columns is {}", header_.columns()); - - if (!isString(removeNullable(removeLowCardinality(header_.getByPosition(0).type)))) - throw Exception(ErrorCodes::BAD_ARGUMENTS, - "This input format is only suitable for tables with a single column of type String but the column type is {}", - header_.getByPosition(0).type->getName()); } -void JSONAsStringRowInputFormat::resetParser() +void JSONAsRowInputFormat::resetParser() { IRowInputFormat::resetParser(); buf.reset(); } -void JSONAsStringRowInputFormat::readPrefix() +void JSONAsRowInputFormat::readPrefix() { /// In this format, BOM at beginning of stream cannot be confused with value, so it is safe to skip it. skipBOMIfExists(buf); @@ -47,7 +43,7 @@ void JSONAsStringRowInputFormat::readPrefix() } } -void JSONAsStringRowInputFormat::readSuffix() +void JSONAsRowInputFormat::readSuffix() { skipWhitespaceIfAny(buf); if (data_in_square_brackets) @@ -63,6 +59,51 @@ void JSONAsStringRowInputFormat::readSuffix() assertEOF(buf); } +bool JSONAsRowInputFormat::readRow(MutableColumns & columns, RowReadExtension &) +{ + assert(columns.size() == 1); + assert(serializations.size() == 1); + + if (!allow_new_rows) + return false; + + skipWhitespaceIfAny(buf); + if (!buf.eof()) + { + if (!data_in_square_brackets && *buf.position() == ';') + { + /// ';' means the end of query, but it cannot be before ']'. + return allow_new_rows = false; + } + else if (data_in_square_brackets && *buf.position() == ']') + { + /// ']' means the end of query. + return allow_new_rows = false; + } + } + + if (!buf.eof()) + readJSONObject(*columns[0]); + + skipWhitespaceIfAny(buf); + if (!buf.eof() && *buf.position() == ',') + ++buf.position(); + skipWhitespaceIfAny(buf); + + return !buf.eof(); +} + + +JSONAsStringRowInputFormat::JSONAsStringRowInputFormat( + const Block & header_, ReadBuffer & in_, Params params_) + : JSONAsRowInputFormat(header_, in_, params_) +{ + if (!isString(removeNullable(removeLowCardinality(header_.getByPosition(0).type)))) + throw Exception(ErrorCodes::BAD_ARGUMENTS, + "This input format is only suitable for tables with a single column of type String but the column type is {}", + header_.getByPosition(0).type->getName()); +} + void JSONAsStringRowInputFormat::readJSONObject(IColumn & column) { PeekableReadBufferCheckpoint checkpoint{buf}; @@ -140,35 +181,21 @@ void JSONAsStringRowInputFormat::readJSONObject(IColumn & column) buf.position() = end; } -bool JSONAsStringRowInputFormat::readRow(MutableColumns & columns, RowReadExtension &) + +JSONAsObjectRowInputFormat::JSONAsObjectRowInputFormat( + const Block & header_, ReadBuffer & in_, Params params_, const FormatSettings & format_settings_) + : JSONAsRowInputFormat(header_, in_, params_) + , format_settings(format_settings_) { - if (!allow_new_rows) - return false; + if (!isObject(header_.getByPosition(0).type)) + throw Exception(ErrorCodes::BAD_ARGUMENTS, + "Input format JSONAsObject is only suitable for tables with a single column of type Object but the column type is {}", + header_.getByPosition(0).type->getName()); +} - skipWhitespaceIfAny(buf); - if (!buf.eof()) - { - if (!data_in_square_brackets && *buf.position() == ';') - { - /// ';' means the end of query, but it cannot be before ']'. - return allow_new_rows = false; - } - else if (data_in_square_brackets && *buf.position() == ']') - { - /// ']' means the end of query. - return allow_new_rows = false; - } - } - - if (!buf.eof()) - readJSONObject(*columns[0]); - - skipWhitespaceIfAny(buf); - if (!buf.eof() && *buf.position() == ',') - ++buf.position(); - skipWhitespaceIfAny(buf); - - return !buf.eof(); +void JSONAsObjectRowInputFormat::readJSONObject(IColumn & column) +{ + serializations[0]->deserializeTextJSON(column, buf, format_settings); } void registerInputFormatProcessorJSONAsString(FormatFactory & factory) @@ -193,4 +220,26 @@ void registerNonTrivialPrefixAndSuffixCheckerJSONAsString(FormatFactory & factor factory.registerNonTrivialPrefixAndSuffixChecker("JSONAsString", nonTrivialPrefixAndSuffixCheckerJSONEachRowImpl); } +void registerInputFormatProcessorJSONAsObject(FormatFactory & factory) +{ + factory.registerInputFormatProcessor("JSONAsObject", []( + ReadBuffer & buf, + const Block & sample, + IRowInputFormat::Params params, + const FormatSettings & settings) + { + return std::make_shared(sample, buf, std::move(params), settings); + }); +} + +void registerFileSegmentationEngineJSONAsObject(FormatFactory & factory) +{ + factory.registerFileSegmentationEngine("JSONAsObject", &fileSegmentationEngineJSONEachRowImpl); +} + +void registerNonTrivialPrefixAndSuffixCheckerJSONAsObject(FormatFactory & factory) +{ + factory.registerNonTrivialPrefixAndSuffixChecker("JSONAsObject", nonTrivialPrefixAndSuffixCheckerJSONEachRowImpl); +} + } diff --git a/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.h b/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.h index c70d9efb178..2efa16cde69 100644 --- a/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.h +++ b/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.h @@ -13,26 +13,46 @@ class ReadBuffer; /// Each JSON object is parsed as a whole to string. /// This format can only parse a table with single field of type String. -class JSONAsStringRowInputFormat : public IRowInputFormat +class JSONAsRowInputFormat : public IRowInputFormat { public: - JSONAsStringRowInputFormat(const Block & header_, ReadBuffer & in_, Params params_); + JSONAsRowInputFormat(const Block & header_, ReadBuffer & in_, Params params_); bool readRow(MutableColumns & columns, RowReadExtension & ext) override; - String getName() const override { return "JSONAsStringRowInputFormat"; } void resetParser() override; void readPrefix() override; void readSuffix() override; -private: - void readJSONObject(IColumn & column); - +protected: + virtual void readJSONObject(IColumn & column) = 0; PeekableReadBuffer buf; +private: /// This flag is needed to know if data is in square brackets. bool data_in_square_brackets = false; bool allow_new_rows = true; }; +class JSONAsStringRowInputFormat final : public JSONAsRowInputFormat +{ +public: + JSONAsStringRowInputFormat(const Block & header_, ReadBuffer & in_, Params params_); + String getName() const override { return "JSONAsStringRowInputFormat"; } + +private: + void readJSONObject(IColumn & column) override; +}; + +class JSONAsObjectRowInputFormat final : public JSONAsRowInputFormat +{ +public: + JSONAsObjectRowInputFormat(const Block & header_, ReadBuffer & in_, Params params_, const FormatSettings & format_settings_); + String getName() const override { return "JSONAsObjectRowInputFormat"; } + +private: + void readJSONObject(IColumn & column) override; + const FormatSettings format_settings; +}; + } From 3bd96d709d944378dbe9a82cb0334c450059e76f Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 11 Sep 2021 03:20:54 +0300 Subject: [PATCH 045/132] dynamic columns: fix several cases of parsing json --- src/Columns/ColumnObject.cpp | 58 ++++++++++++++----- ....reference => 01825_type_json_1.reference} | 0 ...25_type_json.sql => 01825_type_json_1.sql} | 0 .../0_stateless/01825_type_json_6.reference | 3 + .../queries/0_stateless/01825_type_json_6.sh | 56 ++++++++++++++++++ 5 files changed, 103 insertions(+), 14 deletions(-) rename tests/queries/0_stateless/{01825_type_json.reference => 01825_type_json_1.reference} (100%) rename tests/queries/0_stateless/{01825_type_json.sql => 01825_type_json_1.sql} (100%) create mode 100644 tests/queries/0_stateless/01825_type_json_6.reference create mode 100755 tests/queries/0_stateless/01825_type_json_6.sh diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 6b5610ce7d1..0953e1ec538 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -13,7 +13,6 @@ #include #include - namespace DB { @@ -28,25 +27,45 @@ namespace ErrorCodes namespace { +Array createEmptyArrayField(size_t num_dimensions) +{ + Array array; + Array * current_array = &array; + for (size_t i = 1; i < num_dimensions; ++i) + { + current_array->push_back(Array()); + current_array = ¤t_array->back().get(); + } + + return array; +} + class FieldVisitorReplaceNull : public StaticVisitor { public: - [[maybe_unused]] explicit FieldVisitorReplaceNull(const Field & replacement_) + [[maybe_unused]] explicit FieldVisitorReplaceNull( + const Field & replacement_, size_t num_dimensions_) : replacement(replacement_) + , num_dimensions(num_dimensions_) { } - Field operator()(const Null &) const { return replacement; } - template Field operator()(const T & x) const { - if constexpr (std::is_base_of_v) + if constexpr (std::is_same_v) { + return num_dimensions + ? createEmptyArrayField(num_dimensions) + : replacement; + } + else if constexpr (std::is_same_v) + { + assert(num_dimensions > 0); const size_t size = x.size(); - T res(size); + Array res(size); for (size_t i = 0; i < size; ++i) - res[i] = applyVisitor(*this, x[i]); + res[i] = applyVisitor(FieldVisitorReplaceNull(replacement, num_dimensions - 1), x[i]); return res; } else @@ -54,7 +73,8 @@ public: } private: - Field replacement; + const Field & replacement; + size_t num_dimensions; }; class FieldVisitorToNumberOfDimensions : public StaticVisitor @@ -66,16 +86,24 @@ public: return 1; const size_t size = x.size(); - size_t dimensions = applyVisitor(*this, x[0]); - for (size_t i = 1; i < size; ++i) + std::optional dimensions; + + for (size_t i = 0; i < size; ++i) { + /// Do not count Nulls, because they will be replaced by default + /// values with proper number of dimensions. + if (x[i].isNull()) + continue; + size_t current_dimensions = applyVisitor(*this, x[i]); - if (current_dimensions != dimensions) + if (!dimensions) + dimensions = current_dimensions; + else if (current_dimensions != *dimensions) throw Exception(ErrorCodes::NUMBER_OF_DIMENSIONS_MISMATHED, "Number of dimensions mismatched among array elements"); } - return 1 + dimensions; + return 1 + dimensions.value_or(0); } template @@ -239,6 +267,7 @@ void ColumnObject::Subcolumn::insert(Field field) if (is_nullable && !base_type->isNullable()) base_type = makeNullable(base_type); + auto value_type = createArrayOfType(base_type, value_dim); if (!is_nullable && base_type->isNullable()) { base_type = removeNullable(base_type); @@ -248,10 +277,11 @@ void ColumnObject::Subcolumn::insert(Field field) return; } - field = applyVisitor(FieldVisitorReplaceNull(base_type->getDefault()), std::move(field)); + value_type = createArrayOfType(base_type, value_dim); + auto default_value = value_type->getDefault(); + field = applyVisitor(FieldVisitorReplaceNull(default_value, value_dim), std::move(field)); } - auto value_type = createArrayOfType(base_type, value_dim); bool type_changed = false; if (data.empty()) diff --git a/tests/queries/0_stateless/01825_type_json.reference b/tests/queries/0_stateless/01825_type_json_1.reference similarity index 100% rename from tests/queries/0_stateless/01825_type_json.reference rename to tests/queries/0_stateless/01825_type_json_1.reference diff --git a/tests/queries/0_stateless/01825_type_json.sql b/tests/queries/0_stateless/01825_type_json_1.sql similarity index 100% rename from tests/queries/0_stateless/01825_type_json.sql rename to tests/queries/0_stateless/01825_type_json_1.sql diff --git a/tests/queries/0_stateless/01825_type_json_6.reference b/tests/queries/0_stateless/01825_type_json_6.reference new file mode 100644 index 00000000000..2efc2031545 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_6.reference @@ -0,0 +1,3 @@ +Tuple(key String, `out.outputs.index` Array(Array(Int32)), `out.outputs.n` Array(Array(Int8)), `out.type` Array(Int8), `out.value` Array(Int8)) +v1 [0,0] [1,2] [[],[1960131]] [[],[1960131]] +v2 [1,1] [4,3] [[1881212],[]] [[1881212],[]] diff --git a/tests/queries/0_stateless/01825_type_json_6.sh b/tests/queries/0_stateless/01825_type_json_6.sh new file mode 100755 index 00000000000..5ab0b77ab6b --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_6.sh @@ -0,0 +1,56 @@ +#!/usr/bin/env bash + +CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +# shellcheck source=../shell_config.sh +. "$CURDIR"/../shell_config.sh + +$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_6;" + +$CLICKHOUSE_CLIENT -q"CREATE TABLE t_json_6 (data JSON) ENGINE = MergeTree ORDER BY tuple();" + +cat < Date: Sat, 11 Sep 2021 03:25:28 +0300 Subject: [PATCH 046/132] fix test --- tests/queries/0_stateless/01825_type_json_6.reference | 4 ++-- tests/queries/0_stateless/01825_type_json_6.sh | 4 ++-- 2 files changed, 4 insertions(+), 4 deletions(-) diff --git a/tests/queries/0_stateless/01825_type_json_6.reference b/tests/queries/0_stateless/01825_type_json_6.reference index 2efc2031545..d3229d48632 100644 --- a/tests/queries/0_stateless/01825_type_json_6.reference +++ b/tests/queries/0_stateless/01825_type_json_6.reference @@ -1,3 +1,3 @@ Tuple(key String, `out.outputs.index` Array(Array(Int32)), `out.outputs.n` Array(Array(Int8)), `out.type` Array(Int8), `out.value` Array(Int8)) -v1 [0,0] [1,2] [[],[1960131]] [[],[1960131]] -v2 [1,1] [4,3] [[1881212],[]] [[1881212],[]] +v1 [0,0] [1,2] [[],[1960131]] [[],[0]] +v2 [1,1] [4,3] [[1881212],[]] [[1],[]] diff --git a/tests/queries/0_stateless/01825_type_json_6.sh b/tests/queries/0_stateless/01825_type_json_6.sh index 5ab0b77ab6b..837b0d2290c 100755 --- a/tests/queries/0_stateless/01825_type_json_6.sh +++ b/tests/queries/0_stateless/01825_type_json_6.sh @@ -6,7 +6,7 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) $CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_6;" -$CLICKHOUSE_CLIENT -q"CREATE TABLE t_json_6 (data JSON) ENGINE = MergeTree ORDER BY tuple();" +$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_6 (data JSON) ENGINE = MergeTree ORDER BY tuple();" cat < Date: Mon, 13 Sep 2021 15:40:39 +0300 Subject: [PATCH 047/132] dynamic columns: optimize check for ambiguos paths --- src/DataTypes/ObjectUtils.cpp | 32 ++++++++++++++++---------------- src/DataTypes/ObjectUtils.h | 2 +- 2 files changed, 17 insertions(+), 17 deletions(-) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 7352dda256a..48f0a7415c3 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -143,7 +143,7 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con if (it == storage_columns_map.end()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Column '{}' not found in storage", name_type.name); - getLeastCommonTypeForObject({type_tuple, it->second}); + getLeastCommonTypeForObject({type_tuple, it->second}, true); name_type.type = type_tuple; column.type = type_tuple; @@ -165,26 +165,25 @@ static bool isPrefix(const Strings & prefix, const Strings & strings) void checkObjectHasNoAmbiguosPaths(const Strings & key_names) { - for (const auto & name : key_names) + size_t size = key_names.size(); + std::vector names_parts(size); + + for (size_t i = 0; i < size; ++i) + boost::split(names_parts[i], key_names[i], boost::is_any_of(".")); + + for (size_t i = 0; i < size; ++i) { - Strings name_parts; - boost::split(name_parts, name, boost::is_any_of(".")); - - for (const auto & other_name : key_names) + for (size_t j = 0; j < i; ++j) { - if (other_name.size() > name.size()) - { - Strings other_name_parts; - boost::split(other_name_parts, other_name, boost::is_any_of(".")); - - if (isPrefix(name_parts, other_name_parts)) - throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Data in Object has ambiguous paths: '{}' and '{}", name, other_name); - } + if (isPrefix(names_parts[i], names_parts[j]) || isPrefix(names_parts[j], names_parts[i])) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, + "Data in Object has ambiguous paths: '{}' and '{}", + key_names[i], key_names[j]); } } } -DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) +DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambiguos_paths) { std::unordered_map subcolumns_types; for (const auto & type : types) @@ -228,7 +227,8 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types) auto tuple_names = extractVector<0>(tuple_elements); auto tuple_types = extractVector<1>(tuple_elements); - checkObjectHasNoAmbiguosPaths(tuple_names); + if (check_ambiguos_paths) + checkObjectHasNoAmbiguosPaths(tuple_names); return std::make_shared(tuple_types, tuple_names); } diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 1da7031670d..0c0074d2c98 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -16,7 +16,7 @@ DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); void checkObjectHasNoAmbiguosPaths(const Strings & key_names); -DataTypePtr getLeastCommonTypeForObject(const DataTypes & types); +DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambiguos_paths = false); NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescription & object_columns, bool with_subcolumns); From d09f973b83a0dd35d4cb9e3f17be8dbc041179be Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Mon, 13 Sep 2021 17:02:38 +0300 Subject: [PATCH 048/132] dynamic columns: fix several cases of parsing json --- src/Columns/ColumnObject.cpp | 10 +++++-- .../0_stateless/01825_type_json_7.reference | 4 +++ .../queries/0_stateless/01825_type_json_7.sh | 29 +++++++++++++++++++ 3 files changed, 41 insertions(+), 2 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_7.reference create mode 100755 tests/queries/0_stateless/01825_type_json_7.sh diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 0953e1ec538..9476a5b2a2e 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -245,10 +245,16 @@ void ColumnObject::Subcolumn::checkTypes() const void ColumnObject::Subcolumn::insert(Field field) { - auto value_dim = applyVisitor(FieldVisitorToNumberOfDimensions(), field); auto column_dim = getNumberOfDimensions(*least_common_type); + auto value_dim = applyVisitor(FieldVisitorToNumberOfDimensions(), field); - if (!isNothing(least_common_type) && value_dim != column_dim) + if (isNothing(least_common_type)) + column_dim = value_dim; + + if (field.isNull()) + value_dim = column_dim; + + if (value_dim != column_dim) throw Exception(ErrorCodes::NUMBER_OF_DIMENSIONS_MISMATHED, "Dimension of types mismatched beetwen inserted value and column." "Dimension of value: {}. Dimension of column: {}", diff --git a/tests/queries/0_stateless/01825_type_json_7.reference b/tests/queries/0_stateless/01825_type_json_7.reference new file mode 100644 index 00000000000..263f1688a91 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_7.reference @@ -0,0 +1,4 @@ +Tuple(categories Array(String), key String) +v1 [] +v2 ['foo','bar'] +v3 [] diff --git a/tests/queries/0_stateless/01825_type_json_7.sh b/tests/queries/0_stateless/01825_type_json_7.sh new file mode 100755 index 00000000000..24de546b206 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_7.sh @@ -0,0 +1,29 @@ +#!/usr/bin/env bash + +CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +# shellcheck source=../shell_config.sh +. "$CURDIR"/../shell_config.sh + +$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_7;" + +$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_7 (data JSON) ENGINE = MergeTree ORDER BY tuple();" + +cat < Date: Mon, 13 Sep 2021 17:45:33 +0300 Subject: [PATCH 049/132] dynamic columns: fix write to replicated --- src/DataTypes/IDataType.h | 4 +++- src/Storages/StorageInMemoryMetadata.cpp | 13 ++++++++++--- tests/queries/0_stateless/01825_type_json_2.sql | 2 +- tests/queries/0_stateless/01825_type_json_3.sql | 2 +- 4 files changed, 15 insertions(+), 6 deletions(-) diff --git a/src/DataTypes/IDataType.h b/src/DataTypes/IDataType.h index 5954a7493f2..3ddee3ffa8c 100644 --- a/src/DataTypes/IDataType.h +++ b/src/DataTypes/IDataType.h @@ -384,10 +384,12 @@ inline bool isDecimal(const DataTypePtr & data_type) { return WhichDataType(data inline bool isTuple(const DataTypePtr & data_type) { return WhichDataType(data_type).isTuple(); } inline bool isArray(const DataTypePtr & data_type) { return WhichDataType(data_type).isArray(); } inline bool isMap(const DataTypePtr & data_type) {return WhichDataType(data_type).isMap(); } -inline bool isObject(const DataTypePtr & data_type) {return WhichDataType(data_type).isObject(); } inline bool isNothing(const DataTypePtr & data_type) { return WhichDataType(data_type).isNothing(); } inline bool isUUID(const DataTypePtr & data_type) { return WhichDataType(data_type).isUUID(); } +template +inline bool isObject(const T & data_type) {return WhichDataType(data_type).isObject(); } + template inline bool isUInt8(const T & data_type) { diff --git a/src/Storages/StorageInMemoryMetadata.cpp b/src/Storages/StorageInMemoryMetadata.cpp index b1531ad430e..074b0be4e3c 100644 --- a/src/Storages/StorageInMemoryMetadata.cpp +++ b/src/Storages/StorageInMemoryMetadata.cpp @@ -507,7 +507,10 @@ void StorageInMemoryMetadata::check(const NamesAndTypesList & provided_columns) listOfColumns(available_columns)); const auto * available_type = it->getMapped(); - if (!column.type->equals(*available_type) && !isCompatibleEnumTypes(available_type, column.type.get())) + + if (!isObject(*available_type) + && !column.type->equals(*available_type) + && !isCompatibleEnumTypes(available_type, column.type.get())) throw Exception( ErrorCodes::TYPE_MISMATCH, "Type mismatch for column {}. Column has type {}, got type {}", @@ -554,7 +557,9 @@ void StorageInMemoryMetadata::check(const NamesAndTypesList & provided_columns, const auto * provided_column_type = it->getMapped(); const auto * available_column_type = jt->getMapped(); - if (!provided_column_type->equals(*available_column_type) && !isCompatibleEnumTypes(available_column_type, provided_column_type)) + if (!isObject(*provided_column_type) + && !provided_column_type->equals(*available_column_type) + && !isCompatibleEnumTypes(available_column_type, provided_column_type)) throw Exception( ErrorCodes::TYPE_MISMATCH, "Type mismatch for column {}. Column has type {}, got type {}", @@ -596,7 +601,9 @@ void StorageInMemoryMetadata::check(const Block & block, bool need_all) const listOfColumns(available_columns)); const auto * available_type = it->getMapped(); - if (!column.type->equals(*available_type) && !isCompatibleEnumTypes(available_type, column.type.get())) + if (!isObject(*available_type) + && !column.type->equals(*available_type) + && !isCompatibleEnumTypes(available_type, column.type.get())) throw Exception( ErrorCodes::TYPE_MISMATCH, "Type mismatch for column {}. Column has type {}, got type {}", diff --git a/tests/queries/0_stateless/01825_type_json_2.sql b/tests/queries/0_stateless/01825_type_json_2.sql index fa87aacae29..126ae297e1b 100644 --- a/tests/queries/0_stateless/01825_type_json_2.sql +++ b/tests/queries/0_stateless/01825_type_json_2.sql @@ -1,7 +1,7 @@ DROP TABLE IF EXISTS t_json_2; CREATE TABLE t_json_2(id UInt64, data Object('JSON')) -ENGINE = MergeTree ORDER BY tuple(); +ENGINE = ReplicatedMergeTree('/clickhouse/tables/{database}/test_01825_2/t_json_2', 'r1') ORDER BY tuple(); INSERT INTO t_json_2 FORMAT JSONEachRow {"id": 1, "data": {"k1": 1, "k2" : 2}} {"id": 2, "data": {"k2": 3, "k3" : 4}}; diff --git a/tests/queries/0_stateless/01825_type_json_3.sql b/tests/queries/0_stateless/01825_type_json_3.sql index a90ec162609..93dab846c17 100644 --- a/tests/queries/0_stateless/01825_type_json_3.sql +++ b/tests/queries/0_stateless/01825_type_json_3.sql @@ -1,7 +1,7 @@ DROP TABLE IF EXISTS t_json_3; CREATE TABLE t_json_3(id UInt64, data JSON) -ENGINE = MergeTree ORDER BY tuple(); +ENGINE = ReplicatedMergeTree('/clickhouse/tables/{database}/test_01825_3/t_json_3', 'r1') ORDER BY tuple(); SYSTEM STOP MERGES t_json_3; From b0c0b2bc1096ad49d773fcf7520f827f895bd928 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Tue, 14 Sep 2021 17:02:32 +0300 Subject: [PATCH 050/132] fix some builds --- src/Columns/ColumnObject.cpp | 19 +++++-------- src/Columns/ColumnObject.h | 2 -- src/Columns/ya.make | 1 + src/DataTypes/FieldToDataType.h | 28 ------------------- src/DataTypes/ObjectUtils.cpp | 13 +++------ .../Serializations/SerializationObject.cpp | 6 ++-- .../Serializations/SerializationObject.h | 4 +-- src/DataTypes/ya.make | 3 ++ src/Functions/IFunction.h | 6 ++-- src/Interpreters/InterpreterDescribeQuery.cpp | 17 ++++++----- src/Interpreters/convertFieldToType.cpp | 2 +- src/Storages/IStorage.cpp | 4 --- src/Storages/StorageSnapshot.cpp | 1 - src/Storages/ya.make | 1 + .../01825_type_json_schema_race_long.sh | 2 +- 15 files changed, 34 insertions(+), 75 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 9476a5b2a2e..807eb4fb62f 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -22,6 +22,7 @@ namespace ErrorCodes extern const int ILLEGAL_COLUMN; extern const int DUPLICATE_COLUMN; extern const int NUMBER_OF_DIMENSIONS_MISMATHED; + extern const int NOT_IMPLEMENTED; } namespace @@ -181,14 +182,6 @@ private: } -ColumnObject::Subcolumn::Subcolumn(const Subcolumn & other) - : least_common_type(other.least_common_type) - , is_nullable(other.is_nullable) - , data(other.data) - , num_of_defaults_in_prefix(other.num_of_defaults_in_prefix) -{ -} - ColumnObject::Subcolumn::Subcolumn(MutableColumnPtr && data_) : least_common_type(getDataTypeByColumn(*data_)) , is_nullable(least_common_type->isNullable()) @@ -238,7 +231,7 @@ void ColumnObject::Subcolumn::checkTypes() const auto prefix_common_type = getLeastSupertype(prefix_types); if (!prefix_common_type->equals(*current_type)) throw Exception(ErrorCodes::LOGICAL_ERROR, - "Data type {} of column at postion {} cannot represent all columns from i-th prefix", + "Data type {} of column at position {} cannot represent all columns from i-th prefix", current_type->getName(), i); } } @@ -256,7 +249,7 @@ void ColumnObject::Subcolumn::insert(Field field) if (value_dim != column_dim) throw Exception(ErrorCodes::NUMBER_OF_DIMENSIONS_MISMATHED, - "Dimension of types mismatched beetwen inserted value and column." + "Dimension of types mismatched between inserted value and column." "Dimension of value: {}. Dimension of column: {}", value_dim, column_dim); @@ -273,7 +266,7 @@ void ColumnObject::Subcolumn::insert(Field field) if (is_nullable && !base_type->isNullable()) base_type = makeNullable(base_type); - auto value_type = createArrayOfType(base_type, value_dim); + DataTypePtr value_type; if (!is_nullable && base_type->isNullable()) { base_type = removeNullable(base_type); @@ -287,6 +280,8 @@ void ColumnObject::Subcolumn::insert(Field field) auto default_value = value_type->getDefault(); field = applyVisitor(FieldVisitorReplaceNull(default_value, value_dim), std::move(field)); } + else + value_type = createArrayOfType(base_type, value_dim); bool type_changed = false; @@ -496,7 +491,7 @@ void ColumnObject::forEachSubcolumn(ColumnCallback callback) void ColumnObject::insert(const Field & field) { - const auto & object = field.get(); + const auto & object = field.get(); HashSet inserted; size_t old_size = size(); diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 26976d6afe6..80749e42183 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -25,8 +25,6 @@ public: Subcolumn() = default; Subcolumn(size_t size_, bool is_nullable); Subcolumn(MutableColumnPtr && data_); - Subcolumn(const Subcolumn & other); - Subcolumn & operator=(Subcolumn && other) = default; size_t size() const; size_t byteSize() const; diff --git a/src/Columns/ya.make b/src/Columns/ya.make index 9cf23e27809..d287bd6d4f9 100644 --- a/src/Columns/ya.make +++ b/src/Columns/ya.make @@ -29,6 +29,7 @@ SRCS( ColumnLowCardinality.cpp ColumnMap.cpp ColumnNullable.cpp + ColumnObject.cpp ColumnSparse.cpp ColumnString.cpp ColumnTuple.cpp diff --git a/src/DataTypes/FieldToDataType.h b/src/DataTypes/FieldToDataType.h index 84024f75fdb..9dc06e4b386 100644 --- a/src/DataTypes/FieldToDataType.h +++ b/src/DataTypes/FieldToDataType.h @@ -49,32 +49,4 @@ private: bool allow_convertion_to_string; }; - -// template struct FieldTypeToTypeIndex; - -// #define DEFINE_FOR_TYPE(T) \ -// template <> struct FieldTypeToTypeIndex { static constexpr auto value = TypeIndex::T; }; - -// DEFINE_FOR_TYPE(UInt64) -// DEFINE_FOR_TYPE(UInt128) -// DEFINE_FOR_TYPE(UInt256) -// DEFINE_FOR_TYPE(Int64) -// DEFINE_FOR_TYPE(Int128) -// DEFINE_FOR_TYPE(Int256) -// DEFINE_FOR_TYPE(UUID) -// DEFINE_FOR_TYPE(Float64) -// DEFINE_FOR_TYPE(String) -// DEFINE_FOR_TYPE(Array) -// DEFINE_FOR_TYPE(Tuple) -// DEFINE_FOR_TYPE(Map) -// DEFINE_FOR_TYPE(Decimal32) -// DEFINE_FOR_TYPE(Decimal64) -// DEFINE_FOR_TYPE(Decimal128) -// DEFINE_FOR_TYPE(Decimal256) - -// template <> struct FieldTypeToTypeIndex { static constexpr auto value = TypeIndex::Nothing; }; -// template <> struct FieldTypeToTypeIndex { static constexpr auto value = TypeIndex::AggregateFunction; }; - -// #undef DEFINE_FOR_TYPE - } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 48f0a7415c3..92b6273ec73 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -33,11 +33,6 @@ namespace ErrorCodes extern const int DUPLICATE_COLUMN; } -static const IDataType * getTypeObject(const DataTypePtr & type) -{ - return typeid_cast(type.get()); -} - size_t getNumberOfDimensions(const IDataType & type) { if (const auto * type_array = typeid_cast(&type)) @@ -107,11 +102,11 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con for (auto & name_type : columns_list) { - if (const auto * type_object = getTypeObject(name_type.type)) + if (isObject(name_type.type)) { auto & column = block.getByName(name_type.name); - if (!getTypeObject(column.type)) + if (!isObject(column.type)) throw Exception(ErrorCodes::TYPE_MISMATCH, "Type for column '{}' mismatch in columns list and in block. In list: {}, in block: {}", name_type.name, name_type.type->getName(), column.type->getName()); @@ -131,7 +126,7 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con subcolumn.getFinalizedColumnPtr()); std::sort(tuple_elements.begin(), tuple_elements.end(), - [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); } ); + [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); }); auto tuple_names = extractVector<0>(tuple_elements); auto tuple_types = extractVector<1>(tuple_elements); @@ -222,7 +217,7 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambi tuple_elements.emplace_back(ColumnObject::COLUMN_NAME_DUMMY, std::make_shared()); std::sort(tuple_elements.begin(), tuple_elements.end(), - [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); } ); + [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); }); auto tuple_names = extractVector<0>(tuple_elements); auto tuple_types = extractVector<1>(tuple_elements); diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 1326a7b56e8..4d3a526b276 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -21,7 +21,7 @@ namespace ErrorCodes extern const int NOT_IMPLEMENTED; extern const int INCORRECT_DATA; extern const int CANNOT_READ_ALL_DATA; - extern const int TYPE_MISMATCH; + extern const int LOGICAL_ERROR; } template @@ -97,8 +97,8 @@ void SerializationObject::deserializeTextCSV(IColumn & column, ReadBuffe } template -template -void SerializationObject::checkSerializationIsSupported(Settings & settings, StatePtr & state) const +template +void SerializationObject::checkSerializationIsSupported(TSettings & settings, TStatePtr & state) const { if (settings.position_independent_encoding) throw Exception(ErrorCodes::NOT_IMPLEMENTED, diff --git a/src/DataTypes/Serializations/SerializationObject.h b/src/DataTypes/Serializations/SerializationObject.h index da490e6f461..532de22a47a 100644 --- a/src/DataTypes/Serializations/SerializationObject.h +++ b/src/DataTypes/Serializations/SerializationObject.h @@ -53,8 +53,8 @@ public: void deserializeTextCSV(IColumn & column, ReadBuffer & istr, const FormatSettings & settings) const override; private: - template - void checkSerializationIsSupported(Settings & settings, StatePtr & state) const; + template + void checkSerializationIsSupported(TSettings & settings, TStatePtr & state) const; template void deserializeTextImpl(IColumn & column, Reader && reader) const; diff --git a/src/DataTypes/ya.make b/src/DataTypes/ya.make index a912c215b18..35f920bbc91 100644 --- a/src/DataTypes/ya.make +++ b/src/DataTypes/ya.make @@ -32,6 +32,7 @@ SRCS( DataTypeNothing.cpp DataTypeNullable.cpp DataTypeNumberBase.cpp + DataTypeObject.cpp DataTypeString.cpp DataTypeTuple.cpp DataTypeUUID.cpp @@ -41,6 +42,7 @@ SRCS( FieldToDataType.cpp IDataType.cpp NestedUtils.cpp + ObjectUtils.cpp Serializations/ISerialization.cpp Serializations/SerializationAggregateFunction.cpp Serializations/SerializationArray.cpp @@ -60,6 +62,7 @@ SRCS( Serializations/SerializationNothing.cpp Serializations/SerializationNullable.cpp Serializations/SerializationNumber.cpp + Serializations/SerializationObject.cpp Serializations/SerializationSparse.cpp Serializations/SerializationString.cpp Serializations/SerializationTuple.cpp diff --git a/src/Functions/IFunction.h b/src/Functions/IFunction.h index ba3b5dfaf12..9bfdae7df93 100644 --- a/src/Functions/IFunction.h +++ b/src/Functions/IFunction.h @@ -81,7 +81,7 @@ protected: /** If function arguments has single sparse column and all other arguments are constants, call function on nested column. * Otherwise, convert all sparse columns to ordinary columns. * If default value doesn't change after function execution, returns sparse column as a result. - * Otherwide, result column is converted to full. + * Otherwise, result column is converted to full. */ virtual bool useDefaultImplementationForSparseColumns() const { return true; } @@ -367,7 +367,7 @@ protected: /** If function arguments has single sparse column and all other arguments are constants, call function on nested column. * Otherwise, convert all sparse columns to ordinary columns. * If default value doesn't change after function execution, returns sparse column as a result. - * Otherwide, result column is converted to full. + * Otherwise, result column is converted to full. */ virtual bool useDefaultImplementationForSparseColumns() const { return true; } @@ -425,7 +425,7 @@ public: /** If function arguments has single sparse column and all other arguments are constants, call function on nested column. * Otherwise, convert all sparse columns to ordinary columns. * If default value doesn't change after function execution, returns sparse column as a result. - * Otherwide, result column is converted to full. + * Otherwise, result column is converted to full. */ virtual bool useDefaultImplementationForSparseColumns() const { return true; } diff --git a/src/Interpreters/InterpreterDescribeQuery.cpp b/src/Interpreters/InterpreterDescribeQuery.cpp index 5c976c1cd23..385508cee51 100644 --- a/src/Interpreters/InterpreterDescribeQuery.cpp +++ b/src/Interpreters/InterpreterDescribeQuery.cpp @@ -67,26 +67,25 @@ BlockInputStreamPtr InterpreterDescribeQuery::executeImpl() const auto & ast = query_ptr->as(); const auto & table_expression = ast.table_expression->as(); - auto context = getContext(); - const auto & settings = context->getSettingsRef(); + const auto & settings = getContext()->getSettingsRef(); if (table_expression.subquery) { auto names_and_types = InterpreterSelectWithUnionQuery::getSampleBlock( - table_expression.subquery->children.at(0), context).getNamesAndTypesList(); + table_expression.subquery->children.at(0), getContext()).getNamesAndTypesList(); columns = ColumnsDescription(std::move(names_and_types)); } else if (table_expression.table_function) { - TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().get(table_expression.table_function, context); - columns = table_function_ptr->getActualTableStructure(context); + TableFunctionPtr table_function_ptr = TableFunctionFactory::instance().get(table_expression.table_function, getContext()); + columns = table_function_ptr->getActualTableStructure(getContext()); } else { - auto table_id = context->resolveStorageID(table_expression.database_and_table_name); - context->checkAccess(AccessType::SHOW_COLUMNS, table_id); - auto table = DatabaseCatalog::instance().getTable(table_id, context); - auto table_lock = table->lockForShare(context->getInitialQueryId(), settings.lock_acquire_timeout); + auto table_id = getContext()->resolveStorageID(table_expression.database_and_table_name); + getContext()->checkAccess(AccessType::SHOW_COLUMNS, table_id); + auto table = DatabaseCatalog::instance().getTable(table_id, getContext()); + auto table_lock = table->lockForShare(getContext()->getInitialQueryId(), settings.lock_acquire_timeout); auto metadata_snapshot = table->getInMemoryMetadataPtr(); storage_snapshot = table->getStorageSnapshot(metadata_snapshot); diff --git a/src/Interpreters/convertFieldToType.cpp b/src/Interpreters/convertFieldToType.cpp index 575efaa8d92..7256a6b4b0f 100644 --- a/src/Interpreters/convertFieldToType.cpp +++ b/src/Interpreters/convertFieldToType.cpp @@ -359,7 +359,7 @@ Field convertFieldToTypeImpl(const Field & src, const IDataType & type, const ID return src; } - else if (const auto * object_type = typeid_cast(&type)) + else if (isObject(type)) { const auto * from_type_tuple = typeid_cast(from_type_hint); if (src.getType() == Field::Types::Tuple && from_type_tuple && from_type_tuple->haveExplicitNames()) diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp index dbc960838e1..94f3b648f18 100644 --- a/src/Storages/IStorage.cpp +++ b/src/Storages/IStorage.cpp @@ -22,10 +22,6 @@ namespace ErrorCodes extern const int TABLE_IS_DROPPED; extern const int NOT_IMPLEMENTED; extern const int DEADLOCK_AVOIDED; - extern const int NOT_FOUND_COLUMN_IN_BLOCK; - extern const int EMPTY_LIST_OF_COLUMNS_QUERIED; - extern const int NO_SUCH_COLUMN_IN_TABLE; - extern const int COLUMN_QUERIED_MORE_THAN_ONCE; } bool IStorage::isVirtualColumn(const String & column_name, const StorageMetadataPtr & metadata_snapshot) const diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp index d452f3d9137..d3922b1c769 100644 --- a/src/Storages/StorageSnapshot.cpp +++ b/src/Storages/StorageSnapshot.cpp @@ -4,7 +4,6 @@ #include #include #include -#include namespace DB { diff --git a/src/Storages/ya.make b/src/Storages/ya.make index c85a0dbd902..71b9fc724a4 100644 --- a/src/Storages/ya.make +++ b/src/Storages/ya.make @@ -149,6 +149,7 @@ SRCS( StorageReplicatedMergeTree.cpp StorageSQLite.cpp StorageSet.cpp + StorageSnapshot.cpp StorageStripeLog.cpp StorageTinyLog.cpp StorageURL.cpp diff --git a/tests/queries/0_stateless/01825_type_json_schema_race_long.sh b/tests/queries/0_stateless/01825_type_json_schema_race_long.sh index 70da8b52d61..3bd3e0388dc 100755 --- a/tests/queries/0_stateless/01825_type_json_schema_race_long.sh +++ b/tests/queries/0_stateless/01825_type_json_schema_race_long.sh @@ -28,7 +28,7 @@ function test_case() done } -for i in {1..30}; do test_case; done +for _ in {1..30}; do test_case; done $CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_race" echo OK From 63fceca6a8c5371bc2d89af26ec1b54063e1132b Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 1 Dec 2021 05:58:24 +0300 Subject: [PATCH 051/132] support nested in json type (wip) --- src/Columns/ColumnObject.cpp | 129 ++++++--- src/Columns/ColumnObject.h | 25 +- src/DataTypes/NestedUtils.cpp | 6 + src/DataTypes/ObjectUtils.cpp | 269 ++++++++++++++++-- src/DataTypes/ObjectUtils.h | 17 +- .../Serializations/JSONDataParser.cpp | 80 ++++++ src/DataTypes/Serializations/JSONDataParser.h | 102 +++++-- .../Serializations/SerializationObject.cpp | 83 +++++- .../tests/gtest_json_parser.cpp | 154 +++++++++- src/Functions/FunctionsConversion.h | 8 +- src/Interpreters/InterpreterDescribeQuery.cpp | 10 +- src/Storages/StorageSnapshot.cpp | 10 +- .../0_stateless/01825_type_json_1.reference | 6 +- .../0_stateless/01825_type_json_3.reference | 22 +- .../0_stateless/01825_type_json_5.reference | 2 +- .../0_stateless/01825_type_json_6.reference | 2 +- .../01825_type_json_distributed.reference | 4 +- .../01825_type_json_insert_select.reference | 12 +- 18 files changed, 770 insertions(+), 171 deletions(-) create mode 100644 src/DataTypes/Serializations/JSONDataParser.cpp diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 807eb4fb62f..67ba7aaf600 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include @@ -9,10 +10,13 @@ #include #include #include +#include #include #include #include +#include + namespace DB { @@ -41,6 +45,14 @@ Array createEmptyArrayField(size_t num_dimensions) return array; } +ColumnPtr recreateWithDefaultValues(const ColumnPtr & column) +{ + if (const auto * column_array = checkAndGetColumn(column.get())) + return ColumnArray::create(recreateWithDefaultValues(column_array->getDataPtr()), IColumn::mutate(column_array->getOffsetsPtr())); + else + return column->cloneEmpty()->cloneResized(column->size()); +} + class FieldVisitorReplaceNull : public StaticVisitor { public: @@ -83,9 +95,6 @@ class FieldVisitorToNumberOfDimensions : public StaticVisitor public: size_t operator()(const Array & x) const { - if (x.empty()) - return 1; - const size_t size = x.size(); std::optional dimensions; @@ -111,7 +120,7 @@ public: size_t operator()(const T &) const { return 0; } }; -class FieldVisitorToScalarType: public StaticVisitor<> +class FieldVisitorToScalarType : public StaticVisitor<> { public: using FieldType = Field::Types::Which; @@ -182,14 +191,15 @@ private: } -ColumnObject::Subcolumn::Subcolumn(MutableColumnPtr && data_) +ColumnObject::Subcolumn::Subcolumn(MutableColumnPtr && data_, bool is_nullable_) : least_common_type(getDataTypeByColumn(*data_)) - , is_nullable(least_common_type->isNullable()) + , is_nullable(is_nullable_) { data.push_back(std::move(data_)); } -ColumnObject::Subcolumn::Subcolumn(size_t size_, bool is_nullable_) +ColumnObject::Subcolumn::Subcolumn( + size_t size_, bool is_nullable_) : least_common_type(std::make_shared()) , is_nullable(is_nullable_) , num_of_defaults_in_prefix(size_) @@ -277,7 +287,7 @@ void ColumnObject::Subcolumn::insert(Field field) } value_type = createArrayOfType(base_type, value_dim); - auto default_value = value_type->getDefault(); + auto default_value = base_type->getDefault(); field = applyVisitor(FieldVisitorReplaceNull(default_value, value_dim), std::move(field)); } else @@ -384,6 +394,17 @@ void ColumnObject::Subcolumn::finalize() num_of_defaults_in_prefix = 0; } +Field ColumnObject::Subcolumn::getLastField() const +{ + if (data.empty()) + return Field(); + + const auto & last_part = data.back(); + assert(!last_part.empty()); + return (*last_part)[last_part->size() - 1]; +} + + void ColumnObject::Subcolumn::insertDefault() { if (data.empty()) @@ -436,13 +457,13 @@ void ColumnObject::checkConsistency() const return; size_t first_size = subcolumns.begin()->second.size(); - for (const auto & [name, column] : subcolumns) + for (const auto & [key, column] : subcolumns) { if (first_size != column.size()) { throw Exception(ErrorCodes::LOGICAL_ERROR, "Sizes of subcolumns are inconsistent in ColumnObject." " Subcolumn '{}' has {} rows, subcolumn '{}' has {} rows", - subcolumns.begin()->first, first_size, name, column.size()); + subcolumns.begin()->first.getPath(), first_size, key.getPath(), column.size()); } } } @@ -495,9 +516,10 @@ void ColumnObject::insert(const Field & field) HashSet inserted; size_t old_size = size(); - for (const auto & [key, value] : object) + for (const auto & [key_str, value] : object) { - inserted.insert(key); + Path key(key_str); + inserted.insert(key_str); if (!hasSubcolumn(key)) addSubcolumn(key, old_size); @@ -506,7 +528,7 @@ void ColumnObject::insert(const Field & field) } for (auto & [key, subcolumn] : subcolumns) - if (!inserted.has(key)) + if (!inserted.has(key.getPath())) subcolumn.insertDefault(); } @@ -523,7 +545,7 @@ Field ColumnObject::operator[](size_t n) const Object object; for (const auto & [key, subcolumn] : subcolumns) - object[key] = (*subcolumn.data.back())[n]; + object[key.getPath()] = (*subcolumn.data.back())[n]; return object; } @@ -536,7 +558,7 @@ void ColumnObject::get(size_t n, Field & res) const auto & object = res.get(); for (const auto & [key, subcolumn] : subcolumns) { - auto it = object.try_emplace(key).first; + auto it = object.try_emplace(key.getPath()).first; subcolumn.data.back()->get(n, it->second); } } @@ -562,8 +584,11 @@ ColumnPtr ColumnObject::replicate(const Offsets & offsets) const throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot replicate non-finalized ColumnObject"); auto res_column = ColumnObject::create(is_nullable); - for (auto & [key, subcolumn] : subcolumns) - res_column->addSubcolumn(key, Subcolumn(subcolumn.data.back()->replicate(offsets)->assumeMutable())); + for (const auto & [key, subcolumn] : subcolumns) + { + auto replicated_data = subcolumn.data.back()->replicate(offsets)->assumeMutable(); + res_column->addSubcolumn(key, std::move(replicated_data), is_nullable); + } return res_column; } @@ -577,59 +602,93 @@ void ColumnObject::popBack(size_t length) subcolumn.data.back()->popBack(length); } -const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const String & key) const +const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) const { auto it = subcolumns.find(key); if (it != subcolumns.end()) return it->second; - throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key); + throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key.getPath()); } -ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const String & key) +ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) { auto it = subcolumns.find(key); if (it != subcolumns.end()) return it->second; - throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key); + throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key.getPath()); } -bool ColumnObject::hasSubcolumn(const String & key) const +std::optional ColumnObject::findSubcolumnForNested(const Path & key, size_t expected_size) const +{ + for (const auto & [other_key, other_subcolumn] : subcolumns) + { + if (key == other_key || expected_size != other_subcolumn.size()) + continue; + + auto split_lhs = Nested::splitName(key.getPath(), true); + auto split_rhs = Nested::splitName(other_key.getPath(), true); + + if (!split_lhs.first.empty() && split_lhs.first == split_rhs.first) + return other_key; + } + + return {}; +} + +bool ColumnObject::hasSubcolumn(const Path & key) const { return subcolumns.count(key) != 0; } -void ColumnObject::addSubcolumn(const String & key, size_t new_size, bool check_size) +void ColumnObject::addSubcolumn(const Path & key, size_t new_size, bool check_size) { if (subcolumns.count(key)) - throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key); + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); if (check_size && new_size != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", - key, new_size, size()); + key.getPath(), new_size, size()); - subcolumns[key] = Subcolumn(new_size, is_nullable); + if (key.hasNested()) + { + auto nested_key = findSubcolumnForNested(key, new_size); + if (nested_key) + { + auto & nested_subcolumn = subcolumns[*nested_key]; + nested_subcolumn.finalize(); + auto default_column = recreateWithDefaultValues(nested_subcolumn.getFinalizedColumnPtr()); + subcolumns[key] = Subcolumn(default_column->assumeMutable(), is_nullable); + } + else + { + subcolumns[key] = Subcolumn(new_size, is_nullable); + } + } + else + { + subcolumns[key] = Subcolumn(new_size, is_nullable); + } } -void ColumnObject::addSubcolumn(const String & key, Subcolumn && subcolumn, bool check_size) +void ColumnObject::addSubcolumn(const Path & key, MutableColumnPtr && subcolumn, bool check_size) { if (subcolumns.count(key)) - throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key); + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); - if (check_size && subcolumn.size() != size()) + if (check_size && subcolumn->size() != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", - key, subcolumn.size(), size()); + key.getPath(), subcolumn->size(), size()); - subcolumn.setNullable(is_nullable); - subcolumns[key] = std::move(subcolumn); + subcolumns[key] = Subcolumn(std::move(subcolumn), is_nullable); } -Strings ColumnObject::getKeys() const +Paths ColumnObject::getKeys() const { - Strings keys; + Paths keys; keys.reserve(subcolumns.size()); for (const auto & [key, _] : subcolumns) keys.emplace_back(key); @@ -657,7 +716,7 @@ void ColumnObject::finalize() } if (new_subcolumns.empty()) - new_subcolumns[COLUMN_NAME_DUMMY] = Subcolumn{ColumnUInt8::create(old_size)}; + new_subcolumns[Path(COLUMN_NAME_DUMMY)] = Subcolumn{ColumnUInt8::create(old_size), is_nullable}; std::swap(subcolumns, new_subcolumns); checkObjectHasNoAmbiguosPaths(getKeys()); diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 80749e42183..038d1317ff3 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -5,6 +5,7 @@ #include #include #include +#include #include @@ -23,8 +24,8 @@ public: { public: Subcolumn() = default; - Subcolumn(size_t size_, bool is_nullable); - Subcolumn(MutableColumnPtr && data_); + Subcolumn(size_t size_, bool is_nullable_); + Subcolumn(MutableColumnPtr && data_, bool is_nullable_); size_t size() const; size_t byteSize() const; @@ -40,7 +41,8 @@ public: void insertRangeFrom(const Subcolumn & src, size_t start, size_t length); void finalize(); - void setNullable(bool value) { is_nullable = value; } + + Field getLastField() const; IColumn & getFinalizedColumn(); const IColumn & getFinalizedColumn() const; @@ -55,7 +57,7 @@ public: size_t num_of_defaults_in_prefix = 0; }; - using SubcolumnsMap = std::unordered_map; + using SubcolumnsMap = std::unordered_map; private: SubcolumnsMap subcolumns; @@ -64,22 +66,23 @@ private: public: static constexpr auto COLUMN_NAME_DUMMY = "_dummy"; - ColumnObject(bool is_nullable); + explicit ColumnObject(bool is_nullable_); ColumnObject(SubcolumnsMap && subcolumns_, bool is_nullable_); void checkConsistency() const; - bool hasSubcolumn(const String & key) const; + bool hasSubcolumn(const Path & key) const; - const Subcolumn & getSubcolumn(const String & key) const; - Subcolumn & getSubcolumn(const String & key); + const Subcolumn & getSubcolumn(const Path & key) const; + Subcolumn & getSubcolumn(const Path & key); + std::optional findSubcolumnForNested(const Path & key, size_t expected_size) const; - void addSubcolumn(const String & key, size_t new_size, bool check_size = false); - void addSubcolumn(const String & key, Subcolumn && subcolumn, bool check_size = false); + void addSubcolumn(const Path & key, size_t new_size, bool check_size = false); + void addSubcolumn(const Path & key, MutableColumnPtr && subcolumn, bool check_size = false); const SubcolumnsMap & getSubcolumns() const { return subcolumns; } SubcolumnsMap & getSubcolumns() { return subcolumns; } - Strings getKeys() const; + Paths getKeys() const; bool isFinalized() const; void finalize(); diff --git a/src/DataTypes/NestedUtils.cpp b/src/DataTypes/NestedUtils.cpp index d3c42b0d029..7d75f5cb2b8 100644 --- a/src/DataTypes/NestedUtils.cpp +++ b/src/DataTypes/NestedUtils.cpp @@ -30,6 +30,12 @@ namespace Nested std::string concatenateName(const std::string & nested_table_name, const std::string & nested_field_name) { + if (nested_table_name.empty()) + return nested_field_name; + + if (nested_field_name.empty()) + return nested_table_name; + return nested_table_name + "." + nested_field_name; } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 70d90dbf14b..76b29ef8ccf 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -1,10 +1,10 @@ #include #include -#include #include #include #include #include +#include #include #include #include @@ -13,6 +13,7 @@ #include #include #include +#include #include #include #include @@ -120,30 +121,35 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con "Cannot convert to tuple column '{}' from type {}. Column should be finalized first", name_type.name, name_type.type->getName()); - std::vector> tuple_elements; + std::vector> tuple_elements; + tuple_elements.reserve(subcolumns_map.size()); for (const auto & [key, subcolumn] : subcolumns_map) tuple_elements.emplace_back(key, subcolumn.getLeastCommonType(), subcolumn.getFinalizedColumnPtr()); std::sort(tuple_elements.begin(), tuple_elements.end(), - [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); }); + [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs).getPath() < std::get<0>(rhs).getPath(); }); - auto tuple_names = extractVector<0>(tuple_elements); + auto tuple_paths = extractVector<0>(tuple_elements); auto tuple_types = extractVector<1>(tuple_elements); auto tuple_columns = extractVector<2>(tuple_elements); - auto type_tuple = std::make_shared(tuple_types, tuple_names); - auto it = storage_columns_map.find(name_type.name); if (it == storage_columns_map.end()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Column '{}' not found in storage", name_type.name); + Strings tuple_names; + tuple_names.reserve(tuple_paths.size()); + for (const auto & path : tuple_paths) + tuple_names.push_back(path.getPath()); + + auto type_tuple = std::make_shared(tuple_types, tuple_names); + getLeastCommonTypeForObject({type_tuple, it->second}, true); - name_type.type = type_tuple; - column.type = type_tuple; - column.column = ColumnTuple::create(tuple_columns); + std::tie(column.type, column.column) = unflattenTuple(tuple_paths, tuple_types, tuple_columns); + name_type.type = column.type; } } } @@ -159,13 +165,13 @@ static bool isPrefix(const Strings & prefix, const Strings & strings) return true; } -void checkObjectHasNoAmbiguosPaths(const Strings & key_names) +void checkObjectHasNoAmbiguosPaths(const Paths & paths) { - size_t size = key_names.size(); + size_t size = paths.size(); std::vector names_parts(size); for (size_t i = 0; i < size; ++i) - boost::split(names_parts[i], key_names[i], boost::is_any_of(".")); + names_parts[i] = paths[i].getParts(); for (size_t i = 0; i < size; ++i) { @@ -174,14 +180,15 @@ void checkObjectHasNoAmbiguosPaths(const Strings & key_names) if (isPrefix(names_parts[i], names_parts[j]) || isPrefix(names_parts[j], names_parts[i])) throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Data in Object has ambiguous paths: '{}' and '{}", - key_names[i], key_names[j]); + paths[i].getPath(), paths[i].getPath()); } } } DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambiguos_paths) { - std::unordered_map subcolumns_types; + std::unordered_map subcolumns_types; + for (const auto & type : types) { const auto * type_tuple = typeid_cast(type.get()); @@ -189,19 +196,18 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambi throw Exception(ErrorCodes::LOGICAL_ERROR, "Least common type for object can be deduced only from tuples, but {} given", type->getName()); - const auto & tuple_names = type_tuple->getElementNames(); - const auto & tuple_types = type_tuple->getElements(); - assert(tuple_names.size() == tuple_types.size()); + auto [tuple_paths, tuple_types] = flattenTuple(type); + assert(tuple_paths.size() == tuple_types.size()); - for (size_t i = 0; i < tuple_names.size(); ++i) - subcolumns_types[tuple_names[i]].push_back(tuple_types[i]); + for (size_t i = 0; i < tuple_paths.size(); ++i) + subcolumns_types[tuple_paths[i]].push_back(tuple_types[i]); } - std::vector> tuple_elements; - for (const auto & [name, subtypes] : subcolumns_types) + std::vector> tuple_elements; + for (const auto & [key, subtypes] : subcolumns_types) { assert(!subtypes.empty()); - if (name == ColumnObject::COLUMN_NAME_DUMMY) + if (key.getPath() == ColumnObject::COLUMN_NAME_DUMMY) continue; size_t first_dim = getNumberOfDimensions(*subtypes[0]); @@ -209,24 +215,24 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambi if (first_dim != getNumberOfDimensions(*subtypes[i])) throw Exception(ErrorCodes::TYPE_MISMATCH, "Uncompatible types of subcolumn '{}': {} and {}", - name, subtypes[0]->getName(), subtypes[i]->getName()); + key.getPath(), subtypes[0]->getName(), subtypes[i]->getName()); - tuple_elements.emplace_back(name, getLeastSupertype(subtypes, /*allow_conversion_to_string=*/ true)); + tuple_elements.emplace_back(key, getLeastSupertype(subtypes, /*allow_conversion_to_string=*/ true)); } if (tuple_elements.empty()) - tuple_elements.emplace_back(ColumnObject::COLUMN_NAME_DUMMY, std::make_shared()); + tuple_elements.emplace_back(Path(ColumnObject::COLUMN_NAME_DUMMY), std::make_shared()); std::sort(tuple_elements.begin(), tuple_elements.end(), - [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); }); + [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs).getPath() < std::get<0>(rhs).getPath(); }); - auto tuple_names = extractVector<0>(tuple_elements); + auto tuple_paths = extractVector<0>(tuple_elements); auto tuple_types = extractVector<1>(tuple_elements); if (check_ambiguos_paths) - checkObjectHasNoAmbiguosPaths(tuple_names); + checkObjectHasNoAmbiguosPaths(tuple_paths); - return std::make_shared(tuple_types, tuple_names); + return unflattenTuple(tuple_paths, tuple_types); } NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list) @@ -257,6 +263,211 @@ void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescript columns_list.splice(columns_list.end(), std::move(subcolumns_list)); } +namespace +{ + +struct SubcolumnsHolder +{ + SubcolumnsHolder( + const std::vector & paths_, + const DataTypes & types_, + const Columns & columns_) + : paths(paths_) + , types(types_) + , columns(columns_) + { + parts.reserve(paths.size()); + levels.reserve(paths.size()); + + for (const auto & path : paths) + { + parts.emplace_back(path.getParts()); + + size_t num_parts = path.getNumParts(); + + levels.emplace_back(); + levels.back().resize(num_parts); + + for (size_t i = 1; i < num_parts; ++i) + levels.back()[i] = levels.back()[i - 1] + path.isNested(i - 1); + } + } + + std::pair reduceNumberOfDimensions(size_t path_idx, size_t key_idx) const + { + auto type = types[path_idx]; + auto column = columns[path_idx]; + + if (!isArray(type)) + return {type, column}; + + size_t type_dimensions = getNumberOfDimensions(*type); + size_t column_dimensions = getNumberOfDimensions(*column); + + if (levels[path_idx][key_idx] > type_dimensions) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Level of nested ({}) cannot be greater than number of dimensions in array ({})", + levels[path_idx][key_idx], type_dimensions); + + if (type_dimensions != column_dimensions) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Number of dimensionsin type ({}) is incompatible with number of dimension in column ({})", + type_dimensions, column_dimensions); + + size_t dimensions_to_reduce = levels[path_idx][key_idx]; + while (dimensions_to_reduce--) + { + const auto & type_array = assert_cast(*type); + const auto & column_array = assert_cast(*column); + + type = type_array.getNestedType(); + column = column_array.getDataPtr(); + } + + return {type, column}; + } + + std::vector paths; + DataTypes types; + Columns columns; + + std::vector parts; + std::vector> levels; +}; + + +void flattenTupleImpl(Path path, DataTypePtr type, size_t array_level, Paths & new_paths, DataTypes & new_types) +{ + bool is_nested = isNested(type); + if (is_nested) + type = assert_cast(*type).getNestedType(); + + if (const auto * type_tuple = typeid_cast(type.get())) + { + const auto & tuple_names = type_tuple->getElementNames(); + const auto & tuple_types = type_tuple->getElements(); + + for (size_t i = 0; i < tuple_names.size(); ++i) + { + auto next_path = Path::getNext(path, Path(tuple_names[i]), is_nested); + size_t next_level = array_level + is_nested; + flattenTupleImpl(next_path, tuple_types[i], next_level, new_paths, new_types); + } + } + else if (const auto * type_array = typeid_cast(type.get())) + { + flattenTupleImpl(path, type_array->getNestedType(), array_level + 1, new_paths, new_types); + } + else + { + new_paths.push_back(path); + new_types.push_back(createArrayOfType(type, array_level)); + } +} + +void unflattenTupleImpl( + const SubcolumnsHolder & holder, + size_t from, size_t to, size_t depth, + Names & new_names, DataTypes & new_types, Columns & new_columns) +{ + size_t start = from; + for (size_t i = from + 1; i <= to; ++i) + { + if (i < to && holder.parts[i].size() <= depth) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot unflatten Tuple. Not enough name parts in path"); + + if (i == to || holder.parts[i][depth] != holder.parts[start][depth]) + { + if (i - start > 1) + { + Names tuple_names; + DataTypes tuple_types; + Columns tuple_columns; + + unflattenTupleImpl(holder, start, i, depth + 1, tuple_names, tuple_types, tuple_columns); + + assert(!tuple_names.empty()); + assert(tuple_names.size() == tuple_types.size()); + assert(tuple_names.size() == tuple_columns.size()); + + new_names.push_back(holder.parts[start][depth]); + + if (holder.paths[start].isNested(depth)) + { + auto array_column = holder.reduceNumberOfDimensions(start, depth).second; + auto offsets_column = assert_cast(*array_column).getOffsetsPtr(); + + new_types.push_back(createNested(tuple_types, tuple_names)); + new_columns.push_back(ColumnArray::create(ColumnTuple::create(std::move(tuple_columns)), offsets_column)); + } + else + { + new_types.push_back(std::make_shared(tuple_types, tuple_names)); + new_columns.push_back(ColumnTuple::create(std::move(tuple_columns))); + } + } + else + { + WriteBufferFromOwnString wb; + wb << holder.parts[start][depth]; + for (size_t j = depth + 1; j < holder.parts[start].size(); ++j) + wb << "." << holder.parts[start][j]; + + auto [new_type, new_column] = holder.reduceNumberOfDimensions(start, depth); + + new_names.push_back(wb.str()); + new_types.push_back(std::move(new_type)); + new_columns.push_back(std::move(new_column)); + } + + start = i; + } + } +} + +} + +std::pair flattenTuple(const DataTypePtr & type) +{ + Paths new_paths; + DataTypes new_types; + + flattenTupleImpl({}, type, 0, new_paths, new_types); + return {new_paths, new_types}; +} + +DataTypePtr unflattenTuple(const Paths & paths, const DataTypes & tuple_types) +{ + assert(paths.size() == types.size()); + Columns tuple_columns(tuple_types.size()); + for (size_t i = 0; i < tuple_types.size(); ++i) + tuple_columns[i] = tuple_types[i]->createColumn(); + + return unflattenTuple(paths, tuple_types, tuple_columns).first; +} + +std::pair unflattenTuple( + const Paths & paths, + const DataTypes & tuple_types, + const Columns & tuple_columns) +{ + assert(paths.size() == types.size()); + assert(paths.size() == columns.size()); + + Names new_names; + DataTypes new_types; + Columns new_columns; + SubcolumnsHolder holder(paths, tuple_types, tuple_columns); + + unflattenTupleImpl(holder, 0, paths.size(), 0, new_names, new_types, new_columns); + + return + { + std::make_shared(new_types, new_names), + ColumnTuple::create(new_columns) + }; +} + static void addConstantToWithClause(const ASTPtr & query, const String & column_name, const DataTypePtr & data_type) { auto & select = query->as(); diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 0c0074d2c98..869f396fde9 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -4,6 +4,8 @@ #include #include #include +#include +#include namespace DB { @@ -15,11 +17,24 @@ DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); -void checkObjectHasNoAmbiguosPaths(const Strings & key_names); +void checkObjectHasNoAmbiguosPaths(const Paths & paths); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambiguos_paths = false); NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescription & object_columns, bool with_subcolumns); +using DataTypeTuplePtr = std::shared_ptr; + +std::pair flattenTuple(const DataTypePtr & type); + +DataTypePtr unflattenTuple( + const Paths & paths, + const DataTypes & tuple_types); + +std::pair unflattenTuple( + const Paths & paths, + const DataTypes & tuple_types, + const Columns & tuple_columns); + void replaceMissedSubcolumnsByConstants( const ColumnsDescription & expected_columns, const ColumnsDescription & available_columns, diff --git a/src/DataTypes/Serializations/JSONDataParser.cpp b/src/DataTypes/Serializations/JSONDataParser.cpp new file mode 100644 index 00000000000..a91b205e96d --- /dev/null +++ b/src/DataTypes/Serializations/JSONDataParser.cpp @@ -0,0 +1,80 @@ +#include +#include +#include + +#include +#include + +#include +#include + +namespace DB +{ + +Path::Path(std::string_view path_) + : path(path_) + , num_parts(1 + std::count(path.begin(), path.end(), '.')) +{ +} + +void Path::append(const Path & other) +{ + if (!other.path.empty()) + { + path.reserve(path.size() + other.path.size() + 1); + if (!path.empty()) + path += "."; + path += other.path; + } + + is_nested |= other.is_nested << num_parts; + num_parts += other.num_parts; +} + +Strings Path::getParts() const +{ + Strings parts; + parts.reserve(num_parts); + boost::algorithm::split(parts, path, boost::is_any_of(".")); + return parts; +} + +void Path::writeBinary(WriteBuffer & out) const +{ + writeStringBinary(path, out); + writeVarUInt(num_parts, out); + writeVarUInt(is_nested.to_ullong(), out); +} + +void Path::readBinary(ReadBuffer & in) +{ + readStringBinary(path, in); + readVarUInt(num_parts, in); + + UInt64 bits; + readVarUInt(bits, in); + is_nested = {bits}; +} + +Path Path::getNext(const Path & current_path, const Path & key, bool make_nested) +{ + Path next(current_path); + next.append(key); + + if (!next.empty()) + { + size_t nested_index = 0; + if (!current_path.empty()) + nested_index = current_path.num_parts - 1; + next.is_nested.set(nested_index, make_nested); + } + + return next; +} + +size_t Path::Hash::operator()(const Path & value) const +{ + return std::hash{}(value.path); +} + +} diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index c5d6bdd2826..3be7d461981 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -3,6 +3,7 @@ #include #include #include +#include namespace DB { @@ -10,8 +11,50 @@ namespace DB namespace ErrorCodes { extern const int LOGICAL_ERROR; + extern const int NUMBER_OF_DIMENSIONS_MISMATHED; } +class ReadBuffer; +class WriteBuffer; + +class Path +{ +public: + // using BitSet = boost::dynamic_bitset, 8>>; + + Path() = default; + explicit Path(std::string_view path_); + + void append(const Path & other); + void append(std::string_view key); + + const String & getPath() const { return path; } + bool isNested(size_t i) const { return is_nested.test(i); } + bool hasNested() const { return is_nested.any(); } + + size_t getNumParts() const { return num_parts; } + bool empty() const { return path.empty(); } + + Strings getParts() const; + + static Path getNext(const Path & current_path, const Path & key, bool make_nested = false); + + void writeBinary(WriteBuffer & out) const; + void readBinary(ReadBuffer & in); + + bool operator==(const Path & other) const { return path == other.path; } + bool operator!=(const Path & other) const { return !(*this == other); } + struct Hash { size_t operator()(const Path & value) const; }; + +private: + String path; + size_t num_parts = 0; + /// TODO: use dynamic bitset + std::bitset<64> is_nested; +}; + +using Paths = std::vector; + template static Field getValueAsField(const Element & element) { @@ -25,22 +68,9 @@ static Field getValueAsField(const Element & element) throw Exception(ErrorCodes::LOGICAL_ERROR, "Unsupported type of JSON field"); } -static String getNextPath(const String & current_path, const std::string_view & key) -{ - String next_path = current_path; - if (!key.empty()) - { - if (!next_path.empty()) - next_path += "."; - next_path += key; - } - - return next_path; -} - struct ParseResult { - Strings paths; + std::vector paths; std::vector values; }; @@ -63,12 +93,12 @@ public: return {}; ParseResult result; - traverse(document, "", result); + traverse(document, {}, result); return result; } private: - void traverse(const Element & element, String current_path, ParseResult & result) + void traverse(const Element & element, Path current_path, ParseResult & result) { checkStackSize(); @@ -81,14 +111,16 @@ private: for (auto it = object.begin(); it != object.end(); ++it) { const auto & [key, value] = *it; - traverse(value, getNextPath(current_path, key), result); + traverse(value, Path::getNext(current_path, Path(key)), result); } } else if (element.isArray()) { auto array = element.getArray(); - using PathToArray = HashMap; + using PathWithArray = std::pair; + using PathToArray = HashMap; + PathToArray arrays_by_path; Arena strings_pool; @@ -97,32 +129,37 @@ private: for (auto it = array.begin(); it != array.end(); ++it) { ParseResult element_result; - traverse(*it, "", element_result); + traverse(*it, {}, element_result); - auto && [paths, values] = element_result; + auto & [paths, values] = element_result; for (size_t i = 0; i < paths.size(); ++i) { - const auto & path = paths[i]; - - if (auto found = arrays_by_path.find(path)) + if (auto * found = arrays_by_path.find(paths[i].getPath())) { - auto & path_array = found->getMapped(); + auto & path_array = found->getMapped().second; + assert(path_array.size() == current_size); path_array.push_back(std::move(values[i])); } else { - StringRef ref{strings_pool.insert(path.data(), path.size()), path.size()}; - auto & path_array = arrays_by_path[ref]; - + Array path_array; path_array.reserve(array.size()); path_array.resize(current_size); path_array.push_back(std::move(values[i])); + + const auto & path_str = paths[i].getPath(); + StringRef ref{strings_pool.insert(path_str.data(), path_str.size()), path_str.size()}; + + auto & elem = arrays_by_path[ref]; + elem.first = std::move(paths[i]); + elem.second = std::move(path_array); } } - for (auto & [path, path_array] : arrays_by_path) + for (auto & [_, value] : arrays_by_path) { + auto & path_array = value.second; assert(path_array.size() == current_size || path_array.size() == current_size + 1); if (path_array.size() == current_size) path_array.push_back(Field()); @@ -141,16 +178,19 @@ private: result.paths.reserve(result.paths.size() + arrays_by_path.size()); result.values.reserve(result.paths.size() + arrays_by_path.size()); - for (auto && [path, path_array] : arrays_by_path) + bool is_nested = arrays_by_path.size() > 1 || arrays_by_path.begin()->getKey().size != 0; + + for (auto && [_, value] : arrays_by_path) { - result.paths.push_back(getNextPath(current_path, static_cast(path))); + auto && [path, path_array] = value; + result.paths.push_back(Path::getNext(current_path, path, is_nested)); result.values.push_back(std::move(path_array)); } } } else { - result.paths.push_back(current_path); + result.paths.push_back(std::move(current_path)); result.values.push_back(getValueAsField(element)); } } diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 4d3a526b276..f97571ce463 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -24,6 +25,37 @@ namespace ErrorCodes extern const int LOGICAL_ERROR; } +namespace +{ + +class FieldVisitorReplaceScalars : public StaticVisitor +{ +public: + explicit FieldVisitorReplaceScalars(const Field & replacement_) : replacement(replacement_) + { + } + + template + Field operator()(const T & x) const + { + if constexpr (std::is_same_v) + { + const size_t size = x.size(); + Array res(size); + for (size_t i = 0; i < size; ++i) + res[i] = applyVisitor(*this, x[i]); + return res; + } + else + return replacement; + } + +private: + const Field & replacement; +}; + +} + template template void SerializationObject::deserializeTextImpl(IColumn & column, Reader && reader) const @@ -37,12 +69,12 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & if (!result) throw Exception(ErrorCodes::INCORRECT_DATA, "Cannot parse object"); - auto && [paths, values] = *result; + auto & [paths, values] = *result; assert(paths.size() == values.size()); HashSet paths_set; for (const auto & path : paths) - paths_set.insert(path); + paths_set.insert(path.getPath()); if (paths.size() != paths_set.size()) throw Exception(ErrorCodes::INCORRECT_DATA, "Object has ambiguous paths"); @@ -61,8 +93,33 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & for (auto & [key, subcolumn] : column_object.getSubcolumns()) { - if (!paths_set.has(key)) - subcolumn.insertDefault(); + if (!paths_set.has(key.getPath())) + { + if (key.hasNested()) + { + auto nested_key = column_object.findSubcolumnForNested(key, subcolumn.size() + 1); + + if (nested_key) + { + const auto & subcolumn_nested = column_object.getSubcolumn(*nested_key); + auto last_field = subcolumn_nested.getLastField(); + if (last_field.isNull()) + continue; + + auto default_scalar = getBaseTypeOfArray(subcolumn_nested.getLeastCommonType())->getDefault(); + auto default_field = applyVisitor(FieldVisitorReplaceScalars(default_scalar), last_field); + subcolumn.insert(std::move(default_field)); + } + else + { + subcolumn.insertDefault(); + } + } + else + { + subcolumn.insertDefault(); + } + } } } @@ -154,17 +211,17 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( for (const auto & [key, subcolumn] : column_object.getSubcolumns()) { settings.path.back() = Substream::ObjectStructure; - settings.path.back().object_key_name = key; + settings.path.back().object_key_name = key.getPath(); const auto & type = subcolumn.getLeastCommonType(); if (auto * stream = settings.getter(settings.path)) { - writeStringBinary(key, *stream); + key.writeBinary(*stream); writeStringBinary(type->getName(), *stream); } settings.path.back() = Substream::ObjectElement; - settings.path.back().object_key_name = key; + settings.path.back().object_key_name = key.getPath(); if (auto * stream = settings.getter(settings.path)) { @@ -201,13 +258,13 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( settings.path.back() = Substream::ObjectElement; for (size_t i = 0; i < num_subcolumns; ++i) { - String key; + Path key; String type_name; settings.path.back() = Substream::ObjectStructure; if (auto * stream = settings.getter(settings.path)) { - readStringBinary(key, *stream); + key.readBinary(*stream); readStringBinary(type_name, *stream); } else @@ -217,7 +274,7 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( } settings.path.back() = Substream::ObjectElement; - settings.path.back().object_key_name = key; + settings.path.back().object_key_name = key.getPath(); if (auto * stream = settings.getter(settings.path)) { @@ -225,12 +282,12 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( auto serialization = type->getDefaultSerialization(); ColumnPtr subcolumn_data = type->createColumn(); serialization->deserializeBinaryBulkWithMultipleStreams(subcolumn_data, limit, settings, state, cache); - column_object.addSubcolumn(key, subcolumn_data->assumeMutable()); + column_object.addSubcolumn(Path(key), subcolumn_data->assumeMutable()); } else { throw Exception(ErrorCodes::CANNOT_READ_ALL_DATA, - "Cannot read subcolumn '{}' of DataTypeObject, because its stream is missing", key); + "Cannot read subcolumn '{}' of DataTypeObject, because its stream is missing", key.getPath()); } } @@ -278,7 +335,7 @@ void SerializationObject::serializeTextImpl(const IColumn & column, size if (it != subcolumns.begin()) writeCString(",", ostr); - writeDoubleQuoted(it->first, ostr); + writeDoubleQuoted(it->first.getPath(), ostr); writeChar(':', ostr); auto serialization = it->second.getLeastCommonType()->getDefaultSerialization(); diff --git a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp index f7d84db5e7f..c14b1fa1f72 100644 --- a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp +++ b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #if USE_SIMDJSON @@ -9,6 +10,8 @@ using namespace DB; const String json1 = R"({"k1" : 1, "k2" : {"k3" : "aa", "k4" : 2}})"; + +/// Nested(k2 String, k3 Nested(k4 String)) const String json2 = R"({"k1" : [ { @@ -24,7 +27,6 @@ R"({"k1" : [ TEST(JSONDataParser, ReadJSON) { - { String json_bad = json1 + "aaaaaaa"; @@ -46,31 +48,153 @@ TEST(JSONDataParser, ReadJSON) } } +static void check( + const String & json_str, + const Strings & expected_paths, + const std::vector & expected_values, + const std::vector> & expected_nested, + const String & tag) +{ + JSONDataParser parser; + auto res = parser.parse(json_str.data(), json_str.size()); + ASSERT_TRUE(res.has_value()) << tag; + + const auto & [paths, values] = *res; + + ASSERT_EQ(paths.size(), expected_paths.size()) << tag; + ASSERT_EQ(values.size(), expected_values.size()) << tag; + + Strings paths_str; + std::vector> paths_is_nested; + + for (const auto & path : paths) + { + paths_str.push_back(path.getPath()); + paths_is_nested.emplace_back(); + for (size_t i = 0; i < path.getNumParts(); ++i) + paths_is_nested.back().push_back(path.isNested(i)); + } + + ASSERT_EQ(paths_str, expected_paths) << tag; + ASSERT_EQ(values, expected_values) << tag; + ASSERT_EQ(paths_is_nested, expected_nested) << tag; +} + TEST(JSONDataParser, Parse) { { - JSONDataParser parser; - auto res = parser.parse(json1.data(), json1.size()); - ASSERT_TRUE(res.has_value()); - - const auto & [paths, values] = *res; - ASSERT_EQ(paths, (Strings{"k1", "k2.k3", "k2.k4"})); - ASSERT_EQ(values, (std::vector{1, "aa", 2})); + check(json1, + {"k1", "k2.k3", "k2.k4"}, + {1, "aa", 2}, + {{false}, {false, false}, {false, false}}, + "json1"); } { - JSONDataParser parser; - auto res = parser.parse(json2.data(), json2.size()); - ASSERT_TRUE(res.has_value()); - - const auto & [paths, values] = *res; - ASSERT_EQ(paths, (Strings{"k1.k3.k4", "k1.k2"})); + Strings paths = {"k1.k3.k4", "k1.k2"}; auto k1k3k4 = Array{Array{"bbb", "ccc"}, Array{"eee", "fff"}}; auto k1k2 = Array{"aaa", "ddd"}; - ASSERT_EQ(values, (std::vector{k1k3k4, k1k2})); + + check(json2, paths, {k1k3k4, k1k2}, {{true, true, false}, {true, false}}, "json2"); } + { + /// Nested(k2 Tuple(k3 Array(Int), k4 Array(Int)), k5 String) + const String json3 = + R"({"k1": [ + { + "k2": { + "k3": [1, 2], + "k4": [3, 4] + }, + "k5": "foo" + }, + { + "k2": { + "k3": [5, 6], + "k4": [7, 8] + }, + "k5": "bar" + } + ]})"; + + Strings paths = {"k1.k2.k4", "k1.k5", "k1.k2.k3"}; + + auto k1k2k3 = Array{Array{1, 2}, Array{5, 6}}; + auto k1k2k4 = Array{Array{3, 4}, Array{7, 8}}; + auto k1k5 = Array{"foo", "bar"}; + + check(json3, paths, + {k1k2k4, k1k5, k1k2k3}, + {{true, false, false}, {true, false}, {true, false, false}}, + "json3"); + } + + { + /// Nested(k2 Nested(k3 Int, k4 Int), k5 String) + const String json4 = + R"({"k1": [ + { + "k2": [{"k3": 1, "k4": 3}, {"k3": 2, "k4": 4}], + "k5": "foo" + }, + { + "k2": [{"k3": 5, "k4": 7}, {"k3": 6, "k4": 8}], + "k5": "bar" + } + ]})"; + + Strings paths = {"k1.k2.k4", "k1.k5", "k1.k2.k3"}; + + auto k1k2k3 = Array{Array{1, 2}, Array{5, 6}}; + auto k1k2k4 = Array{Array{3, 4}, Array{7, 8}}; + auto k1k5 = Array{"foo", "bar"}; + + check(json4, paths, + {k1k2k4, k1k5, k1k2k3}, + {{true, true, false}, {true, false}, {true, true, false}}, + "json4"); + } + + { + const String json5 = R"({"k1": [[1, 2, 3], [4, 5], [6]]})"; + check(json5, {"k1"}, {Array{Array{1, 2, 3}, Array{4, 5}, Array{6}}}, {{false}}, "json5"); + } + + { + /// Array(Nested(k2 Int, k3 Int)) + const String json6 = R"({ + "k1": [ + [{"k2": 1, "k3": 2}, {"k2": 3, "k3": 4}], + [{"k2": 5, "k3": 6}] + ] + })"; + + Strings paths = {"k1.k2", "k1.k3"}; + + auto k1k2 = Array{Array{1, 3}, Array{5}}; + auto k1k3 = Array{Array{2, 4}, Array{6}}; + + check(json6, paths, {k1k2, k1k3}, {{true, true}, {true, true}}, "json6"); + } + + { + /// Nested(k2 Array(Int), k3 Array(Int)) + const String json7 = R"({ + "k1": [ + {"k2": [1, 3], "k3": [2, 4]}, + {"k2": [5], "k3": [6]} + ] + })"; + + Strings paths = {"k1.k2", "k1.k3"}; + + auto k1k2 = Array{Array{1, 3}, Array{5}}; + auto k1k3 = Array{Array{2, 4}, Array{6}}; + + check(json7, paths, {k1k2, k1k3}, {{true, false}, {true, false}}, "json7"); + } } #endif diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index 8cddcbc3ec8..d02f3db25f0 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -3046,15 +3046,15 @@ private: size_t tuple_size = to_types.size(); const ColumnTuple & column_tuple = assert_cast(*arguments.front().column); - ColumnObject::SubcolumnsMap subcolumns; + auto res = ColumnObject::create(has_nullable_subcolumns); for (size_t i = 0; i < tuple_size; ++i) { ColumnsWithTypeAndName element = {{column_tuple.getColumns()[i], from_types[i], "" }}; auto converted_column = element_wrappers[i](element, to_types[i], nullable_source, input_rows_count); - subcolumns[names[i]] = converted_column->assumeMutable(); + res->addSubcolumn(Path(names[i]), converted_column->assumeMutable()); } - return ColumnObject::create(std::move(subcolumns), has_nullable_subcolumns); + return res; }; } else if (checkAndGetDataType(from_type.get())) @@ -3069,7 +3069,7 @@ private: } throw Exception(ErrorCodes::TYPE_MISMATCH, - "Cast to Object can be performed only from flatten named tuple. Got: {}", from_type->getName()); + "Cast to Object can be performed only from flatten named tuple or string. Got: {}", from_type->getName()); } template diff --git a/src/Interpreters/InterpreterDescribeQuery.cpp b/src/Interpreters/InterpreterDescribeQuery.cpp index 9eb098c9f3b..da5fcedd469 100644 --- a/src/Interpreters/InterpreterDescribeQuery.cpp +++ b/src/Interpreters/InterpreterDescribeQuery.cpp @@ -93,7 +93,9 @@ BlockIO InterpreterDescribeQuery::execute() columns = metadata_snapshot->getColumns(); } - bool include_subcolumns = getContext()->getSettingsRef().describe_include_subcolumns; + bool extend_object_types = settings.describe_extend_object_types && storage_snapshot; + bool include_subcolumns = settings.describe_include_subcolumns; + Block sample_block = getSampleBlock(include_subcolumns); MutableColumns res_columns = sample_block.cloneEmptyColumns(); @@ -101,7 +103,7 @@ BlockIO InterpreterDescribeQuery::execute() { res_columns[0]->insert(column.name); - if (settings.describe_extend_object_types && storage_snapshot) + if (extend_object_types) res_columns[1]->insert(storage_snapshot->getConcreteType(column.name)->getName()); else res_columns[1]->insert(column.type->getName()); @@ -137,6 +139,8 @@ BlockIO InterpreterDescribeQuery::execute() { for (const auto & column : columns) { + auto type = extend_object_types ? storage_snapshot->getConcreteType(column.name) : column.type; + IDataType::forEachSubcolumn([&](const auto & path, const auto & name, const auto & data) { res_columns[0]->insert(Nested::concatenateName(column.name, name)); @@ -159,7 +163,7 @@ BlockIO InterpreterDescribeQuery::execute() res_columns[6]->insertDefault(); res_columns[7]->insert(1u); - }, {column.type->getDefaultSerialization(), column.type, nullptr, nullptr}); + }, { type->getDefaultSerialization(), type, nullptr, nullptr }); } } diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp index d3922b1c769..44dd77b2ce2 100644 --- a/src/Storages/StorageSnapshot.cpp +++ b/src/Storages/StorageSnapshot.cpp @@ -33,15 +33,15 @@ NamesAndTypesList StorageSnapshot::getColumns(const GetColumnsOptions & options) { /// Virtual columns must be appended after ordinary, /// because user can override them. - auto virtuals = storage.getVirtuals(); - if (!virtuals.empty()) + if (!virtual_columns.empty()) { NameSet column_names; for (const auto & column : all_columns) column_names.insert(column.name); - for (auto && column : virtuals) - if (!column_names.count(column.name)) - all_columns.push_back(std::move(column)); + + for (const auto & [name, type] : virtual_columns) + if (!column_names.count(name)) + all_columns.emplace_back(name, type); } } diff --git a/tests/queries/0_stateless/01825_type_json_1.reference b/tests/queries/0_stateless/01825_type_json_1.reference index 4c21f14d4e9..59fad00bfae 100644 --- a/tests/queries/0_stateless/01825_type_json_1.reference +++ b/tests/queries/0_stateless/01825_type_json_1.reference @@ -1,12 +1,12 @@ 1 aa bb c 2 ee ff 3 foo -all_1_1_0 data Tuple(k1 String, `k2.k3` String, `k2.k4` String, k5 String) +all_1_1_0 data Tuple(k1 String, k2 Tuple(k3 String, k4 String), k5 String) all_2_2_0 data Tuple(k5 String) -all_1_2_1 data Tuple(k1 String, `k2.k3` String, `k2.k4` String, k5 String) +all_1_2_1 data Tuple(k1 String, k2 Tuple(k3 String, k4 String), k5 String) ============ 1 ['aaa','ddd'] [['bbb','ccc'],['eee','fff']] -all_3_3_0 data Tuple(`k1.k2` Array(String), `k1.k3.k4` Array(Array(String))) +all_3_3_0 data Tuple(k1 Nested(k2 String, `k3.k4` Array(String))) ============ 1 a 42 2 b 4200 diff --git a/tests/queries/0_stateless/01825_type_json_3.reference b/tests/queries/0_stateless/01825_type_json_3.reference index 830d44d779c..24d191a6e5d 100644 --- a/tests/queries/0_stateless/01825_type_json_3.reference +++ b/tests/queries/0_stateless/01825_type_json_3.reference @@ -3,29 +3,29 @@ 1 0 2 v1 2 ======== -1 ([],[]) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) -2 (['v1','v4'],['v3','']) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +1 ([]) Tuple(k1 Nested(k2 String, k3 String)) +2 ([('v1','v3'),('v4','')]) Tuple(k1 Nested(k2 String, k3 String)) 1 [] [] 2 ['v1','v4'] ['v3',''] -1 ([],[]) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) -2 (['v1','v4'],['v3','']) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) -3 ([],[]) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) -4 ([],[]) Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) -all_2_2_0 data Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +1 ([]) Tuple(k1 Nested(k2 String, k3 String)) +2 ([('v1','v3'),('v4','')]) Tuple(k1 Nested(k2 String, k3 String)) +3 ([]) Tuple(k1 Nested(k2 String, k3 String)) +4 ([]) Tuple(k1 Nested(k2 String, k3 String)) +all_2_2_0 data Tuple(k1 Nested(k2 String, k3 String)) all_3_3_0 data Tuple(_dummy UInt8) 1 [] [] 2 ['v1','v4'] ['v3',''] 3 [] [] 4 [] [] -data Tuple(`k1.k2` Array(String), `k1.k3` Array(String)) +data Tuple(k1 Nested(k2 String, k3 String)) 1 [] [] 2 ['v1','v4'] ['v3',''] 3 [] [] 4 [] [] ======== -1 (1,'foo',[]) Tuple(`k1.k2` Int8, `k1.k3` String, k4 Array(Int8)) -2 (0,'',[1,2,3]) Tuple(`k1.k2` Int8, `k1.k3` String, k4 Array(Int8)) -3 (10,'',[]) Tuple(`k1.k2` Int8, `k1.k3` String, k4 Array(Int8)) +1 ((1,'foo'),[]) Tuple(k1 Tuple(k2 Int8, k3 String), k4 Array(Int8)) +2 ((0,''),[1,2,3]) Tuple(k1 Tuple(k2 Int8, k3 String), k4 Array(Int8)) +3 ((10,''),[]) Tuple(k1 Tuple(k2 Int8, k3 String), k4 Array(Int8)) 1 1 foo [] 2 0 [1,2,3] 3 10 [] diff --git a/tests/queries/0_stateless/01825_type_json_5.reference b/tests/queries/0_stateless/01825_type_json_5.reference index 8abbbe74968..6b4dfab0643 100644 --- a/tests/queries/0_stateless/01825_type_json_5.reference +++ b/tests/queries/0_stateless/01825_type_json_5.reference @@ -2,4 +2,4 @@ {"s":{"a.c":2,"a.b":1}} 1 [22,33] 2 qqq [44] -Tuple(k1 Int8, `k2.k3` String, `k2.k4` Array(Int8)) +Tuple(k1 Int8, k2 Tuple(k3 String, k4 Array(Int8))) diff --git a/tests/queries/0_stateless/01825_type_json_6.reference b/tests/queries/0_stateless/01825_type_json_6.reference index d3229d48632..7fcd2a40826 100644 --- a/tests/queries/0_stateless/01825_type_json_6.reference +++ b/tests/queries/0_stateless/01825_type_json_6.reference @@ -1,3 +1,3 @@ -Tuple(key String, `out.outputs.index` Array(Array(Int32)), `out.outputs.n` Array(Array(Int8)), `out.type` Array(Int8), `out.value` Array(Int8)) +Tuple(key String, out Nested(outputs Nested(index Int32, n Int8), type Int8, value Int8)) v1 [0,0] [1,2] [[],[1960131]] [[],[0]] v2 [1,1] [4,3] [[1881212],[]] [[1],[]] diff --git a/tests/queries/0_stateless/01825_type_json_distributed.reference b/tests/queries/0_stateless/01825_type_json_distributed.reference index 21308748ef3..9ae85ac888c 100644 --- a/tests/queries/0_stateless/01825_type_json_distributed.reference +++ b/tests/queries/0_stateless/01825_type_json_distributed.reference @@ -1,4 +1,4 @@ -(2,'qqq',[44,55]) Tuple(k1 Int8, `k2.k3` String, `k2.k4` Array(Int8)) -(2,'qqq',[44,55]) Tuple(k1 Int8, `k2.k3` String, `k2.k4` Array(Int8)) +(2,('qqq',[44,55])) Tuple(k1 Int8, k2 Tuple(k3 String, k4 Array(Int8))) +(2,('qqq',[44,55])) Tuple(k1 Int8, k2 Tuple(k3 String, k4 Array(Int8))) 2 qqq [44,55] 2 qqq [44,55] diff --git a/tests/queries/0_stateless/01825_type_json_insert_select.reference b/tests/queries/0_stateless/01825_type_json_insert_select.reference index 3a7fe84af9e..ebf4c1ee736 100644 --- a/tests/queries/0_stateless/01825_type_json_insert_select.reference +++ b/tests/queries/0_stateless/01825_type_json_insert_select.reference @@ -4,9 +4,9 @@ Tuple(k1 Int8, k2 String, k3 String) 1 (1,'foo','') 2 (2,'bar','') 3 (3,'','aaa') -Tuple(`arr.k11` Array(Int8), `arr.k22` Array(String), `arr.k33` Array(Int8), k1 Int8, k2 String, k3 String) -1 ([],[],[],1,'foo','') -2 ([],[],[],2,'bar','') -3 ([],[],[],3,'','aaa') -4 ([5,7],['6','0'],[0,8],0,'','') -5 ([],['str1'],[],0,'','') +Tuple(arr Nested(k11 Int8, k22 String, k33 Int8), k1 Int8, k2 String, k3 String) +1 ([],1,'foo','') +2 ([],2,'bar','') +3 ([],3,'','aaa') +4 ([(5,'6',0),(7,'0',8)],0,'','') +5 ([],0,'','') From 079b08a28a1b9752c4c6062d21e9fa170d832a13 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Mon, 13 Dec 2021 14:37:23 +0300 Subject: [PATCH 052/132] support nested in json type (wip) --- src/Columns/ColumnObject.cpp | 272 +++++++++--------- src/Columns/ColumnObject.h | 18 +- src/DataTypes/ObjectUtils.cpp | 11 +- .../{JSONDataParser.cpp => DataPath.cpp} | 6 +- src/DataTypes/Serializations/DataPath.h | 217 ++++++++++++++ src/DataTypes/Serializations/JSONDataParser.h | 39 +-- .../Serializations/SerializationObject.cpp | 91 +++--- src/Functions/transform.cpp | 2 +- .../WindowView/WindowViewProxyStorage.h | 5 +- 9 files changed, 438 insertions(+), 223 deletions(-) rename src/DataTypes/Serializations/{JSONDataParser.cpp => DataPath.cpp} (89%) create mode 100644 src/DataTypes/Serializations/DataPath.h diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 67ba7aaf600..43a8e118a89 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -45,10 +45,12 @@ Array createEmptyArrayField(size_t num_dimensions) return array; } -ColumnPtr recreateWithDefaultValues(const ColumnPtr & column) +ColumnPtr recreateColumnWithDefaultValues(const ColumnPtr & column) { if (const auto * column_array = checkAndGetColumn(column.get())) - return ColumnArray::create(recreateWithDefaultValues(column_array->getDataPtr()), IColumn::mutate(column_array->getOffsetsPtr())); + return ColumnArray::create( + recreateColumnWithDefaultValues(column_array->getDataPtr()), + IColumn::mutate(column_array->getOffsetsPtr())); else return column->cloneEmpty()->cloneResized(column->size()); } @@ -171,16 +173,8 @@ public: type_indexes.insert(TypeId>); } - DataTypePtr getScalarType() const - { - - auto res = getLeastSupertype(type_indexes, true); - if (have_nulls) - return makeNullable(res); - - return res; - } - + DataTypePtr getScalarType() const { return getLeastSupertype(type_indexes, true); } + bool haveNulls() const { return have_nulls; } bool needConvertField() const { return field_types.size() > 1; } private: @@ -248,6 +242,17 @@ void ColumnObject::Subcolumn::checkTypes() const void ColumnObject::Subcolumn::insert(Field field) { + FieldVisitorToScalarType to_scalar_type_visitor; + applyVisitor(to_scalar_type_visitor, field); + + auto base_type = to_scalar_type_visitor.getScalarType(); + + if (isNothing(base_type) && (!is_nullable || !to_scalar_type_visitor.haveNulls())) + { + insertDefault(); + return; + } + auto column_dim = getNumberOfDimensions(*least_common_type); auto value_dim = applyVisitor(FieldVisitorToNumberOfDimensions(), field); @@ -259,39 +264,24 @@ void ColumnObject::Subcolumn::insert(Field field) if (value_dim != column_dim) throw Exception(ErrorCodes::NUMBER_OF_DIMENSIONS_MISMATHED, - "Dimension of types mismatched between inserted value and column." + "Dimension of types mismatched between inserted value and column. " "Dimension of value: {}. Dimension of column: {}", value_dim, column_dim); - FieldVisitorToScalarType to_scalar_type_visitor; - applyVisitor(to_scalar_type_visitor, field); - - auto base_type = to_scalar_type_visitor.getScalarType(); - if (isNothing(base_type)) - { - insertDefault(); - return; - } - - if (is_nullable && !base_type->isNullable()) + if (is_nullable) base_type = makeNullable(base_type); DataTypePtr value_type; - if (!is_nullable && base_type->isNullable()) + if (!is_nullable && to_scalar_type_visitor.haveNulls()) { - base_type = removeNullable(base_type); - if (isNothing(base_type)) - { - insertDefault(); - return; - } - - value_type = createArrayOfType(base_type, value_dim); auto default_value = base_type->getDefault(); + value_type = createArrayOfType(base_type, value_dim); field = applyVisitor(FieldVisitorReplaceNull(default_value, value_dim), std::move(field)); } else + { value_type = createArrayOfType(base_type, value_dim); + } bool type_changed = false; @@ -394,17 +384,6 @@ void ColumnObject::Subcolumn::finalize() num_of_defaults_in_prefix = 0; } -Field ColumnObject::Subcolumn::getLastField() const -{ - if (data.empty()) - return Field(); - - const auto & last_part = data.back(); - assert(!last_part.empty()); - return (*last_part)[last_part->size() - 1]; -} - - void ColumnObject::Subcolumn::insertDefault() { if (data.empty()) @@ -421,6 +400,56 @@ void ColumnObject::Subcolumn::insertManyDefaults(size_t length) data.back()->insertManyDefaults(length); } +void ColumnObject::Subcolumn::popBack(size_t n) +{ + assert(n <= size); + + size_t num_removed = 0; + for (auto it = data.rbegin(); it != data.rend(); ++it) + { + if (n == 0) + break; + + auto & column = *it; + if (n < column->size()) + { + column->popBack(n); + n = 0; + } + else + { + ++num_removed; + n -= column->size(); + } + } + + data.resize(data.size() - num_removed); + num_of_defaults_in_prefix -= n; +} + +Field ColumnObject::Subcolumn::getLastField() const +{ + if (data.empty()) + return Field(); + + const auto & last_part = data.back(); + assert(!last_part.empty()); + return (*last_part)[last_part->size() - 1]; +} + +ColumnObject::Subcolumn ColumnObject::Subcolumn::recreateWithDefaultValues() const +{ + Subcolumn new_subcolumn; + new_subcolumn.least_common_type = least_common_type; + new_subcolumn.num_of_defaults_in_prefix = num_of_defaults_in_prefix; + new_subcolumn.data.reserve(data.size()); + + for (const auto & part : data) + new_subcolumn.data.push_back(recreateColumnWithDefaultValues(part)); + + return new_subcolumn; +} + IColumn & ColumnObject::Subcolumn::getFinalizedColumn() { assert(isFinalized()); @@ -444,7 +473,7 @@ ColumnObject::ColumnObject(bool is_nullable_) { } -ColumnObject::ColumnObject(SubcolumnsMap && subcolumns_, bool is_nullable_) +ColumnObject::ColumnObject(SubcolumnsTree && subcolumns_, bool is_nullable_) : subcolumns(std::move(subcolumns_)) , is_nullable(is_nullable_) { @@ -456,14 +485,16 @@ void ColumnObject::checkConsistency() const if (subcolumns.empty()) return; - size_t first_size = subcolumns.begin()->second.size(); - for (const auto & [key, column] : subcolumns) + const auto & first_leaf = *subcolumns.begin(); + size_t first_size = first_leaf->column.size(); + + for (const auto & leaf : subcolumns) { - if (first_size != column.size()) + if (first_size != leaf->column.size()) { throw Exception(ErrorCodes::LOGICAL_ERROR, "Sizes of subcolumns are inconsistent in ColumnObject." " Subcolumn '{}' has {} rows, subcolumn '{}' has {} rows", - subcolumns.begin()->first.getPath(), first_size, key.getPath(), column.size()); + first_leaf->path.getPath(), first_size, leaf->path.getPath(), leaf->column.size()); } } } @@ -473,7 +504,7 @@ size_t ColumnObject::size() const #ifndef NDEBUG checkConsistency(); #endif - return subcolumns.empty() ? 0 : subcolumns.begin()->second.size(); + return subcolumns.empty() ? 0 : (*subcolumns.begin())->column.size(); } MutableColumnPtr ColumnObject::cloneResized(size_t new_size) const @@ -488,16 +519,16 @@ MutableColumnPtr ColumnObject::cloneResized(size_t new_size) const size_t ColumnObject::byteSize() const { size_t res = 0; - for (const auto & [_, column] : subcolumns) - res += column.byteSize(); + for (const auto & entry : subcolumns) + res += entry->column.byteSize(); return res; } size_t ColumnObject::allocatedBytes() const { size_t res = 0; - for (const auto & [_, column] : subcolumns) - res += column.allocatedBytes(); + for (const auto & entry : subcolumns) + res += entry->column.allocatedBytes(); return res; } @@ -506,8 +537,8 @@ void ColumnObject::forEachSubcolumn(ColumnCallback callback) if (!isFinalized()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot iterate over non-finalized ColumnObject"); - for (auto & [_, column] : subcolumns) - callback(column.data.back()); + for (auto & entry : subcolumns) + callback(entry->column.data.back()); } void ColumnObject::insert(const Field & field) @@ -527,15 +558,15 @@ void ColumnObject::insert(const Field & field) subcolumn.insert(value); } - for (auto & [key, subcolumn] : subcolumns) - if (!inserted.has(key.getPath())) - subcolumn.insertDefault(); + for (auto & entry : subcolumns) + if (!inserted.has(entry->path.getPath())) + entry->column.insertDefault(); } void ColumnObject::insertDefault() { - for (auto & [_, subcolumn] : subcolumns) - subcolumn.insertDefault(); + for (auto & entry : subcolumns) + entry->column.insertDefault(); } Field ColumnObject::operator[](size_t n) const @@ -544,8 +575,8 @@ Field ColumnObject::operator[](size_t n) const throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot get Field from non-finalized ColumnObject"); Object object; - for (const auto & [key, subcolumn] : subcolumns) - object[key.getPath()] = (*subcolumn.data.back())[n]; + for (const auto & entry : subcolumns) + object[entry->path.getPath()] = (*entry->column.data.back())[n]; return object; } @@ -556,10 +587,10 @@ void ColumnObject::get(size_t n, Field & res) const throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot get Field from non-finalized ColumnObject"); auto & object = res.get(); - for (const auto & [key, subcolumn] : subcolumns) + for (const auto & entry : subcolumns) { - auto it = object.try_emplace(key.getPath()).first; - subcolumn.data.back()->get(n, it->second); + auto it = object.try_emplace(entry->path.getPath()).first; + entry->column.data.back()->get(n, it->second); } } @@ -567,12 +598,12 @@ void ColumnObject::insertRangeFrom(const IColumn & src, size_t start, size_t len { const auto & src_object = assert_cast(src); - for (auto & [name, subcolumn] : subcolumns) + for (auto & entry : subcolumns) { - if (src_object.hasSubcolumn(name)) - subcolumn.insertRangeFrom(src_object.getSubcolumn(name), start, length); + if (src_object.hasSubcolumn(entry->path)) + entry->column.insertRangeFrom(src_object.getSubcolumn(entry->path), start, length); else - subcolumn.insertManyDefaults(length); + entry->column.insertManyDefaults(length); } finalize(); @@ -584,10 +615,10 @@ ColumnPtr ColumnObject::replicate(const Offsets & offsets) const throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot replicate non-finalized ColumnObject"); auto res_column = ColumnObject::create(is_nullable); - for (const auto & [key, subcolumn] : subcolumns) + for (const auto & entry : subcolumns) { - auto replicated_data = subcolumn.data.back()->replicate(offsets)->assumeMutable(); - res_column->addSubcolumn(key, std::move(replicated_data), is_nullable); + auto replicated_data = entry->column.data.back()->replicate(offsets)->assumeMutable(); + res_column->addSubcolumn(entry->path, std::move(replicated_data), is_nullable); } return res_column; @@ -595,128 +626,105 @@ ColumnPtr ColumnObject::replicate(const Offsets & offsets) const void ColumnObject::popBack(size_t length) { - if (!isFinalized()) - throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot popBack from non-finalized ColumnObject"); - - for (auto & [_, subcolumn] : subcolumns) - subcolumn.data.back()->popBack(length); + for (auto & entry : subcolumns) + entry->column.popBack(length); } const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) const { - auto it = subcolumns.find(key); - if (it != subcolumns.end()) - return it->second; + if (const auto * node = subcolumns.findLeaf(key)) + return node->column; throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key.getPath()); } ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) { - auto it = subcolumns.find(key); - if (it != subcolumns.end()) - return it->second; + if (const auto * node = subcolumns.findLeaf(key)) + return const_cast(node)->column; throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key.getPath()); } -std::optional ColumnObject::findSubcolumnForNested(const Path & key, size_t expected_size) const -{ - for (const auto & [other_key, other_subcolumn] : subcolumns) - { - if (key == other_key || expected_size != other_subcolumn.size()) - continue; - - auto split_lhs = Nested::splitName(key.getPath(), true); - auto split_rhs = Nested::splitName(other_key.getPath(), true); - - if (!split_lhs.first.empty() && split_lhs.first == split_rhs.first) - return other_key; - } - - return {}; -} - bool ColumnObject::hasSubcolumn(const Path & key) const { - return subcolumns.count(key) != 0; + return subcolumns.findLeaf(key) != nullptr; } void ColumnObject::addSubcolumn(const Path & key, size_t new_size, bool check_size) { - if (subcolumns.count(key)) - throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); - if (check_size && new_size != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", key.getPath(), new_size, size()); + bool inserted = false; if (key.hasNested()) { - auto nested_key = findSubcolumnForNested(key, new_size); - if (nested_key) + const auto * nested_node = subcolumns.findBestMatch(key); + if (nested_node && nested_node->isNested()) { - auto & nested_subcolumn = subcolumns[*nested_key]; - nested_subcolumn.finalize(); - auto default_column = recreateWithDefaultValues(nested_subcolumn.getFinalizedColumnPtr()); - subcolumns[key] = Subcolumn(default_column->assumeMutable(), is_nullable); - } - else - { - subcolumns[key] = Subcolumn(new_size, is_nullable); + const auto * leaf = subcolumns.findLeaf(nested_node, [&](const auto & ) { return true; }); + assert(leaf); + + auto new_subcolumn = leaf->column.recreateWithDefaultValues(); + if (new_subcolumn.size() == new_size + 1) + new_subcolumn.popBack(1); + + inserted = subcolumns.add(key, new_subcolumn); } } - else - { - subcolumns[key] = Subcolumn(new_size, is_nullable); - } + + if (!inserted) + inserted = subcolumns.add(key, Subcolumn(new_size, is_nullable)); + + if (!inserted) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); } void ColumnObject::addSubcolumn(const Path & key, MutableColumnPtr && subcolumn, bool check_size) { - if (subcolumns.count(key)) - throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); - if (check_size && subcolumn->size() != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", key.getPath(), subcolumn->size(), size()); - subcolumns[key] = Subcolumn(std::move(subcolumn), is_nullable); + bool inserted = subcolumns.add(key, Subcolumn(std::move(subcolumn), is_nullable)); + if (!inserted) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); } Paths ColumnObject::getKeys() const { Paths keys; keys.reserve(subcolumns.size()); - for (const auto & [key, _] : subcolumns) - keys.emplace_back(key); + for (const auto & entry : subcolumns) + keys.emplace_back(entry->path); return keys; } bool ColumnObject::isFinalized() const { return std::all_of(subcolumns.begin(), subcolumns.end(), - [](const auto & elem) { return elem.second.isFinalized(); }); + [](const auto & entry) { return entry->column.isFinalized(); }); } void ColumnObject::finalize() { size_t old_size = size(); - SubcolumnsMap new_subcolumns; - for (auto && [name, subcolumn] : subcolumns) + SubcolumnsTree new_subcolumns; + for (auto && entry : subcolumns) { - const auto & least_common_type = subcolumn.getLeastCommonType(); + const auto & least_common_type = entry->column.getLeastCommonType(); if (isNothing(getBaseTypeOfArray(least_common_type))) continue; - subcolumn.finalize(); - new_subcolumns[name] = std::move(subcolumn); + entry->column.finalize(); + new_subcolumns.add(entry->path, std::move(entry->column)); } if (new_subcolumns.empty()) - new_subcolumns[Path(COLUMN_NAME_DUMMY)] = Subcolumn{ColumnUInt8::create(old_size), is_nullable}; + new_subcolumns.add(Path{COLUMN_NAME_DUMMY}, Subcolumn{ColumnUInt8::create(old_size), is_nullable}); std::swap(subcolumns, new_subcolumns); checkObjectHasNoAmbiguosPaths(getKeys()); diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 038d1317ff3..41cdea125a0 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -6,6 +6,7 @@ #include #include #include +#include #include @@ -39,10 +40,12 @@ public: void insertDefault(); void insertManyDefaults(size_t length); void insertRangeFrom(const Subcolumn & src, size_t start, size_t length); + void popBack(size_t n); void finalize(); Field getLastField() const; + Subcolumn recreateWithDefaultValues() const; IColumn & getFinalizedColumn(); const IColumn & getFinalizedColumn() const; @@ -57,17 +60,19 @@ public: size_t num_of_defaults_in_prefix = 0; }; - using SubcolumnsMap = std::unordered_map; + // using SubcolumnsMap = std::unordered_map; + using SubcolumnsTree = SubcolumnsTree; private: - SubcolumnsMap subcolumns; + // SubcolumnsMap subcolumns; + SubcolumnsTree subcolumns; bool is_nullable; public: static constexpr auto COLUMN_NAME_DUMMY = "_dummy"; explicit ColumnObject(bool is_nullable_); - ColumnObject(SubcolumnsMap && subcolumns_, bool is_nullable_); + ColumnObject(SubcolumnsTree && subcolumns_, bool is_nullable_); void checkConsistency() const; @@ -75,13 +80,12 @@ public: const Subcolumn & getSubcolumn(const Path & key) const; Subcolumn & getSubcolumn(const Path & key); - std::optional findSubcolumnForNested(const Path & key, size_t expected_size) const; void addSubcolumn(const Path & key, size_t new_size, bool check_size = false); void addSubcolumn(const Path & key, MutableColumnPtr && subcolumn, bool check_size = false); - const SubcolumnsMap & getSubcolumns() const { return subcolumns; } - SubcolumnsMap & getSubcolumns() { return subcolumns; } + const SubcolumnsTree & getSubcolumns() const { return subcolumns; } + SubcolumnsTree & getSubcolumns() { return subcolumns; } Paths getKeys() const; bool isFinalized() const; @@ -134,7 +138,7 @@ public: void getIndicesOfNonDefaultRows(Offsets &, size_t, size_t) const override { throwMustBeConcrete(); } private: - [[noreturn]] void throwMustBeConcrete() const + [[noreturn]] static void throwMustBeConcrete() { throw Exception("ColumnObject must be converted to ColumnTuple before use", ErrorCodes::LOGICAL_ERROR); } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 76b29ef8ccf..3db5b679757 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -20,6 +20,7 @@ #include #include #include +#include #include #include @@ -123,10 +124,10 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con std::vector> tuple_elements; tuple_elements.reserve(subcolumns_map.size()); - for (const auto & [key, subcolumn] : subcolumns_map) - tuple_elements.emplace_back(key, - subcolumn.getLeastCommonType(), - subcolumn.getFinalizedColumnPtr()); + for (const auto & entry : subcolumns_map) + tuple_elements.emplace_back(entry->path, + entry->column.getLeastCommonType(), + entry->column.getFinalizedColumnPtr()); std::sort(tuple_elements.begin(), tuple_elements.end(), [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs).getPath() < std::get<0>(rhs).getPath(); }); @@ -179,7 +180,7 @@ void checkObjectHasNoAmbiguosPaths(const Paths & paths) { if (isPrefix(names_parts[i], names_parts[j]) || isPrefix(names_parts[j], names_parts[i])) throw Exception(ErrorCodes::DUPLICATE_COLUMN, - "Data in Object has ambiguous paths: '{}' and '{}", + "Data in Object has ambiguous paths: '{}' and '{}'", paths[i].getPath(), paths[i].getPath()); } } diff --git a/src/DataTypes/Serializations/JSONDataParser.cpp b/src/DataTypes/Serializations/DataPath.cpp similarity index 89% rename from src/DataTypes/Serializations/JSONDataParser.cpp rename to src/DataTypes/Serializations/DataPath.cpp index a91b205e96d..51a007eb1a9 100644 --- a/src/DataTypes/Serializations/JSONDataParser.cpp +++ b/src/DataTypes/Serializations/DataPath.cpp @@ -1,5 +1,9 @@ -#include +#include #include +#include +#include +#include +#include #include #include diff --git a/src/DataTypes/Serializations/DataPath.h b/src/DataTypes/Serializations/DataPath.h new file mode 100644 index 00000000000..35b97d5f938 --- /dev/null +++ b/src/DataTypes/Serializations/DataPath.h @@ -0,0 +1,217 @@ +#pragma once + +#include +#include +#include +#include +#include + +namespace DB +{ + +class ReadBuffer; +class WriteBuffer; + +class Path +{ +public: + /// TODO: use dynamic bitset + using BitSet = std::bitset<64>; + + Path() = default; + explicit Path(std::string_view path_); + + void append(const Path & other); + void append(std::string_view key); + + const String & getPath() const { return path; } + bool isNested(size_t i) const { return is_nested.test(i); } + bool hasNested() const { return is_nested.any(); } + BitSet getIsNestedBitSet() const { return is_nested; } + + size_t getNumParts() const { return num_parts; } + bool empty() const { return path.empty(); } + + Strings getParts() const; + + static Path getNext(const Path & current_path, const Path & key, bool make_nested = false); + + void writeBinary(WriteBuffer & out) const; + void readBinary(ReadBuffer & in); + + bool operator==(const Path & other) const { return path == other.path; } + bool operator!=(const Path & other) const { return !(*this == other); } + struct Hash { size_t operator()(const Path & value) const; }; + +private: + String path; + size_t num_parts = 0; + BitSet is_nested; +}; + +using Paths = std::vector; + +template +class SubcolumnsTree +{ +public: + struct Node + { + enum Kind + { + TUPLE, + NESTED, + SCALAR, + }; + + Kind kind = TUPLE; + const Node * parent = nullptr; + std::unordered_map> children; + + bool isNested() const { return kind == NESTED; } + + std::shared_ptr addChild(const String & key_, Kind kind_) + { + auto next_node = kind_ == SCALAR ? std::make_shared() : std::make_shared(); + next_node->kind = kind_; + next_node->parent = this; + children[key_] = next_node; + return next_node; + } + + virtual ~Node() = default; + }; + + struct Leaf : public Node + { + Path path; + ColumnHolder column; + }; + + using NodePtr = std::shared_ptr; + using LeafPtr = std::shared_ptr; + + bool add(const Path & path, const ColumnHolder & column) + { + auto parts = path.getParts(); + auto is_nested = path.getIsNestedBitSet(); + + if (parts.empty()) + return false; + + if (!root) + { + root = std::make_shared(); + root->kind = Node::TUPLE; + } + + Node * current_node = root.get(); + for (size_t i = 0; i < parts.size() - 1; ++i) + { + assert(current_node->kind != Node::SCALAR); + + auto it = current_node->children.find(parts[i]); + if (it != current_node->children.end()) + { + current_node = it->second.get(); + bool current_node_is_nested = current_node->kind == Node::NESTED; + + if (current_node_is_nested != is_nested.test(i)) + return false; + } + else + { + auto next_kind = is_nested.test(i) ? Node::NESTED : Node::TUPLE; + current_node = current_node->addChild(parts[i], next_kind).get(); + } + } + + auto it = current_node->children.find(parts.back()); + if (it != current_node->children.end()) + return false; + + auto node = current_node->addChild(parts.back(), Node::SCALAR); + auto leaf = std::dynamic_pointer_cast(node); + assert(leaf); + + leaf->path = path; + leaf->column = column; + leaves.push_back(std::move(leaf)); + + return true; + } + + const Node * findBestMatch(const Path & path) const + { + if (!root) + return nullptr; + + auto parts = path.getParts(); + const Node * current_node = root.get(); + + for (const auto & part : parts) + { + auto it = current_node->children.find(part); + if (it == current_node->children.end()) + return current_node; + + current_node = it->second.get(); + } + + return current_node; + } + + const Leaf * findLeaf(const Path & path) const + { + return typeid_cast(findBestMatch(path)); + } + + using LeafPredicate = std::function; + + const Leaf * findLeaf(const LeafPredicate & predicate) + { + return findLeaf(root.get(), predicate); + } + + static const Leaf * findLeaf(const Node * node, const LeafPredicate & predicate) + { + if (const auto * leaf = typeid_cast(node)) + return predicate(*leaf) ? leaf : nullptr; + + for (const auto & [_, child] : node->children) + if (const auto * leaf = findLeaf(child.get(), predicate)) + return leaf; + + return nullptr; + } + + using NodePredicate = std::function; + + static const Node * findParent(const Node * node, const NodePredicate & predicate) + { + while (node && !predicate(*node)) + node = node->parent; + return node; + } + + bool empty() const { return root == nullptr; } + size_t size() const { return leaves.size(); } + + using Leaves = std::vector; + const Leaves & getLeaves() const { return leaves; } + + using iterator = typename Leaves::iterator; + using const_iterator = typename Leaves::const_iterator; + + iterator begin() { return leaves.begin(); } + iterator end() { return leaves.end(); } + + const_iterator begin() const { return leaves.begin(); } + const_iterator end() const { return leaves.end(); } + +private: + NodePtr root; + Leaves leaves; +}; + +} diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index 3be7d461981..5e2acb5e824 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -3,6 +3,7 @@ #include #include #include +#include #include namespace DB @@ -17,44 +18,6 @@ namespace ErrorCodes class ReadBuffer; class WriteBuffer; -class Path -{ -public: - // using BitSet = boost::dynamic_bitset, 8>>; - - Path() = default; - explicit Path(std::string_view path_); - - void append(const Path & other); - void append(std::string_view key); - - const String & getPath() const { return path; } - bool isNested(size_t i) const { return is_nested.test(i); } - bool hasNested() const { return is_nested.any(); } - - size_t getNumParts() const { return num_parts; } - bool empty() const { return path.empty(); } - - Strings getParts() const; - - static Path getNext(const Path & current_path, const Path & key, bool make_nested = false); - - void writeBinary(WriteBuffer & out) const; - void readBinary(ReadBuffer & in); - - bool operator==(const Path & other) const { return path == other.path; } - bool operator!=(const Path & other) const { return !(*this == other); } - struct Hash { size_t operator()(const Path & value) const; }; - -private: - String path; - size_t num_parts = 0; - /// TODO: use dynamic bitset - std::bitset<64> is_nested; -}; - -using Paths = std::vector; - template static Field getValueAsField(const Element & element) { diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index f97571ce463..4f44f9220e3 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -10,6 +10,8 @@ #include #include +#include + #include #include #include @@ -31,7 +33,8 @@ namespace class FieldVisitorReplaceScalars : public StaticVisitor { public: - explicit FieldVisitorReplaceScalars(const Field & replacement_) : replacement(replacement_) + explicit FieldVisitorReplaceScalars(const Field & replacement_) + : replacement(replacement_) { } @@ -54,6 +57,41 @@ private: const Field & replacement; }; +bool tryInsertDefaultFromNested( + ColumnObject::SubcolumnsTree::LeafPtr entry, const ColumnObject::SubcolumnsTree & subcolumns) +{ + if (!entry->path.hasNested()) + return false; + + const auto * node = subcolumns.findLeaf(entry->path); + if (!node) + return false; + + const auto * node_nested = subcolumns.findParent(node, + [](const auto & candidate) { return candidate.isNested(); }); + + if (!node_nested) + return false; + + const auto * leaf = subcolumns.findLeaf(node_nested, + [&](const auto & candidate) + { + return candidate.column.size() == entry->column.size() + 1; + }); + + if (!leaf) + return false; + + auto last_field = leaf->column.getLastField(); + if (last_field.isNull()) + return false; + + auto default_scalar = getBaseTypeOfArray(leaf->column.getLeastCommonType())->getDefault(); + auto default_field = applyVisitor(FieldVisitorReplaceScalars(default_scalar), last_field); + entry->column.insert(std::move(default_field)); + return true; +} + } template @@ -91,34 +129,14 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & subcolumn.insert(std::move(values[i])); } - for (auto & [key, subcolumn] : column_object.getSubcolumns()) + const auto & subcolumns = column_object.getSubcolumns(); + for (const auto & entry : subcolumns) { - if (!paths_set.has(key.getPath())) + if (!paths_set.has(entry->path.getPath())) { - if (key.hasNested()) - { - auto nested_key = column_object.findSubcolumnForNested(key, subcolumn.size() + 1); - - if (nested_key) - { - const auto & subcolumn_nested = column_object.getSubcolumn(*nested_key); - auto last_field = subcolumn_nested.getLastField(); - if (last_field.isNull()) - continue; - - auto default_scalar = getBaseTypeOfArray(subcolumn_nested.getLeastCommonType())->getDefault(); - auto default_field = applyVisitor(FieldVisitorReplaceScalars(default_scalar), last_field); - subcolumn.insert(std::move(default_field)); - } - else - { - subcolumn.insertDefault(); - } - } - else - { - subcolumn.insertDefault(); - } + bool inserted = tryInsertDefaultFromNested(entry, subcolumns); + if (!inserted) + entry->column.insertDefault(); } } } @@ -208,26 +226,27 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( if (auto * stream = settings.getter(settings.path)) writeVarUInt(column_object.getSubcolumns().size(), *stream); - for (const auto & [key, subcolumn] : column_object.getSubcolumns()) + const auto & subcolumns = column_object.getSubcolumns().getLeaves(); + for (const auto & entry : subcolumns) { settings.path.back() = Substream::ObjectStructure; - settings.path.back().object_key_name = key.getPath(); + settings.path.back().object_key_name = entry->path.getPath(); - const auto & type = subcolumn.getLeastCommonType(); + const auto & type = entry->column.getLeastCommonType(); if (auto * stream = settings.getter(settings.path)) { - key.writeBinary(*stream); + entry->path.writeBinary(*stream); writeStringBinary(type->getName(), *stream); } settings.path.back() = Substream::ObjectElement; - settings.path.back().object_key_name = key.getPath(); + settings.path.back().object_key_name = entry->path.getPath(); if (auto * stream = settings.getter(settings.path)) { auto serialization = type->getDefaultSerialization(); serialization->serializeBinaryBulkWithMultipleStreams( - subcolumn.getFinalizedColumn(), offset, limit, settings, state); + entry->column.getFinalizedColumn(), offset, limit, settings, state); } } @@ -335,11 +354,11 @@ void SerializationObject::serializeTextImpl(const IColumn & column, size if (it != subcolumns.begin()) writeCString(",", ostr); - writeDoubleQuoted(it->first.getPath(), ostr); + writeDoubleQuoted((*it)->path.getPath(), ostr); writeChar(':', ostr); - auto serialization = it->second.getLeastCommonType()->getDefaultSerialization(); - serialization->serializeTextJSON(it->second.getFinalizedColumn(), row_num, ostr, settings); + auto serialization = (*it)->column.getLeastCommonType()->getDefaultSerialization(); + serialization->serializeTextJSON((*it)->column.getFinalizedColumn(), row_num, ostr, settings); } writeChar('}', ostr); } diff --git a/src/Functions/transform.cpp b/src/Functions/transform.cpp index a11ba9c7d74..de9f1a5ba05 100644 --- a/src/Functions/transform.cpp +++ b/src/Functions/transform.cpp @@ -117,7 +117,7 @@ public: + " has signature: transform(T, Array(T), Array(U), U) -> U; or transform(T, Array(T), Array(T)) -> T; where T and U are types.", ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT}; - return getLeastSupertype({type_x, type_arr_to_nested}); + return getLeastSupertype(DataTypes{type_x, type_arr_to_nested}); } else { diff --git a/src/Storages/WindowView/WindowViewProxyStorage.h b/src/Storages/WindowView/WindowViewProxyStorage.h index 55426bddd5d..53443938492 100644 --- a/src/Storages/WindowView/WindowViewProxyStorage.h +++ b/src/Storages/WindowView/WindowViewProxyStorage.h @@ -20,18 +20,17 @@ public: setInMemoryMetadata(storage_metadata); } -public: std::string getName() const override { return "WindowViewProxy"; } QueryProcessingStage::Enum - getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageMetadataPtr &, SelectQueryInfo &) const override + getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const override { return to_stage; } Pipe read( const Names &, - const StorageMetadataPtr & /*metadata_snapshot*/, + const StorageSnapshotPtr & /*storage_snapshot*/, SelectQueryInfo & /*query_info*/, ContextPtr /*context*/, QueryProcessingStage::Enum /*processed_stage*/, From a70e5c1b2d7f254c8282c340a117d823bb58e72f Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 17 Dec 2021 18:08:34 +0300 Subject: [PATCH 053/132] support nested in json type (wip) --- src/Columns/ColumnObject.cpp | 73 +++++++++++++------ src/Columns/ColumnObject.h | 18 ++++- src/DataTypes/Serializations/DataPath.h | 43 +++++++---- .../Serializations/SerializationObject.cpp | 21 +++--- 4 files changed, 107 insertions(+), 48 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 43a8e118a89..6d0635f1218 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -185,6 +185,20 @@ private: } +FieldInfo getFieldInfo(const Field & field) +{ + FieldVisitorToScalarType to_scalar_type_visitor; + applyVisitor(to_scalar_type_visitor, field); + + return + { + to_scalar_type_visitor.getScalarType(), + to_scalar_type_visitor.haveNulls(), + to_scalar_type_visitor.needConvertField(), + applyVisitor(FieldVisitorToNumberOfDimensions(), field), + }; +} + ColumnObject::Subcolumn::Subcolumn(MutableColumnPtr && data_, bool is_nullable_) : least_common_type(getDataTypeByColumn(*data_)) , is_nullable(is_nullable_) @@ -242,19 +256,22 @@ void ColumnObject::Subcolumn::checkTypes() const void ColumnObject::Subcolumn::insert(Field field) { - FieldVisitorToScalarType to_scalar_type_visitor; - applyVisitor(to_scalar_type_visitor, field); + auto info = getFieldInfo(field); + insert(std::move(field), std::move(info)); +} - auto base_type = to_scalar_type_visitor.getScalarType(); +void ColumnObject::Subcolumn::insert(Field field, FieldInfo info) +{ + auto base_type = info.scalar_type; - if (isNothing(base_type) && (!is_nullable || !to_scalar_type_visitor.haveNulls())) + if (isNothing(base_type) && (!is_nullable || !info.have_nulls)) { insertDefault(); return; } auto column_dim = getNumberOfDimensions(*least_common_type); - auto value_dim = applyVisitor(FieldVisitorToNumberOfDimensions(), field); + auto value_dim = info.num_dimensions; if (isNothing(least_common_type)) column_dim = value_dim; @@ -263,7 +280,6 @@ void ColumnObject::Subcolumn::insert(Field field) value_dim = column_dim; if (value_dim != column_dim) - throw Exception(ErrorCodes::NUMBER_OF_DIMENSIONS_MISMATHED, "Dimension of types mismatched between inserted value and column. " "Dimension of value: {}. Dimension of column: {}", value_dim, column_dim); @@ -272,7 +288,7 @@ void ColumnObject::Subcolumn::insert(Field field) base_type = makeNullable(base_type); DataTypePtr value_type; - if (!is_nullable && to_scalar_type_visitor.haveNulls()) + if (!is_nullable && info.have_nulls) { auto default_value = base_type->getDefault(); value_type = createArrayOfType(base_type, value_dim); @@ -301,7 +317,7 @@ void ColumnObject::Subcolumn::insert(Field field) } } - if (type_changed || to_scalar_type_visitor.needConvertField()) + if (type_changed || info.need_convert) { auto converted_field = convertFieldToTypeOrThrow(std::move(field), *value_type); data.back()->insert(std::move(converted_field)); @@ -441,6 +457,7 @@ ColumnObject::Subcolumn ColumnObject::Subcolumn::recreateWithDefaultValues() con { Subcolumn new_subcolumn; new_subcolumn.least_common_type = least_common_type; + new_subcolumn.is_nullable = is_nullable; new_subcolumn.num_of_defaults_in_prefix = num_of_defaults_in_prefix; new_subcolumn.data.reserve(data.size()); @@ -470,12 +487,15 @@ const ColumnPtr & ColumnObject::Subcolumn::getFinalizedColumnPtr() const ColumnObject::ColumnObject(bool is_nullable_) : is_nullable(is_nullable_) + , num_rows(0) { } ColumnObject::ColumnObject(SubcolumnsTree && subcolumns_, bool is_nullable_) - : subcolumns(std::move(subcolumns_)) - , is_nullable(is_nullable_) + : is_nullable(is_nullable_) + , subcolumns(std::move(subcolumns_)) + , num_rows(subcolumns.empty() ? 0 : (*subcolumns.begin())->column.size()) + { checkConsistency(); } @@ -485,16 +505,13 @@ void ColumnObject::checkConsistency() const if (subcolumns.empty()) return; - const auto & first_leaf = *subcolumns.begin(); - size_t first_size = first_leaf->column.size(); - for (const auto & leaf : subcolumns) { - if (first_size != leaf->column.size()) + if (num_rows != leaf->column.size()) { throw Exception(ErrorCodes::LOGICAL_ERROR, "Sizes of subcolumns are inconsistent in ColumnObject." - " Subcolumn '{}' has {} rows, subcolumn '{}' has {} rows", - first_leaf->path.getPath(), first_size, leaf->path.getPath(), leaf->column.size()); + " Subcolumn '{}' has {} rows, but expected size is {}", + leaf->path.getPath(), leaf->column.size(), num_rows); } } } @@ -504,7 +521,7 @@ size_t ColumnObject::size() const #ifndef NDEBUG checkConsistency(); #endif - return subcolumns.empty() ? 0 : (*subcolumns.begin())->column.size(); + return num_rows; } MutableColumnPtr ColumnObject::cloneResized(size_t new_size) const @@ -543,6 +560,7 @@ void ColumnObject::forEachSubcolumn(ColumnCallback callback) void ColumnObject::insert(const Field & field) { + ++num_rows; const auto & object = field.get(); HashSet inserted; @@ -565,6 +583,7 @@ void ColumnObject::insert(const Field & field) void ColumnObject::insertDefault() { + ++num_rows; for (auto & entry : subcolumns) entry->column.insertDefault(); } @@ -596,6 +615,7 @@ void ColumnObject::get(size_t n, Field & res) const void ColumnObject::insertRangeFrom(const IColumn & src, size_t start, size_t length) { + num_rows += length; const auto & src_object = assert_cast(src); for (auto & entry : subcolumns) @@ -626,6 +646,7 @@ ColumnPtr ColumnObject::replicate(const Offsets & offsets) const void ColumnObject::popBack(size_t length) { + num_rows -= length; for (auto & entry : subcolumns) entry->column.popBack(length); } @@ -653,12 +674,15 @@ bool ColumnObject::hasSubcolumn(const Path & key) const void ColumnObject::addSubcolumn(const Path & key, size_t new_size, bool check_size) { + if (num_rows == 0) + num_rows = new_size; + if (check_size && new_size != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", key.getPath(), new_size, size()); - bool inserted = false; + std::optional inserted; if (key.hasNested()) { const auto * nested_node = subcolumns.findBestMatch(key); @@ -668,22 +692,27 @@ void ColumnObject::addSubcolumn(const Path & key, size_t new_size, bool check_si assert(leaf); auto new_subcolumn = leaf->column.recreateWithDefaultValues(); - if (new_subcolumn.size() == new_size + 1) - new_subcolumn.popBack(1); + if (new_subcolumn.size() > new_size) + new_subcolumn.popBack(new_subcolumn.size() - new_size); + else if (new_subcolumn.size() < new_size) + new_subcolumn.insertManyDefaults(new_size - new_subcolumn.size()); inserted = subcolumns.add(key, new_subcolumn); } } - if (!inserted) + if (!inserted.has_value()) inserted = subcolumns.add(key, Subcolumn(new_size, is_nullable)); - if (!inserted) + if (!*inserted) throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); } void ColumnObject::addSubcolumn(const Path & key, MutableColumnPtr && subcolumn, bool check_size) { + if (num_rows == 0) + num_rows = subcolumn->size(); + if (check_size && subcolumn->size() != size()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 41cdea125a0..b202e53c4a1 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -18,6 +18,16 @@ namespace ErrorCodes extern const int LOGICAL_ERROR; } +struct FieldInfo +{ + DataTypePtr scalar_type; + bool have_nulls; + bool need_convert; + size_t num_dimensions; +}; + +FieldInfo getFieldInfo(const Field & field); + class ColumnObject final : public COWHelper { public: @@ -37,6 +47,8 @@ public: void checkTypes() const; void insert(Field field); + void insert(Field field, FieldInfo info); + void insertDefault(); void insertManyDefaults(size_t length); void insertRangeFrom(const Subcolumn & src, size_t start, size_t length); @@ -65,8 +77,10 @@ public: private: // SubcolumnsMap subcolumns; + const bool is_nullable; + SubcolumnsTree subcolumns; - bool is_nullable; + size_t num_rows; public: static constexpr auto COLUMN_NAME_DUMMY = "_dummy"; @@ -81,6 +95,8 @@ public: const Subcolumn & getSubcolumn(const Path & key) const; Subcolumn & getSubcolumn(const Path & key); + void incrementNumRows() { ++num_rows; } + void addSubcolumn(const Path & key, size_t new_size, bool check_size = false); void addSubcolumn(const Path & key, MutableColumnPtr && subcolumn, bool check_size = false); diff --git a/src/DataTypes/Serializations/DataPath.h b/src/DataTypes/Serializations/DataPath.h index 35b97d5f938..446419760cf 100644 --- a/src/DataTypes/Serializations/DataPath.h +++ b/src/DataTypes/Serializations/DataPath.h @@ -143,27 +143,17 @@ public: const Node * findBestMatch(const Path & path) const { - if (!root) - return nullptr; + return findImpl(path, false); + } - auto parts = path.getParts(); - const Node * current_node = root.get(); - - for (const auto & part : parts) - { - auto it = current_node->children.find(part); - if (it == current_node->children.end()) - return current_node; - - current_node = it->second.get(); - } - - return current_node; + const Node * findExact(const Path & path) const + { + return findImpl(path, true); } const Leaf * findLeaf(const Path & path) const { - return typeid_cast(findBestMatch(path)); + return typeid_cast(findExact(path)); } using LeafPredicate = std::function; @@ -210,6 +200,27 @@ public: const_iterator end() const { return leaves.end(); } private: + const Node * findImpl(const Path & path, bool find_exact) const + { + if (!root) + return nullptr; + + auto parts = path.getParts(); + const Node * current_node = root.get(); + + for (const auto & part : parts) + { + auto it = current_node->children.find(part); + if (it == current_node->children.end()) + return find_exact ? nullptr : current_node; + + current_node = it->second.get(); + } + + return current_node; + + } + NodePtr root; Leaves leaves; }; diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 4f44f9220e3..3e0b1ad6e17 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -111,22 +111,25 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & assert(paths.size() == values.size()); HashSet paths_set; - for (const auto & path : paths) - paths_set.insert(path.getPath()); - - if (paths.size() != paths_set.size()) - throw Exception(ErrorCodes::INCORRECT_DATA, "Object has ambiguous paths"); - size_t column_size = column_object.size(); + for (size_t i = 0; i < paths.size(); ++i) { + auto field_info = getFieldInfo(values[i]); + if (isNothing(field_info.scalar_type)) + continue; + + if (!paths_set.insert(paths[i].getPath()).second) + throw Exception(ErrorCodes::INCORRECT_DATA, + "Object has ambiguous path: {}", paths[i].getPath()); + if (!column_object.hasSubcolumn(paths[i])) column_object.addSubcolumn(paths[i], column_size); auto & subcolumn = column_object.getSubcolumn(paths[i]); assert(subcolumn.size() == column_size); - subcolumn.insert(std::move(values[i])); + subcolumn.insert(std::move(values[i]), std::move(field_info)); } const auto & subcolumns = column_object.getSubcolumns(); @@ -139,6 +142,8 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & entry->column.insertDefault(); } } + + column_object.incrementNumRows(); } template @@ -240,8 +245,6 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( } settings.path.back() = Substream::ObjectElement; - settings.path.back().object_key_name = entry->path.getPath(); - if (auto * stream = settings.getter(settings.path)) { auto serialization = type->getDefaultSerialization(); From aa515b7126293b57f896fe3ef89ba38c250a318b Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 23 Dec 2021 15:28:40 +0300 Subject: [PATCH 054/132] support nested in json type (wip) --- src/Columns/ColumnObject.cpp | 126 ++++++++++-------- src/Columns/ColumnObject.h | 7 +- src/DataTypes/ObjectUtils.cpp | 20 +++ src/DataTypes/ObjectUtils.h | 3 + .../Serializations/SerializationObject.cpp | 7 +- .../0_stateless/01825_type_json_2.reference | 8 +- .../0_stateless/01825_type_json_5.reference | 4 +- .../01825_type_json_nullable.reference | 8 +- 8 files changed, 111 insertions(+), 72 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 4578480a16c..ec6f9c7b590 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -45,14 +45,19 @@ Array createEmptyArrayField(size_t num_dimensions) return array; } -ColumnPtr recreateColumnWithDefaultValues(const ColumnPtr & column) +ColumnPtr recreateColumnWithDefaultValues( + const ColumnPtr & column, const DataTypePtr & scalar_type, size_t num_dimensions) { - if (const auto * column_array = checkAndGetColumn(column.get())) + const auto * column_array = checkAndGetColumn(column.get()); + if (column_array && num_dimensions) + { return ColumnArray::create( - recreateColumnWithDefaultValues(column_array->getDataPtr()), + recreateColumnWithDefaultValues( + column_array->getDataPtr(), scalar_type, num_dimensions - 1), IColumn::mutate(column_array->getOffsetsPtr())); - else - return column->cloneEmpty()->cloneResized(column->size()); + } + + return createArrayOfType(scalar_type, num_dimensions)->createColumn()->cloneResized(column->size()); } class FieldVisitorReplaceNull : public StaticVisitor @@ -454,16 +459,17 @@ Field ColumnObject::Subcolumn::getLastField() const return (*last_part)[last_part->size() - 1]; } -ColumnObject::Subcolumn ColumnObject::Subcolumn::recreateWithDefaultValues() const +ColumnObject::Subcolumn ColumnObject::Subcolumn::recreateWithDefaultValues(const FieldInfo & field_info) const { Subcolumn new_subcolumn; - new_subcolumn.least_common_type = least_common_type; + new_subcolumn.least_common_type = createArrayOfType(field_info.scalar_type, field_info.num_dimensions); new_subcolumn.is_nullable = is_nullable; new_subcolumn.num_of_defaults_in_prefix = num_of_defaults_in_prefix; new_subcolumn.data.reserve(data.size()); for (const auto & part : data) - new_subcolumn.data.push_back(recreateColumnWithDefaultValues(part)); + new_subcolumn.data.push_back(recreateColumnWithDefaultValues( + part, field_info.scalar_type, field_info.num_dimensions)); return new_subcolumn; } @@ -561,7 +567,6 @@ void ColumnObject::forEachSubcolumn(ColumnCallback callback) void ColumnObject::insert(const Field & field) { - ++num_rows; const auto & object = field.get(); HashSet inserted; @@ -580,13 +585,16 @@ void ColumnObject::insert(const Field & field) for (auto & entry : subcolumns) if (!inserted.has(entry->path.getPath())) entry->column.insertDefault(); + + ++num_rows; } void ColumnObject::insertDefault() { - ++num_rows; for (auto & entry : subcolumns) entry->column.insertDefault(); + + ++num_rows; } Field ColumnObject::operator[](size_t n) const @@ -616,7 +624,6 @@ void ColumnObject::get(size_t n, Field & res) const void ColumnObject::insertRangeFrom(const IColumn & src, size_t start, size_t length) { - num_rows += length; const auto & src_object = assert_cast(src); for (auto & entry : subcolumns) @@ -627,6 +634,7 @@ void ColumnObject::insertRangeFrom(const IColumn & src, size_t start, size_t len entry->column.insertManyDefaults(length); } + num_rows += length; finalize(); } @@ -639,7 +647,7 @@ ColumnPtr ColumnObject::replicate(const Offsets & offsets) const for (const auto & entry : subcolumns) { auto replicated_data = entry->column.data.back()->replicate(offsets)->assumeMutable(); - res_column->addSubcolumn(entry->path, std::move(replicated_data), is_nullable); + res_column->addSubcolumn(entry->path, std::move(replicated_data)); } return res_column; @@ -647,9 +655,10 @@ ColumnPtr ColumnObject::replicate(const Offsets & offsets) const void ColumnObject::popBack(size_t length) { - num_rows -= length; for (auto & entry : subcolumns) entry->column.popBack(length); + + num_rows -= length; } const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) const @@ -673,55 +682,56 @@ bool ColumnObject::hasSubcolumn(const Path & key) const return subcolumns.findLeaf(key) != nullptr; } -void ColumnObject::addSubcolumn(const Path & key, size_t new_size, bool check_size) +void ColumnObject::addSubcolumn(const Path & key, MutableColumnPtr && subcolumn) { - if (num_rows == 0) - num_rows = new_size; - - if (check_size && new_size != size()) - throw Exception(ErrorCodes::LOGICAL_ERROR, - "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", - key.getPath(), new_size, size()); - - std::optional inserted; - if (key.hasNested()) - { - const auto * nested_node = subcolumns.findBestMatch(key); - if (nested_node && nested_node->isNested()) - { - const auto * leaf = subcolumns.findLeaf(nested_node, [&](const auto & ) { return true; }); - assert(leaf); - - auto new_subcolumn = leaf->column.recreateWithDefaultValues(); - if (new_subcolumn.size() > new_size) - new_subcolumn.popBack(new_subcolumn.size() - new_size); - else if (new_subcolumn.size() < new_size) - new_subcolumn.insertManyDefaults(new_size - new_subcolumn.size()); - - inserted = subcolumns.add(key, new_subcolumn); - } - } - - if (!inserted.has_value()) - inserted = subcolumns.add(key, Subcolumn(new_size, is_nullable)); - - if (!*inserted) - throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); -} - -void ColumnObject::addSubcolumn(const Path & key, MutableColumnPtr && subcolumn, bool check_size) -{ - if (num_rows == 0) - num_rows = subcolumn->size(); - - if (check_size && subcolumn->size() != size()) - throw Exception(ErrorCodes::LOGICAL_ERROR, - "Cannot add subcolumn '{}' with {} rows to ColumnObject with {} rows", - key.getPath(), subcolumn->size(), size()); - + size_t new_size = subcolumn->size(); bool inserted = subcolumns.add(key, Subcolumn(std::move(subcolumn), is_nullable)); if (!inserted) throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); + + if (num_rows == 0) + num_rows = new_size; +} + +void ColumnObject::addSubcolumn(const Path & key, size_t new_size) +{ + bool inserted = subcolumns.add(key, Subcolumn(new_size, is_nullable)); + if (!inserted) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); + + if (num_rows == 0) + num_rows = new_size; +} + +void ColumnObject::addNestedSubcolumn(const Path & key, const FieldInfo & field_info, size_t new_size) +{ + if (!key.hasNested()) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Cannot add Nested subcolumn, because path doesn't contain Nested"); + + bool inserted = false; + const auto * nested_node = subcolumns.findBestMatch(key); + if (nested_node && nested_node->isNested()) + { + const auto * leaf = subcolumns.findLeaf(nested_node, [&](const auto & ) { return true; }); + assert(leaf); + + auto new_subcolumn = leaf->column.recreateWithDefaultValues(field_info); + if (new_subcolumn.size() > new_size) + new_subcolumn.popBack(new_subcolumn.size() - new_size); + else if (new_subcolumn.size() < new_size) + new_subcolumn.insertManyDefaults(new_size - new_subcolumn.size()); + + inserted = subcolumns.add(key, new_subcolumn); + } + else + inserted = subcolumns.add(key, Subcolumn(new_size, is_nullable)); + + if (!inserted) + throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); + + if (num_rows == 0) + num_rows = new_size; } Paths ColumnObject::getKeys() const diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index b202e53c4a1..d781cef8997 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -57,7 +57,7 @@ public: void finalize(); Field getLastField() const; - Subcolumn recreateWithDefaultValues() const; + Subcolumn recreateWithDefaultValues(const FieldInfo & field_info) const; IColumn & getFinalizedColumn(); const IColumn & getFinalizedColumn() const; @@ -97,8 +97,9 @@ public: void incrementNumRows() { ++num_rows; } - void addSubcolumn(const Path & key, size_t new_size, bool check_size = false); - void addSubcolumn(const Path & key, MutableColumnPtr && subcolumn, bool check_size = false); + void addSubcolumn(const Path & key, MutableColumnPtr && subcolumn); + void addSubcolumn(const Path & key, size_t new_size); + void addNestedSubcolumn(const Path & key, const FieldInfo & field_info, size_t new_size); const SubcolumnsTree & getSubcolumns() const { return subcolumns; } SubcolumnsTree & getSubcolumns() { return subcolumns; } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 3db5b679757..09c66888b37 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -63,6 +63,26 @@ DataTypePtr getBaseTypeOfArray(const DataTypePtr & type) return last_array ? last_array->getNestedType() : type; } +ColumnPtr getBaseColumnOfArray(const ColumnPtr & column) +{ + const ColumnArray * last_array = nullptr; + const IColumn * current_column = column.get(); + while (const auto * column_array = checkAndGetColumn(current_column)) + { + current_column = &column_array->getData(); + last_array = column_array; + } + + return last_array ? last_array->getDataPtr() : column; +} + +ColumnPtr createArrayOfColumn(ColumnPtr column, size_t num_dimensions) +{ + for (size_t i = 0; i < num_dimensions; ++i) + column = ColumnArray::create(column); + return column; +} + DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension) { for (size_t i = 0; i < dimension; ++i) diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 869f396fde9..421470872d7 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -15,6 +15,9 @@ size_t getNumberOfDimensions(const IColumn & column); DataTypePtr getBaseTypeOfArray(const DataTypePtr & type); DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); +ColumnPtr getBaseColumnOfArray(const ColumnPtr & column); +ColumnPtr createArrayOfColumn(const ColumnPtr & column, size_t num_dimensions); + DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); void checkObjectHasNoAmbiguosPaths(const Paths & paths); diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 3e0b1ad6e17..4e7b721e2fb 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -124,7 +124,12 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & "Object has ambiguous path: {}", paths[i].getPath()); if (!column_object.hasSubcolumn(paths[i])) - column_object.addSubcolumn(paths[i], column_size); + { + if (paths[i].hasNested()) + column_object.addNestedSubcolumn(paths[i], field_info, column_size); + else + column_object.addSubcolumn(paths[i], column_size); + } auto & subcolumn = column_object.getSubcolumn(paths[i]); assert(subcolumn.size() == column_size); diff --git a/tests/queries/0_stateless/01825_type_json_2.reference b/tests/queries/0_stateless/01825_type_json_2.reference index 6afe2ebcb60..8524035a3a4 100644 --- a/tests/queries/0_stateless/01825_type_json_2.reference +++ b/tests/queries/0_stateless/01825_type_json_2.reference @@ -18,7 +18,7 @@ 1 ['1','2','3.3'] 2 ['a','4','b'] ============ -1 ([11,0],[0,22],[]) Tuple(`k1.k2` Array(Int8), `k1.k3` Array(Int8), `k1.k4` Array(Int8)) -2 ([],[33,0,55],[0,44,66]) Tuple(`k1.k2` Array(Int8), `k1.k3` Array(Int8), `k1.k4` Array(Int8)) -1 [11,0] [0,22] [] -2 [] [33,0,55] [0,44,66] +1 ([(11,0,0),(0,22,0)]) Tuple(k1 Nested(k2 Int8, k3 Int8, k4 Int8)) +2 ([(0,33,0),(0,0,44),(0,55,66)]) Tuple(k1 Nested(k2 Int8, k3 Int8, k4 Int8)) +1 [11,0] [0,22] [0,0] +2 [0,0,0] [33,0,55] [0,44,66] diff --git a/tests/queries/0_stateless/01825_type_json_5.reference b/tests/queries/0_stateless/01825_type_json_5.reference index 6b4dfab0643..4ac0aa26ffd 100644 --- a/tests/queries/0_stateless/01825_type_json_5.reference +++ b/tests/queries/0_stateless/01825_type_json_5.reference @@ -1,5 +1,5 @@ -{"a.c":2,"a.b":1} -{"s":{"a.c":2,"a.b":1}} +{"a.b":1,"a.c":2} +{"s":{"a.b":1,"a.c":2}} 1 [22,33] 2 qqq [44] Tuple(k1 Int8, k2 Tuple(k3 String, k4 Array(Int8))) diff --git a/tests/queries/0_stateless/01825_type_json_nullable.reference b/tests/queries/0_stateless/01825_type_json_nullable.reference index 7f1691a6469..587fb1b1bc9 100644 --- a/tests/queries/0_stateless/01825_type_json_nullable.reference +++ b/tests/queries/0_stateless/01825_type_json_nullable.reference @@ -11,7 +11,7 @@ 3 \N \N 10 4 \N 5 str ============ -1 ([11,NULL],[NULL,22],[]) Tuple(`k1.k2` Array(Nullable(Int8)), `k1.k3` Array(Nullable(Int8)), `k1.k4` Array(Nullable(Int8))) -2 ([],[33,NULL,55],[NULL,44,66]) Tuple(`k1.k2` Array(Nullable(Int8)), `k1.k3` Array(Nullable(Int8)), `k1.k4` Array(Nullable(Int8))) -1 [11,NULL] [NULL,22] [] -2 [] [33,NULL,55] [NULL,44,66] +1 ([(11,NULL,NULL),(NULL,22,NULL)]) Tuple(k1 Nested(k2 Nullable(Int8), k3 Nullable(Int8), k4 Nullable(Int8))) +2 ([(NULL,33,NULL),(NULL,NULL,44),(NULL,55,66)]) Tuple(k1 Nested(k2 Nullable(Int8), k3 Nullable(Int8), k4 Nullable(Int8))) +1 [11,NULL] [NULL,22] [NULL,NULL] +2 [NULL,NULL,NULL] [33,NULL,55] [NULL,44,66] From 751d9e6a447f8bba1fade3e5dab0473cacc2d79a Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 21 Jan 2022 17:55:26 +0300 Subject: [PATCH 055/132] support nested in json type (wip) --- src/Columns/ColumnObject.cpp | 21 +++----- src/DataTypes/ObjectUtils.cpp | 13 +++++ src/DataTypes/ObjectUtils.h | 1 + .../Serializations/SerializationObject.cpp | 54 +++++++++++++------ 4 files changed, 58 insertions(+), 31 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index ec6f9c7b590..36531d86335 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -32,19 +32,6 @@ namespace ErrorCodes namespace { -Array createEmptyArrayField(size_t num_dimensions) -{ - Array array; - Array * current_array = &array; - for (size_t i = 1; i < num_dimensions; ++i) - { - current_array->push_back(Array()); - current_array = ¤t_array->back().get(); - } - - return array; -} - ColumnPtr recreateColumnWithDefaultValues( const ColumnPtr & column, const DataTypePtr & scalar_type, size_t num_dimensions) { @@ -269,7 +256,7 @@ void ColumnObject::Subcolumn::insert(Field field, FieldInfo info) { auto base_type = info.scalar_type; - if (isNothing(base_type) && (!is_nullable || !info.have_nulls)) + if (isNothing(base_type) && info.num_dimensions == 0) { insertDefault(); return; @@ -467,9 +454,13 @@ ColumnObject::Subcolumn ColumnObject::Subcolumn::recreateWithDefaultValues(const new_subcolumn.num_of_defaults_in_prefix = num_of_defaults_in_prefix; new_subcolumn.data.reserve(data.size()); + auto scalar_type = field_info.scalar_type; + if (new_subcolumn.is_nullable) + scalar_type = makeNullable(scalar_type); + for (const auto & part : data) new_subcolumn.data.push_back(recreateColumnWithDefaultValues( - part, field_info.scalar_type, field_info.num_dimensions)); + part, scalar_type, field_info.num_dimensions)); return new_subcolumn; } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 09c66888b37..516b44d3dc6 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -90,6 +90,19 @@ DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension) return type; } +Array createEmptyArrayField(size_t num_dimensions) +{ + Array array; + Array * current_array = &array; + for (size_t i = 1; i < num_dimensions; ++i) + { + current_array->push_back(Array()); + current_array = ¤t_array->back().get(); + } + + return array; +} + DataTypePtr getDataTypeByColumn(const IColumn & column) { auto idx = column.getDataType(); diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 421470872d7..4f13882f4b8 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -14,6 +14,7 @@ size_t getNumberOfDimensions(const IDataType & type); size_t getNumberOfDimensions(const IColumn & column); DataTypePtr getBaseTypeOfArray(const DataTypePtr & type); DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); +Array createEmptyArrayField(size_t num_dimensions); ColumnPtr getBaseColumnOfArray(const ColumnPtr & column); ColumnPtr createArrayOfColumn(const ColumnPtr & column, size_t num_dimensions); diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 4e7b721e2fb..aa8fc459aa1 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -33,8 +33,8 @@ namespace class FieldVisitorReplaceScalars : public StaticVisitor { public: - explicit FieldVisitorReplaceScalars(const Field & replacement_) - : replacement(replacement_) + explicit FieldVisitorReplaceScalars(const Field & replacement_, size_t num_dimensions_to_keep_) + : replacement(replacement_), num_dimensions_to_keep(num_dimensions_to_keep_) { } @@ -43,6 +43,9 @@ public: { if constexpr (std::is_same_v) { + if (num_dimensions_to_keep == 0) + return replacement; + const size_t size = x.size(); Array res(size); for (size_t i = 0; i < size; ++i) @@ -55,6 +58,7 @@ public: private: const Field & replacement; + size_t num_dimensions_to_keep; }; bool tryInsertDefaultFromNested( @@ -63,21 +67,30 @@ bool tryInsertDefaultFromNested( if (!entry->path.hasNested()) return false; - const auto * node = subcolumns.findLeaf(entry->path); - if (!node) - return false; + const ColumnObject::SubcolumnsTree::Node * node = subcolumns.findLeaf(entry->path); + const ColumnObject::SubcolumnsTree::Leaf * leaf = nullptr; + size_t num_skipped_nested = 0; - const auto * node_nested = subcolumns.findParent(node, - [](const auto & candidate) { return candidate.isNested(); }); + while (node) + { + const auto * node_nested = subcolumns.findParent(node, + [](const auto & candidate) { return candidate.isNested(); }); - if (!node_nested) - return false; + if (!node_nested) + break; - const auto * leaf = subcolumns.findLeaf(node_nested, - [&](const auto & candidate) - { - return candidate.column.size() == entry->column.size() + 1; - }); + leaf = subcolumns.findLeaf(node_nested, + [&](const auto & candidate) + { + return candidate.column.size() == entry->column.size() + 1; + }); + + if (leaf) + break; + + node = node_nested->parent; + ++num_skipped_nested; + } if (!leaf) return false; @@ -86,9 +99,18 @@ bool tryInsertDefaultFromNested( if (last_field.isNull()) return false; - auto default_scalar = getBaseTypeOfArray(leaf->column.getLeastCommonType())->getDefault(); - auto default_field = applyVisitor(FieldVisitorReplaceScalars(default_scalar), last_field); + const auto & least_common_type = entry->column.getLeastCommonType(); + size_t num_dimensions = getNumberOfDimensions(*least_common_type); + assert(num_skipped_nested < num_dimensions); + + size_t num_dimensions_to_keep = num_dimensions - num_skipped_nested; + auto default_scalar = num_skipped_nested + ? createEmptyArrayField(num_skipped_nested) + : getBaseTypeOfArray(least_common_type)->getDefault(); + + auto default_field = applyVisitor(FieldVisitorReplaceScalars(default_scalar, num_dimensions_to_keep), last_field); entry->column.insert(std::move(default_field)); + return true; } From 3e5af3023d50368125c09a1263e2878656c92eda Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 22 Jan 2022 03:19:47 +0300 Subject: [PATCH 056/132] mark test data as binary --- .gitattributes | 1 + 1 file changed, 1 insertion(+) diff --git a/.gitattributes b/.gitattributes index bcc7d57b904..a23f027122b 100644 --- a/.gitattributes +++ b/.gitattributes @@ -1,2 +1,3 @@ contrib/* linguist-vendored *.h linguist-language=C++ +tests/queries/0_stateless/data_json/* binary From b78415908623e8ff5390e9895d83be97ac8b696e Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Sat, 22 Jan 2022 03:20:20 +0300 Subject: [PATCH 057/132] add more tests for JSON type --- .../queries/0_stateless/01825_type_json_1.sql | 2 + .../queries/0_stateless/01825_type_json_2.sql | 2 + .../queries/0_stateless/01825_type_json_3.sql | 2 + .../queries/0_stateless/01825_type_json_4.sh | 1 + .../queries/0_stateless/01825_type_json_5.sql | 2 + .../queries/0_stateless/01825_type_json_6.sh | 1 + .../queries/0_stateless/01825_type_json_7.sh | 1 + .../0_stateless/01825_type_json_btc.reference | 5 +++ .../0_stateless/01825_type_json_btc.sh | 23 ++++++++++ .../0_stateless/01825_type_json_describe.sql | 2 + .../01825_type_json_distributed.sql | 2 + .../0_stateless/01825_type_json_field.sql | 2 + .../01825_type_json_insert_select.sql | 2 + .../01825_type_json_nbagames.reference | 12 ++++++ .../0_stateless/01825_type_json_nbagames.sh | 40 ++++++++++++++++++ .../0_stateless/01825_type_json_nullable.sql | 2 + .../01825_type_json_schema_race_long.sh | 1 + .../data_json/btc_transactions.json | Bin 0 -> 210270 bytes .../data_json/nbagames_sample.json | Bin 0 -> 6381971 bytes 19 files changed, 102 insertions(+) create mode 100644 tests/queries/0_stateless/01825_type_json_btc.reference create mode 100755 tests/queries/0_stateless/01825_type_json_btc.sh create mode 100644 tests/queries/0_stateless/01825_type_json_nbagames.reference create mode 100755 tests/queries/0_stateless/01825_type_json_nbagames.sh create mode 100644 tests/queries/0_stateless/data_json/btc_transactions.json create mode 100644 tests/queries/0_stateless/data_json/nbagames_sample.json diff --git a/tests/queries/0_stateless/01825_type_json_1.sql b/tests/queries/0_stateless/01825_type_json_1.sql index 73110cd866d..233d0fae1e8 100644 --- a/tests/queries/0_stateless/01825_type_json_1.sql +++ b/tests/queries/0_stateless/01825_type_json_1.sql @@ -1,3 +1,5 @@ +-- Tags: no-fasttest + DROP TABLE IF EXISTS t_json; CREATE TABLE t_json(id UInt64, data Object('JSON')) diff --git a/tests/queries/0_stateless/01825_type_json_2.sql b/tests/queries/0_stateless/01825_type_json_2.sql index 126ae297e1b..cf5a74ad1e8 100644 --- a/tests/queries/0_stateless/01825_type_json_2.sql +++ b/tests/queries/0_stateless/01825_type_json_2.sql @@ -1,3 +1,5 @@ +-- Tags: no-fasttest + DROP TABLE IF EXISTS t_json_2; CREATE TABLE t_json_2(id UInt64, data Object('JSON')) diff --git a/tests/queries/0_stateless/01825_type_json_3.sql b/tests/queries/0_stateless/01825_type_json_3.sql index 93dab846c17..279460a6dcf 100644 --- a/tests/queries/0_stateless/01825_type_json_3.sql +++ b/tests/queries/0_stateless/01825_type_json_3.sql @@ -1,3 +1,5 @@ +-- Tags: no-fasttest + DROP TABLE IF EXISTS t_json_3; CREATE TABLE t_json_3(id UInt64, data JSON) diff --git a/tests/queries/0_stateless/01825_type_json_4.sh b/tests/queries/0_stateless/01825_type_json_4.sh index 8eeb8b926e9..062c77677ac 100755 --- a/tests/queries/0_stateless/01825_type_json_4.sh +++ b/tests/queries/0_stateless/01825_type_json_4.sh @@ -1,4 +1,5 @@ #!/usr/bin/env bash +# Tags: no-fasttest CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) # shellcheck source=../shell_config.sh diff --git a/tests/queries/0_stateless/01825_type_json_5.sql b/tests/queries/0_stateless/01825_type_json_5.sql index 7d9498e454b..eeea03432b4 100644 --- a/tests/queries/0_stateless/01825_type_json_5.sql +++ b/tests/queries/0_stateless/01825_type_json_5.sql @@ -1,3 +1,5 @@ +-- Tags: no-fasttest + SELECT '{"a": {"b": 1, "c": 2}}'::JSON AS s; SELECT '{"a": {"b": 1, "c": 2}}'::JSON AS s format JSONEachRow; diff --git a/tests/queries/0_stateless/01825_type_json_6.sh b/tests/queries/0_stateless/01825_type_json_6.sh index 837b0d2290c..b992023fee0 100755 --- a/tests/queries/0_stateless/01825_type_json_6.sh +++ b/tests/queries/0_stateless/01825_type_json_6.sh @@ -1,4 +1,5 @@ #!/usr/bin/env bash +# Tags: no-fasttest CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) # shellcheck source=../shell_config.sh diff --git a/tests/queries/0_stateless/01825_type_json_7.sh b/tests/queries/0_stateless/01825_type_json_7.sh index 24de546b206..41708d80ed7 100755 --- a/tests/queries/0_stateless/01825_type_json_7.sh +++ b/tests/queries/0_stateless/01825_type_json_7.sh @@ -1,4 +1,5 @@ #!/usr/bin/env bash +# Tags: no-fasttest CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) # shellcheck source=../shell_config.sh diff --git a/tests/queries/0_stateless/01825_type_json_btc.reference b/tests/queries/0_stateless/01825_type_json_btc.reference new file mode 100644 index 00000000000..d3d852b633f --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_btc.reference @@ -0,0 +1,5 @@ +100 +data Tuple(double_spend UInt64, fee Int32, hash String, inputs Nested(index Int8, prev_out Tuple(addr String, n Int16, script String, spending_outpoints Nested(n Int8, tx_index Int64), spent UInt64, tx_index Int64, type Int8, value Int64), script String, sequence Int64, witness String), lock_time Int32, out Nested(addr String, n Int8, script String, spending_outpoints Nested(n Int8, tx_index Int64), spent UInt64, tx_index Int64, type Int8, value Int64), rbf UInt64, relayed_by String, size Int16, time Int32, tx_index Int64, ver Int8, vin_sz Int8, vout_sz Int8, weight Int16) +8174.56 2680 +2.32 1 +[[],[(0,359661801933760)]] diff --git a/tests/queries/0_stateless/01825_type_json_btc.sh b/tests/queries/0_stateless/01825_type_json_btc.sh new file mode 100755 index 00000000000..b189f16c16b --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_btc.sh @@ -0,0 +1,23 @@ +#!/usr/bin/env bash +# Tags: no-fasttest + +CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +# shellcheck source=../shell_config.sh +. "$CUR_DIR"/../shell_config.sh + +${CLICKHOUSE_CLIENT} -q "DROP TABLE IF EXISTS btc" + +${CLICKHOUSE_CLIENT} -q "CREATE TABLE btc (data JSON) ENGINE = MergeTree ORDER BY tuple()" + +cat $CUR_DIR/data_json/btc_transactions.json | ${CLICKHOUSE_CLIENT} -q "INSERT INTO btc FORMAT JSONAsObject" --input_format_parallel_parsing 0 + +${CLICKHOUSE_CLIENT} -q "SELECT count() FROM btc" +${CLICKHOUSE_CLIENT} -q "DESC btc SETTINGS describe_extend_object_types = 1" + +${CLICKHOUSE_CLIENT} -q "SELECT avg(data.fee), median(data.fee) FROM btc" + +${CLICKHOUSE_CLIENT} -q "SELECT avg(length(data.inputs.prev_out.spending_outpoints) AS outpoints_length), median(outpoints_length) FROM btc" + +${CLICKHOUSE_CLIENT} -q "SELECT data.out.spending_outpoints AS outpoints FROM btc WHERE arrayExists(x -> notEmpty(x), outpoints)" + +${CLICKHOUSE_CLIENT} -q "DROP TABLE IF EXISTS btc" diff --git a/tests/queries/0_stateless/01825_type_json_describe.sql b/tests/queries/0_stateless/01825_type_json_describe.sql index fa002e9cbff..f4aabaed715 100644 --- a/tests/queries/0_stateless/01825_type_json_describe.sql +++ b/tests/queries/0_stateless/01825_type_json_describe.sql @@ -1,3 +1,5 @@ +-- Tags: no-fasttest + DROP TABLE IF EXISTS t_json_desc; CREATE TABLE t_json_desc (data JSON) ENGINE = MergeTree ORDER BY tuple(); diff --git a/tests/queries/0_stateless/01825_type_json_distributed.sql b/tests/queries/0_stateless/01825_type_json_distributed.sql index faa0717e21e..a528352e938 100644 --- a/tests/queries/0_stateless/01825_type_json_distributed.sql +++ b/tests/queries/0_stateless/01825_type_json_distributed.sql @@ -1,3 +1,5 @@ +-- Tags: no-fasttest + DROP TABLE IF EXISTS t_json_local; DROP TABLE IF EXISTS t_json_dist; diff --git a/tests/queries/0_stateless/01825_type_json_field.sql b/tests/queries/0_stateless/01825_type_json_field.sql index b1e00b3ee96..f6df156030b 100644 --- a/tests/queries/0_stateless/01825_type_json_field.sql +++ b/tests/queries/0_stateless/01825_type_json_field.sql @@ -1,3 +1,5 @@ +-- Tags: no-fasttest + DROP TABLE IF EXISTS t_json_field; CREATE TABLE t_json_field (id UInt32, data JSON) diff --git a/tests/queries/0_stateless/01825_type_json_insert_select.sql b/tests/queries/0_stateless/01825_type_json_insert_select.sql index da0545993b2..878c106ca1e 100644 --- a/tests/queries/0_stateless/01825_type_json_insert_select.sql +++ b/tests/queries/0_stateless/01825_type_json_insert_select.sql @@ -1,3 +1,5 @@ +-- Tags: no-fasttest + DROP TABLE IF EXISTS type_json_src; DROP TABLE IF EXISTS type_json_dst; diff --git a/tests/queries/0_stateless/01825_type_json_nbagames.reference b/tests/queries/0_stateless/01825_type_json_nbagames.reference new file mode 100644 index 00000000000..467d74b5155 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_nbagames.reference @@ -0,0 +1,12 @@ +1000 +data Tuple(`_id.$oid` String, `date.$date` String, teams Nested(abbreviation String, city String, home UInt64, name String, players Nested(ast Int8, blk Int8, drb Int8, fg Int8, fg3 Int8, fg3_pct String, fg3a Int8, fg_pct String, fga Int8, ft Int8, ft_pct String, fta Int8, mp String, orb Int8, pf Int8, player String, pts Int8, stl Int8, tov Int8, trb Int8), results Tuple(ast Int8, blk Int8, drb Int8, fg Int8, fg3 Int8, fg3_pct String, fg3a Int8, fg_pct String, fga Int8, ft Int8, ft_pct String, fta Int8, mp Int16, orb Int8, pf Int8, pts Int16, stl Int8, tov Int8, trb Int8), score Int16, won Int8)) +Boston Celtics 70 +Los Angeles Lakers 64 +Milwaukee Bucks 61 +Philadelphia 76ers 57 +Atlanta Hawks 55 +Larry Bird 10 +Clyde Drexler 4 +Magic Johnson 3 +Alvin Robertson 3 +Fat Lever 2 diff --git a/tests/queries/0_stateless/01825_type_json_nbagames.sh b/tests/queries/0_stateless/01825_type_json_nbagames.sh new file mode 100755 index 00000000000..6abec0a92fe --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_nbagames.sh @@ -0,0 +1,40 @@ +#!/usr/bin/env bash +# Tags: no-fasttest + +CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +# shellcheck source=../shell_config.sh +. "$CUR_DIR"/../shell_config.sh + +${CLICKHOUSE_CLIENT} -q "DROP TABLE IF EXISTS nbagames" + +${CLICKHOUSE_CLIENT} -q "CREATE TABLE nbagames (data JSON) ENGINE = MergeTree ORDER BY tuple()" + +cat $CUR_DIR/data_json/nbagames_sample.json | ${CLICKHOUSE_CLIENT} -q "INSERT INTO nbagames FORMAT JSONAsObject" --input_format_parallel_parsing 0 + +${CLICKHOUSE_CLIENT} -q "SELECT count() FROM nbagames" +${CLICKHOUSE_CLIENT} -q "DESC nbagames SETTINGS describe_extend_object_types = 1" + +${CLICKHOUSE_CLIENT} -q \ + "SELECT teams.name AS name, sum(teams.won) AS wins FROM nbagames \ + ARRAY JOIN data.teams AS teams GROUP BY name \ + ORDER BY wins DESC LIMIT 5;" + +${CLICKHOUSE_CLIENT} -q \ +"SELECT player, sum(triple_double) AS triple_doubles FROM \ +( \ + SELECT \ + tupleElement(players, 'player') AS player, \ + ((tupleElement(players, 'pts') >= 10) + \ + (tupleElement(players, 'ast') >= 10) + \ + (tupleElement(players, 'blk') >= 10) + \ + (tupleElement(players, 'stl') >= 10) + \ + (tupleElement(players, 'trb') >= 10)) >= 3 AS triple_double \ + FROM \ + ( \ + SELECT arrayJoin(arrayJoin(data.teams.players)) as players from nbagames \ + ) \ +) \ +GROUP BY player ORDER BY triple_doubles DESC LIMIT 5" + + +${CLICKHOUSE_CLIENT} -q "DROP TABLE IF EXISTS nbagames" diff --git a/tests/queries/0_stateless/01825_type_json_nullable.sql b/tests/queries/0_stateless/01825_type_json_nullable.sql index a89bebe82c2..5c4a364b81a 100644 --- a/tests/queries/0_stateless/01825_type_json_nullable.sql +++ b/tests/queries/0_stateless/01825_type_json_nullable.sql @@ -1,3 +1,5 @@ +-- Tags: no-fasttest + DROP TABLE IF EXISTS t_json_null; CREATE TABLE t_json_null(id UInt64, data Object('JSON', 'Null')) diff --git a/tests/queries/0_stateless/01825_type_json_schema_race_long.sh b/tests/queries/0_stateless/01825_type_json_schema_race_long.sh index 3bd3e0388dc..b0e2ec95be2 100755 --- a/tests/queries/0_stateless/01825_type_json_schema_race_long.sh +++ b/tests/queries/0_stateless/01825_type_json_schema_race_long.sh @@ -1,4 +1,5 @@ #!/usr/bin/env bash +# Tags: no-fasttest set -e diff --git a/tests/queries/0_stateless/data_json/btc_transactions.json b/tests/queries/0_stateless/data_json/btc_transactions.json new file mode 100644 index 0000000000000000000000000000000000000000..136f8ea29c1f94164d27b6b4ed75da733370825a GIT binary patch literal 210270 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 W@VpL;UuzB~u(z8*GUWgJ|NQ^w4WU&4 literal 0 HcmV?d00001 diff --git a/tests/queries/0_stateless/data_json/nbagames_sample.json b/tests/queries/0_stateless/data_json/nbagames_sample.json new file mode 100644 index 0000000000000000000000000000000000000000..9ae75d64f846b3d2d5f2e3cdd7a6cd631579f12f GIT binary patch literal 6381971 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 D{@CJN?F5U(&{s6Z=Fm;vi$GM=?8p2 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 z

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

}=_)i(Xi2m~_VjkQi_wV{{0cD|H@2F@BX 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

F;f4o@0`5a?cN=aJ*M~g<`^W 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

BEJj{kG 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�< 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

dWGC{kzzT_hew< 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%0AlW}`J2UUa%h&b*SD7o4+6Av4T6)1 zeh7$fRTA+VlVN{tc^pbE4T(U891TC&Y*MP#2}T;f_iLI-DJ=eNbTYJ2Nchgd0VR=5s#;x^;GF zqL+%*=d{!9<@2SVe{~43+v;VdUn&A2H-vZAdVvkSL$G5M33E()ArL}6{6L4pi!+9?*Z2r^_*f;drVOLh-@x*Q%~9(Qs;v&5t8 z6P!HYvho)g5d4Nt)BXWQ$cVv(X-dV*ls-?Aks{Kf5ZSwr=$RseQO_14C`U&Kz^72) zQcMKH0)ZmZ!MtJBkn(_|%l#8kprRiH1(1wxx)}+3k?;Yx)q#pNU1*p9g6=sz`6w;) zy`H^Zrmb$v<1_Fw)e(fD3NiKqL|{PM59G#)?&G7;mSKTL6{4X>bO{s?u?`fJ2nq*Y z;h=c8xw=jjxM_A}yC|Y9u&MT>$P_&{EyuXKl zfk99(PJ;b}Q!2cm$XMk0BBgCoxb^dT@gKL}i+V0!pH0mn%pgewj^n+k0c1p0MsgEl zjzpQ8nHx1GxRyb0(1y06&)3WEsiN!kdh?^GVRAwOTGeVJ1RCgb?NEsP(~1z2W}snS zgBX!YX%sVWqABo7KIf^S&sB1A+zmd7icv#~{L;yqs{#vfVbrPE%egWvgda^T##qtY zBAu$)aNsKh1Kd&Zi1l2!CE~#=!ys3Frkbv_YecbaB6=_d2fVrF1pc}+*cip3;DacL z1|OmgLF*Nakfbs!FfvYWUfe9xKIt#g=DS4@4%XCK6Yt*{Zs1dDQB6w-B2)Pw5QUiq zzG@d2f@-ktqYJM4X;sr_)M;$KmlhO1sCj_DW|v~083laoEywRQve2yT z>$B$yK7?OQ(;Uwz|HjuMqr0_Q(#m`&5}KIl&VF}+85rdqx;zyo{YP`M4--OQLm(Kc zC+k(Jx=rRPDd^IL0SYxUoeMJ$>EaF=XtI>cP{B?|eXs0>06nBO7+U zl>vC4s>j}3rep3?PQ>{!PBV}Nm5L0608nFu;80G-An!>bQXwn=zbIv9Dk2|nJFCcG zE6|%}c=Po3DlN)Rl`;$byA1{2TL-**K>>h7Ngil6dkgmYI)h?Z@+Fdiam+}BIVDpP zyfUlFGexkC#}7Y|;1_b?2Z{sPp*fJQvA{zr7KVddH8tffk8*zOtMciU?eE{m5<2#t zqQNV};nfoB``%op&GN5(2{u?zn+$Se0HQ1!GGG2*Ig^kg!2iTREn)PN(6D&sI+a)8 zKmPD|!-<3^%k@ofdB)?PFUr`09(g;q0CvrJ1g?ct)c~$$i)m?6A6uxNu*C4NMoSm; z32W^BFwekv*Y9&Alh5|#`CN>P2nKgw63Hlo3r7cL3Ux6wyRM^-zvtk>4f`o`fNEn5 z@x?cC6F;goq&bnYmOxZwg~H$}3JUC+kFZYszBY3F!0=ILH;>M{Tf}z*3|bBo3fcGU z@oMW6VW$xA+GILxLU9i3pldY5Qi7h8>9)Oy$^l;~im!|9@;S{hbyeSKK*Kl@(0H0u zLrRijhm#O)VTcqF!cb+5gA;*=YAG>#h`2PhC4Iuq%=1}qUImeoXGXTPmDxBAz9kWm z;5)s-IaFC)zF4fi-SFo~(pXeTgyZS)P)!Yydr)Jll%VIK3Qf?If+Iz8(TpG zSY`JzFawPhcY+)-Igx_XM=68j!SFkqI9d=Fu^nOY4$y9ZVQ7ddn9PgbK?;1G^Cr3q zBc7wsrG=)>-!4+B^pkU|{O<7RPVG;`goG0j0G16&y1YyDdDP3E6JrNOwlu;CG)6fQ z15o1xXyqj2aq_ZpQd_wV5|FFi3H-I4jX=8^lt_OS7|^l<%CPeu%HnF{^AmEW^WbHp zjZLw5xlCLAq(yC)pKiMQ=~5c1pey8L@KB8c{wgTQ)l|6U6Il>2V9#6GC>C+fepz09DNY=A5VRFS@~=w2 zT71|lb&hkX64Ab;aPFsG-u$PRKb5{MlhN6?-M12-ON(_FAa|;hq=-d=e`mN=GR-B; zDn*UAST?(Ts%OXQG{!vuq^?ZV(|cyl(HN1-VncjCzfIRHd$&#tosJgcqdhep&7adG z`c!!wc4^VHm?1zcO*@Zd0HOn9w8T4{XmVR)c(%!v^ILs0MLp`>h8&^O(704mSiqyp zkf(#uTa`eZ`(WU<+NuZ!ZYd#3Fu2*z^K{rxSTlql)L1y4#Le&lcg+lQZ0U%$J^eAq zw!08pbe0KG>DW3bq6fpdgI0>{aXN6fl|AbEhdbGe>w5MC!#w*}OWF4cJA3*(p##COftE~M`%og} zV_>Hyr0;09lMFPWD6bs6HDQDN$VfjJ7MgLlCW8+e6eEXH2V;&OilPWkZORsYPieAL zfbQ4kdy4`tW`lxDK_jeQY8wz!6C`w7G{z`VZWYIBP!S6e5JM~jT19;ESTM4oB^s#| zA6wowasl{B?c3q6ibcqdfIhW&2nRq6L1n7>FcTT&1MKs;fXtqqk&a=(E0YmUyuQEP zUKeW;{3>krUi1W|MM#nKMDXyoiC60%*L&qnPwu_Hhv}d6Kd8(9p8mOqAO7cm`Mgk-`|)Cad>JaRKaA#0U0L{)g`RWfL9%~Y)@1aqL7c^wKz;$FWy)d*)4sPn||Wlvx1wM6_lvb;?cVb6tkd03olJbpb?P1>ls1 zQk}7H7$?8d6S7*%gQ!P5D`MSN4!i8;gQ8|kH^;|I`FhioCOwsgh)WxRUOV`0FKzVo z2pDC>hnFH2K|gSftOA0MDJ?`rqU{GN%YiSn8aAyGgN>37cus9-L;{lC_AWb%UcF0& zo+%XQPi9Iv$pkf`NZ?YDknAy#VAI>o7&9AZkkpiQ0|-D<8_w!_}jr2x@AH*S-!T`l#*7i)LIS3tpLP)m!`OS32P*syZDl_L^rgS^&iZ^2ntT z5dffx`C@~j&4~VLPjbVd&|2$=kJW6zFO>};0z;E(HUPYTPY$`eFF@#gbEzvjqn&4u zt7*0ngX5vP^LHJ7r!eS5kVF)Py~cmv7<_D{XPX81ys@ARGMr0a<&vMLEqv2zv5T8U zDjoa<1^=7Q)-KO4egUbi68oTxGAHkKT);&2XpY5^p>rqRO*8z9-mb{7sq3?2znW^y z<$pMr1$i0+qA8-ON|zrWP?ZhcnO%M#{-fpD<%c(;qi`~sPj0i*QmEqmH!&FX>k8BD z@*?=2x7}HbRUvRZJ`=zQ0N|ao-BKuV@nv=6XFdG{uoF|q&XF^*0k-nN=-}oTM0m}5 zk0DX!%B1*YqRBc5l>z8a(`4bGxW`F!eqiEjyD1l4qEoff#$S~v!E6EWT5oau=*EzSE;9iMOPn|i`#!dd#ODE4Qt;9zg852n-8Xpp&)on z))Bo*5lWp=p`TQbo1Au$c)r}EWjrsq*Mq|WJg#+RABVQC#Ph-iiud&FNN?+3lFM+2 zDgw7vL&PJ2Fd*ti;L0fRdigEwT#y34>yS!DC#FyWUl^l=XwJ!$D9tGK46P^`)`tSO zJ5T_nCKRcnVe=*Vpr2MZ%TLRNufK%N8|6hPQ3rT67@`~CV#?KYFpBwUk&698zp!w_ zC_%^4C;=@o`|EQ1X_MCA`ZWtqOHd@L2q>XYI{rT|KCc(oX=(X+fS?Y;wo)y{AsnAJ-FZ7Me^;7KSL|HPy>CRIJv;G24w*t zR;%f2S4MoPXg5WE2KV6T?9{LFJEy-+$*9hs&1ckzAHj;6R-}O*s$5`nhe*SXI;~|6 zHPCjo4yO!#Rjqu(2>aQEjw?k8-sMq76y!$^g)-hiTc;*XPrKHWn!@BFCx)JUS}s5P z#a(lNuj&E6$p{%h!F)Qify?Yp0d}z)5;)z}aJZmD5{HJ{d9mpad|B0&ry)l|-Ox&% z=9O+K?)Y4;=OM!s4h)FGfsbTgJ2+JUtyY&DOcF%A!s&3_Klc-GE~PH2)8NQfMnnXC z&TxdiP0%J05?&cOB<^^!NT+gK6&19$P<}-3h`Ilw=!;w1RfKm#j?qwJq(Ys zrU%a{9 zzVz6u~}D!}@iJ&Dr^-YAe5| zVY~1-O-*+6_N`Jr2Ix8{xXhlOar4yWlu0qamEREdO0AhZYRdR*?k9#Ha)2cUf}!$B z)zZ`JmXQExB`IDuczXB`70ANVbC&y*#;WJ(q2)CsEJ~a(11b4OE&F)pTC)=h>r=x2tV=&>~u2TQ0mt-I`cMVrZa|N(!1X-l8h7t#$@$kf$a^qpUWMoItf*LKc|d>A;)WLa^SD(^NO?_gvb54 z-|f;ZNhHmj>dMMq*nuy092;~*WCRa6cD&mlqTS3MuhZ#K<@yR=KY?GVVF&*elfC?2 z)8&*x%_b^31JP}0JK8)ivC~YmFas8XZ*rLA&2t443`oW#%s)_xw<~_0Gki4su-R9=8xnNze|F4@QWlE}kw^2=w=~ zk9_iUzN9DcoG$UkZ?b&>0+K&+V8jK9Z8Y!$Q5od)bjLT(J??OP+nk8LKdC^W;FSS^ zjV{t255N9a8`wcOvSYCi0=sNT7JETKh%iJGjuNHH1mxM<3#kG_g38k&!DX3P$<6K7 z93|R}Ku=XXf(>aa2(uvv5+eHy0)=>0fP$|xC`{#wrtnyVYD6?t!~=~hRK<_kUsu#>5lU61gX?NgzPG7QBq9)367Bd^%wj^5y_FM%3 zvXHYvcsxr0Re_4qH;~-tn1P(4fR-r=l;mB$Hk;k{9F9uG;PR;yFxUMuVTNXBA1Vlg z0f1K&ilKEFDSA+wOs5!FueR4)=Ri3;Sz@I8$$0ApkLU4kv!3aI}>} zaInFJ8V(K~X(0re>`mo3TkHj+S~``H6}fm<%mtpytO$kLgn&*2y5(3ga%3-lQ&R(f zRf!1;z<^zig^385sj)^>6C>0xn;5;R{izWTswD=kIHPw^E&XG~0&TA|sv$IYSm09C zg>-u`{L>xF!L%~i=(4m3ae$KQKr*RknG<1p3^ z2A|M8}j^tR;UQnk^*9)Z^K_(pzf@#MgxMyC0iMqejzw$Dj*AP>7RHq;)uigxoG1 z1d*v+FylcxIT427P@@SFY4gf-B2q6`v$ttM6O^k)8hEC56!2G72-O@@?>ySKsXXd> z^^e)bt(??QO)b5B@iRU=)DWFR`Q_+t-jP9HKf77S0x2NP*TX~0uK)4bThSYlouv|@!bqX&{5!KGYuw-H-1{A zM3|FKlBO0?A<)^6Tin1?lKlWXI!YO*n{%sq1G+SEsz_ z=X6|_V?<}YIzF$A2vIKjSrY>2Xf}*jdudBF&}+-?=IMOUeEAXa2w^{(CE`I?3=HgH zn5wel?1A@Z@rydB3F6Uag>($!!C^c=Q502|=FbKoqRzx^RTTX#9Rm`Nm)q;KWFr;M zY`%Og=hobOJo>3%@KTIQaBT5rr3NllMDV;&LttrAV@yQu=G+H`iPkh3!R^8>(#*4# zEURgCdZLX%pAdLnF#sHbfm}_-;J8Bwg6kwBr<*HvISy0;{ z7`fVP5D;NPNPOT>d$_1Wra*-A^Z9lGN&)1vV%TJ$EjE~zg z?~W&HMgYZL%%ic*?>VJ*750Qm>q17R)E?cWqMMsVDlz%qDdc7scI7L ztk9v1w(xgR4czNlhg*8C0}c?f^XNwW{^(>Hno}D}@gN}wW2+N(>Bq7VMONJt1p4eI z4Mz`EkqQR%e6mOc4M_{p(hN^GX?xAp|G7oB@zsBPU6eI#8X)$zCr6SC%Ici|! zD(^u!GTCx=cT7j4d~IhgTB%IuX@CPi6jlV&`7U`6KN1vCO#*pE0-db=sQs*`hy(e- zwzu8NUHr)N$YM7b5Q+g6Q#!~GH zoKV9N3b~prC%t)uN_C!`I75n&%&Z7v0;)Gz@pN-Jd$&qOGXB zVjL#J&;h#)WktfI(&^YdOqSL8|P5~^jbhj5cRi1*ny8I8jcjW zywl`TZyr9N5dv~RpTXF-gze(%?N!=P{lf=`g5PbEeHRl#9V##c6wu!q1!2N(=3h#n zF}%*SgcA!iBqOk|Sfmr}X0JBamkYlOEncKVz-28JVUn?p0Edgp0r!8yV1uvQg+MpX zz`!^U8~e_tRZKA_gKvyNkgR7}ucpo{9o|&AGaMLYhgeNIke27YW=D7Lc?B4K6!`m+v>CDSr1_xlz+^ptEoPv zsqRfIK#|oFNf9C+4_$bATAYL9&Wl1voSqJOQ(qwzG!tY*)O4ifGHqm0AHj;J6dJ&< z$na8hQ(rRikn+KFlUz-fE6A)7IT0~Dwmx;TbBoG$mpi`n4$P4r6yC+pcjB1O8 z@y+2)@LO<8wIsfwI8c~(MK{wV!}J5yjalyK&*HW^FmXk?;Sr>xdmgRB13#{vn2-qo z7iu_!43H1nxOVhQJ=dFRD>BEwMXhmHQFP9v^(Tfo0l{msHSKN-<^%-K@0?B8NsIyw ziShuhTn%Y}qrA#Z90&}h@*?i{iUv00oY%|b+5WQGOxo`!q(s1*+K<=^h!IK{>thz3 zWb2CuZfE~Klu;TC6ckez-Q#(IxT*`hSH*+;&|oh*xaP?2kwHHFEo;Aj{d8B~f^#_VGds3nmK;cu4o+tejefA97?7rJ=pH}nRVDSKz{AU?f9*5`9#U3t{AfePy=vkyq9KmD zH3?eDG=O2cLq{St3pF?X`&I?Ardt7 z^XPQ$_r;Q_3Wgl84PHRHOI>5h3PGTsNuHR>Y#!A+Z@UvtUj{D|udgLV_yBbwDxitQ z7&FQ}1UY}AOSb|JS)7Cy=wh~@`({RZCy@HOHpdGGMF>K7LE#i9gs4!Qd45C{Ctl@? zcY4bj`5v>R{ZwH*!3#fZ3Q7B5T8v`Wr|D8f1TRr_8uI8)LeOiK5OVk~`eHzdmA9l8 zg@edC7`hu`9q+3v+GnwLa;6T4k-|2oDsZ_o2#czMW9@1`OE5$~K;rmv1A|f~(t$f! zIzn>7_`oaE5*L@7o16MDPNydD)|wD|xtNB7Q<>6Fb1F>tcZyaX6cMRKVS51)Clv4_ z5e!}#5Z$9`Jt^>;8jBE+;-Ok);;%b7F{U!_#D}0PjSc~Y-ubkS5BRNOKsW|Bd-rZw zhJjo)&BiXd80r|PB&bQLBxsXNE{s;{W2R=SaO_*vhP`F#)$sU^>Pq&%@~r|LfLBci zu>g=~m4`vJoxi<59SjB{YcLFG3JQ3xje=1E&$#p@cZqwIcAZ6Q)C0#OH3o!3=+G|- z$3r>lNS7iKZ1nV`L`ek#Nh$~$gVz5TRWYXCq;V5dA9`831==~m)@h7Dx9%O#E6Mk zIO%-1Nvk$eRYWlZ&bXqMPxMA%30^+#jOr*Spd3t3hTI7?-$Ir__|o1Bei@J3{YqG2 z59XLaz`)REFuG-i7(WNbFPrW9YWDbO_NP=Y;$_tNx9ExT1fNhm;v_>`X^W}`F%*QB z(jGK!$Jg)HR1srGj;!4(%^eRRG1X0)IG-j>3a4WQ(qR+62Dc3cUeX2wFI95jp{y#> zrD%$gWC_L~#X+>x?4HvR-L*{^R2K@5Xz%Fm8xR;DM~pXeXm2`_^y|u(ip)XQT2Ro` ztUtOrWru~Z0b~HBI@55YSRDIfCM@v5Hyjj4IsYbEQ|u1_?94AdrFp2C9PqS}&%YS0)tPK=GG!uz*(( z>0zY-KCAk{0T5Ds2O|{QGLT?##D2R^Uy_iV*GKp&AV7H^87~6ZJS13OT-*D$$nsj`;U4Adl?}mOKwUt#Z*$~qFo-=LBa;?T3XMSU7+S{KUw(l})q}m}C zMz9%TF_uyqfd1KUa#liS-IxVY$6=5PbDPC`l1JU`V#ndJH1qzJkMm6n2rtn5n$~uvi04 z{X(rER?~pWCwxoy{Ys5ElR}@7K2tE5?LCIMMO^JPIJFQeGtm7S3Gtrq;56j0NoL^* zEP=r1yziLRr~rX3=I|;^!UIcT0$$;~=>A5s7{qba5bT9x1prf4;IHC59LkE`PH?2w zE~^-82jqI{aIjW%mw^Uq0sEIqZu@DCmtZ+yOJeD~>3X!)MS)=~heLo#P zH_OQv85+ZTR7Io~Wv4nA3=)DOLSZpPI=hnlJ(huC?O2D2CD6A_d|5rR80QP^Js9E7B^+w@NFI!vgr471i2(tq&6AtCS>FPxL0`MHGZKGTf?%s?P} zj}Qa5v(5liJ%c{+mY1SIpP z!XeJPviB5_pfa$#Nfx{NXL%=ao*lwZ139-P#SRduxAVoy_DTuBa ziOCp)B1*`PjdjtkgXhxU_6WvyfWh{CWN3sHAqqu1nw~{Er68R+K6|xXrlpSl zWGcwGa>5~jo+&4S{n*6`!DK2DqD(EFJJHenpE579(Ok*^Lg2$+zNZ7D*Nb8`n{}Uk z79y10FK5|?eYZI+JuG9IyfNBCsKOlj?Yn^K1Y@K`gxF{QR!|2M{Zf5p<-nt(c|J)~ zRJCX|yM3mIv#YA+OJyXe)SYOSu^-CPyXX;3PiNtFBZhmMP`%2L1>u;N3am~bb1FCpSFaSS@Tvk{n6OL(gy zgH9?i!K=kXiUdBTNXW304C#-ZG~t;0QZBc3(~SG;rQ=W-V%93iWM=~`^sH7(^yx&% zg98Jq{SFE`&x`CZRc$sz9}ayIaUd_uPW5)k15~xWCNr8@V<#ARNa;YIGkS5jzpw9- zOC<#a#*NeplsKmpa>78w0*ueDOIU5&1!CF;U=E02u5qVkg8?DBVyclE!dU@=+LJ&K zOar3LhL}319MGeuY#1BbTjPP?wLst{ZPkD~wQ68X?@~!QWCm!f4Fc*MgJ7hfG;C9W z7Bz)pWD7JG-Qc^~fEX4bDFlFPI+&WIb!+F%cb*$^<|kOCUS*o|64&<`AYiHU>pMGN zb!svkGlB=_n1OGpmM~^W;;<1oXI;_tXwhy5M`vre zPM(ZB5v92o9HJp$Lj{;79Ah>#7g-1tXuG)fe4PnOM^^;vi64oO1YNZU^{_Ltt#${fPfQR`q2ALzU!i!EumLr=Bw_S0wY zK_)BToWnZj0JALL#6UFX7CHB%Jb=PbNsz4^#BZR@Z_C0U&YcPO)6-&Z?H*MOttAg_ z^^;2FG9`Y$5n#H>MXtKZ^_%RvjyY|zx(H~y4*K{G8R&bh5@pH+;xHCsir7npEdpc) zGFPRlRWP$4SHpwRK;pI<$hh$t`qUH&X1`u9R$o3Wi|KYh^V-o3A6wQ`^glM`b* z$DT z5@gNK&jl)4OcJ=ga4qKyE0YmgAl)SED)$%kDg zG)wxRC3{g4c(Gn@G2C=MygE}iN$EeRi%ey-pD?a$X&tHt$V_I7dETbcCdpPu5= z=Gxwa5zemdA#*4AeNKs+MHHjC4QBZv5VagwFeXXV_RP^ZR zceL>sGh3&5vQ0cXzHfg$)nBMZL`+ZpH60Z(`_p=vHhuQiBqsv~97IHZ z13$)PifI~6TT;M8N#IV$ox`oBl6buRk)Zfxu}x=2_#IsN!CFZ;D1se#P~c+8NYl@{~h)fg?%B&R4YZqkzI*~QK3YdTWp*My0e68uW3 zfy+AT=}#aurG)LDZazwC5Yzpw$2=4wpbhFwlt?g1l!|O`isg&=+9(7e5zuA?(7TJH zFJu{?LEtmBe&`hhkr8G)+56{OC{Yz9NY}tExt~;{R+yyeq;ocm+qN zx{P0x!kpf(=Eazebvp8Xu?Ifa^NU_6{A!l;s3?#Pc|8ggPPPc(v&ucbk{u?defIFH zVHUE}Aj*(_^?~V+2YM`u=8UOlsR@Xc10dI!ia4MVsuxc~%nLiyG?yeZ5?y%|v`AV2L`0$A|v=(1|ql*1_ZCnfWBOPnY~@6LmR&>eU{7zpH7z&6wwy_h|6(8 z`VS-y2{=;x@r#Pd0N|(oU@CY#SKtSs&^wWS25r7i(f*_2LZ}4 z-(9Ct#7x7koH~n5YvY#R56OS^U*HfHt4JUCn%akEwYfdFcVHgqY7Mbg3^~PvDMCJO z)Z7aB&~=qSG*|t#Iogv$KKd!D&8n#s{9Yvz)<})Dbce=Ol+$Dzb$aaAS95E1iFsja zT>nR0+0!7M(Cy6x5Go)ZC&plwZ=2SLdDp%(m4fk9d}65Me0#9FLPR_|0>ZvHR#;~` zOLI=niY>0qhha=<&YZnSXo1`6*TzW|jE|r~d`xF^Z_3Au^*SX>oy2lNOBsXTX2#%B z>~@#|XP#Lpf*&X#0s|;Qa!Ybh$zr*Wp$;{pCCF>tAP@KUoy<@R@u7-()K zCivw6{%wwC#MvjNEg;A(;RL>(K?t0{E#U;OOj*26d%i8VvnQMD>!Q#S-%}9KznTj=C@ zbwmhtAbK?lA_PF;Fe*5qp|5W+$d#$pygFU@fYvJ?_TH%@)uN}v>0U4a?}P%1cNB== z?>m`5@0AV!PW=4?=}<0d6k7pY`C`+RZJC&dY#~X|3VN6nnx%b>KP(rw|8OX@>3|L@ z9YPuzcWOG|ErNm&W3r1i*w(-XzRpnSPrQb_kjVw!;51~~{(bW$Ipv>H=<{j0@ZJQN zH%f?PGfMye=f!7iqoCa0h?*M2Vuxj z$DT7ybiR}dP!d@`3Ijml(-DyvjGY=yQ6nbyWwp-ezGvrtXX#$hLEl+j2$DnRnb>n3 zbvjB?m&4i&m4LI+`YkkEQ9ySU1t$=qAtp;iIhDZnNYFv2%!x#~_8%jWov0uaXsI9& zWa8B#ZKM2U_UOaa?fQ=|Q;fRUIt}6XKf@1e=OH@T=^;e~pHxJQ7P2aH`V9R2(<0zN zPunH=S*2DcBbMYFBD^x|DLbI0ZKiKN`KhMjJgO!X!L5YLQEN+at05uItyG!}5fFPak zG80>pLbL=p7W75r1a4;!JFM=*2)7l+?KageExvpxrxef|1p=3#*;;9ELMfZ|FC zVLO`6A#5v(Xg}mp6OrR%zqXBGJ-uu+Y$Roa+Z{B}EHxmwauR|fu4O9F-)z1X0SBNR zB}T}mq7SvU5FIg$WE+k#ZIKOx1RSO|DR6xO!R-u12)%GipgPiL~P;eNhLs15xd>vUKR|9*ZjNrCH5f?(EAx#;1boAtCmhx723ckR( znh|$~q33M}7=pJAW!OOhKWw6q;*Q(x?D_50m)q;BZ)Ke$-dBqUx~zIL7}GWw`0LII zm#8g-KErt1ZH6DBF+nrF+(d*@RwX8a)-){eYcCwD&&xFN^t{-UAJ5bvpnVp9l|hH| z@vDi4i{;|xCe7?z+$K$QvAJGdwoA<}o;^ZeTmXQ<$N|8<(+=GAQ|So-SN+XD%aHg8 zKv-)T#JH7*=s6pca&_`U8x-}0?a2pP(=H=JCrx--PCLL(s{*Im$`OF$A@jp(xA1r- zA{DicYr+ zxj{c`n;yJ8ytoDfKNUvM5{u%l2r+19Nh{-3ejaMLO(As=5np6dI_!Wce851c+Byk# zi~`y!6?nefF4FdVFP8P{1;5p;L&QmJaB|SP8WHIns3cdDhQNWdkoz2*OMQI$K)|5d$znz-TgJOg3^_OuBDm*suG+%S9X1nZlLnNI7`;Z=2g< z`6EWH77Dzi4FTGu5a1zI57Kc!Fv5Z{2uhiy?*woK9roA2K~uP`cFXXS8U=PMkNMkqrb4QqbK zd6tuVVL8v~=se4t)%yG5HZ9JWJx=@Av}3F{e-4u@b2w=^#@ct1#o0-i#OyS=Y@xH1 zDiszP4f_&^eUO;M-G1PYY&_@B=`@^(KWR@sIKD@@QkNRz)(WxETGa}Swlu_I&sF@< zT=kK7DL&HaXoQ8{){;OC7FUFec$l*=_`jVhrn7RHf~f?#G6b?M6$F4!C#W!y;FW2{ zw~O2L>}}fT>szrsAOjf%$H@a#gn$!@^BpDde5ORY6bDiv81$Me>e^)?=f$}yBpLZY zj+wu3luzXmFc_O=G=hRaW14p2VkOIYHrJQibQG7<559T_5Y{nga2XsRc)s!_51w%9 z?g0hdT^9N1;XPl{#qVW2y8csiCt14lLO4cn zUQynThyZj&dDw&9J>&Wt?gj~w2;*%^ zR9zOuZH^b{Q_YK@F3^SAw**K#_2(EbdP#L6=5%Lv!$o(3gjqhi{v{rAyhz)FrCosj zgwqQPMUkGWd4bO>FZ!iCPCkqlGSp2yF@{6#Uko!SZVre3YPV3-gm#Dt350mG#**sS zX%o&uKA@Ir9GraYHLoDr0ZbM|CgV`1A}C`M5;7s&LhA(sUYV}sw#(1cQcz#x*G9lG zVJ`$I%d{9G8 zDh&y_nvBGql5-(D$)2||FsZaH75~0l{lv5>!-**Y2= zSqXe-jNF;zXLG+0_1uKBnp?^qk5H2p_QK6_ZV3{nZZ6DoUSxR>A6Dqm-0aF?L{urC zGE1)N{TuX+pId61ZfC1T2)WCdJ1gB=G1zDTUvKg`*!ap~#q}GE`C7TspSP%!+#oTw z-ma2g2Zks}enQ336Js*TpHVL#9Y8w{%n_EGe7bTXQp|yp&AosEwyMsG8$;oTLJcs$ znenW%P(@lsgpM^GM1m=A(?qxtOc?v&JiOtod3Eqas?2ZO^L*-oY?Tg=ix&(JwA$hE z>PMQnezUmr6?YB^%8aNk{4jH)TU&+aRcnyYv}Ba@>2)K$5*i}xNRjotYKzo@?ArxH z#;&(~{^!eUEC9Qfq|%^A(wk~C=3od0-6_u|3~cvw7;^WbYZqXkcPJ3xPPXM?+c?}( zm5D2}<=i`dIZJb}zZSb7;RmB2^o0U=C>Mm^chwTbPT6w{gmpu`L3}FT24j{v5di55 zMxJzgx!GPVyr0+EI-EMAIroUp*P)L=B3F~$n`|V77lsDq&WT4E660eTis0^=c<{=& zk^H-5Dzw}Fb9L=)h~GaBG*LV2fCxDf+!@P};3XXkG8X%k0s_`aZh)^dAld@b4}|d| zCm`Gu`R(E#WjWPO@d&PNTSu_XcX9gj7)Koe#9hj)5{z_vs-n;oVl1+2`~0MZ2t_|1 zfQKrZA&^WKio9?s0UqB5BU zaFa}2SmIQ|(Zgezj#BRlzMrUsGS(si#CPIlo@By*=$In_$Too2I?HrGtYyZLlOWTb zrcw{M9e4R=GYU~7dh;0eb}{n^u$^U)Y*3m(C}&(dAr@YvZgen@xKo=){8eJ_e{YofwX+ls4E!|5SHWulD{E$m%mWQ(5!z^o7LbGt zji5`&Jb2&}GNe}vh+(S|Q4#oT#-Tg!7(^tUJd?tTw0h+_Ov5@TXeq0*gb-r^q?#8J zU;+tI98IISix)XHE{2n@BpT$8(IO;f94q2UBPJyQ4U{jmc5TN9jK*4_s1eWCV3?2y zL7HHU(V~|_-(PjcYz#mWKLW58sx$4(`lGeb4d5vjPDap#j*Q^VwTy7^#G0o22Lu;o zI-MbpL>Fk4v!l_FI9|lvB@GR<&Y|&ivHhN;BrR$3ex(ny@Plk(aoKdO0o@o9Z25F; z(Tg$m2jVzP%d`9RDWC=%5HFW$?|}EWX-i_iCbq3B2#MejYzXeuIEYZ((T3cusB!-k zL|VJ@^M8A_*-l%}6m;e;J^-f!B%>E-?5`%`Mhbm}x%uz`do$hKEQ&1lPDX^{gf=7a zS@E#sYO=yC6A;pW5R9)g%R!x6W$3!DRWKUw7C%}x1K+4^h7*e9N|e(~kGDy`tbbfr zvrLG6{gFrl?`>@Pe7aJp|c z2SV9tq0KxWDI!h{Ugq7qQemIV7*O147;QL?viqZM4PMlWd@!DxGR4a@JIszN@GQm3 zY8kJ|dUjVHoVcu;ji9pu; zI@SVkfE63?L!sfNXzJj|;7+ZnjSqB94}jwSiTF8ECL;iV3iOv96#2+zfr6N2EV>>p zt+-*4Z1+?vZ|VB(Dwc!>~Ndi=9$e&EF!vlnK16Gfp=)u37>9$mi3Qh_qei9i0cgl9GXe+Q1v1BZJeo1LIo1`3{3Zk zV0wcJcPB&Kl?lSql*+R!SqWMu^u1j!*1oIN2lteOy010x0aw*ns7cUwW-RoNd4NV{ zb!S}RaoNKL*frUSz9W^_R4`%RsUi^ilyD1ko;b?ZVUs;&@3N2Os?c<%H9620Q;R?j z=R9yxs-w!G26Z^!AxBgTy>yVmJXx9!gkFe7!t45KfzyUZoa2W#Y+B0mEw-b5vAwBb?)g0=Gv;MmMJxC@R^0aBF|LK#5+!PKDbMDH?+d9hIQ;R70ts)Qb9?mT>? zoieJLb9_tXMA6m4jv>=bxVSVN#V<4qKa&y;X95q|$!f;*1ugT#+Mp!0=g3}k&nj}c zXq=nT?AF!(5SWx2hCxS2L}eM$2h?+MtRs1 zjPA@POT;o6PK%wI*h6Ik5rYb1&_d(Y>f>tm53!`>*X4&RKQyDWXf>K=IuW|#fmE%Q zZgd}=U)w^)cDwnPwjzXOE@*piJP(>8SA)?6Kfc-db=m32z;O)Hznq0dLK$@b7 zelHx}F^Pp7YB;ecF}l03M3G2kH3b5%kZ92bA{fb=Z?ZJj8gX~rZGy&WXb=L8Ht`Tc zBTSRWnOZXNQw4)@VVf0q>E_AYFL3X=;TX(kX5^sNWYZxM>d7$VX7sJwv7E_xg+etB z@ARf2_QtoWtwcivsI6*gGcg@Al5*8aS{fY)an4Be`{81gNkV96Js`&x%;!KvB!CoZN_f$?8 zcTk{}$;;wUO!sz7AEn;XUbcCXfi5+>W-LO|9HkbQ!yeNfv5K{(VPLS%(AV=PcKrecuY z33G9^fAZ$^|3r#UjHg*c@VM~6*+iWxj1*;ig5b*38{0SGrVkmqEoMxkB^x?k&x9?o^lNX zjy_Y%EOH(OCaTlN5X_YG`0^MYlGGTlZgM;y&3Rk^0~8GfZ8_NEqB*n8AwqXnr#(%2 z!Ek<1UNcIKTX0iem?=3-_NXK}E)|E*(DYV+TinR5lfoP)&pvv=vke>E!=MREf#J-U zVU8rhJv**_z)~heY)+23Kg&!LfA>DCM z;3A`iF89auZ%-_Cp2(C2Q`As|>JR~-T7$ICU&#*lGHIn+{sCRGs#wzhFvKVXrz(iC?Em*Z5oG!au{6pR)z<7^FWg=rlnMCu7lPlAj(-x zxTwYff4z_I4l03{n&7%)42PdLF?fIQxlK^+Kf zLjO3Slcl>+6K|T`M$}7h8X>5~H&t4YAQ=!2O@98X47>D};i6iH1`m}Op@#)$YBaKC z;GvxqCx>lqA6oWG(;K%^--rdCm;(Gjj*JCf+X*K3xtDz?e_yZs@Hz(uO{4073*jw3 zLk)&P0OzmvGFdLmLYa!>&f#spKbB}@K0IH4!RifTL+czPh(}W@aK=Eu^~rzAp-KhL zcNj4y6=nXPK_I$)%kXRnB_VQv?h_YzHmnz`tqe&1^66HVhU&~>AplB~*cuWRXc=I$A9 z7@~n+H|3H0brFNbC$EtBLEU~@#vqVo!l!xNU)jg@Xta;*d~vZ|e3Ahu8%{o8_`+cO|-t*y~dQ%zCOg!#Ne3bOK<5HBL5sTH%DP!YGbh28Dk+eBKTIOnaQAAqNWAOk+;}4M=M&HCVSdVM83cleeW9kHfl}O_Tb_@ z!>9SfBWDPjqD*v=^KK+fdCczN$EEDiy_BAV<*hddzmq-SGi)Gy7D|Um61T1OKs_U% z*t0WfZvCegN#;zGch3IdAURW|0*IIr&Ct<^ucOLxW1Ew%tb|)}V6sy!K)X4Gh+BC92 zz~J@>7kd3Bc&Cx688~fF#KC--4?N12@p^GC8{xt<>P|J>ul5#bopB;07x?Ce2A*Pi zsq%0ip*Zq2xv2v@0CPMo?uY*YBM|keB0S^^!&*=USNptAA^ah zBWcIUIy*%7dwz=fBfqocDg7VGNZoM$`{4A@uY=7PObxT_Lm~||*QZ%(WY0z$@KC7c%0I+OOqi z5x$=huifz3A&7H8;0NZbRBsW)>3F~CWuN)69~Q-JwY0xL#X8fX+iw#0TgqsVAek1_ z={KvJ3)xo2?>=?+;K4BD901g$$N{aQGC9d9XY$d^T8VFeSkzGv>}((bi6>jETk&GG z{v=avoo1s6CLN9yJZySyXv&z=qG?a(M0YF@-oy!I+d5)oj~}UZ1QcW>la0{oFKgoXPZ=_T8YWa1CYLN4%A-}-`#;jsbdAL_B z8%IoLX$T;Y3iT`{Ts5i;eGKp@Gm1=xJ(Z!vfR?p;JRiab+5p3+Dt!1wrsQB#nc2%* z8E5Xv;EV#F*^GjRgHgn&b_iYn%yRirn38fjS}u3nd(O_*tIx8LCtF#S%wNZnIU}eP zQ}0|dcN)nWh4JB7H39L1UufCLG5G$Rsdk2EofJEYoRVhhI%#V;&p9|fEkbKNzY$s^ z*j1OobRa2WCwgRnZkjkgIty=O$^iLDR*_NI*H@IK4{h{NT64`WV{2ChiY4=|K0IAs zZ&o)m`OkkYWC<|uFmSs%X<{XnfXIcMnHL*a3Oe^a`kvFvh z$Z^n$uFrUdP0HV{K7GDgm0bvJFz^O#?+KV{r-8q!_uP{iJNNPA6h?$J+-m&gelT zp7;%;?!B3`vA|!A8KH8_sUkHs_yL)MD#JC*o-CcgSTZKOQ78y@}6Hm4dH4ub#!0<)D;#qeSA8RY+S7kln_&Fzb&vfVAEpMT-& zdP}hlPS48aeVk^v;KEr+h`7;GBL*%?PL+*B^8wEum720ofu=?);q5XbhLL`idiJM2 zQ%7^&!TtNzGM4fA<=2HQqUg*7Z5s_Z0~Ss(@Q?}%He-4!TIS?7sd1oI27}B}An2vQ1?IH$L;F(C?7MTHJfxH-Vtu4`1@%H z`c<+%#qJDRT-K(Hj>5`m{(IF&# z%Kn`!&)J)0vi1cw;fII7XO228dYb75S^6u^5pOTqacTo;6aah+Gs+n1LOKls9A$NS zA~~S+JIEm0n{w+6j_;{mmJ{k=lYrL1K$u|Sq>=>S@XI}fx)dj75hR03_Tcpn`lZv* z#g(DJEgTda8S#8ku4?0yiA}FYMT8PEE~+V^JOB!NhPcNk$LiPV)~z!I_lq#3=ua7u zE#kYld?#L{DbueO+qHyrYnejnT-712uj$}SUJxOo5%_$34G>Jl?XsEt*d#V_JD7Q=kDV*ig8nLj1wm4^gCAoq>~43A98-Px%gN* z4X2ghb&4x+s0GweNJevO5VYw4f%e=s4)qGnY%kl5It_Wq1Q5E#A?id9AjE54%>KUk zb+MI!3yuno2{^1JQgWNJh>XbfudE(F9<3ff-EdaL*>Ziex@gyppZ;);1`k6q4!I(J zsvDPMF@Rcgq&0_B+s8+snvyzlR(s!_4cK80dy*+z!monrP9JxJY2GS3iGzoyejy`{ zqizM$crSGmEVQMvvEK{;FOfLUVNkuFegF%W0amkwSBS)pk$_uhSqMy>+DTBc_k}wAU0Q3wEJk5+lg9Rv~FAGiq zqs*{e%)pyuS_~Sh)WAC!HR3eyE*P(tn8^C(;^kuP1M1Fz4BVz2Gcf2hEP$9{k#)jj zf!m1N%pdhGohTOWp)sqk2%$p^s&P62(v2N(k@K25k`5b+ICsI~f!PVJPx^sF^O?bE zIzz!nGdO^Z#?*ZC=}vP1icXV(*zS4}*R{giwDm$(SpGJ9A|voUC-Ag7dLkT(K}aj` zm5mV&0{!;14uUaVGi?>K{for0I7$XIXY9#bwb@ULu;-M+0qrs_I2`&tDGmo5DizEc zTqrdd26ew(Egxo_C=L^;a2U)XQvvVg%t1FBK9_3wO?N_uLjm_m7SWySj*HA7)C|z{ zJyGaQOX2ODQkLDWK+A+7?!dx0H4fBBKDq_m1M6ZMEEEUqKyRZTW6JmM444;9#?gfJX_vu zF~;Ma>~pZul@zMZl4sA~3cczA$n6T{+^;IZu~IH4=HQaF#*tmow6 z4jCT6G92hunb_>vSu%fAELB7-X_)G;bNlz`AqeUumWc(u>#-k4Xi%-s4w}$S0FX_e zagkxcOiXir`QsiMb$sdvnlociG6ZLxSykmVajIOV1McCBluK{CUaUU-yewx8;<`i> zIjkf3IQ9eJ)y@jIsC|sohSejr%U|0cQ3@$Pt$OJVQRs_{vLiav^8^eJgae78mmOyA_gnLltcT)u<6G`0BH4kg;&Gjfd8hz<0M$HWWedgg*g^UMPzfarJSMs;UL;yc3|TH^{Mr z<*Xdo_9z4)w*z@<2$TYd=ABxS&o0@|*4^l)z7Fq1?$TasfzP z>Ey(wx2PLw)zt^QagxbysvD4aj;`gi+wHRKE^!H-!vVB1N`#`|U6j~UCzBh{bf3Ps z72pR(cpO5O$JR5^#g}n9iEd@-V#gjjP9)oOa4-Zq;7qL$`0Kwe&kcDFUZyDxoTm0- z^>e9_xZE@nhjnz{&vL;Di=ys}fW{R2WVvCTs&4DguCQ6`TPX||s~hgp{4%+*EM~V} zv!nM9Kv4My6#nn>?*shszy90*oqhMeSC?=qa`bN-J^b$E=$E6#;qh^pb0N6=7rxCB zt1HP*I3DU+mL@8;qD)wZYIhAq0^TjKR(IV#snj4gsE)UG+Olg1c-E zsqX}mXt6OPbP@ou+FfR?*pnFZW53_}Va6etNe;^EG_yO_BG}2u};F14+V>h4W2&j)fxwep=^PA(Dg<)EH>XArpIIP|nMueYFDWHU_Z^F%tn_ z%*o}*v;v2N1r^T8305jRs_&rUOjF9ZVl-M{p+t$r$XpYbWC2R!1YuFT z2=xbCWSqd`Qdl8}_sK5ykF7(F*`)*LcJDUD!V#hBHgJJ#)psy$ip68FCPlV8cN*Z` z68vbZ;m^(l{Qx$vxXH%oyz!Zf{j>|G<@eJj#eHl$_fss6VZ@sCms2e8cV(pR`e4iS z;BG0nb*!WBPQfkRbT7Dd7Kz{|u@LCoE1WwmHuz&Lt!0wYY2&$8^q7Za4^1@$aO5-^ z3ogcK1%A^m2MlhK;@S|tK!arkC(F;1$NG@K%z|#^I zVJ%LOxGC42sTS}MW;J+bE!A<4rZy5vgM0Yz)WBE}i$L^)xsU+jjT8tTWgF?tvv59( zj!HXFc&I)r)Pq2q+D7h;L%F`3GY@&34{8%$b$}nV0`J)*M02VIOle9)>rlX9@*H?s z)&nT?jeyFnkjSMbu54PR6n8w3FUk3w+MxQ{>RB18-`|8GnW$*Wc< z(cdttKY<$W=5XjuwZLZ|1tM5P8wmXMUlZB~b;OG_y@c-g`7-PSgUd%-UrnFheWJ-9 zQ!@W~v}FG7YPDWmF4wZU%3}8DVQ-P5cQ5}AOB@CxJ;qm0X~nJubNA&TizWkZg(7a$ z)){zmmvfjO`8leO7>LmlYyxu*I3E`4G|%x?>K)3Y0(US~q#{^S;pomOC@DU2F5rZW zH`~eG6temN6dxYE7DF|EoZmNaEX2@_H=)F2m(ZVwI1j!tTLRi#D8a2P-6cDPT`iX% zIXNkfIdP5waYHSNVW=RkH!SdslweWHsfv4oQPzIknmoLp2g6Xalp=HCyLsqLBnMap z!`nGD&aR|iS=QuvDw$T8m?$ZFo89U?IbUANoIDw4zFn5vOoBYMQ8+4ux&xjts*`el4=R*( z2h~MjN_6kih3+;WVE6TPm3#DfX1T;NPtxiMe$*5RWX0N{5t#RM(Uuiu4U*G z^`{zb|Ms7+iU9W%9xesAyVlL=<7$2KWpmbV+WCG~Vl9-?=G>5w`H@bM)`FPZw@Pb5 z*^8eZYMsP_8Zf67;AS7r;-|%MY;=lnn*+-=y$(&3E8&H4}icVGx+$i~<)` zL9Cj`WJl562Swo+m=OC3aN6h)r(0wsc$5|5#d5n?U(V{~+*x#}!El7=D})0Bhnm}r zC`9xZ%AKK|2W2^AqUVeSV!V-BMu6gPvZTB09{?a5*pd4bc37hSc)-JDE3-(s%bi|y_8FC`qf*(fan9B6J02j7@s zgdR2F7*oqqCrFsxbz;|!Rk)1ZVtcgG=ui!YN#VQ1^$hwi7cxOx6cWS5)A4tQk53=| z`-AzvKlo#c<`;Jq%{R;I)o<9^q@7K?d-(&vAIjy2T;VgN6Fb(+kDVp(_ok2hyK2JN zN~fb=-&R}F@aa)j1P=W6^{>PetAF7;sVS7jaTR5iQJ%>6sY;-a2c+LATP;FPEcrP71KVh%7sdY3085#eRue3Gn>3x5OD!0=%xV zfe>5ui)K6>i$@P0Dp^?cap{Dj;{1pW+_J>dMUinl65dsv1U{exLzmxqD~mDvMHY^o zD&o+10*9PbA%qSH631kbuf7iy<%(tUlxAKrcp8I3u1kUBuDvMVFTTm=F4p(N_cfis^+`i<*n|NW86R+HFz~$@G4Q>o!%!|-hOeM7 z;2F+ij08_{Yh?UVMS|`l^MUj8WJAhJ>yEbc0-{m_;Y4C$iUq#xkz$omBp$Co=+U5- z5eS^_5Q5Eb8Aj?`d?!=&%4Lagx7vB&(;6wlk`Fjjiv+*oeMpgPUjvDZ1)sei>r^KguqINB;biP6&wsZWfU0(J(`+PxCnwb*d2l}8V$d0s>0Ld z_FA^EXl#@e`%!hqAJRdIy5141rxKAauhPZ#U8P}Lc!A99ZmT8q_T22l>p;&D2 z?y0rGP}*?duWBfGf$3r1{{Ad3Sd;+>e0aAMAM=mp_G+{Ib?NKq_=OPy&8W2^41;h8 z;HMVxE7M^f8s<&)=m+;&uqe*2#yhH21R4N^EtcE+dAYd#%}FKX{Dzy^s_SiLwKyo3x#t-8R=iDt z(8>TrAjR8ky4e8Z1pV~%*C}S;&|mC*SyDcw^udpph3&YX3m zl1k-DkGrupUeh@c9axCm!|{T7L>*G#I~y;;cznE9%?ol_b8|VrM@Z3Il7aT;U?|5M z<2B87#C1x#HuC1%#nocnDw%jJ93^6*#*K&_9(xV%inRtlz~A6)TcNwLe>F@YcR;+`w${^qr{RjC8v)APN%>s zM499Qoha=j$J=KzbO(D!%Xs|jrSF4t899DZCtyJ?aZwEgywIOgSthqK6hl-}$>m`P zG1-110os&u*_f07;6}|ObhvRe<8HQ*XIGq^LtufO^G9$Dm zfvB|5iB71EADiRYsm9LlMkExI$zoY{Jt++svjW(RM1QpBt~gl!^-6;A9lBibB8Gzq zW+=2OjlilpLijMs@xj#PBzr;x_lKOiV3LBiA6NrlQN$?)ci1)q3cyBJwHrr1!=gC0_o=Suq?vL-G+WiPPS_s; zysQ*F%C?bKD13J%D;)R$57!wAY`WD?G73Q^@Pf5@C}jZM5bx zffPX}G7@N_i*>Qwlk6UhT_Qat+J=FYQP%q0M^g=vdm-Vt^ z7~S|TU?2)9^Dh6fU6gqb9x`ecJCPxagQ77RgQR{M@T)Pv%7RM9fFGw*z~3E(8Gv{q zle;z>-@nl20ae0WMcEtM=0V0lkM4{1&5(jhHu*pAe0OL+}sw+6TtP? zRKQJgr2juK2H%!7!I|0|@YnnJ3AGfeBX31H*qsL5i3<2AP7=6s>FlWtGW)ps`sJhF zNg5BU_0i!_b+TAu^H+AV$b5*APL^jFjUsbe7r!piLW*8B0s7gK*8n?rudp*Ab+7C= zW#Pz$)9_{~Y|5%QcamU-S^EZesQ!We&`*FqId*(_%-~cB5&Y%Bqfq>dn$aHJ=I(>u{88~RCVRIB>C!DI4fksR)`1b9trfCs_OGG`fE1<=Xp+H!e8b=f@w7w3b0fo{EV-w@ zaO*$eDXumY$$`@eiy)U2$yNf6eIjN3j*lyy{*<7=o7YlFRLpaR@Bycc8F-f2iOK@L z;(fZ^=8t^0n;Yk*vN4EG!~>@j9wFDtcGi$^MEX;n;^;rw~24gINCL0l|7@@%U@>a7qaZpCxHjhXmuNpsfChY40%`C zwV-ir)v@qwc`bqN?CtG`4@Lrwf_;h)I?&HU6)#bl$J<7P$%W(SMJ>nQ-h+F9h2 z_42pb^Xm^HPgjnSoSQM~uKN1qpimCLU8(*~Mq(fe4RdN;>^PWa*65&1?+<=FkbPvY zefYwM83g!YtxI9V3}{oc0ca>2=w#F&^pAamP=m<^aZ(JfJEY%Jd%)eZKn)}Q)g17x zQ$QC2Tu|360!KNZ``hAX_F4vI`{2dzvh1MX;UG}HA_9XoC~%P(MrH$`x_585gFywt z;Z<}k0j>@VcsqrG7Ls9*@e#6ULjl`ge z74MO8;4KsaoH3C&3R+2NU@;(2Ld(Yz(1n%JorU1GwdW8@gm{jD+irE!MJqd%; zr9C5c)3dA9#o~jc^|$MFJB~aH%cAQDjZPd11e;^hxg)22e{j^qK}Sz(V&m)~G9YF) zbOWwxdUEXJ$Wt`}%C07SgFYNQdaOcXVPtlkMHoqeF|UbtNpYkfoWigneQ~@{iX=xz zr#LgfjSU9AFi}v~*$kf|2x>98Y2EP{yK7`z5FEd31`jWm;xJ^Tykcqe9ioSj;Q_W< zBK7Oy^C>P(G{!{XeyeDP{zZH-#Q<;P0;sfb0VbRj1IQ5c)P576%P11od1-S3e^p1J zcuYp2oCQl_F_hG!%$x40l;|O{JQ9-}Km4%O+Mx6@uD7eOCOY2U&>#frHYt}HQUtWGC6hhb1Vj~g8rbL9-WoI$ej8r7>LdjtSZcrQOFajd4zDX_U&EmqZ zuIiIeHopoWf_31YwRLEt{#DiyN26y>@F;VFi#f>Za7(NS4`VeAb;jX9;Ne|#K+7w^ z9HGOgMD(W1<4s(m)d?Iz7ZbmJiwCkG76R+-@2l&gM+HBqjRFE=5)lSpJELf#ux|n4 zVX+0bo4A9gI2gk4YrJSOiO{*!B}5vh^!;XgS#}@b6B-z3r}!UJc4Ne@%E0}ms)-2z)F5bEMd)wDMPt&SU`%!yL+3QBF!%ymjtXpu zSp`lT9S+0d33$<__dH)+%1SrY(uocTw86N52bf`mv;r5^K=6~@qeh$^iI$_}AqoU< zoIOQH9sZ|QB{s_53;~a_L^82@Df4xT;k~$MlnT{g42$8bBJtm^FIS7}g-nCF=uJ5N z``c$|LoO0OfIg?-z8n#O7i-4$ocL)U0k)Z9dwff^$hjU)=Hp4RKHDi-tsWaM(@&=9;n&YVqF}xL?1ti=!cg!w}Gn2G{Pb&&9fI zRusn#L;KrAj4Kx6D>TFTm&@(XSl@TODwn70%&BzJ9Lit-wKhk7H=5(V-ny7KwqM78 z@KcTnKqXtHELL$X>z6D)m0Q`6FJ_mNBaPnBAXBCw(T);$Ru#C6q`PBYs@K7-Vm-vV zQKE5rs>l9Oc5!)9&p+^!=+Ls117{?HzlL$uq#%Py3Z=(nap;wPs5M!mBN8~BoK*

&=XpXO6Yc<+qoCpy;zJeivi;NTebVLG=-J@Jyx^3DRRg%E= zk-+JMMCeA!NZ{oh5<1EB{ATrealQFaJx!01slLZ*j@)M(saG|Q>S6!GSe^RPex zT$jOd914R3fo>zfA(e9(3p0Da`htyaV7Hd$&?nYlpvgv!u!0B6Nwt-z% zaVed6feE3^aTsGvyC4u`NLJ0W^-8u3kYVStQ(PEKcc+nrTnDtQfgqRv3?re<^^F9l zlaX{?NMHqf5M(gjO_BLJ9MG6Lv<(i#nFkI{EcgNMA)8qatuIAxJ%JFRqm?YscuMZ$ zbV4SXE@k~=EHZfg<>%Y2FN6TnQPT*j*#;sLLLr%I8R}&J&~YF{BijUN@M5vOUf$d| zX~0#Z%@-b&ody=j|AoB>W^+I+DX?GpGj^nMl224AijlP1`pg73uI&FCRZ7Y%G`NgI%3!iJCQ3)R$Dm*ducYxpr#)}+3C^S=bAy0&+ zHsB$ukN9XlZ2V_b1qz!D6L5Mtvi88;jh z3IKu!HzdVuW%%@C$wpe7#aspN$H0uc_)s`fAn-CBAjkw-2lXO*jaQ59a`|cYyw>Vq;?Ndy|+oeh1t=FRj2X70_8{et?Bbp#cy zK1RU1jmhUKd}gV5+msMJK+_F>UXx-Ow9dZ3_^|v#+^*IsZ4lm=-e)p5!(M{>Yzq|E zaLi_kmvd(Nb#1%D%mOm62pq( zDp%lm0%F%x==I`UX0wA7n@^tu7=f?uh3^&M%?q_;`*)9NLe!79X@NX*Ml>dXexEQ>^c7E>IXPY$$7N6#-W zMJ*cz69)y|heAQU&=5DU!9fA&Oe8WCY9W)MIDY8aK(E#;u8-6Sx&w*uO3pBTxRH&^ zu|e@?-|ysbfVd@>ibKUA^ugVQgWAVr9PZyY8)qPAx51-aFVR3()`R{E^|s&wj=vTM zM~47|lSv#J9h3yHW+ldC7>*zL{krLcnf%f3WW#7DJV)KU53lH$fPH9Qt(WBxLx+GP z0uPl4VG1@rbgd2g`GEkQxo1Gx+g)NO6oNwHH_fb%(SuAozWLqJz(tr21T@O5A#}O5 zLEw8*AoXZ64Ti~0^p-?&Vhx}hLlKW`46+#bdM1lT{t5kUe=rJU*6zm8O?!hapa**P zO4d6rM&#q&O%8Bqs>nk%hH6Y*&gTBiUblzkT%DuC(O$PVtM%8#?Z>6eytwTxarEZz zafu^{SV}O<0e$!c%`P`~#h4i2=gB)}J@iW)@k_c2&@eZ(GwHjm0-Z8PQ*&Vak!A7V zVKG_f7%{hok7b7&{;rz90dgt7^yBSu=j02~3N!x`x&hPDFOWGus1HA?B{74*K&PEu z4*q>=#aP8*NXBDch0_*6$AwC02(9wRyT$E#_D()@xy*5=UX0rqIw54jhpOSovfzAV zMTy~?xBFmwQ&p53T{LhyivTi==4RZ`GB&;Qhw@-2rR!hhhLP#)_WC(K>d?3J7%fkc|E^t2jG$}#)TN13r1bmn ztJnt`0e7{EjRd~Cn<)( z>lhQ~qme(FSUWCl4Vc90|8&#ruI{58?X?~)Gm)AH`=nLUXWM!HY2Yb8nzNo3B>VCk7r+6GLqSYQc}#wvsVN-ka$~{mn>p9C?_~ zlcO0Pbh3xO3}z#~Qj+r!Ya)P_La!@mlGxDjs`f~U)CY^cI@puI)3Q6MGM ziT4NL;v%yM9I9I41+0Xwf9z*FWV>77rp$J-Sn@u1apACAJ*H`7F7$fWKxLx?eql<9 zXPY#HEEs2MgU~jE4cfY?(vVF)4jBq446a925{7Fkc^JybY=0}|<4V{+$yU{l5BPke zMlsPQ)HFi!ckJIxr0Km}256@Q8?fzzUEt?Gef|SqUfZx!Eg><~)*D!$Os$*zt$xY`Kx1qAo~Dh>oRJb}R0;@Xky>Mmm_AvnyA zl4YfA4cV7ek#tP4@QTfX*!N4>vHs0sE&Hl^bwspROG7_;gmWEpmb%!bhL05^hPXiU z3KiANh=+%d@oKhgW`Bc#{xpr_(EmrmUS9ak;`;VRx@R|jW4=4%hB*2jKQIUYSp|U( z!VCakEP$8V4XxX=bR5WjesroWqd$;9?y=Zhnq62tP3%4K+gG8Rj|H%O23diIiYN$(u;GwF= zot|iSoXRB`m?#l?mIy#gA!HF%A%slTi2*>*C7*g}@ z$Td4;2-P^eqs9=Ru9FAsSo!8cYX8!c;-~==MGuH~`VNX7KEE@X776o>9@!%L%1k~} zsafMtr+b z3vQ1d7h|n8!iU9c)Sr%n(2R^jphW7l*P?>TM$azX}{OJKxVV z^-JcF2Z{!uG@aNf!sR!NeU1E_4vjG%G5|%LP`^2tTBgLvAenApgD>lFkYx%!O2E;W zspE*@pm4+py(+k9j2QT3r&nbRic&I_34nr(>q6lu5eJFjJ(Ut66=t1CIvKBv;wg-N zib%9!(2tMz-V=s<&CLkaW4uCBBYs?bYef?Pa})xJ^vn6zPq$)M>u=Y8X8HJ07?UrV z!^r*_FE_VeP&@u{BYc<9C(@*9V9v`Q{sVu{wc}$jWNPi0>qnU(AcVBofq&NM`ou*K zMu)-k55p)dx>RA!r%z6cZgvSy*)nyGU z$*CqJ-O=d%HNgTTPmlr2Fa%jIf9;E>KI3qJ;MY?;r#2lr>1-r=&O197PLI{2L^$wy zTx6MXRU5(S6k3Mb2wp)cf;V&&dAq_UH{Xh`S6rX0M-EeNibD&s%Nh|VSUXSr z_0Ay)+SGP6y*J{RFgvYCPS&(S9&0$nu^ITZO&osQaGCfw7cy_d7t0X47!XcHc&I>x zfC_I`1A*(UGQp$CRidN?nv^p>o6rdz^df^m<;XGi_bcp0EyIn!6jdVds>Xm;q8Nlq z8D6i(faGOR$=9DQoV{^Mc##pS!0BWaA&|glQ8o~g421M2AmRFPx$;)whptf=?uxG4 zWXM**z<3WJj(l&MTSJjF%Vy!+C(a}gLUo2sZ)Kfa&PG&HLMmB1q}-Jae!F%bXm49B z@erc~E=na$cc!#F1(6z~BNA_*8RA8G7xJ%n-;!G`*AdlLF!@v%QFPS}mC!#77aNcuw ze-Q)%;3*C~$||W-9G_pUH&7ajyz#8sBpeE1w6jA2hkpw>@v4rMbLr50BI|u!uQs#u&$pdv8Rt*V@${Vi zan@VP{>mBIc#HPHAsDie5?|6jhx!;==G;j&aG4b7&rf|R-Sw@Q6B`IFt0ileWDy-a zrD|2tx5A&92PZjgpB29M5s3=GInpfL`LCt65nh+EFvabBDNC>G>MGthTp0RWO%5CQN)BV9&yN|ro^$_ccl zetJO`fZhakBApEdpYj(q5}Zj`1Q(XEz(o!V87?zBm!TrR%Dg(q3YYcay-YnE5W$Jz z%$R}T{B%+{jOfI87m|WtWe`GFEUrsHbjKfqISvS0)@F5cvnb}Mz!FE@c^FoQH!~#g z8b%5A8K4AsH64ktQX+Ua!JEf^HrfL-o|yk)q@`?6^|8!$oL+)H$(P_z%_7vwaQzq? zSoECkJIZ3nh(x4fftm%rU}8hJDui$4*dQ|!WW?#s&DHX&4{3bgD}GTU(PsmYGdAF- zRfvo8K9-{mXWFxs_hF*~{AxS4&TaJMAK{;ZFjhx2Vg`A{i4uyk|3rU=Q1C zDFZk*IG^d*z(Zw&^gowjz6bGqX0xk z;FW6Q$c!+t1Q`0qT!|P%AZ1efb-V7`+o-GioXd)$vXP@7_Uj~~Z5VwXpq0i0{raxy z?r`uPBPi%8a)8)TCiSTNdBuS^4IV$TXbMM}1G1Xx#~Id?U41EbH^mQX9ynzPJ6wasTbKiyVm_MgLRXs}c zW8b6HUE~){v~L2nFxc7h#6AZ+dp?YR<4b+v&1w`f2>T8vd{}HNdZ^(mQI!X}c;z4k zHmcHmoQYFh(+T%b2!dhC(u}gc6>^=hBw^c85vO*}*G5BmfS1>>c5=@5@X)V=@5Wa0 z&UaboQ7}(%O>w~MI(PM6rW4-G-pk~rVyHF2Hq!)Emq8dz zOBsRIrT{j~(aAv2B(mQ=yOLO5Y5;GSi?ts$ht?Yq_-!hW;86JxD(1LtZ5-Ns&_Pvu zG99{mk~0qQNIdezAbfy?L^tEb%Q;HOe2gu}N-frb6ri4AL4#0I;0+9mPy)b>Yb>&9 zC@Pb&IJB`pu^h6SWrS`dHl8)}pb)P&w?c>?w#9;_O#pCzba!Dh|nsI^cuQJ`8a{hZmQH~DE zE`!u^W|8_?R3LC&LZX}V2R=OA{LH;$FnYyBG5Ex_O*l$~;bQm*H6{4v?lYov*R{VR zC%ja4bA5_tmP%O$@lvL1RcjL9vYHZrF@+VoMD|%8G@@wMJ_f<>#Zo7Q_f$5(;vz2+ zf0P$^*TjpE^y9Ufk;IGTb|K3{)_twM7(_l)CK7U9TvSs-HR2v>k%n2QTBt_gc0n$O zGNVG_#3JUtqyxo*pk!hosNygkXCJsvZ6EkyCPf+Lr*M9^9;NyF2e4rI2Mze|^6vxu z@W1}s|DApJzh%s`G*piMZKH?ZogDpgv^YFI4KtQbMthWog@z~XA_Dq$G7Nm_W}lK@ zOBlLtb&umr0>9dos%NhM43iMeDpXZmhVj^2h08FGcz-9Ck8LXfi>ERf$}wx137m8? z^eH(}EXJ%schhGd9kYhEnV$}>HNUBVQhy_j?7I8IUoN6Z- zT=ToJTLil@4Gnx}i>`TS*;Xip;8d-V{C;$w3e4n?vaF6Cl3o)-s)z>Ow21~Pgx_ZG zWKr@9-=#zwtlg)>A}|AR*HEaosHZn6ukujc%w{?;Xakmh@%^j$mo=Bd}p|&1nX+5=V z>l6sQe2ODNq@97lmvVy9+gt`OKI%Y2pbbT;r85KJXfZ`P%ZZKJ2@f#waa?UC$^}j* zxd`zk8m5#8NOX3KV1cSe0)U!N3HxT?*|mXWB=E~UvaiGWu`(u5Vs|8tLJo>wDiS;@ z0xIczt~L+>UbRx-YZ?$?MVU4w^y}ZlHp;+~yrO3E##tl?mf8i*7#j||@PHXIFjgWX#nOo2^qMbzEhGVqI03J3sYSUm)>RsHFBKtyP_pq1MR{VTwIyY?c<&YQ11Me{gcB zr7x=s;bA&t$ozS}^5Kb2-M8=-H&R;m!ds4#O5ts9xhsfbif+k2qwyEmm|x8m!ecPt z(dMgc)lyu%cLlvbfXRd+K&Y}wW+)Yb48V6Wz@;{mnz+c>CA+p>FIJy^UKXX}9Y#$B zdBQiZb(*gnV>*-U;Y;R*7$@|C;rzk;qzH4fnexJn$gl&W0)kd2w-pB2X0fK#da+)w zzs=rnSD&StzJRr)jxJ}cl&C7^53!5`1g~lQz)v;%aY3&BF{gkPAbLRtq`TZNn(Q2T zf9L7rZbXA;IfnfG%W84OE!h_ol>~=#U--xt^t;e51iHB1_<<)>p&etf=^0SzzT666 zgv?PRU072iAb}TcMl{c{$L!hdc3IXA51kvsL+ifq(7E9B6Pz+6aComl=&1;%!b!uU zD~mQ#0)aO+8;RXbcq0V@RCbiWzRS;UKP`&sg?M1?%Sa7P0)sPm=Fvof4Vcb{UZ@}F zkS)x-hl3$>Hf0#_N)84Y7J;&QJ<1XvxP}7Xp&i%Y31%8jDFD!)LWlrGnA(R%rsytM z23}4H!J{mi94_-_A$zj>qPkNEw6N}U>*qXwBqPdkw|J=uQ+0yd$Xo~ryx&NOe|a?oemGh;es{H6FD{p|;=*b%d-Slk3*Ebye=lQemV#30xSZ~c_BSiXoc(FvABLEM z28|UERG!d!RTps^NquuzFt`9MgQ$e&(c zc~fj%RKZ|zX8SI-J{heXv))`s3z`BjoE)o|4xJztPAX&>hq4ON53q+VXVgdF?M)fy zA@u`%h69eWGNvt5pDwl^%T=#^)wFFIN11-apO4Dg@`~a_xk>Jy^_r%o^NH|iXUa`7uUrnsG$gla zUm~;dYq;O;yf_N66kt+20i2E(@3nJbakE~^2IVg8^7TTrs0JfM5xA%ZgI|xrp<&h3 zBGEx_S^^C%+eq7k9tF9;2WiR$$DW_xY(6f1uH{GDIzr&l=0!(_p97CdDHM*$ASBLf zia{jlK7wsTp}=V~j<`o*779|s3FmtGN#?@W!L{#@Cjy#>6BiAsf>7Y;H6i%jA|cdd zvO~=c=@cf?0!CJ>k|#}wEh8)NO3Dhnhck|MG>$i$F9j)ZkqIW6SQ|!2xN!R#2W>LT zRdRk0l}KZ96aq>OIkCG)9EM?z83!I^PUueDlgB26@ob=6jRRkoe9)+AvTfXN`g1qN z#(Oy`oG&kBdZUzMwo91~?{xCcL?Z+fZ8qSq8cXQWWEAeVIh~CEK$A9>8lmZ}db+H! ze6?7vWw`il;W+Wmb+UoK_L2=B+gBC!VbeBA?56BLefR($Ek*vj4om0$K*mda%%s`0 zC=zpS@-(<$ANr@NjtLbN+4q1Jdj_16;~M#Efj!4Hk8H6|tBc^uM&!>(+*}x*l_GyO zy`f5o#_S`^M<*f!y4pH32z=e?WuXxA)7sg7MZz`TO3m7QG_4cz%C|s*)&)o zsx~CQ6M_)Xq1^@n?w^EG4%Ky$#?vLD+yzSwj1oZ{@5CT1V1k!0eZ*15;7w=qZC5nL z18arYDbL9Up;kZHAnr$m00Q2j2|{P*={6Jaz0DW`6M$JQ3d(!1SJ5B_xQQ=_+%@*N z7tWDfnG7Qu8OMjv7FyvM$$?&QryWj)F9CKJ#i?P#LL+)`Id2LYh-`I zEsZ2&FnI%Nw5IJV@M2~jc!=?VuS=h)M^hz2sX{Jj%LhJX42BA9#f4ovR9YL6<8h-r z*eT=9?cb9Jr9@I=CisaRbDRkqPoqIb00E%vO&M~SKeIpOaTtgHXtY0Nubo3!_35Nk z_>9fo6pr^X13*A+2Ea}h3l&DH!~=&rwVzTJAFE@ayi_UGkq%!mV}NqBQYyTQc}x0= zw010PH@N}aI#qgjY$Y!;-@=S9cnLpJ2@f(AhEs5?9-Y^PC~Gz?oVoG7kGnW^X4QJkJA> z>Zr9+bj>3G@ndg~2(ZhbphZ;uCn1_{L%|m&C17ED^c!^Nx&|oP;dC6UhL$u1GcB>* z+B5`Ds!0KS?u@7L(@G`C=IMop`%gvaCs@QKyV1^05p7CPFjOT%qKVdzSqG>%of6q8 zs7&xKyGPdjeF=kQ^!5yKD4>C+l{{1w!fJrPwssmy0)${AC`^kj@nYJqsE`bm-i(-q zmU5vvj*w^Jt<*kvlo`?7GXoKt8HPi`@gaDPHXkw)dNe(nDAs$MNQbV&2mnmqG6OG? z1)|KidRu0^yV@+TSHEFxcXr}di`l+=`2&=0n3{2lLT^fV%F$y$yP5C!m5mUwqV8@DJ7*6YxozPRjMmJ*^**5g$?WfPOn9Z{2^2dj) zT{j+)`S?FDQ-1MfsL+ieG2*%-8`Ojy8+KirA%%XGLdBsVXk62UW97Bwc7`>`3N-La zh6bQ)METv7D)7_FeeW65%^wzP91~NbkMH7Rx^5Rze?I_HB#X5!-1>GQ%ke=h8bjv* zV(qy4!7UzOKxp&fxJE=`v>srK7OD5Ry;HCm)8*om zHx0afl2AFUEh9uSK*um}mT_MU4i4=@D+F#nKE=d2jJ`&MerCLqY6Oq6WxU0Lo&Q)| zZ#)bjUJZkj%P`d#DAzEky8snNTn+tZ`Tp*NZI{tK7ux5%DE!hvBdY zV-9epmIgdeqp5!x7GYFv#sY8Tib674Oh#MJWO7PDiZ%}Tt8rqd@LsI}cCjZ8$?Bs* z@^-tZLqFpSIHXbd?_@ina%pP^g)1f~5Pm3>CGMHW_ zXv!i_vJGNqWBQ-YpF*&QWb2Td$+xpDVAsyJoKylj0Qbzc9{D|WA8RZL zI?O@YBCNDMHk1#XA7t6qLy*V@Qy$_D7GC4eX}}&^ZeN|AQOkksZ!eJ1m41flfE}ZNw+A`m@2EuK0-YnK4lP;3nVS-M`FMw+uKRAD( zsO+Q;`m5Z^aw8dL`cq3n^WZk{HqC_Vh0IEkmGIW9GOFY(Frx~7Yhfi1RV+i9&`|>y znStm?Jy3biUX^kuJ~w``S|Os$G@=3e1M@(1chRUKM>Be~l;5f7b@XhJi{PHt2-DJ<#|c;*yd zI3S>*#tR(Y=|o54?4n$l1%s-S9Vl<1AmEGB?K(D5)s0Qamd zBP^Byh#R7rx$s91XVtYxG6)Bciv4WaQ=3d9qDOf98V*2e zF6A(URcLsP2T-~fBYKMgC^rUi&B?mb0;dxg!8Y)sP1|_C`6TO3%kn(yrJn=uXDi{i z#tf3AshK!aBZ0pv5_;5hAtSb-r^d%@we2E~Tf_64PUG3_rA%<0J>4$wU);<>4E&;2 z2d9%ejoQklp+{2@7`m4C&Nf1aLI#3I*<*0!?Q1Dle)G|U(@0!jD?}As=UA2@uT*uf z7oV0;_V1qDtQXfei`mP?*UnA}Pu{=AC&&>lZ8Al;yUt0W$2T^*5Z5jBbfT)wuVEi% zFsp+h>DTG#5RzZ~JcMGagu@5G#bO#g%y&AmO$F3G*^8kDdQ`-?ct<7YF%NA7mDeNK zb^;&oo?_h59tC_ng8_{+hn3}t#)OI*yIby~#K~W~lx;VPh!;91)(vUq zLAD7*D;3uD8h@(l0=|q)sjB9ugc=E6&ENoAj3WB(_bHs+YnlAG$P<-{FyQMrX2=E- zOY!9r@@w~G>RFJhYCn#qCO^JYAvqh$p2=W#&}t=aat1}kQ6dd1Q7fVQO|Cpl!bUTi zuKd~NV)o4 z9SKm0LkMqik>P+>to?`lvEx4YA={I-qE+mH!%-kawh1DVgBnePUt^2a4_IH)p#j8d zQV^G>Vc`0j6nL^41{{llp?}QvqG3T614NmWzxSg@enfJ1rMxbSLQyoKy&Sg$2%D93 z+Kov9)FJ7k(jQ;UrfkqtsL?x7NGfllfIIj!V}9fV>_;p*(p%_FGY<|<=R57l=HhFz z!mnmnBoEjAqRq$+~s2b}C3hJE)edcv(W>sHGcylDi&Wt?%BgbW1U*)igW ztrRLQH?yBMoAq`TR(676)LsJjN=bRyzvA$~q2a-|W`>17?!k+4ce*SOyq&X;Br|Fs z06*DBNG!5G;39`cs-OR`2y4MPB=FRv95}SDgb-N6x6~#=zjmKwvxI{DYQ@!&8F**I zqQ4+~Wg;?!OZFsNV)ZlUHSy5eYvRWSMW`0y*|m}I)ro}CqbZs>KG6CUEy35Pit%i& z457dbhB7kZGi*yny=<4#f0Z@yHrwA11YHGowYzF76OBuLTZN`SH>gMCGSt84EIu^(O0sRP%;oPQn zBXH?RlO_B<#rKT7s7rpwWi&+G_<-}BGJWKA=@G+!8e+BM^66nQ4;zG0Wh&<-&{L^O zL)xqs%9b1KF1)7>Chg&P(q4Fv$JIU?53_=xHGHZa&Wn-wwh0_=5_CCwZJah?j@w1x zO_Y&PRu{pH^&qfU$N++cS`_2cpVBOWVhspjQb73r?fCXiPV`(i;m+cGkdmV+>FGm) z1{IJrs>OZ=vcrPBv52n30*KdGWCPKosS{; z3&%pa#QFb)H(Fv$tOQqFUuPJQbB@(`B~v@U{k+_sZ?0Dt?Q;3~^C$QUc~}mMf}MC8 zpR!pmXJ53D04AB@Y1T9~o+gLeG`K5vnwR?v)1)+>)|zP!%pcj}nWm9h9m;q*OGCN8 zFxqF|oq>@RH=Oy;M@Qx0N3|)a0pJsjU@&3|VV>_H?=n#wV|_GB0^ZJvqis9>a>=6@(!jXj5Vgj_zn{C5B@|Z{^&$IRsp{$^+cFL*swR3}2b(`{qJM zmadk5d~GM5Mw64L2%QLcJ0k}$Hxr?MqlIWBG1+mJ$(D_(1-hhNb`@Dr)i`iEdCt(C zlGPG#=ivB$A#)nfS06w5ZRmV20wuBMC3%)QZp+}P`(L-W)MjVD} zSY`xpb&N=L(RWv}9g**A2AgXroD1D4ir`ly6pRR`YsE=#c_Z3gX2nRwJdgq)HiIdQ zx0e1C*|)OTg|0IM11&RB1oHq!wRz+`V+4u29BCO+I$aK)7$(E5utZGcD9Dr7a_76DLxmFhgibcji9ERka z|JW|di78GYC=05Uczl}-ZH3_LYFLF2H{C2sg~$N~1t(iY^cgs9WH<~RNtq0IIj0Z` zMBEs`S7OM53WzWu2am3$G6R8|>;Xit%U}W!fe~yz(@sK?8G$Vczs=4!K_BpiYsbnt!GNAVMYG9nh*OTKp;a0IaWqnE09;#n9(}PDxe&1;~tFTOa7~Co~(OL^y4%u|W zo^Hv~9=vZ-C3zr-cqCRbra+DlV>p^O*OG|&1L3r5PXjv)hF0@5&RI>3zQ>r-f z9;eiS1*#lq$aYbgh~n7Zb6`E*gd&IZkv3kOl9B zcT!I9D5D`W5I9`u=~_~sa-oJJJgt^2hev<|20R9bhIo@>nsW0Lt%v|!;_O5sDZCm8 zK4yyRLT5q-10T>C$g`#Nddn2At(26Ubo-*IGmt(IPA_ng8Auk*5g_i8i_}Of8mehD z&=`qq;zFKXIL;TJX0j35$8v^B2Mq$F{R;g)CcJL)A#$h%^$|4GJ*f9kTgu$ubxOh* z5`h?`L#w;(ds!Y%_MX02Ui%HeJQ8@jx|b=`i@@DF#=}!9B=nEDOFp-v?MK{smInwb zH3Og5sb{|M&e$JqYG#6%aawgZ`T1LIG(yCSi^kC4i>r7>H1fz&~D*L3$|+IMa#zyY?Z0*mCwSvZB(5L8qrFi%RYz8#SQ1&%JkcROUK_GK0bZ; z?+@nx{$Rhpg`dM9{GUhr7HmUoS=|d0Z#n_?^Y>`8>sNrur2soj_XU635w?>AcnuRr zTQrmbwlf3cLiq*TL!}PpkNg^mF1Xg!a-82hE!HLA>NIKzWpIr)s2Z>|oPukv0AimT z2$%@6Ad-UX(LM#Vua*Iu-^(a!PXx-XQ{7s40NSZQR74j!#PJwe3eZ#+IXsnB2xhMr zD=Cf@p@WaD@%8G8Y20!eQf6@AX_dEh`PLLV9QV=;6~}>65e%F*U5qb z>-D$U`|axU?Zro5N%xyapmBFPOgy6I2L7rJQ+0o;I364q%a$;+)vi}N9MCv;{J;;a zWr~x~*i|UM-z;a(Za*!`qA74St8qx6J!Uk)S<<^26llNkLMcFGRLxJzO;Dgpw_{+Fb@Al#lNMLE)IJlWBL5y$0(9VPMN! z6?Co=`C|2RS(d`(qco`F>E+FKvyzV_<7fOLHh;gqTrI8_vv-RN>%*&Nm;U|jvofrG zfDe$u+Fk3$_>D0Ud`VHQ5|G}CQqoE8?pVZT{?M0=IY`{Rchsje7S}S}9N3kSE#+C$ ze!O^!Y}s-H9%_^#TPMi#(c$N~&`?0j4Fwft2DW>0u^bWMhM%iE<>)2tuUb3pFd%|* zLGb(97^V|wyr-c7U^SLwAh3r#m0f-88&Eoo zvjG7^a@?T|L=v>@^W}2;b90$S=d6f;iWE>y(Oj5Kh#TNjKKRDBh)BpAB1DFR1fkI3Sm28 z5F;1-$g*A>Wy`>Bkx%L|WT3WTfWxF2IMlEuScOwchk+AH`Q;u)(Hm`y$N2~@jTcab za5iximUF_lYDRERx8Fn{ep+nN7wO30qglrWG}4d=0UX*~n*=58uDCu&X<81{A7vdZ zlN=SAR&BH&+sEAj`f#8SARTS8G{qz^LRAngFfedvra?vf*M)LHCh=lQi69TU<<a*+)@ayX0${_&))@}p0GFF6%8F#S)A7T&t=nae5Nh9LkUs)q~lr=&I;$Pp$!d4eo zvOInn)S<<-R?<*ZCqitG>uc+1>V!d(=|5D%+r{z}B~)EXyMYmc+iV$u74M~UO?psf z=QoS%FF)UI{rpj^Qwg9@|JZJ2Nl51}eaW0+pwdW{R7VkpTr=peg&~Iy0M!|;Mp}4{C4yijv6$0M-6ohosk&juH>3y?Cdy>L#B~Yz&CY{QvwJv zk@w5RhoTbU6Ad=Kst|_Y0T+#-03PlUQkF>uLEXJf8q+PnuT%iB90>20;$0;Fmd!1H zEtWmU18Xi&GMWJ;o=~GeaU&PlfaxLBk##1kS&&dIt2ihVPdwI)BJNR060}NFx-;MT zr`3(mFYrWz0c@|;A#6YffNB_&0-&(!Ce^`sk=1bc;_a+6RUZ`!x}n_(5htkN;YtV| zWtn`v{DQ3-&ojxSk;od?9-K5x?N%sAGD5){Ww$Y0 zS9y*8B3A(p*vD3S8CO3q7q`DTN9qz!{KSZXMj0HT!?mrI+Hw#>k0!f~KVawS5LRTV z;8A9VY}qLLsJy%li^l@}nis@Gg(3j)CkaJawguW6U*d7jebVnJ9dO1(qQCD}kjw9v z+s!8l$FEj5%d6$WdryZ0?renMq2eGV+cM?AB62cVw(3@Sz4;=gzz@r{j4PIu|Feu9 zZI2mx{p1Yoae+TrnF9ZNcCHXOO80z(o3T`;mpV-=*2X{OO=+r(+TDiHkl{=j|;?U4%_F(pSJh}%K-rLj)hnD={R@G2S1tv$iW1-AYDq-!|jTxdJ za7xwf`ksdsE1@t70FSbHzPgn(`0Yye9A4cP10wJ!Gf>J?74i377|h6^(6k3iMY)~s z$;$+YQSvlT9_JW z_Pki+;N8hn7BC$ z@*?FK&M6=WNO^|$j-#^^oDJX+RdB6g_Ea0_FN%j3^I2BuE%CGzMFmHJA2y??r!ok? zIcUjQ1e%th!J!obLYE^xjWGhS7#12wf)IN~lqV059TyHYpvL`_6 z$q?7qLZJZAbIAD)Deej=k8SI5B?i^E6+jHPsp82viwW;)jsr)T7ZOl@6*SH^8$Ybg zu>!v|q2Qs4X6TM}nh7eHW@c94mmMg^?4ztxW&7amcGHRAKk!OT$^22~J~y@|cR)DB zM03r11i{2bwNPYE>%DwOX&ZR+ zDLo6_X?>Kk&op%JPf0IKP~xjDKN#(r9?KNfQBtLSK*!2yXd ztqQSzn-~;WqCs()9^v*nnl!k}=9NY)8WwovLSm9vc zp_)s80iVCN4_tqry7578^lJUB-XW+Fg^HBidibjqR_^}yA z2xLI~+HI&gKwU?G7!sAv$eF`KUnt8ygLKPaIFZ1a1jMdITsqI8EXkennbw`5r|D})_Yr^?@T?NQSQx<%RV0G@c)rDy^cUOP z>t9MZ{89z@wc)`-tC;OF!7UrezJl2sg&VNwkRlXD*!tE0J6MN|JT1c8c2tKiY?cwG z@8C?$2)^fCE@SwT9YP#G@HSCcw11ED#52#*^9wm}eppht^Re$%kMU66s_4j_q|=wnA=IdkwV4 zC?VNz8R(~Y{?F`Hxd;nB$%;~An@KD#wz4dww2bx8_UNtiIC_htl~RsTj@|R4vOk$R4NqthcFSauhE%HmLNB!Szd zk50d6?58DI)I|RGk__C~V8Cyxx|rfI*%}@m`&lgBpvh3?qb~#G61WS@I_?mkDrK*x_(x1cT>I9b(dj zkJZ%4AD16Kh}(RBwJb)n`8f)}&wQpsBg7E6s0IU%)#!T9l&c)Jq^Si$Gh&;0(GMz* zgWJrs0JWUMc)d86nHoT1^XYS-Mmw;?JG3({G~2+y*EK82%-Ao0$lp6wO-Z4QMkjy> zJxusfGuz^N!#|*#>9X6&gdf+O2pJbHsyTr#pq$tbhJ#+>NwQ@WMnGz)C^8JVsA9vOntA_GZ2j(6P}SMS^UKTjYENy$z=vpOT#gZ-fkBZO zK?9#&ig_;kj=Yb#8rV$nr!9}$~ z0G>OG5i!74jUBwg!I3Sxt|F0B&z;R9E}8%kRVeU&jutwV=h=4o6^diMj!;DlF>tvd zfqNJwq8pVnwMYP;JCPXkqGdIL-iPsZU_{o`D)Ec~HvI)D0VEv^mRSw_gXoMqs!3as$QPRa5vLJYyD4vxo-T79o=uMylQUZcqcnF70>$?jam`T)4P z<^uj|T-d2Hh3l0IdNeh>RRYx_--sE&>n+3Hr&NO(;A&*Ov7&{F*9vwV}-`A3)4ae(_K%iV}4~{AOymKrY zg}IyZ_czO9^K*(LQ^>X-R>_`1oqgcvgB)Fs?T4v)h@Xk5_3&^$2!qpH1r0G}K6%>U5W7^wJ!( z$#o)-U1}3JlVX>U`DP#jEwCK^%UhYbv|TOz!1GRl)Y(h$*`P~}1V18?!1<1|8Z(e? z=1YuS7?&(bp}=z!6k!+uJ$0)n_GJC5EPwUn5_^=&&l@AA=&Gw4KnUaTVg>|Eq6+O5 zk|rg_fJk9#ESd+Uh`|d^-w8zEgvM}hW%Rj^XJOT~`QJ#4%Kn*Nr>JS zB9tG;hh#oAA3|>{8{gu?Tdd^z4_WuBpaY&W3PTV}e1I{>u^$ZiGbm)#?{*u99C zRGs8e_8QMGW##?xI}a$D8gk(l?H^kDv`1EF}X@ zC!6Sob3oJu^iO4-M46k@Dh0XT1Kc@<7C6-0KSZ>S5lzETSSAZZ8PY2RLyx61j8Z6f z!U7jLEY5W@pDgoRvO=yJwT$2~91b`%fxw}XLXRfnklLrD$T$$zj6>URc1IuJ*A4>N zJadaV;_p^BH({%#CJOkuu^|kw#hKbPG74!$8x0rPH< z5KUkqgBhPM%6?S5yBPp3uRX$HkV1T&S_IVe0hbFBA`h~2>kK>T1x&nq*28?C%1QRS z(V#0%716Ey5>pQRFj~KvlnWNnjzo`gsD-OHIJ3}p1B^X`g~47}^& z7J@F~R5NPA9sn}DJdU_%SH{ss10t{jU#Mn@np>a2}%_wU>Y;7#bmlY@?x;0W|jQGAT#kWS!*w zGA|BJZMuqr0TWMHgibWPl45}-I`epidgz`VES%V{Gbk|cN@w|U1O@fClbfS zI+1Smb+whjVML|C=>$cv5CXv5iUi4d#rvyU!Q$y+Rg%KjUuYLqvK_h;*{_qFsJw?c z4?Ooz$t(zRCPh1ljKkBiPJmsG5SV`=tBh_gK9>Fih?;589ux&Y*j7xuRSg2JR}lEt zZJoHQ3RPwm**bOuB8=X|kD8VtJq4nd=NGrKETA(DTwhCs!yyPJuCE1?FHOUs)VFcq zm+Xwbxc>~sxOGal3vwgdh4iyu%>KUkb+O%C`z@y(BhbhcW8qM9OzAo*Luy2@b(g_r zdxLeaWJfPCy_xJ3`+IMJt9L*A2uxh(0bV-AxI1?qK#S~?xZsXUOer_#XiqQ39hO+r z7*~aD5Tb+mLq84URCNlzz&6szS3W8>#^VA!Dp^I0ONVN149`k2?gKR4i0ETnt{s$2 zl7nA*F)n;UZK2tD>GD)VO1uju&k{Yv&FU;I{%t#q1!9~v`wsKHJsp*m(Xp}_eL6k{e*szqi6o^fXf zYj0xhBsn`kZw zh@w6_|NTq%h^&Z=%&hKeNIGVtQ3+LDRq5s7amgF3ycP)DW(o$lerpyqLIXLq&q$%} zstounuKk#tQ?EpT_pTY>TAzBA%7`B%(nW1~B5%0;XKucIQO?CUzBgJ$f4fkLQ9}+R~$gyIv{&G1xOS|iqK@$f= z)>zhclY*2vYHSb#s1+tm2ndnz|*!fwN~p z>l6+AzK*6tA;S3)9BQ5=>BN>iYs^IM6ixTH&|1dt8AV`3 z8w33HzbBOJx(vLMGYBb0J;x57KDWeGb@TC8ZGII?YUEZGkljM6vscMmcXvm41unRt z4xGPmEtk%;8(wf&qKfW^eL5JG&>5_ z16?p)yFslS)Qjw7tVAAqj#tkH2qI?o;W3$hqmdnZ#cHKC7)HF-w$ev%;ug@*;7z1r zK!ejcybFnrsT5l7*!g<#adqBEb$qWMeo_Z_p%jFRYCQPHqy<|s-HVr#2wkL0YW15N6NRJ@b8u7JghG)MjG?3a|XUHTp`AKN)7oTA3tE!lEnM{xEPLD;*Wqy#5 z0qP%ZBUcE-HsC3<6Awe_3<(~Y6HmS32>Ks=xVT;a<3$>4weWRxeuZp3>F&x6Vl(u7 zb?T)+Eo(+P6zO){h>Bqx?+v9nE>NMOP%;D`ONB~Q@Uj_|zz>{i^5gOM)B~7$L^s9G zqCUvO+bbG)yedhs6r35e6g+>Qx=<1Cc5yI3H7QO{Qy>n*pb5052?Y06dAIodq3~$< zinT{`I0T0d+SWLjg33|TOrnAcWcIB~1>HwLxgo+71wpvHGdW<_bLZmIyZqx1nw-=vpuP(lp2_bk; zn+R^8QV|L!Z7}!==~U%tDi~%xqy*YHfe~Tq4qib-f=A{wizs9~2TV(ro;rgC_^oSVLUBt?^~~*oF2f?BAh+eE+3z3eNvG)oD_+fYS3u4u3c~`t@jWcpNLphocqbx0kE+;$oRf9;?Od!Tnyo z@%H&oFvua_cnFu2(~TW#$n3G#?~kZSBL}w$^RbH^NMyIE>edxQ4~ya0q6AE*V;%Ya zsjmjG@F}WLW*hjK(1BGjbp&j}7}1#m={+K;0M+Sd-SabLv)04hcJ4W}}Mn&1i)U4{^CXEJ#Jn7{$B zG8~~B9HOw zP*8yc2Hag?=vNQXBnJaG=T75sKNTZ0fLfN+bXdpMA=hva;7}o;;%%eEsDhsO_0X(b zMHsh15G%BZE1$SmJsSOOc7D`xs@y1HX{0#1A_|(BBv!7(<%nnf6~xL$|J% zX+?OvkGfHpWl;yjXE-A4lvo%Fax@u*p}fn)!X$yWGkX{!kGcfWt;GZ+-g3#W*PE|C z*F@8m3v9Ze0Bg!&Ry97u#j;gl{qY8SJI|gh*Eg$kKBt;>`1t2Dd<6?~L7yDt?pjml z&}Zc&FjIBX&=xG>8ueNe5^J>x?_gN&yfYxX*bD4bJ_T+nU99e_oa$aU@>Lj~Hlkdp zoH{HX>Ut$kk-`2P$9eGC*V&74sb#fcN@$DMbwMs}n$WP|W2pBC1Y*N>dR`c(juL5D z=MW!Oyo>_`sL%{_d1P8G>oj1$BWInRf+@bW5;IOG!l^ohF@L2b7~0^#7*na^qDDx_ zn*pwcg@ObC&GAd9A>&Pi4m>g>UM{iQ(d+Z)NwGW@POzPk;t7gH*jyI3t$85;kjA)6 zr(QaI&|dMlz=OGn;6a9&X+%75I^z-QA;ye=$I~q8O;b!CaZUMh<=dohz3q)G=hFpwOe+ggGb&jQm^Qxrw5u{2m8cD2bu;~2IkcK z;42dhVG6;JKbme>LpuD(QM_cx=FjA45E#3Um z-_nYAZ*D(+>_FN+U?t0011Im3XSh+jC7!{*oDCW$Afep%m# zP7lOU41V(9{-I0))c6{wMG%TQI`m0cz{ckORQ`v4a6jYo5Vy&GVAoYm098gI9ae=> zHHP8U$7G;eBc-gE2^{2bqKXpY6gIPipap5F5~AuiW%lofAm9gE%V9vc_K*B<^b1nw zo$eUQ{Q-2wFN1VoY)FiFhPV*CL4i-^Wbx5@`TOkI)yE`@K7iy_44EZ{1?a6D2^|V( zb&Z91ge|ec7%9rJm0}1x%VHk{!eJ59`-67}v!}OLesPy}kboa%BPrK*LAqW8;G`j) z@8nlw0QAik%P4Kt6@9OVEkqA{c715f`TX2wt(g+6=K~1JgvE4#^8!D{En{f zu+2;Cy!d-A<_Ib90dpSFjh^v>P8t|ArbUnbSg-u%!oCcHUu;by(8L-IVFPSgaGA`D z>;__1Ns}{?Jjh9x0AbGZhyKd%!8#mU=Tp2!eHJ| z7{R;jo?gdcduWM-PdqZMe70siyV_V7ysK4$fHYCS8AZW`QB*aF9@6=J97b7;!%bQs z3_2rZ09dLIVY&`psEI=wp|x!7xs6*X4s3kYi4xf0aKNFujlT>Bp~c`fj5QSy-K+|) z>2-3wSY4+L>A!xy{aQ}WaFlRRplR80lraR()P{kdN@OiZQw?MI)O*=Q7X=c-%!0eG zCqi7_HNBK{uIffgi*e2#VOO`+W_I@Fwlh8B>`~d1ba)SfpA)@uycE!E=6Ot!^gBSS za)v`arESiIp3N^|aJR>T%!_%qr__8}C?D%$x`PJ~{9usY@|7I4(@6B#ay3Nw1oci# zCzO73MsUjIukgiwycF=M*~l22AP5{y494QQZtsb7_YRhsrXBm?Vsy4DQO6;KflUhn z!EmF_8G8KNhRH}nw0ci0PKsroI7CO(I%1J0=ZZ+-b7m-lebOphGmvE< zsm`WzVSZ<|LO`l42~|LJSJt#J+n~TsPkQq{5F%0*#O$uu{lVr0#iS}Nho7>4={qS$ z7K7YsG6Y~-%7g0_3p_)GLJ)vC@iR`xA~RpGa2<>Rj1b%68)RC99whuwECi%=&g+*n zSLb!AgIq4Z6)~Md0=HH1z_-uZQMxWXpk{@%{|-TZ&SC@!Y7e!NrsqQ2?%2v$127=a zEC)o|Fa!JPrk!NJrQH&pfpnsL+(@AaU9D{>Of1Aynz|W%2T0{-_Lb!je2ra#JKRNi z5py0|MyqF$%K0kI#db(IPQW)PCrA&8aD!4fAez=8t!n}?=0JMGV;CJ7CwL3dOPo;v z4!b20Lg7W?*RZ<5en|Ag}k337uUXC380*f)6z&1R&mH zz812JTVAu4-&k`A-1MebnCGKZ-VHZ{zPp}Q6M9@mc5|6Lb4grgT z5^aHSj7afj*_Y&^`oFV7DQV8g68XO@zFwxDbBtPhe4BPjO=GhXgw?3EU(O!m@589I zv0MWfv~vy52Ed%fff0}-8{#^slekaf#tkVQoj+`5v4`YaZ)bKZ~T}B-!m63H(T;+VdHyFah`aB(gKH43y@W5raO%i z3e7ozFG20g1WsoxLU2h0hy^ZkF%^S|dRcHJX|?+VqUtz;VB#ay%#dO!-`p990AvOt zd9D$FI zKN?Miz656!z(YYWqrmy;QN%$RNm&|Bbd3iG-M)mFh2!h0zrc|RW$IN)29d(4UsuZ_ zo`NH&`QYRsq#2G5c$gv~?S~l%F(%WY*S{pTF^GeCU@;4vR(0qP&%!G^DBf>Ary;(t z(;%&Ke-XzCw5*OSLn$4ktA)~#z+?B|M45F869#=TPPDZlE)dVAx17b(+lw@XZiFB(283UiD@kKY8^GuP}tS#mwWKCuO*g!9q&5PFj(K zxAJB9J=9bO;~G|#)96-WKs!AzwnBesZcA%sc4axSk|T4(N{i^0QLm~Mo~0hj&pn1D zW+#nH^b5>KhfINTqlW1)z!&x*KFvzoFXyaPCr5szC&rjlN8ZQD$L727F`P)f+ob(e zWBB4nli~V0tPO6`pG~|Ne{4fGUEOf6ZKa3{Ddo`U` zTHa`VF?)P4`)8^cI!pDl5S*zJnr1IB&L}frzH@n zCfqT$#g`K-0x@1LS2vew_>jk;Q#3^rvt$Kg0O}eDi)ZlDJ$%bZ_JpDwV2RJ!EFM#Dsu2IE zTN|Q{mTuX0~Ay?;Q3xJ4~9)`BoEBXXuJSm3kgxGs2eBG3wHo?Tq5mW{be4h=^LJVDV2aUIUogph_qBODquZC4-~ z^&Z7g5p$lrhXK(hM2zdqEC`1Y;^`{wBlvoirfn@_q>o1`E6@aW9u9}V3cQ%&fQKk6 zr1ii-5NT@V7!GC5L+jc-@jDE~5WG!OCesE;pVC~EwD$$BkolfyYHb$egm{av%C7?e zhm~32kJCj`uwj9aH`u-Lq5OegH{Io{4L<+uEUn~PPC>yh>c|#<&2FOXX2ch+ErD;n ztq);@0WPv23gpr5D0I8vaUbU(9;e9u_4(7yRoW?|O#(K&8ZZ?mr{SV83aqS{tS(^i0q(E~RN?;BQ&_Kb!lOqR#FWQrG zgM<)oft#qu3?TzPn5qS?S85mzQYmTotHtsQZNRPLl>0@hgqvxb8B0XNwBm<2KBr5L z*SbRJi_P`L!jD7XF29NheqA#o7z^57`%nB-j72R3B#Fi{5<{3BQ8@_kL}nay^9pjr zyy(mCY5AJhi}OiU(vVZ&8`LO}#xcW+C|FY^!xHFB33`=tu@<|ozenM5sKek5nv%h6 zv)X2hY5u5@1Ta8s1p|%AE;SwgiIfnd81fV|kD+i?X+>N&*0chz>9m5Q*U}K3KUT#K z%($v{Bu*@XX#nRM2l>8uaW-LkpK~t0icXjdA+ZbxT9;seGdbH1^%vtpu!3 z))L279S5m@>f7Qr?PHW8+;eeC)tH#qKgI14K%N}o?%ZqOoE9QFwMW?iR@7-iL_@wg zuXX&eSg@2KqbN1~oAL4B!Cbb;5>EC8;4?Il4?kDe;kh^g3 zMrIgop^o!x@gpGxKACe?Y1gmS$Jz5uits%Uh{$Uoa2Hc5zp6D%qK;ss&0Cz+wg_f^ zSoECWN$p;PoDPUWpatr+;&>23z#1`b=D@(ZB;RLmQ#b5+(SZUY)w+!zD;mLR;aiTO zF`^aQ(8ygQ;=V16+1*G&IA>ts77mQJi`(_=Z7O?wEk*!vK%s(xU(_Lf0D~@H(ZCO~ z14)NsBztCm^ZViuG~p2d2CkWb9GvQY8Wk_%p3^{6j3huIt2n(|e!ohijlG%pja2Ya z6%67c0Yd0b!Xs*CSfykFGiV6Tm6rSIx*kSB#+0Qj9C|wmC1kve`cfQOa3gzg{}W?{ z3N*l_+D`D-Y$qYs#}jHeq-FS&eD&!u?y!C&(?5%G0}?S6#_22>0gA4EGS2%kjTQ1y zu5%+43Gt{7hX4cat}x*G%0fn1LHX~DNGNw2ve<&MYzETtAfYeCjDxf=GCV>z!tB-R zYq_^DIIUc87~s*$g`8@Q{<{+fJ1=NOt$d9Yojvt=qKiF$?gjh;H87-whUEW-8RyWBlVy->yy-GEnK6{U5595;#S)tCUMmg0N zX3#9AAA=`q1}@X!pT$$m$>DZ=%#2yB0nhRCwNA?MNumW18LqG6>V*fVT4vQ$1I!m$ zD8?uCs_AUHG9S{DGYvdYsXu33P!;tn-oelHbugd}Y6)&X0C5+S1MD0hsl&u$B#;s) z%t7?WlZJr@<{)qj=ODOT$*aZc^M_@bYiw1K?<+THh5$JR$R>>~M9&a1zO{$3*;2)=`W< zaO1Tm;1SX*p+*M#8jByu@#*nHj*!Gs z1OX~VdYluA$PGNL6F-2uf(7p8Eak;!nO3{{ypS~%YQMp@SMfuCEC#Mu#V}&*Ya_*Y zEsGy^){Fi?rJxtj(pr$SC%4zjazui!9Xmb%%(jK#OdUuW5I8@5Oony6FrJj=gAecw zjt>X-b@3mO3dnS(L)SF$y&N65GUn^W<>uPQlc2eJ6t=zMLof?)Y|Jd2PykjxVvE6G zC!P$NDXj+%gw-^2q=w#2K7(2On`4w3!?pavfNd=Lwt==*wn6KjE)nH8d{?asSVWD$ zX(dIRl0Yi7hOWKeq;-^^r1{?;l5je?bk4L5MW6*9P`gsT@V0KIFCTh=JxuXpKR5`d@=yw${5B1`~hvs)FaCzr`( z&fcVj=!?xVKw=dL{8U3u9%?^D8A;$wEfDytU?7~B9ATD5VLHhhn?4XL(MX)h8d>(N z;1!x2kc@lvp`5!1HjN^XSWu=~n%7iaE5m4}WO7sHWE|eZSI9ZfuH7rtGyN2B(^;R) zD*gIK`dutkA0n0B`bNHc<&;_{-7CD4eUgI*I(tDr3sWNbE=A4*#gUJ~4w#{L#qkeb zA=d=)QL>}vJknmuvn`JE10#f`R!AR{rd;}~Ql8zlDHaLwc!7Wn4cb%GThxjCB}5Qzg(aIQ8N@lvk3q-8!zXeXiwI`x2pxq;Sjo- z09Gy8cps5$334Y(cF%c>c$?64YXbckA4obFdQ&pC5+VQr;A#T_`ga1N3~q%5;1}h_ zOr!0)4nurzA`!UInxBJ9>gb-vA*r#a{#}wB{f%A7!I@x3miIA5%3&^0Y9i?`hH%6M^#)9Kqec*onrd#AWDK^ z5WK_kKG(}{MX?yIu6clFC=UVvxW48Ao^%%;G!r}C)Hu*~3Ze0AGUJ2L_>oCjxN;PN zdcatoQT`WpAkFWExfu6HJCNQizs>$*lO|lfyh`IM+8s!5{^KP;v<{?^wPL}5W(N|- zq$vZSnK_p-*Eq+YwEzgZ_{!H{$Xfl9ODzJLpA;jt7?HB=%P%v=4f`LO(1=%xF3V>{gpP(~D z0+L=!WMPyzdFZ!Db&D49_J+tnEzPde!!=}@hrkg(R8HW?6f%vZO*7T7n$@Q??;p0J z$#-XW5Zp)s3E`sy1oDyrk+y+Lr1SKOXqibkdPFetnvnvAiytExcqIV?7dbG}_!CUV zNShCqV-7lN34>eNWrP_Sctq_pga^O^$;loa2J>S1BDV`8Ma2;#6HKrG@|hT+QceU~ z-s9EgHtoUq^R?eD#1|d#jkAQ{aNDpXd@bdKq}G7p&sGeQ&B4&kE@Qo+ONl3!Y1_p# zqw~#jvG!9j{0J@lxDiH$Fam(pl;9gn0VbW_gA$qbl2lNP={DmCdv4JUsqtD)Aks=87ipE$IL95YTtndH z;ZG}*TMpHpm(!zz0Aent6bO8C6^M{)qiLd*G$=oc|E4Yt?mEjYQ4cl=c(>LGv5Z=sQm z-RMCvr1ltB3N4G?0zX2E{!12GkdBfZ!x3=p&<2?@_@iq$!5`JybZ386ZuaI%U?SJn z{@kyy)ophf`S0cR)$E_^C1xNvQg*tx9WedL7>FK}5PV;%^qv7si1mpqsSuIqm&b!Z zp$ScadcM5=&|IYzLZ&QX`>URl&{F_|Qc?i+9N4BqiS$R}+HGoG7KhzvF|m<>7&IRt zh1tXp$DtBno;zqY${>%fE|P{6p4%^4gqCRx<46(8g1Bvs1pX>W0I5A(_wjw70Xy@+ zo45pcBmwMCF{VJ6+e-VtrHz7T?^jj zBL-#(EAX1?z~ihG{7?)87r9{O@%8tF#4jl$PURD)70!X<)7C+LaNv#=cvfW}`?5lP zLDk0^kZ9XRoV~`j(}m-89SUjH-m9Bg8XuL`Y`rM$1K?+OVnE>W>P$igj59SOr1{8p zL_H_hM~+YZ)^Ac*pk`8oyV(w{TR9Oof1^>f0-Cd%v~c9?>}K_4akcp^f#P`KeF#CQ zgfsXMU|!?F&qoUp;b`J9(7Q9}Iwy8Q4nj;w@JOc^{Q^l`+6r$aR)U*3esIWf>QhPk ztUD|aDAYa#KWzuO+n^9onoyA6osn}x;I&VON;m0&aybOjtj6WlIarbQ1pIJ&?bBeq zx8i`qItvb3fs4i{u^$csQ5Yn}TbXt6n#zTSzIIay9+}%93w~T&U!_Hj91ZY{y7~C6 z(x6`hz(p#RVh2zN{BgPiHNU7@iM!AocETW(3h|q!zc{A;CL6!`0%a;!4(wzOh*LIgKq#t{h7+Gri> zprYYGz^85-2F|ER;O=S{kR$;Cf1K_ohxOcq4!j-NK%$vdM2W!Zt;tnDp|{UCT9)NA z9o7L;unauA4w#G%ax_^W%1PZ_B>H2rj=GT(l_Eq=^$z1sD%*?*(=EW$8V8Yu{UfJ? z!?`%a$Osb57;%sbHR3bS#10|wz0_^u$Z+UwFphiG@l)S4@MdE`>}eXu4}6ko`apge z5YaSnI_H?(^+Ab=A;E$6af9)#dtxSQaWa1>Q7=Em zLn9<#(=jqhlvuDx6dx_LEc;F@u0P_T#`S)REcqtI9mdhwM>A5=9prw>FvXuT2wI8zcy=9OqT43xA)zS)|I3 zLxMemH56W<`cR5R<@*GcccyL$|*f&ntX}&cqiS@La{AubL!>1#{0X z(gH45=bx_1#k^cN=Lq3!BTT+=gunw-B@Bo^nGn2PS0tQiL>!C{6i&n84K|Vfcj`3p zc7gY=>44j-S%hTIq2ROZY>|n^fDnbVbL(KN5kj?%hZl^s< zGs{ap;7K(S_ze3A1c^M|FnZhLL_TEiB0%6%XQ>QM!+<~wozr-n#$lumMXt{BrR-K@ z)o)ZScgl5)7JC{;9s(vVRJbrvExY+nKtoooP3wf}FeZ(w+Hy(3kS_P&Hh^~RHl+D@ z^ZkG@cOXaz8E`*5&&eeNaiIjxC?&d#AU8}Q@>T$E(-iwO1i=MWAoHkkB(G797}Kog z@9aW39qmFnTby4nJ}=YI(Amqp_Gz`6*V&^dXthhV0ChXn0tuR_7CRu61khJ?72IQ2 zRMM~J#V_ba-t!Z7I#W*`_@enK$f>yo)yC=M!=q!z1?EUXhBDPc>m+z!*qmpz`%%=m zb1n(PW>gL5qp230t0DlH6al_3Q>{Ith6fLPACmPT2@n=X<|L#J8ba_y1E7}(a`0~X z@naf1`u=ix>)oXvU_cS5!pNO!<@l*ELE?wW{xTQ)G`Ap!SSJohm~d2nq8~Sq6s8JP z#EXkUW3!w#;1x3v!BMdJw2nZDG~Oa*-tW`?4}R{2gP?62 z!B>K-wXdX-Nl$Y+zeg8JUW!U=gZyfBp^S7Kgt66Ze5(M#dCWhrKP;~=!dO-Zg|iJO zpF1Vq!ht(vS;wcoG`H8%c1K|hj)8%OIpgTfY35Vw*uh~DMlIqAweP_7BAKEXlO^-C zz`}e7K{n4hK_~E$#d(6s4vL>|(u5q$L;2zhQym~^Dk2df*MgJ$3+$uZE@v+wf*0-T zgjDFBrs>TPoFTeM$4Ur*UptQALvi~W2Yxr|gd9yKL@v9DPEdBJ6X5mMkb39!ak0wb z%k{F{5Tz{-REnnS#F;S!fY5ZMG^%SD!G`agRrDc%tvYkS$kiEEzAO@Me6?B@reeU4 zMHa}>R2E3Iz0bJ3ZemGm2;o!OPX6W(X9IZI(Z*MuN0z=Y%lZFiKU}431|RE(rzt2| zq#1yV-{>8;KT zlW#V}Xa^@pKE6LSZBo}|SLTwkgtZ*P(#mg~GLe+pmE>2~gmz~M!sWTzLorqwe+ACI zD+%OP7+}j)F>v2lwp@yq@KBS8q&ca6XMcaf1-+Hg@@(;W_I7z4rc`@i2!`Z04wrry zi?>xEaQ#+iZGE`yd4lsJKgHaQ5F^7343jY-15Rr|8|Pf$vx&zJXuR9Vo_~+mi}O!q z>BDzBqKTO+I25rCVJ*IuasxP2kl@iBvEBwr>9Q=ejr7RZ)%kBwExe!rf~Gmmews#9 zf0{jCq!7l3_^iyTaFG-hKSK8bZd-$4N#6(uW z_Ulac%iXC=N|p#U4ntQXnyYZ&D&>ZN0F9B#x1@b+iYp8q4AoG~0jhtZO69QZ&K94@$uF_H!&Z}+T9W#XbcynUEhNz2m{#mPPjy8Hgs+X@r>YtFqPculPPfLH8VLMUWK_8@ zd`(Y_VTMIpMza<~OX1DUQbOM=9++9t#e%4qp`f;wY#!Cl(5Zs=s!1VKpjZ%; zsS&Sjz09cBjDr{(At=9s0L~~G4#R{_lL)+5;XrQI%U@?_=a<*Z&&kE$tVCb9ux11r zYjwl2FF^v_zp^XgFf8lzaI`Do(M^gLZWhTse(OZrkKTu9yO@ko4%tG>+x-aOx)Q(# z+x%owArmsRtzj^H(FM8GBIuK2A6`AQU_vJ**p&}-_=b?7yTvvPN@59iALMMmn2v!K zZ++yvRaXTY!kp~0eR7al*2tX^lil7NNB{1N< zy+v%&jQ3UAbiT2a(J>yUMu88NF~Xrn5+TZTkpu{&px}|BlRlEb1qq*_F{W^xxr-;g zMSOt&*4jv%k6;=R5Rq*ef2n#KeaKB+sG`gO2A-gX;=qt*Ln$S|nyi$)zIf5h0nUT| zN&umfj2{X&@NSM9@2}H-rYQ+YGkuHhCID8`0?k!gggP>At3ZH8$_jE>vh(!Ej-^oV zyZw${E5tN_E9qt~Bg7Cerfehu2%`jE(*f}^t?!;@e6K}u63=z@EC}hG*Olf?Of{htQe{1a+Nf{x6Mx1@QO>4g`KYVZz#P(j;5J} zJD7!&QHD~+20U-8OvX@(mcSe%h(ntH|Ld=_SFnta*oe#_u{ER&rE~`b4l6zgB$N42 zc1Mdm4iV}uR?){I=);S&PRPs6)%n6N2LS@ARRFr$c?NfZi)yPdI_#+pc}SL6g`uz; z8$zE7ex%V9jx5XKMj($DHz~Y!L;&|{2yhb>h5!MYSVO=!rA6!qL9__oWkRP)s7@IM z!6II5(tQ6vHZvWtGzEv93NnU+98ETeAt$FW;O(UV!P}WZ;KhHfa;z>Bh)2nUv^`E7 z^^L2P3OH12;Gu+)Ro{Z9m zeNhalxV&0o30tY0 zWb1LF<>*0NM6^QX7}wWeh)MvA5o6f~#)BfncPpL|Y7=jBcB&WYm2!|D2F;*JO)&C^ z+n*Po%HHuq@V{1ZSe%MU=!nCa8W6x#)lKD(Rt^|bkKUwP-ovoqEhh}$Pnf(vF)wl zWXX{))6%Wif9x_?1kZ1Wc0joX!jw}WnH;Pda89xrJLgmZD7J!(>K;(rH&8nDe|{{9bmyLgQrgq}XQTCb>`+PS z`Cs@jOUy>hf$uPa>Br6bBCS)LmT$XB)p0EMxRJ6~HH_)UvtQ73OE{Q2z#;PHbpXWL1^Qm%VKMUL#GishQ%&@@bHKhrU8VBWid-bx>Kl>oW`1C zCN@J20F+ZrM2pk_?lbG}B^-EMZ4c%sL?L#<07mC`oIffCOH_&A4!6 zaYI_z`eTYE)9|m{)*jC8MhKNKtvr$t{+?2Gj2&(Te z;vgp2dlL;EmA_nkEJ{P2-V`)iX%a`N_(i|a9<>i~nRf+b7{wx`5z>v+*u8k%ACr!^ zb^JJ6FPC4wr^Ti>-#tIP;W!V9A1fjun83GEOTl4PHXTt5+IJ^4?=G8)mvX^`(+Hf& zNk+)aajMA+3_*U(wGy7B|4*Gv&Q$zNPX~o3N9jZXQY{*0Dr91g$dRX6>gH1VyBK3TJjw_R)!ox*g#mP1=(>85wnfJh!@N2&F2(z zT&`}Gm&=7$3E$@k^y-u&xDh-=O#|0gDzRtEQFgAldIY|UV?_+KJuSLJxB?t7kn1#c zW%XgXxc%Mh1SC$WL2;fAMOs_EQ9@veGtmsqpO&Jc0qWx#3oazB5`$93<3sc zYLx(jsuHQwu}nBn-bz#Js}6?0apnT6`T8l)0JTnzP7+4?nG5)CsXAbh`r(oCP6ktn z(%b3zLr=?x7S!klSa#)u`!Xd@Lwt|5n@V>gZ zMKsVzHIjbF8;qnqWr3B6S~L1a(hl%UGlU>J(L#P?Z9FWhM-#)F{^l}xjAKM|j6SXz zMPXuqHvt8S3JrzcK6yJSMIQyckwc+5X`_t-{+gqVvM7L8s>2FtJ0t?X+@rIlbREQJ z_b@l~HnG_)seHQZO;mvC)m)%TNExvztWTM!uwPyMC`?rNFj`lCzF`KFMi!rcTBg|- zsXZ%>5Wbix%ukDX!D0a*mW1z?_8pw+ zU>~iFAaD_VEW&H1_F5~$YvuTwP1jG3pJs0W@+kAi*FAzBk9mhXL=I&knJo}s$>7W& zuz*Z3FbIB#K{jw~*2&&&(wZh|%ch0 zW1&MiLc!ICc;`Mba5`fV243P+lNhg--_p`1uR=ZDmqoxSH5;@iTTSUN@EH^dJW7cn z?Wb9%Kknf#%EeWwHzWmbY(VtqYs3L7T^yb-J}sA@XFsnO|9ShZ=#A}E4V{sMnF@G@ zVgZ6E7BuR+q~w3XkglUJRe^Rv7m62kF~qyY`pe}kC0~=5kqj9*o>21w2uU6~;zC9( zaomM$j?DCwOXF>?J~loP6wgX@ry<8z9E@W{mC_3GyQGA(tIrm&<16%nhstCd5FOTPPb9O1B493!{k9WuT0BoTo;q%fqP8`yhs}d+_lC*nzg?{2t?FK z-fH(;D}++kd>&cz)5d&Pzoof-803>W+={7fxU|LqEmaJvX$zX&RJ{skOU{l-8)~G* zOU^b|tMhi|bN1{JnmlAaEZgVAXV(>xsOk-$Mec}Yl28)n>Y-&eL&ze`qyf5t*>l}7 zLppjMSV+Sm4BkLbciJL))k zfO@MrO2|K47j4t|?ta#T*K!h-Mp`b`7qjQf#y-@}Wzj4p^}$DOTPSW_Tc~{gL0a}p zeU9(>WY}%COX$pR^&R+eH=03%93uZGZ77j?0Fw(}T&*@g8+XA@V)i5&b14)|UO63vaGJmwR$M3xSkp4Z&eEy2S%( zM*L+!;GLXa($`f%-BAF6?u&9sILwjdSv_x4tpA1HMWqyos$HNdbwm?FTRfrm9-^1f z2}$QgC`1~qQ`$7I)Ae>zl+9fCidK)Dc@#6>s42>es1HU#*qF`yhir3p<+bolp+G)n>!kk)|xpZWNQ!-uE$|8Z~rk9&VkztZ_=ztZCk z2FA^vEY~-^w>T+gYMe3} zr6uSvediw!Wqg;&0k8ER(} zV(IO=M|Tr0JkJG7gI|^AqiH!h2qj{(2YeQ%hH0E_+A-iPO@_V+OXar(5kFUGf+FC0 z#R3=Q8W5gb4OWsrTEsL4#)G3`WR5@pGYhFi^bI(zXdHz;XJXJQm_JT6kW>N*6S+DC zVh=?K5*!w2s$v0(2^4bFbPn5WV?Lh?T8x#f@IXk-Q}UWRjt)TJN8%+2iN#8AlCv}` zA*~r%%vo`TLHsrw3=W&sQBZQsK=9Z-D#T@BkZAr1o-$x?cD}i}NlP4El=z^0ls;5@FEsUnCs(M$^OTely#XzKzr zux>w%S8Bt10+0vnO0?w4ExYSNoWTWlH-jdbmGO90%x3f6gUy%J!OKGED*$yA3j9E2 z0b(Ikpf&H|F3N=wct4s09V;DH*#{V&?*bj?Q_zNS#Q2_LeV3Iwok{My-t zhkA42Q3! zE*x*GzWR_YS8t6EuEGpQqtu(z4D}0sg`xSiukg6qV@Ydqt+pG7WRZtph)^WSkxNZ` z4iEiw3=3p~`wsK3fqB-bKuK^+AmEV&vu_u->)G4%mA@7n-8g}wDOOzsp{oQ9sI{7s zNt3^R)#;&^+sLBPO8PN}32_%?N<75mh8 zHfKjG6^h`v929s~mF(gC9yw0Q3*xzZjuSgf*mNm?1Q62nzwfCYw!H04B_s!`s`yUv z9DXWva2UuRE%zUa7-}DQRX+%%>`J7ONi7K1nb(Spz!S51bZ6P(qdG>&SeWOVv_zga zj&=`PpAcwaEt&$sVAyTjh}pmV$V9UY>=;-y)4t(8;x;@OA@?)Yq~9>Dc!Vm*?9~c$ zOm31%D`q2CD1t!2}wA>X?h*A1=c^rQ6_K~r1?*djN0K9i#x@Z%L7InGux+&C?A zd%arvjT8JDio~I^mQWG^<~1ZnkUhn-xB4?(RNqo?I)f1`h4w+&2w-roXpT^$O_iQCsW7&QcuCN;)9Y913OaW45q#gL4FvN(Tjc=*v%LG7L#v~2F zxY#ZjXieLLI6mMa^&nyx5R5%>D8)ipFhpv`2SQnu3J-%_7zQMT>4a2}-z~pirNyE= z3V2{$D58NhYlV&tcvuxujG(YhDDLD-<9>>U1dj}fyl7-x_;)K1JDCOG`4cOKcz1Cf za%5(aX;Zn55M`1FEpcGH{d)6hS@y5tIiq~2a=;F6?Sq-7LBHG)_)p~J} z2A5o}7PANUwGX+Py!EzPe;MAjoq__FW(s=jbOHHM)&+hrrW}501mTB^t3v)I=Hou| zvF}J2>twsH!&QV3?Bf%EQKX=Zn1A@R5dus! zMvNoC@Obm#!}qjKdpTgKlZW=Hfcw`}pe^5}t0g-J!GX3#D&R%DNOYsBxFUdwM8M(6 zdignJDq8!NPquQ#=B`w5oy;0w{cz5SHJ0OjI z4;-pH=Pu$x&G|@?eUKWh77=$}XfJk`IK0P?E4C_Rwb=N<{bK!JpxBCdK{u5wTCEN% z^U{PnXNl&qroQZ3=taDE^IEc5UJ)4f4)RX?mMg4VHJMoz%mx5{IPTUDfs*rH982|T zu}TBaivr^IRi6&~dWCP6S&rdA8qY@2^*1Qm3V#r{ckIwhBdWmx{olF~u6eBH9O@=L_xGLy0GIc<@3C@W#jy zd^**NB?7d_kpoNLKE3_CD28DBg&P2++6_c{Yjo#`VWABkx=*BA5(BpuE1{wo5Md%0 zBp?$b=r>-e8QVNdL+oZxZm*Z+((ztF94!cn2uLWhLl$dV@XhJSC~$2P*+z@9cIK80 zk7(qwtC$IzoY4r&hNDG-242gt;-{~x#bt8qo6n2Fp8?t0p*dcJ`nuCk{In8`z2)<$ zkWVOq5QCI6Vnhq^ScD2Y{YI;Zmc|yPseO%T&##Q;xPdmSl>}~p1!LUccWiTGEXXN& zK~tNM0|f)YI|wC!m7~P_O)9WINh?@a5l%Q2qkzS~&I!fSrr3Akl4TKsu9fVRd ziRAtu;KiCCa5V1g#pUMOcemhawN>D+ZMAefKx-=qaDET9EQ4LK1mu;xo!JDbB+`I0 zDh+Ygj!6UB;dqdGT5e{Kmm%}PooWd1SA`(eM#@N6gW12cpq%D}jBK&-YV&pWC=Hfc zFVp%xY4sZMh*g07>QNZe#DOB602?SaE6R+dRSOU)WMzakX@D&z!IVdB!UCZo*KJSZ zJGt-W@d14ft>IW$VK*u_^y3O-LWrWG45y}Eli@?2wc)-xo{__A7MI049@F}jKUG1Q z@?R^WfiNM-5R9y4r63#{2I4G+3!{s0QDv+un@#Y@m&rb^&RZS=XsKDy7DOD0mEaRb zHsN~31COYbVFZsc50L``4Jb_=BOSVvpJT-kKNLpLZyFS``tUEC>zhlzSD7D|jFu@? z@Z+|x#5>l^5SxIg?Hf4+D9l^pt#&FC^>dA&l#jn(rz#OAFW}>7)zBvz_(3)r9IDNf zOMw9+MFNM)2^`)n1??gsrZN~vC?kV{Ih+i!11R1k#mhz7z5Vm-(T9uM^*>%DNnQAX zES=%|_}1n;{ESbWsjb8i!F$}fuH{9Y~(1UTzHRWXqmfOUfrIT zITu=1`w)jjpa%F*TZbWm^M9gskaK1oAr;4CbA%a2Ef^9!G8gjb;K{)(b-5I)fjJa# zsH%y!v^Bz^fWyi__}c9>V_P0xj)SD7O-MCDPc>eyshJ$u_4@qBr60Wyq-riW6sm%< zi)yQS^4sL4vFk*thb>m?+2i%%k6zUK_UCu7PFGe&yK~gL>qvgYR!U8@L_Z4iXbpO) zG4ff&*Sld9!!|Dx^ir6LsI>zBVjD-t_zV*Mm7C5UBjs{tiWFW7!5 znm8yzSsmBc%n%X)3gHMtfBEvp4Ev(JuIgS76mM@fVmA^)!RZW0P*0-<-o_9s=2H@MQ`^iy4Awl!^u3 zzmEQ^xHrePe`S4n9tJF@@L;6A{L|INYH_ugyyQKQFa)-fm7|; zGNe!`!2ZiD4yFz#_yYULLosaOA@4#ORO{uHLzNGq_F@l3VVQl~qLZwM4>2|xmp?eU zE+W8Dx>*o8^Q{+TI}Gr9g+Q7OQE=`;u^7Z{ESj1Z8}GP2Sh0xV9-(LknyVbd@*!HP z2;j*4=DSopd^En$Dt@cBfakXb0nN*7NQa69tKfHvEAO<=WJCe4-;AVwS$t2czRcdQ zzG9@A4=dZ60HiYxA(8@G3Ix8s0-=RuaDo}r^kkzfq)PV!ZYS0;P@)}1MIg|sCJ@h; z*B{cF`Rnxx8^q(P+zXSA)l|Htq`!7>KtNl22>e#!YoW$u4>6?Yl73pt%Hf2T# z+{l?l+MM_*?N`0T#Ay!$T9p+e9jaO2#|lH}YQY0)vj9f~1-}1uGITeg;himD7$)0F zynwe+frv-|K4C;a;_0`=_p2qAnq4nezCYT>473LkPj4D!7lV@s9I9pDdcoqq!!Tlg z0sNYVA^FAG&FahIYV%uKKh3kEEfTa7$vt;s1sP1S+|zB8VYM64#XB1-+8WW{Nr6^k zF5}61l{)9sAcf1t^+h=}na`~41JBPgQF6lBhvNkPDx8p`$tsb17^QQ86k`Cv+Zhls zp2q1MPj@Rb_^eJT9$$Y?p5qs6C2;=9kplXrNU-^pb;Kf7y1v#+LqarTG7=>xD8EEP zFd5uNe^N^vrOoEEL=}O+VtPL=uCJEG7;Tqj!@~Susg@VS^aM za4Ta&+blvc2EP`8;E`EHO1YO;X%frX&Eo3ohudr4FO5rUE&xBXigMhFhVfM~{g=hp z%jA+URsZpA+Q1=s=X959_{cA3kMVa4@$cb#=MaC#LOKhY`YG@gRj^$l{g_29`50=c z#;9RFm6SsycK4O^L%)9hLw;dW^N3E-zRSTw9fv1Qth?$b-cdfyArCcjVbilF0S2WY ziy?~t@n|U>O{<-_ndXQS-`2}B*U5F&n2BJYQK@h`d-87P4@jL-{g|fUwL&}GOYuRQ z>QFzFka2x&p?u-Hbb|KQgyxNn4P!_ITV?xOgDsN>OWVq)^}Eu}P{pocF1&-y)=&gT zjwjU2z)%00@Q!yjEZT|{JA=D0yjUg_UN6>Zsuk{(Lw%=Kl&H#cg<246vP=vh z;Q7<50QQ~LHgFf}!)_pS3&(`Rbo=$<>h>lrFShZE*`eLFVB^6m82zLV7v-c6uS}EJ z4}u|j7X&CcqL8?;(ZHZmg-oY&7!$@w7#HxKP8{--)Hv@BUsREBWWa6ONI(l~agcx( zJ{LFXkYSrv9vvN#@PdYAz!3WpG;mtcI1YmYfM`4ENg>_4v~$44uUPA2yKzuAC7g*9 zxY6Jm5K~L%JQN#qp+nB!8GzX<8%GD47ey3$I6&e;pd+ju`@v^(e3f+L<8dj5KA$FNG(n21UqF=#Qa^ z4#beavm6pnQ`WP*nmt{7FB}LSq(D$8#DO>)30*5~Af#OY!llD(gYR@3cIWO4*Ese; z=AlRh?uoY<5e=Nq5*ji=d?4XPu#s2G6qSelHny)7l{`rq`df(qH})#b?~V2ACitmc;&D=P z;+~O0hj5rJ#medv?>Md!RxBDm6s2u|nVBCLjjdo=yWljTLK6{W!Y z_pl$UpX!AMX1?H1gNuIXjmIe>l9hu@`;K2f>CJp2_xc3E=?q6mODUENE$B|nou*kn zm~Ni_^`DDWZg(E_2v^n~72mFd2RkBbpK7jT0!3&GPBzMMEY4_ncf*9fxr#1g=!qW* zJMbK5FK^P0ZnHP5-;2D|yAd{DTq@Y7NQ7}LxP4a8beIJ+9sYOMRfCnV^`r$F<8a^z z_BX4~Y2~e3-xGx|SaSmHRU|@`1rF7WkdHeA0@Ee5WCOj?gyghas30xOHd26fg~2QT zPQ8*>X~z~HX2Ia=D9Zs6$~I_nO$l+100KaDGPAL8bI4KHA!owL8=F-eSB45ynh z+9VHJImj@Ke^IP8?)#zG`YPNEBmeM#ni1j=?!bt0>!8pkT5tS79-VF~@_P+qI8VmgOFDYE`#zu;^RE9+b@EcJ|9+`2x+oZKnez`2S zD?zJAt)g0W(8ab@x&7(#>bJD<>YLk-AA65|ZCwON`di!6B8?l#o{FU6&3;*Gd|_qz=#J1MG_&oIddD&od%vM7*3#rS6Mg zC65wt{KHEq|6mMRof*?9o2!7=X%ud&D41#PyY}C_So@F5&Pn^B1tV#old1m5^v0v*BzffrKDHWQq#x|n3+B6LdzPdOr`D33CfYlF0{c{T?XhPFK z|GBuCy;>#%asuVm+QC4v+EyjOMcFXeBB-@k$mD*}avFQzZRMV1aa%A=jc?=ZGn^6> zh=<8k8e5dcPgHZyaMfrW6Otd?zjoh30^q<9WO^KP(i@eG=Z#o~M;TRG8H!i9TLwN9~F+!R@+|CrT?X%)I61?+@M`q@{3* zg|u<;C>26*54))W;2TSCgX+QX_O4*Y*Y8vgADsFL{cijS^}`^DNia@ltLSEZfeW&4 z%vl;k@_p$87@zYweE>vlnMAW|FvJ4_06Chh58dT2$uq;ELx){qc(&#ap6_o{oL|T! zFs%bQ2SeDP1Mt=`@MXyfVFzL0*L0K^#(pR*aI3;wbhaRzz>02X9A3~_2d5)G`z?*2 z@Giq);V8jFaT&or@X2c|#3(=shlK#-Jm=sSbkst?;y6T7IL#=Z_cU4zn2O)P8)XX# zSkNw72{0E_d%n2(W4-d@iu_tpq=Te84vmli<03@^7pVi4h64?y!$h$#4bURufCTSs zNVE+kbj0Dsnjys7W$K%43|au(qmo$-)t69yx03q9_xIq_(*IC5{NL#xl*ecP^*_>9 zzyEiYRt%R-e>ZaY!^zRFM~lPxNjXq|emGiEf3y5HOKa(;83?mCz1-r>i;!E~Lr|D= zi*gtbAZ(`=Z35`n9ohqa+e!Vm6;9{JMW?L9)1(!J*LZMndU))(&|Ov>xq^C5Ff-TE z*>e5jOed7~Xq-BRlhL92P9U8bXayZFyl*l6{)tCGMn_5FPgorS{gt%mA%sFO*9;$I zBaT!iE!Wzg<59Ie06+!jXr~bi7EbP4Ii5f8F@&pkON8rZGHzkalNtD+fl%v;bbiUzkMh8AIeIYT9kK5s8sYM}h^Is?MUnqBz}#g_YPH zucebrn3WiKYNH?&+(jDs^YZis2gYA4&(>gQzGE1&JUNZ6wSxMv&O*Igb47d8V(eNGhU%Z<*2PMiJzPSw||P ze@kej9K496(2UwP92lXu4R@_+f$Q&7EIlk%RAA@bR3L);pi#8UBbCrUrGTUEiv<~L zC;*W9kIJ@K1n+E8;Q}h0QM(9iz?o)n&0yl^|MhZ{2Jzrd8f!TW@Y5QD zs)YXdI$75G`&Csxmt9?FPnPSO)j4yzYN-0-pU?2@p??0*hqybJ&%s~iBLqT|9PX&2 z9iFtSPPsI%&!JxfcPJ9zhkomv2PRb--qHb5@JEB+upu^b{fx>g`H6b-rL`JZ!#L`oFi#6>eh-;~&dci&-Pol$}Y;@o%Ib}xncwbx>jqF6Yo!ZVZ> zA-KgwH7kS*kZa+`bS!$aI0Th}Swl!v2X|Naxo+#UpB?;M+f&XpkbO#%6&wtBj>14wkSYNFIt2!?g`tKsxhBNs2^FN_!>zVK5CRAMx~U4> zQSD_pK*+V74X)arrudZu@+FD+J9`d}Mtcs<(&VH^S4r(xo7vfy+s;V*vqxoKb;$nQ z+;O{7d6cRi%K{ysdn3oL0FmPI2 zM3Gp@Mx>Hi;SF==L9r|W{8-Md(7NmmIki*e^ed>?8HtZ)D-4j6yF>{=5T)i$MdY2$ z45A|9bj~M&F#tp{1~k-phhNel{MTvd#pUuFGw}?L(?kzV`mrJt0!KWcj-e$w0Bk~y zCLhG&rDv62*o{#ea&RgA2mrXBqGDWlcuxw4;v6`jC}R<#Xv2a>7COqZx2v1;%W|6$ z-*tc&RG#413PyhdaFZ8o#$;s-ykO~qv><3ki?)M^llsU58U^0QF(NsLr7VH`ZL{&S z99@d(P@t=jDsf0Lai*pOP!sE5#bh!HMtac)-i0ubVg|!OIZX%G<@j;eWc$%II+K1} ztv{z?nDdmK6%!p4A;Sd3b>w8$v1b6;9kEAAH7E=-wT^wTkgkIbdQ!^i@qX|g6A5vi zJQQLC^8f|L(AbX{!93hRC8BF+9GvJ%asq~{!o<;g_@Ss~un}4Jr%`%vc_!IV^`wMR zYvAk{6he`vY;JX!7;tI@-2Dg}+OVmHU!K zGs&vmT}Ox|j0Ze2|Cv?^n4P8R@xN_~+3{%7l=P}i1%qJ3Cg}Qh>phu>K`1|=O=1fH zgZJ2Y1p|Ap(=sBC2Qc(e9;A{(nP9kpzUo1Fd%0O&t$qjEBwN*g^7i@9c=*tNa(EAK zoa6j*j1XGT4)cML8YP^64)aByVU^spNzGC}i$!EPI`8zKlrz#FSU6MnpPUr44{)V; z@-oaf)8tlDIg(||6?&*rj^5A;4d0Hb%DpHbUZ9pH<0EdW7*JMRr-3=%POj6PVJcE( zVCD%`;X$FkjHL=JRCZqsmG8RFu%rpWPkJf2e?d;J-Sl1I*)sl@SW{WAy<+#6^ z2oC?WM7Uh?H{H28Kj)xdEe~Ts(1K<_C;f|W7O6Do=-{j6B!Pr;09tVfDG%;nFU*K6`$frq*7smR=$7HnmZJ+6qD#5Q8(d zUIH2c0iLL%mlned5OS#jQThzgNcbUMXA!>1u2=?6XUhm9LGW#a5#)xcMA}{+^YPQx zqs34uc#RqiJV3z+nIG=2VBn%kA@1TlviXZlxcPe|TptdcRygAFo}@&pD!|%E3P~<> zjSm&f?U`_>6FEGYpI-95gI+Xmpl!U=pbXCaT%`oC#v zZEOD-JW_cL2)ak3{_LSThl1=8gXw|H#cdybmuz7S>`;N*ZiHmD#;m- zY@BemIKN(ePThqYjvj6&TW4{3BaW}m$<{udD)2H&1lcy1nlPuX2^EwT4cFNAob&sB zTrEeHiA7MsoirRg&?}V?c&0duGTTDHua1*ep>w_c&~lhvra#_S`G3NAp_gspzGKmY zBpQ=LsN=a`^2^P~5N#N6jLL}9>MM61cK>eq@nhPx{r%;#Sfhk_ZEX)gPmu}HB($`K zf-iiROshBcVrONDTTwA`Y6cC9>rbX1yDmmCN^Ov@k6YU0>h?CGJe7`aG`b%I@fW7)5x9TNsAi z-Q%Y?&DlTzS6%${YH_wm>mzQ7pBy95nyeaS#_1S=i>kPKPaMj6aX+N)yUqS)ydijy z-MHR=FSqV%TZU85Ff^&H5yl5;!hSyEdJ=MH!rG+Q+kt zizJzKk4k5QX56Pu44^zFngY#a1IhI_$+gTtc)OjHBE(bpp&${AgcI1_Uv93y6r~8X zs}>4pAYtk^?pos@W^so^>sU7%798k|CkRF8cr`ZQy$YeYPOJE&jV-^qa1x-`?$a?L zNM)M|W*U1+M45HV_XnVOoQtDkAc504>F!pg0u^3tma~`ZWx2wa^B7JkoyQ1K1OTdu zfb0K~n$+$vgc>E@NDP9suu2SFXIf+U<_|{(JfPz|8`$u@N>r25W$l?8teJPyTte=5_Mh@@oL(E4A89RH4vKuE;`tMWICyrflv^=;! zm(f)c%5W}BE4;@YRH$j2dD{fXKDeE zciAJxFQ*tg!@%tvEwTj(5a4qLBB(V^H63?a)ArNs*`ge9kE?4!&~&5*64V+^A5&|w zl*!>sSqzA9Xf0k z%Ob9IQh{4`DS=m2O2h&o-b%2bm6+>#y!kLoi?w_$kU+`5rUdX*jp&E?cn38M5Je1Q zUy10g@g-t0ME4^DghFs{5)oi{e|eiU;_+fts^uZxyheib5aT!uT}wEXov1-!q}bCs zvh7PyOJ=o#+JRT15qPW;qMrfdA{W@E$tcM-&dzUBeCwi_ttt^H0pP}rV^17|Clfq=Jh zL`cr!eD>4gw?!H*wA#u9ut-6e*n5B%=*T2nuv3pS4XkAmZ4kO0&P2o1@t@br3+%Uq z5v2|STve+A{;CjEp*`aFzp~HZepth4KH6vS=w_V)!$lJQZ=c#729MsqLVGQvV3nht zQ2_hq=q%2LQ2ry>$|W#y2Xv7Wd?Y_{kx=;3=qYbX2FMCg&P$%^LU0;5SqNG77vS$A z2eM3TUK`fO1-K@UKZ3pJ_nuSzreze;9-tt@$@a)7?)x4C?mi*KVV&si9OP*+^#J}o z$Bx~i58lto!P8Azy=j%UM8I-AVF>AobCXavMTm#uCd2q@z&Pe5aefa?=#DmLDB>AW z;Njs2^&f@_%qfC0q!nr|(kjkXkD^}{lmwBi0$^sYlx1R^si80v+0#e#93_$UNE}O6 zDz*WtXJUl){z!*bcJ)4m(McoI*2~4PVi!X?92_M=2TD7w5PjGZO^>(&M z0jG1|)QuU?7$*|4_5;^F>;OSSsB9txkFd4cCX5RL$>bEXw-MU}AVP|1@&LPXK*&yw zX%XqvtB93SUGU)C39UiEaKS^!w^?f0lNLih&>7s@qXwDQrv^?dHR52Lu7#u-pBJ-V zmLEPiD4a$(UI0opkPu4ZqA_0ZwWs^h9t!v-Ta${zKnajZqKIG{n0xSYb9KJ(Yk4^` zI0T$Tgle2a0B@%e75;js5>)9edNPND{c38T9K6fdhsB*YD+L4><5C$1%cr0c2BCpxK#rI_i@_z3hQ?Lv6<b45B1iluy&oxk$=*7)6 zXNuyvdHT@zns8qZk?1nXp(rto;~VBFD8A6eiOV_3aZ)tC=Nnp9o2A9E`)+~ppx8ZC zce;Z%!FhN99v0Is*oYj;hK>TnWt!;W$jp=dct2LF)E?uj)Vzdkt92fRNDi`IgMlBY zOe+rtjde3}M2XtN>~q(c(19Oq!l=>XfCI&eT)_J}9QI$KHgs@1Qs6MVD?Cns0KN7I zY0CAy4pAl2Rw8SP8`l9lNH;rau9E9oS=DCrQsOG;YUr0 z=q*r-k2fk20R+6?7zlr|VeAA#T!5hqLVI0Wm+r#Qw(9otHS{ZDh^<^dW#^EZ5+f3w%}j^oA?X)k%bRsTrVCIw-oEJ>rQpd zl-LCtpism$yzqc#cJnSx&1&p-;0Ie10Z~bOS_LDd{fliDzM{-=+9*id@!C!u1R57n4&PiTAy#Ccx;IRaH{Xgx zsE6T4LI*siK;qMKRxi=(5`O$tO@oJ$>jjm>nVJpwtGG-#YD&a5({%1b^;qc+< z{eRq>|Ksr9UYmi$j-->(j-<4i{I|vJr&It&n8bv(8l3j}r_hyDO!Ns;9A^hkKkz#4N3fY7cmDS>DvGB zNWv^>KlNRG#XN`uB|%cn^is|u&Q=#`O5W^sDu$(ryuZ2vfM3T7ZBlqVIzcF5FNz0# zpsWxSw&1Z%A-cUuA{Hj8dAzMaf-jVljL^Aeh>#POc)nfSu4iu(@ylHgI^NUyjgVsC zwlx|;cAz1~($vebv~ynUq~&sO`XNV-(;^4QSI9_o)iNLIb_na5*+AG)SPj?4{ot-?nUaUUOo^LKbE`6=guL?+aQS~5% z0MpqB4s#Zs4z(J=qsgo&lW;;r$&jPLJPb^+51h`?Wk|x={+41$Z|mdhbBX&p9};Z=Zcn{d?T0z-l3Uv<%!L4#T;iB_|P>Sf>grplnqWGr0H-Q;y@+~ zMD~lKl41?G9UkXE=!e*c!7lJ}0z^>CmuaQ_@3Vidmh0ZG;`nI}ws0tBk*uN&v4?=R z>QQ*IPCEjpVN(|=l>cq9PP}V}yH8#{!&kMDQ}^($xmRJwxfq9_v3?PNpMza9P#^5- z=NT0DV4fG&lN3+{&Y$-Cf}Ao~5;GNxwJUe*RKU+#!7f^^#)wNY{vcK^g)rfp7VH`b zE}T(2wO7w#+Y9)M5!SAf9^(Dzy>MDpJ8phw?8F;7srqGey}p<|KA5H9gnq`HpE>C4 zl!uxNl+iApP^-3lei)W~=*f0kI&!xxrOr1VK#gGVd`2UTsWcyk_j72xmMy+g+3ZWP z{v12fYUu`tlq@0G#Ti8dUtev+&~WSkaLJtw4cQv{_t=4F?j&9P-2m~f4vu%5w5CxS zI#rAjDZ1m*_1SW8D9i|M%wd7H<`7TX4QkNHr`OHqCnu5^NM0z-$Ngw;F7nSDs&b&X z|2%DjF&-IWInc}H>gF=-yY4N-2R3-N;@~VK&e6ep)vk>1%@B|8JspQ$U_*cnhK@h) z4yD7-9Tzz6{PE&rISB!Xsa-e>csO`5zX<|x9fLshlPV#&IJ+3y*)ARqr-cqef(9L; zP~bw?LIfU}Fg#vf&0e2B-CQk-=Hsf-=I>NX7Cpc_?@5DlJqFs=?lcI2zOkSI!P`w5 ze0`HDzQ9S!iFo-M0{m9JM2Pco=FewKYjKFpWYG+j`D9O767naMn{OK z6u@B)nk;IXvwqR`koKiT62)YO4}35$!=`&?4H{tEr4R1O+y$)(;Yx83!_eAx*d)Qy9sEOYmt0`&G6|AO zi~(mfSc>ad;cbKrFj$Ac`-67}v!}OLexSJ%Mh5`yu0-hPQ$SjYU;qduCTEwuJ;d+~ z2f#s&rvwDFFGq~QOS0+AAP9#A3Td^2R0TRazg&D@76o%Ws`it(k0KF<+yf&ONnE5z zh#`OqBbnuxINU!hk}2GJ!sxwN8Kn)hisip7zH@!|&6lo001!0@QbUAcr}cSoy=Wxg zf4W2-9s4z#WLPLAQVQqJMHGvwGZoBc(d}sjN1a)4i@`L#{g3s^kGl8ngZ3ajC`6^1 zUOPhIPzhmB$kAle$Vqc7km4E6G}_t_hvwi%q78T(2g0*8W}wWfaZ0eB+A8o@wTh5O zIS}v!1wmK+XFwRwlGh(zE;=-b3c$Wd(=8`P!6i_WG8o!U4W+4fp^ zHRXjvLSk8%$eu_%IP|@V=CJ}2=I1r#cTj{%Ab#1jkj`EpxL&mbhgmytDAI8lN`Yv8 zjRcsY**}jad#=(tXlB$(JkEu4ffIP;%!#i5CM0GXBOAmxA#K}7Ki6@rFtrd=CSy_d z{hQwqRGi!BjTq|>!pFNgSKeObzZ2pUk_jQcS;vTKj^%tqS3GN@W*vAD&xt%7xz2t= z=MkCEO8c5i{kPT9p)g_^xJu=cZ_8@Xo+7bpKjN55?40!V_rU0ACcbT3GoANvaL}L$ zha5GnBZgLTsWHD7=khv>EJoBK0D>26%4TPyn6^?lEOzQYGAu+hnplikNSOq8l_D|& z@0s(zP$0r92@tr*Nd?oMdW#s}qln+u`CmU1Zn6S4+R6WRM}lxp^B-Lth={q5JZ`Ms z5Ci62=YRx7RI|!{rfi6@=bVJtmGWS;E9KSZYuaY~<8qz$jefQG)ElSu>QR`Mz%GiM zeU;<1(EeufRAN9X zY6DKIHpJm4xQ9RxY~uCeW7=jGk;tui*{AT2zh4lV@&V8Ixmjm0*Xaa^nh;IdJ) z#YYpFSXHQf910|`_omNyk@l4NI!hzhZZ7>YkUp$JLmRPn$VMGC@B_6FzOZ;uFmWHT zJn}tltb#}}9h&d3h}>{~<2dN0fx#ow%d~*-a`}1o=)=YB`X4XS45x+fY4ZD1wlN7k zO?U-mh;tvN8GuX?!Tr)sz{tglYTaF@2h;7kpNv>b1a^V10;j&`4MDS;Juk!CdU^7i^Bl@LFFD0VBw z+twbm-+J7>ZoQFVPwC97VTg1(9uU_)4{$p3pbG>cG4pu6xJ?@oE@!W9&lkR+?5FGy zfU1@n34?NCbv`cFX>;Y!`393# zR-lo!Y=#O29$vG;RC5H0u?VwN2dJEACU0yg^mC3lBA@MVX~XN)&H3f*8TlF$L-`uiy?_FA~xHod>`Op7CJKV@2&?kqwyLL4ASQiqXV_hOfSMC=& zlE0ecilGfq_|?s*JIPZPsMvl^0;%q}`QW}^=!kD6W?FVM*hgWUl$}#CrIMhlDB*=N z1)2EvdK##uwQY*ihNO(xW<-H@=TPXWlvrvb3J|HnX_cyZC@Y(R!p2-K{B9$YaL>~$ z!y>}NJB{))3>(42YdDM*thr1#(Swt@A1$G~gaBWHW`rEd|#L z9?WVd`?7-*UBXvg8BlNfvO#<*J2?st%|wGFu}JUL^4ls^Ro0vD-cAky-Y5{EPp%Dw zNe0gEqZq{&%fbb4i?{0w22Lw0;%3t(7=aZGZD}h1v1Ms`Mw*=PEs+6_(>Mb^7;XRGQ&Ao!LDFkbX?Dk;>pY2uiGnOs@a%HE zaR9Ul;H;n;m9LR(ig5q3G5M!qO#bO;A^B}8esRL@`?L;2+8k!R_@h@$e*5z~wB1G6 zP~jY5?^sOckQy}tFhBcCi5ftCzyBJbOd2_u!7zTdJK^=%nZrZ=oLtydUf(DqD z3$CB6zh5k|JLK=>-l?4#zs@W|$bd677LF0={GC0e001ahoAyu?gSv2CMk4e|lL4#) z1VRBG@GG();lKb`UM^jH)Sk=KE0qaH2HB;i)&;}v zih%)(vzs(+C6x=;<$^A*N`@cQK!n7z4TObHFv^Zh3|T>EK=Sc@KfFs<1b|jhgiI?8 zP(cHyRV?Dn1wg2t14kA~FqmBY9@0)1O5m`rorYM-X+_gSM!*mc*_`id?Gv%!UFbmN zXkdh0C_vzJ1|rbH1cSz6Ks-rPT@g{H{>ZDPFRA+hEclIrL6V4xgrVvV48UHMB=!U2 z;7-HT`+Ly^>v*xe-h56Q3?sYnHLA8w5Dx(%6e580m`xKtcD1Jm~R7$~I{DvCD9ajF*j`DUl~QK~Hz@>T=FO|GychRuT(JnVFrm!K3Sg&L;CjJg#4>i*Yq#c;z+&c;J-rwOFI2^j+exr# z?T9~ji-uI>Xi)FxuiYfmup^5>BlA;b;){{X2BMW`3zjRc9H-5fLWX7%~Y zexfGgv?C0az^f?|&P0qBa@5QNqhJbr_Qj8NX$C>VP0-yPj^N4&LUYXe z=KAyO&Fc4}U!}9YDV0OyA~f%Bb^CSoC%8Wz1l+Q5A4FoAv%JxFKTPvHvD z{=XON-%hy3$8)zi~PlCx(Q z-xk-!T8?;c#Q{H31L0xQhXA3P6uACQKBPCF1CMirh)Ez$t5zI_(itIW4WW6rxlVg3 zT&{{Ge;_)ebO^~XV5=3AZ_CK)PoaY}en_7z+$W>NbKpT81aL|NDjb;?{rQhp4vfnc z0z9~mCi)QIr|LnC3HW129{w_m2t(_-2)tPS`s?h;_2#R077hR$DgZnbQ>gk@TtNSK z_OCn~?O(y3*s~XlKmGv9Rci6C_mA**OD))Y-$^a-F`EPQ*}0+ohw13Y=cpmkfw}XP z!U>oBAL>{mO)cmE{h*A8zBc9t=*#`h4$?pb8NMO5Fvo+$7>d+_b#b)>gfc^)3d-9` zd6!zyQRd1hec}$O1!$ruNONGedzQ~n?jMVV$e3qYm z7lnq@&NsxN*9HgP(82L2r5B5mj~WN^R7BNJAoo)c6jH z1RAYI!jDH+sp>HB+jYKre@S$GlUHe3%sIYAtV3?gcv(v5tSmWlh?J5gS^j#CkC4`LiV6l#R7HZ-A@2@waN;dE2&#J*^rjnrXAZvg?`$NA8F8vz5K zCo4ra-NZ%CNK!X+5{k3)+w1E>GjUlRQKE6#yOy1>jv7F$q6R`s^fMYpdl zs6|rF^Vv^nP5(5RY2{)IhXk8nxsQMZ+B}AYVA9l!5%(dd=tOyg-Caje2>e<+2ahbt zk`!aJ@v}5=$*AL~`VtV#SN#ZQi}UL=kMQbdGkcl0^Qi*;v#JjP%9;cHa_kh|s~zV< ze-wRuI5kNh=i|4XG%xxtku?*r`F%eW{S*(7$gUncrCv@niW>)uX?Ej$gx)!ty@!@7 z?$D4N&Vuz>iALjm+)PmbXB7p$FGCoY>nI%7$f3g19uIMJTFkfPok&LJ4kpu4op4&! zsXrH&ajsGF-7*cTU8WHt%c4l?=P5gr#HUwu`lF{D95@tl5@4Dp87Uz@GPJtm@r4}2 zg%J*%Rybm?kFP8i8sOlv1;1=I7hzz8V+$El`S4I0#6>kbgcI=L{F2kP`hKzTuIow& zP#olrD9wAoK!qYM3I*~D6!^H#Z@pTaE!JyLV-u$*_+BQ*4jyW>8x-5&fy1mB=}_q5 zVwz|zBZ_@+eCpN0)z5hovlQM#u<%fXC>L+mWQB|ec>lc|Vc6+k!d=uxLh&40SGz4- zzcu6^1EF-_jFqVtv?IeHng>p2PIQ+ysU7&IG(Y3R^7Iea>6^an? zLWFVHk~! zmlLG`nuTbldudRg|Y;W0H2(4w|dw(Wv1`{#9~NZSV#O&*9;7B(9HkO+`BEuaU|KI@ADO9vN1ak za|Xu3g&_AEZ%sLxk z%!n1sm%GRHN)ikF#}7{>AXr>W->~feEIvL%doh!HKw_)rgY-7vpLP_rov4_f`DG|5wj)z1zA zdB{oP)8%IQNjeF|Qx*#o0J@okOTbXGY!d#gB|Kjv!KR}ojD*zNGK|tcxZwnqh)kc1JOA`~Q4FiNa1uqZJ_-WU z3>@(48jWlstcPZu3Q-<^&DnuTraq9VpM+3jC<-nGV<%?xw~Y^I$WnM&m>Q*aePzsc-R?LhAP~5|f9vc9}(Km;zv3>tKQ3{OI_&Xc>TMkv|*Vx%T^~+6%8u z!|!X`6p{ZSimMI75sIYKth!mH3vW63*p&KYbbJBDshLTYrEu?OrGpqNGXbzxKN@M$ z{)(8_O2vT?`j^CvO^TaspHpnfxCr&bP$FoDRK28eH_!KS+lCk{`GXjiF#XqVRI zOrj(O%9)@D9mv42saF3}oY!)LZ9Eoo%&OnU!v!{NEOt`vY#&Y}R0DFXizX0JXV{|m zvVN3vXRcg z4CPXO&}=*!zppN4Z)K}bub++@Fn6N{S)v(0@FaMtf#LL12>~;4VBjT!ORmGvGty3m zy8A`*MVT6dxoyQF3kM45Y~}s>^Gvpt|16_$-mUtzJZJzzgTOS=z(X}P*mf~BjA)E1 z=&_%vonv2eE(4L-RY~Z)JJx{0IV2uQ79eBwo)V~TofJAsgn?lq0kWrq0(;U0!+A_aiDp(4mChgQpbR*0d(Om3l~m`eQzGnk~A08 zkTWaH>8U@bxwj^oL8JLl@G2!7e#Q<;p8OI60$hzAVE8b7}J9^vDTcX z$^cMB$y~oc6a?H(;bjYE2Ur2|Mvj)yht5t!9q0$%vZ8S|S zjTsA8V!s%oyW|s<8i5114URa4hl0>r)~4sWJzi}JiG(54(ts)%Pr^_GzFdRB*1MCR zxce;iFzAv!CJB;hVSCQLU2Mt&y!}LVfS7D1LlIVp1Ed-Xwj80*^kZ@=TK28G(KuC$ zEDmheHQmY0#wb!L&NMx(vj!|1MO&7;FpF4VNtyZQ3UQ7F93^q5M16ViYR%Z zdI{x3nVeJ%T^V&u8S<|T1Ip%t2%g@IQ!$I>;qWgt4ESkVDbV<}d1OkcfHuuz8zp+Z z>_FZ@5uFHbCld*?v@;fX$YCK{A;}z`GwHsP_2GV!8x7O&K&6Zpyxc|$Jd^?pxl~%P z9jANLluoI6C<2pc5j&SrIJJ%d1=f4bWGRP?yp#@AelQ9|n9+m}7%@=iD$2(Fj#i9? z7D)~x5DH0_%>-DTX@u#1T_9w|+XtCgU#t(uS85PYzZ7qksW=32%sRd^8&ozk2xWK) z(>BAHhfD+IP&N>b>_##2bRqMBC7$>sBQP$&azcUMY&8sgVhjp4;B>?2b>5L)IqM>& zlnc0HFa!_Ey3>R5Dx-iQ>Uv-nqF9pwKQ%H`%Q!T>sRmn~T*@|u+za=KER?yF-cly{ z)mn}xub!bEIrX`RBBazOOtV5c+PM#YWGw-HCW%t#&D_Vegi0Zq${XjDs zwNJO0!_L#nPoCO@3-e(3yf#ZQ*g^p|q4K#8t8VDSOQzTb&m>zM9c*dyF~|FR#&t<| zwEpw#!1c;i-;zYFKE7t8+V&;r*%)tPU17v zR>`1b$#uMctOo=b7&)pV%-K2*%E=ReDuEG38Sn*V176`gxSXXXoym_6W`C1~%1)*@ zLRVX9KcK-EYCQ0~I&ik*9y-;Vn@!9z6eH109DK@hh0-}JUN0|^6TiRRd@1&@^WBA% zDVv!nzcy}!c)yK>6AGfz4DKknodK6#jLR2iC`P92ce6mWjzi+*a&_}@_Nrh+X9x~; zH59^xGcaw;b1657g8B1o0crN2A)(MUZpS&9XdV~iw%ylZfFTnC-*GVXChNC-xU-F& z##u5S^lCC6dbwW!VaOL$GJ&oIi?f%x#^~3 zMX(JNu4VpHnS270aKmcMj3-A`xhLGjptu+g@ z>S#9Q!(@vX{A!q!%hzRv%wSm%C8bFw(T(s)iX7Vlh_`FmTk@vJbeuV`_SLN1oq%AQ z(H!(@G7x3DN2Q%Wh7dfE0s{fGQ}4?q0xfBWCFAO1^@$`bm>)xWRx@`sbd-wqe^<3(7$aXvbr^5o;{eDOi1 z8sA=Cc9M!0KZ5@*setIDq@tX`1pu2l1%rFD12j^~_H+9mj}TxG_MVq~=qGT^@2M5g zyi_2wLw#Ted6_-H!KpzMNd?c8HDN^Lod#6y;dR#L2v$>4fqI+$pKyk$Dakd;;5V7Y zg9ZZ%nP8C1J9P>UQA7+AcGrWLRWML$_7=-ZAK5a0^G8_D<;;O_RDuxt%~3Ri0?!*1 z8Y=;|v9YB{2)w{g$|&*Ru$lUZssp6hFo3f+OdqT5Rpk@P2ynnTiZrL~r}gHdn5ut- zQW;qg_|y?Y7*qj*4PU`Fq(-7mrhCk|_m7$cA;$Z%x9Im7#|eJ436dj#A#)HmIQjkO z#iw$|8$Yb#=s{dmEe}I1*+xTE0)NslrywPof1L1z@M3}0O7-}yA3Nfa_?W7qYyhgd2n!){l-o~Rg zIwzUaT+Bww-ecUU(a3tCS4~Q=Ej#IVFSy)^4sjrwCef0L=gX_5?2L7#OGeGZg5)(H z90EH@CR^)mfe5{He=!xv ztUeI9Z9s&43*}TCc$IN@zFcoUEN3$5Q@W;H!qo->RJ4FAtmwfVvk82`!U|k!ghdih z?w(U~q03M!*jXNfufVUH_2&}tv(K_F)>R%)kFuazB5v_~HH7fX;`*bmjA5wXJFEJa zv&ZK2o4h@aBoRw9F*b6~^Z)EZ32Y}8s9HBP^s#c=`^c4-AM?P7m z4vy!3K!tlUY2w3I_XQib6BgZgj@FT};Ldf`p1^(|C&4aWjl?o*Km3hnYUw5-8q0-w=%8H92yj$kV7Vs~ zB3Dm)OSSgXaM-!?JSBhe)HJkZ4F!tQW(4lkQ0RCoimsqcW<XOhohc>LQLIpbmzFQ%zoOBLyC+f*HkRIudDL_1Im6k9Y@~l(p(Tjw_n*!)ADk zg$b|EUyEdxyF2!e?_H78i!?-%H6^}&gqf#~mI5JckX?S=G+NH6jN|L=SU zJ~fI&=m%&cfxoIy=+#tCXuz>gfE%XJ;q%G_US)TY=3(PVTE8p-kJajcznVH!vt)8C z`&ag(OMm;wHc06(x7i-2RkNe86JvuN%^r1sv;qXtw1HagpS2RBoIq006TJv`rmQ# zSoX=m)DRii$TN+KRzbQsQY7oD{O0bX3f)th{h}VKqz<$=FhU<0idmb8(g9$MWL{&$ z=pN|KH#;!W5Uqj%s4T#aqYC(8+jZ=8fH&S;+ezp^ZZm`J$2fvv;dExCR9l(B9q1ckosJ#sb7eW-iMT5!L&3RsaD z9?UONJa9W@Ut#W2#)DT`G@7SY`&o{JK#c_DY%2ypu8kz4p*3tqRonWj%E8FY4N}e7 zN#aliMV}f0iq09u&X?c^$;WoF0AMv1iog&Yw{2t_7HOX!wG#?*Q$Q1DTg`;V(Mrm@ zXL#cmwJ&jY66CXuM)oCa&^8)l@|iY^P$blu0$hB~#aDcVqJTSQ9P`ktjJ8p+2#n|* z;q8~LI8Hbe!W_po3M}j$@-GEwpR6PFV4@%vUg9dNL;JjHJU+^SD(6V?ebur4e0_N# zGo;RL7SaXuiv)42b!T?|^Rr)2-`uy(C8#OxFDKHVfbFm!bTi`wX;Rn^R$JJwmpe(7 z+VmjDvPFE+wVqjNJ&F0rL|-#dyhyoObgi=+)4Uitn!WGKF$G>pVEU|Ik?|eQ*kHx(vnF97E48m&-5TW`Da} zfAbR!kARnP6a_GZT$mU71@Kw}1SlFYG`PD|Pov1107ix0(OyUBaLfK9cz+}VqzMprLJvNipAABZs8K$U3ubFQ{~jLoLY zmFwV8E#+u2(~-U-!$W2!nHGB0lnu3mcAA_js6e0=Qzj*cb!I3-lMQc|;$;4@+*)E)9;!e_uFlB<4Kq^3LoK5H!24|mT z=?31E25j-XF#!N3mx9Y?=Q@~EV}QS^2hpp^Oz3TnrJNY_GNwMbZ9v3X`oO3e+<*=n zEWZ48xw!q8!vc=G_8oXna<1hV9PZRm;IDUrqBM%^I%s2=4iO66PEdsDBN>XIlNRXm zyylO~h4-Z3a?J||M(83yON@cR(oYZgQ%a)>L2^+lC-9;R2HxfkL>6ucF`lfiu8JA! z&O%uIYKm?^0NsD``|}y4>V;a!LYAR7yGu3k?ua?JNFXxciIm&@#FPMPX5LbUJE~m z#djb=lj?*c%;<4Ci7%u~lo)IYut7=zDkuK#RPU1`zd)R&(oiZS9MNmwwt0=Xg&<1W zbf7QgfctMUWViZqd;ZA}O8N;ssGNa;rZ%dC#cmD^u*AT?<()ieO0(5zkY98fyR)L3 zXb_aFlt{jw-hN(``v;=#weQ4F4Tj(`P_EiSXw$S1{IX*qW1J{YKcwzV^qp}&E^VTf zXK>e>SBsTwrC9h*(94iu^()^Qk2=Q}#-JDxi!mrpY`j$&k)a^fa!kcnRQ-l=+6J1d zX&BFN-usi=&9d~HF0O1_MI4pH4{8vU1<;6n`A{r^)yZ;G2@%E@P!fd#M(% z12=ZZa*P1@TO|Sy)mQ*Wl?ZjGlk<(!9u~VXBIrZ53j&h$;r*I})StinDw+v)CBN!| zO2-Kz(j0ekFyMJpN{ah7Cpu~u1q?Z;ydw&M4BY(a^+L}0^WkLMEQp3eu+wCHmXr{D zZziB5zSlCPBG!2;ca!7n_Qv29&M3Hm<<+{}3JYpdXPw}YIg2n#@0fr~V**_pVPLVR zrx(L^{|qnqI%-2iA!VnE0*aZE&ajLpO9Qy>P>{ieo0+VSE_YY~Won;^8X63N4Gsnr zu?ijbgdtTg_DG>Njtnu3aySHqL^+#D7MCtOU;SFb;Bn*YsUGc7Q$3(+E{PR4-0@<=-Ji2@ z%wA!$EH&ml0yXtawzAkX4G~t8JCi|1h;z9-dP;D|u)02;~uc^$u zeY0F#7PC$9i<*IrIM^ z?wyZ{G)2lz6OhFl;UF>2n5^|00f`|JCImP@JUirhwGa(uns|%_Fy$sUZlWDfcjVwZ z>c~C}A1KemHxZTNjaI0w^ zm`oKHs&_2I!LZXpHx-4T6jNa6ovy)mWEk4sbKV_K3RdxcgOu;RMEiwJv^xNtO^Dkl z1N{`x|CQrOqW>e~NpC-{E*BSaF5Ab|Vs?7Jx5w<;xE<8UEH)TbJJ~ku<8oQ-_u|tIP~8j&-)K8gCmgsmim=FxCUmH2 za`M&P{D<$$?&IL0nM58rp9Pkq3L`cGL$Ls@Du0(WC98#Zyc21CD zj4&xjjuPE<8*vyqn@3=T1em{mlM$w?0tQg8hJjY1LNRd&T7BzeI`jf7)WN&bL>sjX zV4lLuAetElJmf_4Ys|GxPb33duN_xx?X)YpXoxE9VmBDNNf%nyk>M>*TzS2|_R4^d znMpVlN+OhTwvTG7UiBZZE>?@H#q90kych2N_~t3vbLdo`b7fiTRSz?$fWY>6*ZD1- z;zY-FfI zWpyyh6z{qg7~c~KFRMctRVG*_-R*9)RCCT4?YbVdZJtNn4l~Ah*?VIv;79d|wA_Zt zsELvpGWc;j*2P1H1S*|kUAfd=WS#ibhJsb-OrN@6oGr*P4~_hZmvdXCUZbEXkO?M= zA2z!KUMx4iHg`j6r^AjU!GRCaPr$cda?B|*4I7O@Ha4;`5ifj`<9EI_4 zR6(IY5a85G=Hy?=5}xJfGNki!>R5f1Z5Pr7B=C?Sfy*kCVeBy-iK7$0EtDHuz(>41 zl%zll7%2{e6Q@#-#*LsH}6;1aOPlY5)XW8+KA3pk#Q2sK(&|(2N_( z2xzC;%jEbjRZ+uSd}PAPmDruk%C~5ttJcqMR$mrZ>)+)ZHOCD6sP^h;Xagc7#105N zWI(9@{1bpsNV20z9j>Yt(57S~K{(Nrsun1lQ;Wx&Z(<@`EPC#@dvvD_ zTL^7BS_mE$V;O2O=0ZwFxG^{~EW40wWp&IS=8klskR1l4Lsh0#$;Qza* zY628S8c@6%j?4=-8gl4H<0*W~2biVvWO|wq2@w^*Qc3_+ zrwvcn5@oOCKpNy8VKUDVo~;!Er7*sPAQN|LsZ`UTmB{@LC|YC9$XQJ{XQ6bV%wML( zmq*>juuxlvhKxuqWwS}yl2+G%S+tENs9lD`VIG`k8wi%1v4pzO$( z?L>_!7)sO(s&s!rZqDnwjQsdCt6%k;MI>lhe?}Zp^qXbP3{b?V%85oy!cZT@B8bM* z^|{1UzgwqPO2E*BH7D@?>^=Wq94WMrbH79!@zUBhG9~tmr;-H3e)SMW1lNJWr#L$V zm(&MpXHW{=zWS9+%f0##SAYV$8VoYThT%f`g%B2*~|6S`NF3hu*h03ofip{)lsY(1z=;{R=k=l6Z7LE=RmUm2%Lzvf!juk z2m>qM%tXK3Ud(=3{`#wPrfsj`PzZaiw7GC+6nZNc_~Oh3BBeaQodiJe7`SC26|Qnb z!L=KYWrU^Zo&l7jMA*q3G6Zb7$vH-DU<)OrRL$;)AwsQE&oB&|Vc=B>gABCb0Bi3r z92HQ7)WeNS)rFmKp!HG~6p^V0;f#SVpdRa0nZj2z2pJYDO*7zCuKugFOlA6GEkp7= zvB?<&9;}&wzqZ{3?uQc5QjQ1)f-&u z45>JI3Q*v^H5BTe(2V;+(HmT%++|v{^(kgG_)*hY_Xd_w{!x(*=^dzIC;)Qn2+1h0 z)RW!y;Dyy&18Nm%d}Aj*#Hm6Vh+rH2aTNKKAwj9o{0=oU(+Ei5&KMu?l0Dp2FOJ_G ziQu`jW$-GiL}vsVLRT{aziqp1+^HFnC4!APoe|0Ml@V_601Wh$=yr|8Q_D$&W+ZP;x-Hhgg)cEft4uGyoA2hNbdN)f^U)#3zu(CIUOz4V_ycrV{QB!g zIzSgUE7<{06zhk-zkh_k=ix=BG@Wb{Xf($c{R$osD2=RXl7$Z)Yv$Fog&a4w7w{aP zmJ=FDE>%bs%b^qG;Plu}Xykb^jg*shR4(YH4KVUQQgfrSDNaD0ObJg$SMZ>gbr_{} z2Mi-9(3(5b_>La<1w8v4@^}=+)3P=2Dyzc#kGGpkSp>Wa=TfkARbVw2&yi=GHT zm1>2c0k5yIP#ypajiZ_hF=iXbC!Kkn>NEyzh^_*+Q&8OvpU95PiI><2tvckA*w;SO zu_Ejl0pw~VGAnd)>hx^uVR7E4qXePNl!#E^c7h^wn1gl72~@|K2ll>_6YSywV83h$ z;MF=2W+%0=VB4|Bd{3R|?x0CC%214~jSonW3a!MGBPgHJeyEAY{+NVM%EBY_6k zLov(jA}c0emw}*(saoPrqC*I%vqbPJTZX9R`RvEV?~Bd)YK3=MKQ7*tJgQt82>5aG zr`=o=prt@UE;X~*lMctFSZduNI)pc)5G@0@6BHq??(#v-ZWF^eJHM5)3mg)D-X7~; zO+5%IfkKX{1YWWSA4(5O2Q)RZ4zraq5>$&!3Z4o4WWDx7%!q($t=x$a0K^EPz5)$6 zg2FZr+DkVBCxS$PfkugV@D8irk_c|IBL`7(p zGPz^+=Jvyf-bwCHpS{6%hcN#k0+|%$my-yAax=*1@+2c9S~1xsYHh~ptW*D*rx*_? zT8K-K-5jaoV;|x^%sOSAhJzmu{XuThSTU@`zgsi|j-+uV7r~(tNtN+EQ>5|Tz);27 zDz!G?BMUy=b)OvhDG#<#3-42@8fuSL{H>PhUDsp$ZE-V`88F3m6>}HJq16l$eAo~P zfgCDp5a4;^fwn!0Oih^%L7LNIeZ^UslnVm{2W3D@ek6?!5iMk*8Qja6%re@4CiBd{ zExkqhot_DRinNob&{2$s3=2GDSZJCDER-0NgW6K02`xo>H#T&`S>loPnFok84zS1f zYF#2Xw1YTgISvF|CSj1vJ9Q8r9{PF3Fx)9){@sKZP2vJsIT}u8gw5WRi;UY4;HPF2 zp&QKEgo8j^A3QKQ94vaT#TR^CiwA?JQ)R$&$s)R|Q1Fn0;r+q81KINX%FimsBQ+0D zzcvVE>}Ka@nc5-#N-hKF%*I% z-~%-Z_-Pfw8Y{B24R+t|2|KbG6(*7R(iD>jTmXE{+>TqgKKorVeiy7b$4MnnWpttt zI>#LhsCy*}8p2H`!`+VyIShe3s$hWvuChEnmNj~t*}KK{=iBSh_krKkmO*-`LWV5Y zfq|bI800Ur+&!a)Q>^2JO&b!Zq*;eU zBFvD(oiXbGJbPp{y(yy#$zWh@iRcd`qDqbt&n_`>Sa$r9rAQlR8>m!G2jZc05ZfpN zd5zg6l;@u>%wBE2Z+j0m1?7KvdANU~p z0o{#`6HsiNJ)EBSsc9U(P={IM5Pl&Nn%Hs(t-7^0L-mwJpmydIPB=-}$a9UF`ISg* zPpS36vm@d-`1;Ob=5mdN%Op?(=Pk#&Izj-MMFB11>_N7J#L-f5)~xRkr4dw7bcmkt z0b>QekXV5NQyy9LJu-?Ssmck({z#xU>MOurhlCt0wfV4`J-=Mvo`3u#^~G%+R>F4^ zS>&=-$dF#)%{3VKtAa7Y4a!?*3~2~0xL(t;YH*FLD{MoD+tgR!yD66J&PgIH*>UQT zd~X&qs_Jm?bM?>y1_Y{;Y^LlB#9PN)#eS^FyjQQOWB?Gm`HJ8$X%VeHpGTJxK+PUq zEI#`v3UH2+Ay@`pUt_?M(lT&=4|myHTfo;jE+o>_aYN`B&M;6cG8cYYe3KK`K7WxN z$cs!Hja$1+{Mg747Fo2(kgdYy7KTZ78>tqZuBYyqDe6G-d(wl7hVOWYNk)c)R~Zi3 z)k^lho4uFay?p1e-%1C+NDd{#5juz4a3~1iGPC9Big|qMmu|W(*e6J4=!1d$HTz(g zWt_=^)^cH*?}BkMK~!vdTHi+SgYV@%(h#!Bgmywr)63vSLDpuX@$5p*?YlbvRB{51 zX%^ye;HBaaM%)2(EfpY&`VD6xsvo&?cFb?2O;IBZG(9I3DHl=WfT}0A5qe@!q9zQF zW!oIt_koAeeF?ii0RB-hf)fQ@YB2EEJ4F=bYDHq(8ax@vw}KC)TDE#4-pKgs>>si{ ziuWEswH8fp8l?vXS;kN>9t_TJ$6l#&NRgnndZoxJr2{@>bO=U~0pL|u%Cu?f+iI~p z9yAnKb&W3Z*X%mVY|FBnYUJd_nrDH^ifI|l)}fhdhSZCn|Bi|biO)lTn)03r4|elFqGl&K zQ$*0#36U_wi>6aX1VnUDbM|hz@`o&U_P_H?DTNAeH8Ai{<-$k681r4n<>{fcF)9^d z&eX^`fg*w135g)stUm=C54jBR-9k1?pPel}N7vQ%<4&}9^5fY|U^^Y97{g)+g2NFB zffEr5+)hw*V}2CLL$SV)PzJl4m2-=o6Q^3MaO1~jBf*K|PHiGue+Y(RGPw)6M8ajl zs+@xzwf)y&5DV75MTl3+uX3WytIPGb!Zh%aS|~tG10i%Bw?R;o2M7wsR1k7A@0A4~ zhRIPVj_O0Oil0`WXFQm`>_7*r41_il!e9cPubGfR(5og0+r)C-Ie&aNGK8@N{HUpu zuU9wcA9;ex>cfX}a~3pUO$gM;2oW-2M+iJ*TKRpjxbJs{%yLPN_2m+`O(Wuzm<$LC z=rls4VfA75?BnGcW@cSwjux!H3Is1L^();5-d@v!E%#^ij_}19hPFNgdB^|&B?o}+ zf%rlW)+u%zz*D1^5yn&65U|1S1VIr~qFpScBvDcuh!SHL-L2^Furk z>d_N`J>*$)4qdbpEhs{JdJbO)D34n@&tG_vsI;jYf0AvgSTxCg+$;7gu+jZlVZGVUi&7cY)Lq91(&KeE; zRaHT8nW_rI97GMCx{mT7%{x{s5U-|KIwV*b3zW!V@kBd}UoZX@^pSC^5e2`l1u|ru zz-tVOJ#(xOO)DEf%D{{0DsVf25u(X#8id6W13SYm zurj_l6M})angs3`7sB8>Yu`#L{w6{7C)osb_Uz&-wi0&&i7$@wAtYGaU;u!3hJje_ z&WA1xBu4g^uVe~_>}DoYbe^v_7llaTi!}`R>lBg9Y|yKzffQR=rGYQl9fB~Zn3({3 zcNX#UAFzjbnid|fYwv8KN~~NSQw<|MU0hx+@9eDj;;c;v$+c_keOMo8i61t@H}38KiyZDH zI}Mi0Mj18M+;og3%>L95u+q;8h0Wr^RQ7qiSxP8VGwXS} zl&zb8!&=78^0PdF=giHvxq&(xH=dv&`!L53Ho)$GrXR&4P7^N~|w0W-pgZ$$|W-!YH+& z06=QV{C+4zLa4gt2(mae|=p4qmJ;J`~Flwnq+O(z)XV zzK}Q}mv`zN8-U`FGc}W{NJRS~6mBOZLJCSLX!Vi3UEE&I-bydSb+Hry+%TF@4K$#{ z2aF{ls>Yp~7TGrRYO*+{$(nKeKzon}^NA4@ZYLnZ%smpJ1;p7(r>n_nD6&YUh@kK~ z0|P%#HiJv;L=VG_cxVg^XCru2VyU4fOb>c%w|Wygl_0}AA{yR6g2&7T!mFHZ$#$61 zjsE2JGfuDdUbEO8F@phq85kkB#vKC#mu4br`v|V_;Z8I;21XiFRc4T0G!cBmxy}9@ z{Friq!6ulv%24QOYmYa}+al${Cr3#U!)gZvTHS!q>i-EqpgsHA127JlT27JIN+rm!arOMBEkujiZKv5<5!#M74ak{B|V?msd+X zXQXgQ@KQ+;+-MsKH3?`0?(ZR%WlsdPmtq-6F&K~<2O7*c5l_;>51WD2qf2a!@M?wO zCeYO4&aEO5aBw04u&TIfPaIOWf(is}jX3Ni5OGp##(-DZVZ0Q9{5JdBYFTmtu-9Bb zO}1JE%2#1P8c!dJPZJFk0|GfQww#9`0;Ow`fwAT5^{3_aC%+q{0|Gxad2mJ{9-~~j zH6(e}pxc|}*V#YUvPbXBtL~WFn}5Cp6^A*6r(k2s{&pR5<0@DaDS&3pF{d$6r8HC1 z2C=ruu4zDBQy=B8yZz8lt9!toYdE6~l%Kr+K-cD~iLz8`qvenr-e5kQnV|LsvgV0{ zcykJ69r%Z%tG7_yTB^0W5GV%bZBlOY-bWAT>e!g{xT%FfrAA!Wad2H-!G6Bn$jD0L zuvnh~I)HfDjP+6V8W0wltWbVT_Fbi7yS`&Wy^HfY>UIkSxq7v}l@%&KZ@ganT^h)Z zYCs`GbpXg`M7slUe-HOPhzBi$CPs1K>$+S3^HN9`dIPdz2QJ9Wp$%qA$d)dj3J2~| zV8Cd)!AmuZow|&(PN;!Q=fhp54aMb3tUJ2`0w1u``TLLS%~d%jkJ_4eI=|)U(6Fu5CGh)Fw}Rg}9DpkPxMX2fy%Oo;%-v(43NDLZ`MUi~Hkjf?5YM1Vx>sgz|$fSYZL^0@@~;B@XiC!{G^M|UDsfI`mIzPgcpzhs$sA(nVo zO$=uoVe}Psu93(xVQc^>`o~NR^^ol$=)3KH)&&8jbz;d~jGwH3LwM`hfTwB<@K@7H z5r{IVOQGAJIhL>tt5i-##}eG^uGuSDaGbf68;Rlw&uYj||< zuO^1NN*D>-w2em8O8wCw0S70gp-_4z_KCz*8fZJU z6oQi>dHhYz#*leBa>lf?6TkBpDr$B@lhI%*WEv==p@G^MH`s*gI^>TX(Tr&5j~p7E zoQu!xWGY92A1GlHjMr%;*Lq#fXYyEDFh4VQv-qD8W6#Q;f?`;I#?tq z3q{*fb>i@$ z_6TYw#Fchl$}pMb(S)6nql>1O%WB|y$HSof+kIpjZ1E1hL155R~$Eh9Cw!a(V5jg+l?C6&aKv6XL0|$ArFzQ1I1uzJtj54g5Hn4lWgn&_RTU zYExl>RWaoL9?U5HhRZYPd@?hJPNpiXjImTE1}!E-@m@Aol?`@f|0AJ>vl4#PSV6a; z@s#r*A*{rEYbaRYZT-n(E;Jnn5XTw<5`2ZCfIDU$^N?j^Lf|1s2%F6%UKFQD6dRnh zM;XWtvyO7R8v?f{5JP)*dZYyFJ9SBfIj9uO)&TAM_2-#P zRR1ieE_=PAz2i;!x~vru3fxX+5<*QH2ce+B zWM;hM!i6&&K<%M$sh6V$L20TcK3xOBrlVBs3B`(|PWiXS#n zz_JZFaz;kp9137S?Kkj_whMJA;Icvif84``rr|X88)Ve($!F-J%K)G-&TXht{zEni zTY7uIQ#AzmYa0T*zqSYb)s&J~Q;CobUNPYNS{Mvor-~xFdr%XRtP781zNd82ITir$ zQ3#|rCgh)*>s6ym&t*Z(QpUS){cSUym^r+uw4-T2-kc3*_{DGfp;&Wr3`^H2^%f zc_$`^M#AIK?SJvIQBG>jrjqjD#1@~MU1pW$`F{7$oq+DJI9P$_5o^O^P1QXeHZ{x*ldqx}?g6h`R0+3X}6_}>6Y@^7~ue4?Ae&1d~ z64XWG>~gvMBFoOgNh8i&P$4rHM~$6wVvF{{4TYr%2J~B;J*%pMn@ymcF_GgMzAg(# zc6*gOi!;_yGv!544x2ynd3E#A`7{^iIvb&cSeV;Sflx>j4z2$GQ6T1FWeJ?5$f?f1Fa4VBHWq|Mu?WjCordBegF>75Pk>@)sfaxUC{a@?UM;!*>67(Ud1Nlv0Oy?-m9^{Z&k~zs$Lx>Gh4-YWhVcUMneQMjgG`iZz|V_M z*v0eD9E18TEa^BM9fNwjMhnlLEH7_*!%vTYJ_7@C;&B9oQsS}e@Dn7}Yy#0=3Ntek zj-6Gg6X|!D>7&_so;>g;GM#4cd90WD$p;S(ol5YSlSbZw!m3#?Xib|#vEtU?cqBDA zQxI$M(X<1#t>a3q4XnYXUS=3W$upHZ!FG3F$q;Pk7pYR>w%J5n&Ol9IuuT`5)j=bO z$EzZ)-9-7?BmY zZD1UR{-VqZ(Ag>FQ*6}SI**3X)(wTq-rf zq(=t@o;N6L<|pcp2lnuwJI{LTFAEJ&WFsLcSuO1J)3*y*MeZ|>PB1}O%uGTw;lMz% zCoqV>9k58rWsD|vw~@FLPPP%ElCjX8aL#01hnzd%_Z;nvNO~|z^~5J?UqXL(m;Uv# ze?sj7&_)YMqtxrk%4845h)!20={%rDhAZ zJFmucqMX~6MKgd9MH9D8C+1TIozP_^d#@Hk;rYP&Z;P}Y6o4)TSaMl)(%?~%jKN9d zdURro-rAN4c!aU1%nB67v4ShVX1^>i$}R3)H;p3(e%p>MP_mjBceajRY_UHO_+>K# z)3Xm2*e`0UfjAucJ(-RbxV%e@-B_Kd~WPv-WCdnL+F^m z>&Ifv{k&+zfp3|JL+Gr^IPfZa4jqn^-igh{Cpieyal*}Az;8@6d8uwxuqe||&HAdr zDC{^O4oY@9oxNGgP>Z~*nvD47r#JX}&Ia!xEKAwoKEqI;jHwl)BPHgsYZ1E~^y*-6 z*xHw>DxYtc!%%acqhb@+ftBxNPg#??G0r+v1@DbR9pPgsA!OZCG>1~Aa1M1!!o(QH z7<~<=)LGn*1~VMA!gy9=-e%;FW)Kx`_9h<{N7V43`Ke)loKOSpw44}MnV7okrR;+m zCf+$(I%pg+VF5FMtxc4I!hnWN*Pc-0>`?KbAi4F3!|u{5S0qf!PWwy!V-|!eHB&;a z@j+@V6RnB>&$%$_lsa@LSs}JT&1)By@le)Jr-rR!(qPxk)CK>XX^>uO7Pyo0pO6fq z_zDC05m@o_|MPM!d&1yV^+tyd1gBLY;>VpD1f>G(Lp}Or5Ykevm=zOUmj|ZdDa8SS zV8S5`JK=|l10HhLfnC?JkJ{yG@!8L!=;Xu>iMaCvs#@CzQ2Y)7UNNi2buFVj+es0+ zOYoznZMlQ45im6o4gDoBz8Z?GntQV1=z*WY-R~aAa${~oij#N| z+XF2x?#^5~knbr8Nv%V+g0!-CgGRX_#HscBaE^I@6pT2U?6k z(T)8B6tdmkSJ8_n>vb`CTdJ0VF4SKgse>ZK{@b8X-I(k{QV&SWpb_~sswHu z5P=RThgt@&vS!M@gTG>a&&^GFvNbTR34tFQ5YoLI5}=Jx>hjywZUb>g@9)9g%RlIC z{}1{19)9@W|MtIUKm6B9M)Us1Os@WYt(QNX9R7B=m>KSCp4O?j){o;; zKOFZUD}-$|ke^I(nE6qZMLAKXUnrMpB~2qu1H|*z@bD+e0`Ng=`D4nW8Phdd%4c5= z2FQoO!16NX!2Lb?)^{DK4+@FznnlD}fUI?E+S|MJx7iCxy^2mE-?5Hg8ZM}f!4d`; z+M%VkJC$LK4a3rCWrJp{xrvXD@2OvQOw*@MydDj%WvqcKDne?ra8JaB2e(3$}cy_&3)yY7}myc7o1)nJGjDCnXv zpkbZ6c)66BU9(pO1f7lM$d2|{3%+a^06xP&ErOhoKki{0y&hD2&UuRt1c3=CSd$5_ zHPMhL>dVTfpJ>fdB7__q7}rr$HVoj`0U-{|Dsq|brQ77le=DGjZWC2bga~VVG8(+f zezUi^0%$ynMo7lnGQpOMJv92qoNPoi6vB+gN!crbFHP;RiW?AS&E!>vw-Y(Krh+0lwcxq2 zzsUSQn4I;}w247LR4jsC0<{{2tQC8rP!7Xs-61_BS4N?&6>$WP)ov~OdMxWN-md?@ z+vQDfDAF;(VGt57+^O|aYmP$ihe2*(4X^nYQeiI;@FNSPaFuNWAjoQR9;obyfF`UJ z!hx_85m?l_3`&<;nTeoi3@VbrvUpNTZ{`qZ!lDWa1R=>lyp!2*a+cNCBKdB^fL~fX zRjv0K!ue{D<;lm@`Qn3|<9&O1*$MGq{D>wPLi~p?#}wi3Ji^l9BmQh1AsXj4wJFNA zn(_ej!Ew1A4sVl{7T@J3AKcR^H`*eM#I#9@2p=^xUb1C0z-PsceuxKCe2->NnH>ia zjLB7e53gG5l3F5cl5S@D^nf%aMokiBS6@Y*Z_}lt?#ux2+L`1_*&J*3dU5VgT=263 zNWW@UKrl$OOpO37NDWf?uoDRsx7@VdWy*@k@L)7c+)iF93@6YSTX{~})8MD|=3-Gq zbgmZ!l{JnyiUg01Pt=Gg!T$tKsA&vX9HbThY7Zb_f+F;Spa#v@HXSR5xx~epls?91 z{VQ?=m(_+sn|X`NiUOfD%GE5xeD*6)AM`3eSHeMhCp zFx~u7?wkeOYe!BA(TFZ2K5c5?TU+DWeW{^tJyRnM@~fr5jylXhSxIKfy>lcCYOo@zTZg#$2d`Tqbn0&bp+XQBIN>AOcOVR>Egf< z`m@iQWv3S%Kdf~#coH;EZ5b>qJqar?-Iv}e#*Z5XX9Q4M#{_IFID5PJSJ_VnP8ktU zj}%_u()vV7acD!J6-UdB1XN>0NJQ6gB5Ngim5IPtC<$;U8ABL*MMavz@O*iN6|z^K zdZW+|0un+Y*vWgcq-23!P1eWK7D%cINlq66l*X|@7By`?$XPwhjf_GAPD^+3*fv2Z z#}6!s{}YD~PVR+uJP${Q51#Vac?lPPUt$-mc4F}~9?ZgBUOJft8lkz99A`k85`g=u zXE2lC#Ib;??gtNsTu!@-+41FP>Kyw+IUZ&z=-jYu4q+p?BYa40qR1@R7jE7GrAJn0B8YY;Ih)N=7`00`rXED4s6GOU_;_WQS%y`rZKpwMbx;t^yyZp-^K8t|CHlFr3S)7NVRQ zT74KaQg=bnC#0V-XrN8By2V6Mma}IvZ>jJXs6kB%yd+soi39G`T0tMD`KR39BX&wL zQS21M=iDelX4Tf<39Zl!B7c(2|F37-Gu90sXcg6jzA(zx=7cssIHByA>^pn8h4!Im z-jrjlV3mnQHwPy-ayZSN;zu8DS8@iT^PYaR(c!?$31O7>#Q+Drnv6rQS0->`B*zLp zGno=7k&7dqE@j)+-{g>*kDKLZAr0=@kTgD4+Xvoc_7PHW2=kausHIHCqTGzssUJ>QNWO8Wrb7lpucpg{ z?ZTyQRJCDXSGJ3w68M;zMI2ViVBjG~iNAl9H8Z*UMuP$`?e&0a2-mtpB=1_D2+yCJIeJDTlPLrd-$qiN@Jg8V5B zET@p6Hq9)M`-~YS@$=LxraBE0jc({LZ0p(10*{Z1h1%TjO_j=yY0T|%YMZ5MyKt$C zlCw+$$w$Vy%>0tSzK60K3-O475AS6T`)G883DvC)QzJQAlJc|Zw+=!otiQ@NJ9$vd zzh?GCYO0~;2h)j#3W4)laYOOU&0wCLQ}-M=_-W0|&^yHb`x*|K5=C39*wm?*6{8w{ zZ^1)5p4ieJ6wMgHtBgk1Q2X0kpjggQ(_oX#J1*0}cF!?>edjFDcrsLD%!i#E7wZ&M zslc{KjMTHJ!~kR|oC$+X1fZ1A)ZtW znEP&daa^X5C4-n`Bzi~Mwj*6fiZIfIqSd6xZiJ0E9f?6(83(hMkx0cGY!5Lb5L^)&=+vl!~q)?KilIo;_u>&`{q35YnS4nJz9 zJse_+Co#Gl5al-afqI!-h6t}s1uFeE?=hwiy$+Jy5C|)nvNDhq&K^4FlWt{0um^mg zRtA=pAgEAR|3Th>}D@Sv}o z?l4oVXz{fofcFvUj75JvTU?+(09rw%>cg9bbQ;1;EEn@fJ2`dWrS&6+0VlM4%?xei zz>H`fxkY<^bFQp6ICAo}J2fI6nHp5i>^gptU0&ogr`TiWx2;C`Yi5KlGsg@(Z_LO+ zCGMMCpe$Z4#{6fm%Z!+2Vq{3wNO0SXB=#Hv!)6%q=<@f))$GwlxmMoA5%{IyfZCXV zgiUYo<(e1SLfC}UEu;*t31%y#97LzminuXxCIkV=gy2Ml)$IA@`u65HMA3k%=v{e=M%n z-hH}slg(evd5y^yURpzt4Ps9S${l7h6{t1Y9->I%c1I+$QIHi`9UdrCyA zVc;um!@x(z(7^qU%NTU7<3W34O?+iWWMpt5s6^K|&XyN4>1pg-4D)PTe9biLICKe+kO~0mpEXP7j>rnT=H|do!5ueIxwd4X z6^#;j$iTo`?$nE1_7d4J6U-hh=JVn7pmJdZ3{s$#{|w^`ZCcSCj3e=!tvs-;_mmzG5`!cT#&zlOMvg0;y;=RM*wcYq6V{;~n%Kw@ zzyRR2H&Y4R-TYPzA%mDMiSC@cJ4DtvxM6?svkxF&ug!9zM673}J>@h5$G@h2Vx* zPd4jo&ji%9W`aW?47lM=jQ|VEI0ES*sS92172@EP3 zc>?0@5Ol-I0Kw0Hz#e{*gl}r?%Pi+F8eW=*wLHI$4lkXd3-n4>W31M*voE)u{Oat{ z8E_u*t2swzQi4^^;({Ht$CwZtnJmI+Q^y$KRu6g1RH$tUF=oPN{FI%OvRjBRB^UPG zC4d=&zh z>D?oR;}}V!;;pPg_HdE)UpF@&mtVb6aL+XZhwf2($WS$dCiI>=N}$E6WRr)o?%^u$ z7hT4jKd2M9R3^Jo6KQA(u$w5-yE<&pd>bTU z+1u7J7C6oA7%CfGqT$do^s0*mZYM0lywi*YuX6MtV=CBl7ss04lnYqU(gp_Upv=Hu zjTs|-r_M?&tpXeh%w#i3=f4^pStw8y7fANU9^>Jc3?W-q!u9c75&pG2)7g)i=y^5u_Kk(G6!79d>&h2j=cluI*;L+u88}`)7>gd}KA9u*Rz(>R3FUdMHQW|(y+uNVtfs#27Ean>SI?%=uH4`gX zw?+Mj6cvqToD-*+xmn0@vY~qZL5dEJ?-!doXqP!POAR(ZdHe}Im+GI_7jY9ZD5cM6^Y^(YpF%AW4OsB{A{zlXORH-Vii@J@c3=SZZSRt1h%#5VP*&KC=7wyq) z^ij?kVaq8Z%ptOJACwEcKrKV$sM~)E*c>8HF27wYXHPfFe_a;4I{1DA{KVMe5}?qD zjApCZp@soQDDNi=`0=TqKBM_{D;pflOdXjcN8I0n0H}SGP`v(j{&8{HoH~NS8#x>p zPQ}CMqf3p^wiP!3V<*s!+`#vI$5Hnn7N%5=8|C(K_@Z$m2L33ax^`5^aYF)OhF(&a(werHh{sw3L6grfEx8^ z{lv%dfh|S{GQx*31kxCD9Bbq292HJZ{6?crCL#*iHt-5Z1wo;a0s2vS8iR@^O++)m z(0_)9YLNgW)}zWRiiGk$&sWbeySWj4AiKxjEHm{d!*j&5igx2}Y1t-7j7*33%Z&^= zA_ggK0zaq~0)Mp_C%6y1wnjpE;2fyCENjs5rDePexYcp&1VWsO%&NCKik>VkFEArv z$594SL-`OoN7{T~VQCl2jHc6wI?1{^A3C4wyd1R+dLR0YAd{I^RbSD(JLrUOIpg?g zCHq>$4fNpo>UhFI@s|Ytsvi3cH+7RAnnpGViT7npM&>Zd;48jn@g~}ER3WAMWz3)A zdI|V><6azlN+ClIppGU4lGklVHumXjQu*8FSj+{bJ6_qL|fiYzsf(I8=2{>!A)|u23P{9vrUG%z_AsWE z0SSPq3K5Lrse}*j*3yF<51jF4;S_=vVpxPU%drAKFfi~vRR}idbh%8e9n&m2YUeo) z9?pFaT`}0UI~uZs;FYX*{8o4ln0ZYLqM}fQ@mJJ2g%cTxY#(~nRETX_dAAfJ3^Jh{ zO~3K<_Cj{>m*Ykj_YF>0{gPmZ1b%9q(E1PFe>x|6O2HRr18F;q zd0+#6)I{O^`m-E8^IDEbE_P{$3Dg)kHiX;)cj{y_W1v?}HjMd;k_j}k-Tg(kgOXt6 z{NmM82AJgh0zbHfM`~-pUsLE%isUv9jMV>6wT3Y2%$n0#puo;$zFcCO%IkCVMJ?L4 zz{+a~<#4Eyten!+<0>Clmy3(#rOYc|%uerj$5g({2|RFf#z^=ovr5K<))O?LO+ato zMS5J!AbQ~3IAqid_Ng7?Y=`SLe$y}`F)I*?Lz!8o&KQDi5v3T==~^&z9K;&vDGUJ0@iPT8 zj~AP8?g|q{Gga!7QWS4WrW$tlbeMnwhKa`Zz;6VSF|E3Pe5AK^02CEaI8?TBnwXq@ z71|vK(ar%4%IVNZyFWeoxLlSe3ZU$@ZlMGQM!*7}sC7HjL&Ll#J;ty&wk2yC&-B-} z#po`Z#}ECJn$XG)3|W7Q&9dLicEB?K(rK5Udx;k(BoGRh5B`_&Y@T zc#m@vI?5VPqe4(r`%BV6v)-K$$fod}MS-u&qCj0yUBn#=qC(VwJL({KmGvMkeEz3& zg?w;+5|7mw;IGDlD#m~70{K64Fy$z$+_@MXOnJP%mSsD$C(Fy5)j1boRNEpv{y8q& zK{Y3ir0^KcI;i%k1+xH6`PDk|DD%NEsX%AuQ1{%Z;>mqKSLs2P#kg!I#!kH7$}R8; z%PkmR+um?KJc6yHeh!2S*6`z7!{KGM9%^&|x1fwPThV0ipTI^ z1Oc~GZqdzsgET(H0X(hE5jbpNmO)9VQi~8WxXc32S0Td~ErzMIN(+T?sOQ0vEo`@l znsGTrlG#d@hzJO7CqTl)V|+q+!K*A3xzz@C`7^jDR3oMsf zC@cegA}es)SP?fy$gBupq%NWtl5Ke`z<^O+gqdq-r&>1HdUr`LdO-w==hBOa1a2D= zyU$vaQ%34TS6rG!->G5&I89B%&@14raZn+=L$+Clli55_CWk{ilsF8QfzmXS&7T-f zo~_P5%A^b*OgI#rWw>Bsr+_M>0Q~kDW-E3j2h>w$DTQ7sl-?XDuCh@6O(x~1wSCSc z0J>R(!+@8~5jJqJW&(*zi%>Ks=U0b!!5}QoKoJxIUS$ZFYrkB{L>fFXwp7Q}Ke$cc zJ63;Ew;e~2#+||DUZ&00Wsljmgwy|_=*i-n)K$}@z&mV z3I#B3(q&tG&#EUGBJtEC`KeOl$E!G90&@%oRb+6I&Skn?mUDyL@n{ymWB~f3-Es8+ z6Pwn+mh^aVWqz0_gz3g^64w}aSE zvUXsg`Aw|C+!#=x7HpQ7=Ao`@vcu}G%UA!Md68zNYgb6Niyz{q&$y+g5wPHq)UwL< za<$85$9*K6i8xkdB$OYMktmZK)dg6b3U~%01-%LcU`nxU=odtZnm}+nn?@foZPC<& z)mH-{J(@jZZB76b?Hk;a6XnSXQvF$RSjpTs-3^jIr`+6{wBjuv2KOs(?a& zXRFwq58c?V!l5&FuFVLi4`IF-;4+_qPniGAjMx*2UVzKjWj2hY{qYn<{8B|Cm_~D2 zDLjlBh9d<2YJ>Yhlsqs-FztyAHy@Fm6x8tav4g_Wwwu<%WZsosLGA5!cSk`*^!^z=qhl}~iaTq(1l`bQP>gbu4 zvY_DirEKP{b4sewlc$ef0pwvB%KRQIIb~NnZhFSPd~1E^W(uUUCfXT0v;k8E7xAQ% zbK2eH$A^AR)+y{zJAQbckB_HMANZNH$B;Ail|^zj&k-btebQQY*4&yMKTSQrD6f(J zK3$^m=Nhf#CuTVtz;6r%yy{Lvsb%1pt4|zvlEWB6qm5Jz@Q%V7dPlRnK0s76VS`KS z{|cQSppj7mDqvt}i~!&i77{{LB4^uK*sT{xAIOCH4zbg&ePO*L+S_=b(upd&OeW3T zP*a)gBT849xj~#WHxByQRp=B$4VvL}=NN80Z#F|avHpmR!)`e@xlCs{0>ri`au{w? zhpF~4L}VF_%&%%bQj8^OAMAr5FxhWDU2c}Lam!*;o@d$#CLJ$A?BF!RnTZk}MaM6v z`^|%+)1pHPFJT`cUzd>>nUNH>JVQB^7XgToL%9*h*W5tel4g`P;;_J_Nk+y(Nix|+ zN?K$aq49YvtZ!XO;it47cB2XMBeUYsWt?>0$+_{nHV7zH9Y|$Q`kg`G>oN#qrqN{t zTF5z(=3(`K-MByks7|1n4Tip5I4)$pbatTxnczNBMy=T7$(ef*C4TA7pluV}(;p{JM^^!gw=YT#JQP+X3J% zhn62B#ho(GZvPyKk+t&gUu8Mx<>FUYeH6Ur0xD@Xu@e>kwCYdL%HBvL%H~YsHMRqs z{j`wmtl$B@R0Dw@XCTT1RFl1GjP36?i;wdDKmGv9Rr2@u_mA-RA^AH6n^W$$>&O}x zi5Lk{ZZk;Tj#!5d*x9{X&!9TGfu#pW<%S$=TZ*-LNSg-@6o;Yme1%pVcTAAt7QT$!T63b9 zDmyUVg2cbfWuk2FL27{LLs1VqU7P@87h!jUvt zY;pdnqy*k&l%Qc$$zDJLAE;v%HX(%pmbOoFQydcMCXz-IC|w%mQg_$$<~mK%in~8zGv-oiR!%B+blbThiMLW`Vuy8*3{>jNLLLh)8zUvf4tD z-K*mc@Url)QOTgeL~=NBE+tJK@wD*&wgC|zK{@q1)JS-CM614D}_=W z3>Z<0XdkSvTbGiinrKIeO2j~_j7Gff94qDNf=`k6CWF6TwclO z;_S`shY!7t?w&q-gBBQ)%=r4H)sKlrkhG;vKUUpj5P^!dH|I-QoN&U> z(LBpFxafx%+h(9Ha^UUsG&A*d#vV}+acdBH6g&gaZAMS;58fTjp59*h9xoKVj-;Id zgt!T48V~Rt;{mfF(!g(S7io~)d}my-R0Fqz_HH;a--9;y@0H8@O${{q|sgcO~uqP5}SMa?8g&+@rQ6b<}&M|*keB;q5>vBjH z7GFn>4uX(t!;oqS@Vw5#fZ^xRk&&Q*WF%5n^~>V&Q=yk_D2R&6Wne`c zifkAzdZ3-}IDD4oRj6Um4Yi;c0+328V-HM5B3Oq`M7fk@tA1G)-Cb=RsO?sP0Msdt zA`u{Md*aZWz^mkN;ggNBDGtCZrBy*CP=lsW%Epf}sar-=Wv@ejDx+WU0O-tVppu3} zh$L{wj02z>5?cR3?#fFR^)%wPP+X;%0Q{a|D!K-W>GJ3Y!%-$`oKi^)L zJ#%f%bXbI70sz!ls3F_|i!z>~?zF69L^4B2HDVpNGRJXQ?rOgU_ zck4XXZP|7?s)`S3jzO3+Guqj900O^hI#Hgc^z3)(s&&aWo~}ir1fk3_W&Z@krxsjX zEk1Ko^&i{`OH&Tgy$9l^jBn?0MHk`X_hz7O#ojR)r6x)^ooEkht1Q%~G`p^ka>3fe z%+0xqc$Tb0V$1kY6gAY|q*A}z-<(x9>`|c<*YjE#cr=>vp*Xc^q7-+UR9a4o>UNs< z9ao%FnoX0^omHxTKu%kwP_?%2!i(#0Cfla-T@@WtD;gb?Ik}NTbf+c><I35(mHIm>mkp!1bm70JAE8q-+H82$P-cY$=mS~J-b_1cC z^#wxokI(h#j>Ew*qCdchGMYqaP|OeQCOrEzGN0v*>*K*W#^#c75zy)%{Dc7bmj z8~U*=zE#C^Y9W(Rm=~L0=17LNll@hY2fkoajKV{;*T_hyJDg03 za=<{lm}nS*6EUL0Z6igTOA8ZiLeW20x=jn>(#-uF7(gHe5^||76twB2!P{uj-4t~< zT7=%AObcFBe&gxlYdAu9j)tsF#9 z*N}P2X$D^xx1W|WXIL7$y%Xf? zAH!Nk?&;RaI|1fqd3}4S^YLZf<>Fd9Cm;dIcLKc>Pi1L1R$5Rc&68${dyr4bZY zIr8l?(|DjfKz%tj=()|~enbqW*8gCLA_s~Wen-Y1py10^|_t)#IbLl(v zYcQCon{9v&<}&amLnycmJd~Irmno3IpA{3O$Yk%?JA@ML<`@y9D%{?R28!ea6LZaH zXRA-2d$ZR-NCN^tH6Z38<#3Ux8gL5z$at}Vfo4wzBA1nY;C+J2K#N?F zP8UsYnx`u0@Sb)+5yMOTsENfBIUfGQ?8REP+b@uSjn{6J3~Bbz-~$b*V5LC|B?y&5 z*yYghm5JyB!~Nl?d+nqkxEj*PH%HLGYZ4kkGcqsmHit&{q%GHZ zh4-3%P9=s?9xbU?(_Lz@Q6_oeDd==p@lUub^-zqnRaRu50q|qUX8ib zJFO4sszk62_GCVn)J9h0D3i*3C?KPH<77;?>VbzJC2|Z z_>KAvyvNyt9!2oC)$;Pf`wd5eJ7B<)GOp6AsTkyVTo+NX;^5Ry5QKjH3_&2l%cV?v zpPhX!C%@zIQ8SP{yc~NRQoU;UQI=D0)~g$FM>rLrodiC8_8u*nr<)dokL7ezl&zTq zG72;|orC>H7d&rV=8njE{GziAty|NRwyJSm5GmX-VxUHe7;>o*?w*NH8OM-*n)onI zbd2bBphhh4!)Aob$z`t=tIxkKi$I1adewUEpom+!K;R7vJXLut5_>mx;P-yzPMQ9& zGehyv5HFJ>jq55oUJf)2I& z%8H>?oGjh*qGw&JKZFCB7}?D!65w@0A}rKEL7P78r}a{%XMbL7JPsgq%?iB3B&2U3 zsJoFu&0=slZBmSdF?Z`u4qlwGY-=I3E__|c!Kq#(P!EHE^{xV$uo4=tubH6j4+vcD zr}W6V-xvhlU9Sjkp9;8bREXn{nF=(Ioc7642v@6RYY$nNSS^^Shw&kp1zy|$Ln{t6 zP=<~p9Ydp32!#NzBg}m;aC<8ldJyAEM|`tJ0v2jW%!6s5&NUP)`u7X&2&YC9 z@;MjZ_V;?)dE*jv2FMhLfUr!16YS|$WJr5cGl#)Sw$HVj^6 zF4)0B@75Qe7ajz>s|EpVYs+Mt3ncFyxS$5ZAYZFJDDE}@g15x4)kmO6&RahDD8nx@ z=J@-nIG3|sef%}qLfH#~JGCkNUs!ztk(*x~#QDdslIw6!6^pgo^>@u*jj~xT^Jk8* zot8`a?$1X@*xoF^&g2Lf=?<6Xl|eCSp=!gJH$T0>-(7Nr7%z>mmB|$<-%PF;Sy|)b zp%gKymRKNvO#`zQKe=oVhk7^Up>cDK(FHDXX4<8o$rD*;@#|Vyke~{KLSYCxM zn;IU6c_}$w3ZC)j&875;uCeLe`dCLF+^9+!<#1SQFhR_(Co;A)O*bc@#EP!`tpyA9&G;~CB?i)lF{i1H@mDcCL zNK3vH43M!CHc=s48v#7J{B^mxnY}CzlVYY{drGEQ8ZHDNaA(X;0MvJkAET9|#KTD8 za0p37#sMXAF7xdYo5;8wqH$YQ1a&hkz_!{%LIjD2YAg_vt8ngVA?0LvcX|so$djVC zd?(I;M#Y*2qCLej&{%es`_2adX-M$W#@9k#(Y6o#K%v-=7CDX9F%-U~HE=MvA>{?? zo9rWmQfM=U0%$s3yvOMjk2mYDK8{2S*4E*1C<7_Hvt|UosW9l(bT4w^Pb@|4wEIQz z7`k6FTnYnjCm2GnLxv&vkaUEtsAjnd-c;iNNMlg!X&mJMiuw!)aDZYMd{ZP)$%I7k zrud-}f>x4)ODuN$b~$Uz@^ny;3L0zR8y0E=1yY@|c1G zTMZzEnqUZFJS_`jsK4x?BxluJE_dl@z)y3gU5=-Ti&=lV{B~6hry=9}=X&#L_VTKG zKE#`UzAQ4nhlo27+v)>w5TA5gFu#c$qnOdalJd{FV)Ak{4aggqTpIiu9A zR;p^>&u@Y<(J|2`gNx$ek?du3^L4ZO@bLyf95;)QZ+3xw5;TPZ^|j#TC zW^VT+v+M>?I!uddyKaoYWH#k1u9?;B+NlaEo=MGx})mOKBk~h#a`cS}t2WuDrVTvV6uhFIg-lDxAEcf(KB6-Ca<|`nB+QyLt`K-~Q zJDU~-c3nZ(URh?KY_7WdZSTYeJXEtmE5E-kWP6V|@XgyyB8Ve?qihHmygrwnVwrd$ zt5al0xMhh%n-F-H5u%z!n39{na)9k{bb#&c$JOQHVtM)H<7zQGy)Q#;(2#13?d^*n z@%KB9u|Y_T3hj(*bn}!ntIDDWRnpA&lX;PF(eY}+6&Mja#c*3qWAYfA%eW3vqvR79 zNcS=>{HQjFtPAvP({*8hhn+y#MeM8#aeyrwMQ{_Z7rL*}laI@#u6j(9JAr{oBtC1= zB&ue}1W(}zfv;83lje=nu_(Jo=R}lT0QN53I!HSxSc;LU@IxG3L)Ds*bvmr{@nZ9- zoTA0Gj|K-ZP{)bVB##mB0BB>>VDS|WbE1y_DSFm8O8L~dt+TDOdF;%OxVSO%BZ%ft zx0kEi>)Er7Y#v!8pe~qlc#tU?Tn9MtUV{S<89mSvcNtDO=4AFUZphNF+m4+XN z-gA^gQ6L@}1$G_3yT!0Pyhu_DaG=Hkjo!uqgsXAT+N0p)^mMVR5No#7WN1FmP#xfy-)uP5+p4t<3697Jis?gtVZs zO$f8Qi*wM}F1S2fUMwz`5?^kX_E;Onw+WHi+}aNAfB zXYXaXGYP7*J6UN@2+#K;H9c%=(@z6+B~%WgI!NIk22rT`VX(mNPy12 zDF`S?0wI_NZZ#$1$)%i7F?+ZEHHsyEQS$+RHIWDjIPTOaG))7K`VJ~q!K^~>W%pU0 zc{LG*&`F1PD+s*GOwdlcIHk8OlXRd%msB~p;)D8XfaS-li`C+4F?+i>??wARzIh5P zT(pl0PaR<4KJ?ZU_`Ru=o{`3W(<4TyZAuPu+X?rNPyJ*7H>HlBEn+;|GR(X<6iwM# zhWjX@whG^noRnX$#NJX4gd3l4^7m~ zhl6)!p)t#)9CI$@qPCy*Zk5tJt z(%1S!vH9kVMD$&_JrxR0J$|(=!+gBRa6nrpgTbZQOShv8KQ*1ePpfD~S(2lfG085C zLo2_t%!l?RauYgl8}1e4X_NpZ(#R#tOW)mWcocN@mu9%j7-e@=n(A z|5NvEyKx-LmhbZwjg0~3VQ>hMY>L#p>1NB8WDBCs_Sp}EL0fE#ebi!WnxthJIR8Gm zRzy}rMrIbfnzr{Iz=q4L>Z;0BD^^_cHa|S|)}}|jU)6Y;1=pQ zaAZ1>_6|tHBxdhc*NAoT)a+F7lToDzlIgGj5fux5MY<5G-G0O zfcsKBVj5_U6ffxTkZBrkQq)nT!+w}08mi2|^HncGPZMri>!vwWzIhvsF};`<3qY9z z2|z^I#OaQWpfybolA_(z(UN8^T`sm4B^q!@wRqBEL_9->ESg=L37#xwBCt&MroGjl zD8R-F;wg;4nW;EPfAs7vmWp4morSbBVzNU}2$do{yru+SmIfktOhv&y^&ip6U~Is9 zIlDN&xz!#gKf$xD5%{TEMM#A2f3! zC`MKQ;FIGg27YA!oaw-HMLa3CpML~K>WFLJ&}87??14;h5-I48VKdhtn~~|XB{o|> zHtw8b1Lp!xSnN>VTqBJ0YeL}76autb5s+5n+CAGpKP{#$NuzN;dS2K3oO?*~@ex%C z=iLG4R0E3@WVOs67FXqpRzN_3p$n+SSjWnsL&9;ve4~(JstOF9$)bZ$XCZ=k$sx}) z!K{#oOF^Jz&8R7@9{Xl>_5Ne1h5`KAFQQ>8hhc^e-m&%wc&hltJ%Q-X+akn{65Xjv z$K9dE_;yYhzh9)jgWFG^FVhN<)Q=oJ;?-+ubjA`QX}nqug>gb>vrQ(&!^1=89^7gv z(LBmYeRzE}kDUkdr9j~(ZRwbn-(Gnryl^l$5c|OMl@%dca;yN_DimZfm6FWfLnu!R zB!mkP3i8cZ5$yw~6^ghaJWh#y;BJl@hb-q?`XJ<+64a@cRM4~)=B<8(GCpZ{KVsNjRv7UF`3e)#BUArf&9 zEON>us%fl{qd_%8Ny^#BVd!BqEO=z@L*}PEzeq!uilx3dx^@(aAe+Ewj1~Nh(^+x9 zPNh&kCl6YaGdPbgtrU%5(%A;CR}Ap_btoD15*O7N0GWH$qe{yVWdON&W3voOYMoMb zM{NbGU|;KtG-@lA_kACu1A%rRN=ZD1c-j{y+aTbt_X43TH{hivOi~F8(6i+&Wzc?< z)UmiKlj}P{NKA-bDU9K(UX*V)>x(oM=KN-HvrN-yx7*dGGj!_P^PliZU67AYpM(5e zXRG+m6#QO27agD``qWx6P5De#COsGyY?8qtqHHEW^GAM=?ITld?t1F0Vy7AsYoLz@ zi32M;Q{YF%dzA}-{KokOz_A~u!~n{vg2t=ey(S) zZ`Y|{>ODH}%{r0}bHMh58{U-xMg0`wm=`HWpvu@y)(Zn1Mlitxr58{h|gTp z06)DmuDa7EirA_@{gqgWK;k{KJ%oaC7YBARV&lHB^tDq5G_v-b)uM1eEza1aGdw`Cg^bc_OpXpz0p)~ui|CTQQKdX!U!;KvN z?d0f}qs8G#>{pqO_N$y@$Y>fodVc$Pxjo;cbpj}V)ufg4=Z^uR%e>$nI++)~ZF6Nf zCNRncSW%9#O%qO>LJCD(<~3Np7=&EveCA=XGMp)c2HkdLSwv-GCY&fUFDDN8zPUVD zR7%NvF@YmouYTc}8la+jjZfwKSkPXD0gY4`q&>LSrJuO}t^+GWL0wA6!~I+gH8O;) zTN}YUdmpj+G)vPp(jwDkeaHn3Xj+|h_0_>afxC!0>nbySn z$L6*et;G^);8#-73FYWz^h2$VL6^khhiCO4$w?o>McXuV>7iFIur#7GHQ1+9Ckwp zw8IJI(=_ZmxeJVY?shGp0m=t7Kv4*MXrmx)N7MI1!9oKqSOUP^VFdLEJAaP>UcTCZr`65J zZ}S)QuIgud zlez_vea_ycJrLKkC+o%U8oXEO-kTra;=^0I$J{!nd*x_4yh=0MJ94fHx~}SUDA5~u zIAzij?%+q^pXe|-G0szJKFN73dNq*y;OwCyP&2B;S32 zqtRYA2LgVhAmC6Xn!a|AkpA$IvrU-^#`bF&#M? z-b^_@af+R`@sO_zPSD%7;TR09*O}5;--uwF11D@%HE7L`qe2s1YJ!IGis&&7P#4>b+9gMh!gvpI~4`Bmt;n<*k2rrYDEvBQx)r=}d=vZ^60Zg(VO^2cs zdwP%(2wEC}5J(39VR5i%CQfU76MNV2c7gM>6U&GLPG=l~J{S%_)iFY5IMx}DhXOxV=Rs7&dHl;nyF{|` zo?Yh|i10Km75OF2PfA(e)za5NaGlzO1AvGBUjPs$GP2q9mpn2{_$EzwPI1&GZL_t# zDF$NT!hb#j=1XPDb9$)>NpBYgFxlCGjzNF2Oha@)DD{-PKv3p7Ij2F#*#Ay9%DrfR zWRKdTFjMJdyhm;Eew$XfPb>X#XB2Y0%CF8JKSi@Gzj}ahpq*a_&TAW5_cni{dE;|8Q`6RxG*={chw}GE0dj!49{aV6o-O zd)zt4&3GSm11F;i7Mfmr1!)c&eh(1(o7nRH<{S>n(R(Z;t8<8}LeLb51CVk?@phSp zpI{xI<*ipn?rT*G1F;fm3~>|A)NvEP+I{+v$^j^@RL(nhp}^rYC&qZe8kicP$L>SJlm{Z`iieDz)u*SJ!^kBfL7|aaZF&*c%RGWa*L4OqVC4JD^>S78rQm_1D5MeZWn6te zM6p#j!mG`7T4dnEa-DW@N+aVE>pHV_UR6OZL@EclyUy03*Kc@n85jh+oYIRx=zWx1 zPRpl>^UJXF!hf1_qRKIRWh=_%=a48D4q%9Koj!9mOwRCeeWoIZJt(cO(X!5%F}$S; zw%Mm}v{@e=)9d4h#k_nmO*#N!=^*+CXSx=aSm_}el;gTkET(Z1gJ7mlmltU}m6ZDa zh8h4~OYvd%g))?g=!iN4C(OyfjceI9G-Qv%wxL>z+s=G))TX`PXsGyc#z$VaPW(y@ zAY=w4ltWCn0BWgQ|Mxc8QC$)0EO$0_)mLsB(9ug3(F@J(GjuVze!@d$AGwcw3WsWtF(wkS`pkC2b!xO;DPE`cqkEX9|W{lK>*_S0-+52c{_2W zxUqpSCKQ1VXo4U?Vps;02NphEeDGNcG3*}aeZwZ1_W-hhhmnYzX8G984w*d z?CLpQrR8lF7-ySSZP;EEi@@PQN(ekXM;bU3970DluCH+rTiD-o*oPKBIuVHeC^EdR zbD`XqjMH?SO*ks>`?oru%YfHKwSQ(Uc@b*K4@Yask1<~7W-)uQ_#&G_RE6Zn?_QzV zR!C;tkYns}pbn5|7m{5G)k%Vz5Pw4QiZTi@+_a3r@+F)S12RW(QVg*jTlwmAF0rU+ zB*S{~6y>xGd|Y)C2yb$T?IR}kr{yvbUN|$KNpCO220*nT;IE>LQuA#4hr8V6!w1E1 z9kT|V8*g}>&3#nKKsJY!K_H?0O@Vy2N%7MvMV5_S*$8Vb4^#?~hfpbMqr&PIV+g#( z9x|EN1l7TnBp4lr6iW<`)BdiO-LfH(F^A#CSbEQS*p>+gMI4y{zKtixdOktg)0> z1Tf$`w*`am-=5lOS`x}dyq(dZ4ME&2!KgstGziibb<4C(0M-NWR)L48KH#tpAA&yM zqA?7F5tD7AS4qm8}Vw1t%k14?b+Ojr8XzR1TM!39I9R5uu8!BJ;$~- zl?w*DA9`AK;4kh;zrnlTWgKye27c6Zp9F$DFDAtgLOW5nZ&0ZmC1hE{Z}A?XE=FiyNWId$a^ajo@+(1Aae+5PVxklX5hb5aLWjHxqAVWY`G;{6_SEM+O0RXL!QN^3EJ^(P-4CvdGcY)m z^e#-UZO1M51|oNtiHnkN504jE5W_c|&T&iVH(>J_w*X5Qx4c;{w(GQT;Pqva=rV3$ z_N+9)@9Tg*sC1ha{CIa2%*SYvzqTg33;^h`Jfm;|Jgx9=MVPG?SZ=OX|y$B9?Vl=`A$%~{3~ZZsOy z1kJ=f6%72eDuVF6+gR+bnFd3!jHnULmBy7S*!Y$Qd4{DT*J(-gFCWWVh@Y3?Yy&M) z+X%#PSm63fCGf}T#Zqgdk^*<3|De?wCxT1>G^IowUT9bVFh>bl{`yIpAzaK^0^@5^ zI3Pmii-wL`NIE|qh@r|MIFMNrGT&epct?>+9+}TbLl9<9H)(l-g%=4tt%d+URW9sQ z9K`jK`{EPq0YR^SQ7mK#C5$tom5vLc8^Nf+BZGnKU%yLhWEL|!aibar{8V8G0VdAW zOu%371A{2XADZ#u`#M9&z07H8hH}^eUVRjRD(T}8&Gpx-9eNfI|Lwtk>%PUF#naKA z#kBUuuS+fl@O1I(Vx88nYNwn}Up)uXF6D&ciUwXGa|MTzXoc*;)nvee zY$54T3`9n|HnWQuPvX(uKEm2>M0i^45D~$r)0zy9oWn><`J|PE)3ULCR-Yf-iJvMM zco7974DQ6Isy&7d=>#`$mpwdZZ`m^<*4K&juuP4RWZ+Y^bFJ;-B88K;X|0UyjmHA4 zu6+kl(dtYHB5+Evz-uZoXw;Hvs8RqH)eqzN5Gsgr%B6Pt;k?+t6C9j6&^1h2p@mR0 z@O2$CI6(iW<+WdzzF0>yU0xSw!mv)IEJe}h{R z#Owoc<(o|!mvNKUeFZ?`TAWzm2Z{p^n^hTHUrQ%nm7E}-+c=C#XNiINQQp`v7@!m! z@Gv!xevSdS9UGpl(sYg2tE;qJ<}Yc*OrL$?Yu3Vv->X(k%ro}G!ns?9n7qsWi3SjC zCK@l7tDDQ&tD=+9AwUX>2ZR zHxc2TO}Qfyjv8^S42(vMgGc7VUT?0`e3cpsG*tk5+6ra zP}tY?toeW!P(L2x+;#$FNC4SRY&V8P zw?8&O5lsW9RW*-7K8O#|G>ue6{<1>haO203fr7P0pg9Uezgz|kt4wfDyC{J$N{DO@ zs!A+{4mgt`2zd`RfjSAC935USu5QyNZcjFTa$nmhD43#>As2Q=fkQ=rugvgPG@_Xc zk5QqQ{RJlMZWL@gQ6L_sk!h9VR2aCux`@FoNIq&5ArW>+;A`Z7DjiByKrm?{F+}N| zdQlFNq)tM|Lx~{0oJ540S$ec`;xH7`%`9*W$BD;RH<##hiz`0)en0eC_^Y77SD)@Natj3sl52O55wyW5!6TzY+A3j-3DXe-XB%ipo%;3F0Z*tHfj{mc zlVyiIUaC2!av)XZFoHlB4uK5Vi23#H_VcALir|{sEQp5)MDP{3z9xb+9bQu?(KL%O zff%YK^qRcg?nLN@)`Y@{z~Kl#{*RZNwBj#bMoR#Ar@Hntc0nm)(Iz?RvU!)$$R7#xvM~H=`<@^gb0Ld zf3HvBIOqbKO$2ykX3^Qi(=X?OMk+Keb_mkY4kHZ-nOoDYK-^7;Q$L5xO?ejg>F_v{ z3xyBhV9vlpy%a=h#*&?_JUvzLTg3z4Lz%Kug2DHtfymKhsXRXOo3y*drzPPsBt~`` z3W`acY(-OJdwCuq0#e;{{J>uokFfF+K&vgq2}U}Dbmw& zh}|8FP1P_<>1^ZK8TSb@Ycm69Y9y#^_bDRx@(g?(H;C&XM;rnK+L+_Y?n*aJAR60v zwmIQ6BaGR>tJO%{n-eFe-bNry&6ui_aRuwZ&qXLG8AgZp9(^$DI-GE35%-;HV_>=| zN0W7;?0dxX1p|U>Sw^%AM~7I6z>7A4Xm8-@2XN6As%m}PG2%0a5I;D_qMKd8tIS#&6N_NT8oQnB!Idg zA(%|ohkK=5-PjV%a2TN1HEqtfxk_tK-FuhMGAX#d}yEw9pi>e&ysA3pRt8lOE6GngJAV4U312mw+yg2=fF zV(yBwi8PK=wHku3!KyUvW3=X%gnQs;FdaUi_DgL{EYa*y_ zb5A4Mo`YBNPMs6}o|Tyu!CvCm)+cjT(zMA|nPW4RCj%fx_YWUQXNv@J#ZncaForh~ z2*507oR8Pb-)7IRKBQgoE}e1uF+*sj`YcDwxHN;q0$3_17;-S4m7~d69H05og)#<- zWT5u#qSZU^Bg!!{kJpQBxorj>R2wKhigF~RIL1dPQra5HBb?+)G`%%0s|`8uJK4E#>b0!>vALOld;uOQ%} ziVVttsUVc|*$f2U&Ok6e2?{u^pt)Btv_0J7>(WoZhM?3|(FdYk7{c{p z6>LMh^I)iYDGXVCTy7U(+Uv z&T#@BN^H5oM7xYUxfpc)e!KtvpyOJ=1vzXQy50y zbmpsQ(jd{b-&lorGAbNAJS;X=fr}D#DAEg>x%y7pL!PgK|54(@2D16PPku}_R13NW z8~uEhyIdxr-NO<>w-TXjbt}c_!P@_~dC2|EQJ{5B5mHs~DlMt;`u)@GqUdsVH8I>* z!2x9IC_-HjPpB!O5YX9E%BDNb?iMrD8OMgwRd6V#`igldnbTP^uI7>XiWiHI%jKuE zQ2ydSZ@(04h92Q*wMwGZipOCXrQ-lW%hg827=Q=Zvj;hjwd+j#9N9m0zkG`}(dt-w zy}Egywx&-}#42sPQ}_(OS0P%LZO7o~$JtFZoL(qThWK$TqUw#(0r)Q6>QDQPgV$&t z1cR^`HMm3HGOZ^&HHHY@6UJ1>5YlGQ0*~E;7QHPzc{^t$xg$>EDZrHDscxw(*vR8F zO#UimpNlj<(vM@jrG4po0@|9B`OW+4;9S)0~NWs^=tFQ5{uWf{HN?yp()S8_LDwA>EfbK(%O3@X&z!{}NFpDk| zo+WXZeUs+yc!9uuY7dIPW)E8Svf<3XQscYhIq{pesR8h_w-``nn3~Zs z>q|R!4n0Y3G4|Q36ti{~CwTQZEPnm~vYwN@ou{oK7gr|2;&Zk~ze*W8mP6{0IPku& z7Pmg=%)$KB_aB@A7#RYgQ}pf1vm>AFan_v3Qkm^RV>R2OCg;v1yqKa7PoEPSehKwK zOlj1Vt89-WC2E6|_S_?&pC3!JG@v(!#00^GZfA;=s4^f|Ri2092U;o!z_U1IdcF9N zb{DFp$#*8vCkrzPlRy*3-J{Vp6!Pf-g>(b$k?TG3LxQ-_l8}K;++mTOxL|cksJ?*@Uu<_q#P1* zXylOkm>Eaeo5BDz`|QxuNKUlUJz3c3r_J`J9DI&OtKp!PYB-=k_S+${#}8_Dm|Wm4 zd!#tMk#oGAabqNsjXjMZxJm_%967L+%-hAMp9}p4`n7&LD>)2FuOkIWl!Y@LN}q}= z0VpQJ2enr83dX%9@$o(`jHYhV35O z2)!zJtr`hjFT{|esd2rf#SCr;=kBq6+)xJZASeJ%XB;xO^GVvM?&Ic5xo9LFSzCz1 zA>_T#q8bN&w0qR)0)L~0>$Jx275Nfw`HN+knWT&NQ$M=f1aH9841UDt5$FcYN|BQk4kXKhAZzO za=99cH&-c~kM<-uJHV53t=J5KqP|D?&>Ng1HeopSmqZBB171%62-fgox&67d(o?4v z=AbzYJqeBx03b6W9SR{_vJv@U&Q86iTwv{->qI0Cwyl?uB(osmpezkC_RsNDw@?aD zolbI*h*z7d58h|uOV^$Pzij(VoT(L3ngvJ64>_F}y;zEjGZ;GlGUOX(6l8}f}edmz5{}57!1Q#B!0rnC==q& zgm}58$CP@&`OWI{;%f723L+dM{Ja!GP(@K8_rgVEjNt1}XGB&2u?)0Q({LUQ7GxGy zrCxEuGhRgC2();bhVXryy-eK)n-AVN94{OaJd`LZL=QMqBVoL7;k78KISvwAHA2n} zEj;LMHpM$TVw8O;P>?JU-9k}7;-|&ew1n#H-Rk;cvGyyca8u`6C-AD-p_DcP?$uZb z0?-LTr5RCLxFk*#u=;}eTz8!lW|(9WHwQ-!(Q7;Dj%9=8I>mf?i6yw-#LfcTCF3_%`hnNo}LbASKxiHj|OFJ9-WPj7gH|c2?_$ot5g9liR2TWEV8}$wwP0SNMKtf zfC09>0n3`^@Y z#}#A!ENOy;uboCP%tiwk-(9a3m$P@tAQrwBaCh<(N@RFIty82jk#MF>euhNoN#fUQeWRw>H3uh;2YqpbgC}tx3 zXiCKx7P(R`GJ)?n5sElJ!AOBOc2Hnq{rYef+qaR>!;e4(Z|aHpZC zi%*|_E;AiGua*bgMlB-L0h~oN*?>Pz2SJR5>c|^N-59rWOvpghVbuSUC4V-;U)(`M zNgSC#rtBuI^t`y-Z2c@Ye74$E;wCwSimP2|4F6a5AN)Mpf8aVbW@(cB=hR`=&MaO% zehR3E%;JzyYfde8?M6VPtA@a0txAFnB4Ow>AF+kOqI+TWnIEHZX5Lcr6-S7?Ih7EC z%WH|N=nhiBYYnjhnxP*aQjj|m@Id|Yb9S~Xg|4Aaeo6wfh*}WD0&p>-;OW)DlOyRK z5oL6FMU17-PGre^X+N5yp0XcGQzXqIWWkna+vOL~BKI`|0R@I&NYq4!sTNk&!*EgU zC7BPA4J65QQ8+j$nBah*19n6>>n(BB-$n%Q?4%(r%Ydvr{pUXyse-n5-i3vUM5c;JfxfoD~MXAMJSarUZBUsJ3BOVi{00Y-@XKI;oJokvZ6+u z3GdLrZ&fPpjmGieF&n8iV&Max=g}yg2Clm^nxy|Q8%eX*(k2O5E%WlKER6X%jZl`X zAUG65>31jKdIbYilq^e*CTCf>jRJ-kMkPq_1M7|H1m&eVwJ- zdc>bovvmniyV1i_ALw%3QSn}7pl_dqoBR!dKK`!QLkn}&2Y*)Z$43l7*=st|f+W6` zaAvYP<@`nH=oT*B-8lPe+Tt5I>r7ppFwHbss2FBTplX?N(1iRSXKE}g)(2J{)4a=T zmBnHUW1`o})w3$?IqoiK3qTzh&o5H{+tvGzX*RYq(ZjX}$K%_fjKcyCQ0p*W2r83l zF@IR>gl4e}u{Ez1CfWk99NUIrQ*3@KmXZALhoszoK*Ze(9fwc`R;8o>CJKaD1yn+! zyU9T87}K@A_i@00DoqT6WndNf7q=;#OG{mK;yK`#RRf3Ow8A)JeC^sY7<^GBgcp-R z=k;QW|Ipg`omo&lFL*cs*(8@dWJ+!~31RdRda-Cyc;atNQ z-fvpPv_C8ars|ZEi`bkmILX+N0$d;U8X>p^z%>x0uz1jPzT-7$-JQ{6WdtEifZptE z8xaRU*({%P&#f1!aGXYH`^ByRmjZ#u*CG*sXfs0ead`9TCBtEr7nab?V+bS`NM*pp zHei$LF%CnQGigAz#4Q{lUZ&2Jud{E{Q2bSy^5JH+PT)Q&m;G7@Kv9_>m+vE&y@6u^ zi4mFT4iy5d4vBBmwp%wT*SWgbE`Luw3(h=TAmMZZZBr~l_Sw!@H(4P@ z0g~}{CYiJ_VFb?Px=^oE1=lzj-Y$N@G@Zv67l9DCt|kQjsvuMuk7hN0X1~fsn3wT> zv|r`*YW-z#o0h3b8&cuU|YGc==J^5tz{iLlj_mc_D_Hj5Q>iyNaj$$WE65g>+@M zdKNlfG(;14dNaUGOTw)_%wBBL#+BYk_&h}dK-RnnS!f#x6VMS88KuREcOhh}RMG=2 zqGI55Hju7*;+-8YFihiXD$p#qMODJ@_lx!@6g(8)(vP(PUG}NzP+Y3G$;nYwcghNF z&&0Ezk;k1~yB6{`C0<`=Pqxe3a?~$A;wUMCR)BS5TA=~~OVPuD|0AT3Q(@2!e{UeP zts?fU;73iXcy@b{Ml&V^7Wgl2rm+ToQ40i!)b^yf{$B}!;4HcTFp_w^`M50Sez%*C zzfNgBt`}1vb=!_}ga8A>wSbM=?JkX>KgA&6kyT?PA@$us09YZCsfasJ4sh%pSc z*R2LWKl9s7pHb@hJs8OQVqv*QAZJ{(;(YT~ED7g0pG{Zn@ebK3v2#Vk{9UJDqq&NL zl}hEPsmu`ryrQ2#SJsT(IAg{`CQJwY!Bb(pwGk75IzJ`F^CzpVUv-WNQLW7ka0Qw$ z9>OsKZBZ;-j6Xt%G25J<`eAg+04TgV??K@YPS1SOSFGh4I#dWitA_q^`D@y2`t|!4 z<;==sG_E#M{59)T7-I`MsZQgn3XKtFjDgV|Qb+n2D`NP9(;B|aLw^EZubKS4-Ef)8 zH)-pPau*R0sb&Tqk--Q73`n40I5UyJ9$!+9b}|zok$v;-T1RM>Q;G-(PG>;6J`5kx z*@=$7Zj7G-pGFZ0HA5g+dvW|##8Zx%fQ+z1PVE)Pgj5I5Z^kj_i%+vOE8+d}$}j4J z%WLbvr&2&I}A#!a;dv--V8$^>D+J2b6=I|RNghfRSywN0RzStQG`$87+l*~3?xZWAR5@KO^Z z+n@^8e!Q#`#&5REi!?0-?!xE%xT=N#cTosZ@uQ4vC4T)Y>*g1ub@Qi}tM`i!n^ZMl zuiN4D(-+^tfLu5YXV(d*(ezYIysk7 zs3^c&Xm+=!W0;@$&F47mO00m{fCu2w1DUd*eeSTA93_M_&wK-qOc7t}@Z#^&;K79- zId|gh0c}!vTtpqB1lG)IQKS*y)!TfRb2ywIyKsROBr=f*n{zlg(>3x05WK76(I2pd zPv^uz*0FiI!LThnQj@QC7eXlxz6$|oYAlQ!Al$us-VYgx5(qrcGh^p^IU;*84!oQL z;(79tv!}P)WjUad6B|ZlGOiHm%mkEDGZEW>N$pt=oF96baI;kKJP$=qO@$M9ZstUA z7-Ry|EL`NEc$$`cU#F=E*z~d}hj}o_g=(~MShfWK)U@EoyURp`|I){X+xYA|f9?GW zLZMdPg#kV9zoyN{(#Z2giXMt7->`CJg#!ZbnWeOhA8@?_f$NnN{B#6DS~xX;G8ti7 zAxr?rh_KU%444XMdIROeQFpLX-~^X{f4bTJzPj>b`0$`n>j?b@xL$DpB$aW9Vob&% zw@(N`v7t;5R>Ogu5)5!AW6({xgG8V{JUdTQl}au+ze)m#QSeYoF~KMt2DnHuz@hk2 z@gS2i82Y8j1(QnN&M>f`yCOpzxrSE~tqf$~5&&-&zm-FC@W@dvggg_s9}@>bWGW8M zZ}JAa^B`2Ato1<9$s-4=J=t!)`0xQ&k2byzn&C!Tv_z)5a?s;dE zrGBA24!1Wb&_rjKoF8@mIc?Ff>CH2CNZ`kcMA+r4tViTZD4&XuojO}j)a9qbJm3?l$Y*!yHeJ#*$3jp#fEgTqqX9Zl;S>f~O-1!X;t$h~+A&Y1k%;LT^5_qm4A*M1JiTe+|@6SO% zW1LjH+olrv>|GjdS!BI_KZXFGnlpX^Kr+cQmzYwV9oNzU?gEbN=`|WEYU2c6I?2 zo7n|B<&^@sNF_n0pE8c}lX`_2Hg@#j=;VQ9a#8`J!TT{Nr@m(VNJ1zQD~8yo4~i|O zaHBgi49LuoVYuWThpGV#L{tfnM>7m)NNotx9K0{Zy=@4CL3fs4I4L$rabr*f4GSpy zRpO9km@wcLP94*ny)^Jb`;f{B=lF7}4EVVMga#@;p=^%tQvgaG9b(2&!I$U?lhyiUxj~ zJxMy0xN2X?cv$qPNc*A5ff*sX#C18!4mN@x3KBeWHu5#?GPUMn!k^2csUL2R#?_J$ zA}c(8M{3}Hi6v(2gDQwqWjmcy9Zs`CLC@5Z&|y4o9cTtTj2U=qXDHue@3Gsfi(fbE zLO=0?ni<4J>?AM)XKFBTmwV;pSrnycMc>qlxZ7doVMsX)1iWnl0?p&u;!DWK!RJvF zLLvPw6a5A7^S3@O>$k zeBXA6_>+I?>ObFmyCE~_bkzbXb*cY+J;t1g9S zX|?7Bb~gKUiDGfPPvKd$vn+_8qyC+Tp2JJ)*TARFVlCxksOwy0hjf&W

V~PVLE+ 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

CkrRPJjK#AzXBbQMA1)$lZc>n+a literal 0 HcmV?d00001 From 90b74c2aebb11f22211b1b6ab8f91468ef3086fc Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 27 Jan 2022 03:24:34 +0300 Subject: [PATCH 058/132] better unflattenTuple --- src/Columns/ColumnObject.cpp | 43 +- src/DataTypes/ObjectUtils.cpp | 396 ++++++++++-------- src/DataTypes/ObjectUtils.h | 5 +- src/DataTypes/Serializations/DataPath.h | 62 ++- .../Serializations/SerializationObject.cpp | 20 +- .../tests/gtest_json_parser.cpp | 1 - src/Functions/FunctionsConversion.h | 22 +- .../0_stateless/01825_type_json_1.reference | 2 +- .../01825_type_json_insert_select.reference | 2 +- .../01825_type_json_nbagames.reference | 2 +- .../01825_type_json_schema_race_long.sh | 2 +- 11 files changed, 326 insertions(+), 231 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 24686ee8ac2..94603749554 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -492,7 +492,7 @@ ColumnObject::ColumnObject(bool is_nullable_) ColumnObject::ColumnObject(SubcolumnsTree && subcolumns_, bool is_nullable_) : is_nullable(is_nullable_) , subcolumns(std::move(subcolumns_)) - , num_rows(subcolumns.empty() ? 0 : (*subcolumns.begin())->column.size()) + , num_rows(subcolumns.empty() ? 0 : (*subcolumns.begin())->data.size()) { checkConsistency(); @@ -505,11 +505,11 @@ void ColumnObject::checkConsistency() const for (const auto & leaf : subcolumns) { - if (num_rows != leaf->column.size()) + if (num_rows != leaf->data.size()) { throw Exception(ErrorCodes::LOGICAL_ERROR, "Sizes of subcolumns are inconsistent in ColumnObject." " Subcolumn '{}' has {} rows, but expected size is {}", - leaf->path.getPath(), leaf->column.size(), num_rows); + leaf->path.getPath(), leaf->data.size(), num_rows); } } } @@ -535,7 +535,7 @@ size_t ColumnObject::byteSize() const { size_t res = 0; for (const auto & entry : subcolumns) - res += entry->column.byteSize(); + res += entry->data.byteSize(); return res; } @@ -543,7 +543,7 @@ size_t ColumnObject::allocatedBytes() const { size_t res = 0; for (const auto & entry : subcolumns) - res += entry->column.allocatedBytes(); + res += entry->data.allocatedBytes(); return res; } @@ -553,7 +553,7 @@ void ColumnObject::forEachSubcolumn(ColumnCallback callback) throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot iterate over non-finalized ColumnObject"); for (auto & entry : subcolumns) - callback(entry->column.data.back()); + callback(entry->data.data.back()); } void ColumnObject::insert(const Field & field) @@ -575,7 +575,7 @@ void ColumnObject::insert(const Field & field) for (auto & entry : subcolumns) if (!inserted.has(entry->path.getPath())) - entry->column.insertDefault(); + entry->data.insertDefault(); ++num_rows; } @@ -583,7 +583,7 @@ void ColumnObject::insert(const Field & field) void ColumnObject::insertDefault() { for (auto & entry : subcolumns) - entry->column.insertDefault(); + entry->data.insertDefault(); ++num_rows; } @@ -595,7 +595,7 @@ Field ColumnObject::operator[](size_t n) const Object object; for (const auto & entry : subcolumns) - object[entry->path.getPath()] = (*entry->column.data.back())[n]; + object[entry->path.getPath()] = (*entry->data.data.back())[n]; return object; } @@ -609,7 +609,7 @@ void ColumnObject::get(size_t n, Field & res) const for (const auto & entry : subcolumns) { auto it = object.try_emplace(entry->path.getPath()).first; - entry->column.data.back()->get(n, it->second); + entry->data.data.back()->get(n, it->second); } } @@ -620,9 +620,9 @@ void ColumnObject::insertRangeFrom(const IColumn & src, size_t start, size_t len for (auto & entry : subcolumns) { if (src_object.hasSubcolumn(entry->path)) - entry->column.insertRangeFrom(src_object.getSubcolumn(entry->path), start, length); + entry->data.insertRangeFrom(src_object.getSubcolumn(entry->path), start, length); else - entry->column.insertManyDefaults(length); + entry->data.insertManyDefaults(length); } num_rows += length; @@ -637,7 +637,7 @@ ColumnPtr ColumnObject::replicate(const Offsets & offsets) const auto res_column = ColumnObject::create(is_nullable); for (const auto & entry : subcolumns) { - auto replicated_data = entry->column.data.back()->replicate(offsets)->assumeMutable(); + auto replicated_data = entry->data.data.back()->replicate(offsets)->assumeMutable(); res_column->addSubcolumn(entry->path, std::move(replicated_data)); } @@ -647,7 +647,7 @@ ColumnPtr ColumnObject::replicate(const Offsets & offsets) const void ColumnObject::popBack(size_t length) { for (auto & entry : subcolumns) - entry->column.popBack(length); + entry->data.popBack(length); num_rows -= length; } @@ -655,7 +655,7 @@ void ColumnObject::popBack(size_t length) const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) const { if (const auto * node = subcolumns.findLeaf(key)) - return node->column; + return node->data; throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key.getPath()); } @@ -663,7 +663,7 @@ const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) con ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) { if (const auto * node = subcolumns.findLeaf(key)) - return const_cast(node)->column; + return const_cast(node)->data; throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key.getPath()); } @@ -677,6 +677,7 @@ void ColumnObject::addSubcolumn(const Path & key, MutableColumnPtr && subcolumn) { size_t new_size = subcolumn->size(); bool inserted = subcolumns.add(key, Subcolumn(std::move(subcolumn), is_nullable)); + if (!inserted) throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); @@ -707,7 +708,7 @@ void ColumnObject::addNestedSubcolumn(const Path & key, const FieldInfo & field_ const auto * leaf = subcolumns.findLeaf(nested_node, [&](const auto & ) { return true; }); assert(leaf); - auto new_subcolumn = leaf->column.recreateWithDefaultValues(field_info); + auto new_subcolumn = leaf->data.recreateWithDefaultValues(field_info); if (new_subcolumn.size() > new_size) new_subcolumn.popBack(new_subcolumn.size() - new_size); else if (new_subcolumn.size() < new_size) @@ -737,7 +738,7 @@ Paths ColumnObject::getKeys() const bool ColumnObject::isFinalized() const { return std::all_of(subcolumns.begin(), subcolumns.end(), - [](const auto & entry) { return entry->column.isFinalized(); }); + [](const auto & entry) { return entry->data.isFinalized(); }); } void ColumnObject::finalize() @@ -746,12 +747,12 @@ void ColumnObject::finalize() SubcolumnsTree new_subcolumns; for (auto && entry : subcolumns) { - const auto & least_common_type = entry->column.getLeastCommonType(); + const auto & least_common_type = entry->data.getLeastCommonType(); if (isNothing(getBaseTypeOfArray(least_common_type))) continue; - entry->column.finalize(); - new_subcolumns.add(entry->path, std::move(entry->column)); + entry->data.finalize(); + new_subcolumns.add(entry->path, std::move(entry->data)); } if (new_subcolumns.empty()) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 516b44d3dc6..4c508cdcc86 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -76,6 +76,13 @@ ColumnPtr getBaseColumnOfArray(const ColumnPtr & column) return last_array ? last_array->getDataPtr() : column; } +DataTypePtr createArrayOfType(DataTypePtr type, size_t num_dimensions) +{ + for (size_t i = 0; i < num_dimensions; ++i) + type = std::make_shared(std::move(type)); + return type; +} + ColumnPtr createArrayOfColumn(ColumnPtr column, size_t num_dimensions) { for (size_t i = 0; i < num_dimensions; ++i) @@ -83,13 +90,6 @@ ColumnPtr createArrayOfColumn(ColumnPtr column, size_t num_dimensions) return column; } -DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension) -{ - for (size_t i = 0; i < dimension; ++i) - type = std::make_shared(std::move(type)); - return type; -} - Array createEmptyArrayField(size_t num_dimensions) { Array array; @@ -155,19 +155,16 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con "Cannot convert to tuple column '{}' from type {}. Column should be finalized first", name_type.name, name_type.type->getName()); - std::vector> tuple_elements; - tuple_elements.reserve(subcolumns_map.size()); + Paths tuple_paths; + DataTypes tuple_types; + Columns tuple_columns; + for (const auto & entry : subcolumns_map) - tuple_elements.emplace_back(entry->path, - entry->column.getLeastCommonType(), - entry->column.getFinalizedColumnPtr()); - - std::sort(tuple_elements.begin(), tuple_elements.end(), - [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs).getPath() < std::get<0>(rhs).getPath(); }); - - auto tuple_paths = extractVector<0>(tuple_elements); - auto tuple_types = extractVector<1>(tuple_elements); - auto tuple_columns = extractVector<2>(tuple_elements); + { + tuple_paths.emplace_back(entry->path); + tuple_types.emplace_back(entry->data.getLeastCommonType()); + tuple_columns.emplace_back(entry->data.getFinalizedColumnPtr()); + } auto it = storage_columns_map.find(name_type.name); if (it == storage_columns_map.end()) @@ -180,10 +177,10 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con auto type_tuple = std::make_shared(tuple_types, tuple_names); - getLeastCommonTypeForObject({type_tuple, it->second}, true); - - std::tie(column.type, column.column) = unflattenTuple(tuple_paths, tuple_types, tuple_columns); + std::tie(column.column, column.type) = unflattenTuple(tuple_paths, tuple_types, tuple_columns); name_type.type = column.type; + + getLeastCommonTypeForObject({column.type, it->second}, true); } } } @@ -237,7 +234,9 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambi subcolumns_types[tuple_paths[i]].push_back(tuple_types[i]); } - std::vector> tuple_elements; + Paths tuple_paths; + DataTypes tuple_types; + for (const auto & [key, subtypes] : subcolumns_types) { assert(!subtypes.empty()); @@ -251,17 +250,15 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambi "Uncompatible types of subcolumn '{}': {} and {}", key.getPath(), subtypes[0]->getName(), subtypes[i]->getName()); - tuple_elements.emplace_back(key, getLeastSupertype(subtypes, /*allow_conversion_to_string=*/ true)); + tuple_paths.emplace_back(key); + tuple_types.emplace_back(getLeastSupertype(subtypes, /*allow_conversion_to_string=*/ true)); } - if (tuple_elements.empty()) - tuple_elements.emplace_back(Path(ColumnObject::COLUMN_NAME_DUMMY), std::make_shared()); - - std::sort(tuple_elements.begin(), tuple_elements.end(), - [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs).getPath() < std::get<0>(rhs).getPath(); }); - - auto tuple_paths = extractVector<0>(tuple_elements); - auto tuple_types = extractVector<1>(tuple_elements); + if (tuple_paths.empty()) + { + tuple_paths.emplace_back(ColumnObject::COLUMN_NAME_DUMMY); + tuple_types.emplace_back(std::make_shared()); + } if (check_ambiguos_paths) checkObjectHasNoAmbiguosPaths(tuple_paths); @@ -300,76 +297,6 @@ void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescript namespace { -struct SubcolumnsHolder -{ - SubcolumnsHolder( - const std::vector & paths_, - const DataTypes & types_, - const Columns & columns_) - : paths(paths_) - , types(types_) - , columns(columns_) - { - parts.reserve(paths.size()); - levels.reserve(paths.size()); - - for (const auto & path : paths) - { - parts.emplace_back(path.getParts()); - - size_t num_parts = path.getNumParts(); - - levels.emplace_back(); - levels.back().resize(num_parts); - - for (size_t i = 1; i < num_parts; ++i) - levels.back()[i] = levels.back()[i - 1] + path.isNested(i - 1); - } - } - - std::pair reduceNumberOfDimensions(size_t path_idx, size_t key_idx) const - { - auto type = types[path_idx]; - auto column = columns[path_idx]; - - if (!isArray(type)) - return {type, column}; - - size_t type_dimensions = getNumberOfDimensions(*type); - size_t column_dimensions = getNumberOfDimensions(*column); - - if (levels[path_idx][key_idx] > type_dimensions) - throw Exception(ErrorCodes::LOGICAL_ERROR, - "Level of nested ({}) cannot be greater than number of dimensions in array ({})", - levels[path_idx][key_idx], type_dimensions); - - if (type_dimensions != column_dimensions) - throw Exception(ErrorCodes::LOGICAL_ERROR, - "Number of dimensionsin type ({}) is incompatible with number of dimension in column ({})", - type_dimensions, column_dimensions); - - size_t dimensions_to_reduce = levels[path_idx][key_idx]; - while (dimensions_to_reduce--) - { - const auto & type_array = assert_cast(*type); - const auto & column_array = assert_cast(*column); - - type = type_array.getNestedType(); - column = column_array.getDataPtr(); - } - - return {type, column}; - } - - std::vector paths; - DataTypes types; - Columns columns; - - std::vector parts; - std::vector> levels; -}; - - void flattenTupleImpl(Path path, DataTypePtr type, size_t array_level, Paths & new_paths, DataTypes & new_types) { bool is_nested = isNested(type); @@ -399,63 +326,138 @@ void flattenTupleImpl(Path path, DataTypePtr type, size_t array_level, Paths & n } } -void unflattenTupleImpl( - const SubcolumnsHolder & holder, - size_t from, size_t to, size_t depth, - Names & new_names, DataTypes & new_types, Columns & new_columns) +void flattenTupleImpl(const ColumnPtr & column, Columns & new_columns, Columns & offsets_columns) { - size_t start = from; - for (size_t i = from + 1; i <= to; ++i) + if (const auto * column_tuple = checkAndGetColumn(column.get())) { - if (i < to && holder.parts[i].size() <= depth) - throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot unflatten Tuple. Not enough name parts in path"); - - if (i == to || holder.parts[i][depth] != holder.parts[start][depth]) + const auto & subcolumns = column_tuple->getColumns(); + for (const auto & subcolumn : subcolumns) + flattenTupleImpl(subcolumn, new_columns,offsets_columns ); + } + else if (const auto * column_array = checkAndGetColumn(column.get())) + { + offsets_columns.push_back(column_array->getOffsetsPtr()); + flattenTupleImpl(column_array->getDataPtr(), new_columns, offsets_columns); + offsets_columns.pop_back(); + } + else + { + if (!offsets_columns.empty()) { - if (i - start > 1) - { - Names tuple_names; - DataTypes tuple_types; - Columns tuple_columns; + auto new_column = ColumnArray::create(column, offsets_columns.back()); + for (ssize_t i = static_cast(offsets_columns.size()) - 2; i >= 0; --i) + new_column = ColumnArray::create(new_column, offsets_columns[i]); - unflattenTupleImpl(holder, start, i, depth + 1, tuple_names, tuple_types, tuple_columns); - - assert(!tuple_names.empty()); - assert(tuple_names.size() == tuple_types.size()); - assert(tuple_names.size() == tuple_columns.size()); - - new_names.push_back(holder.parts[start][depth]); - - if (holder.paths[start].isNested(depth)) - { - auto array_column = holder.reduceNumberOfDimensions(start, depth).second; - auto offsets_column = assert_cast(*array_column).getOffsetsPtr(); - - new_types.push_back(createNested(tuple_types, tuple_names)); - new_columns.push_back(ColumnArray::create(ColumnTuple::create(std::move(tuple_columns)), offsets_column)); - } - else - { - new_types.push_back(std::make_shared(tuple_types, tuple_names)); - new_columns.push_back(ColumnTuple::create(std::move(tuple_columns))); - } - } - else - { - WriteBufferFromOwnString wb; - wb << holder.parts[start][depth]; - for (size_t j = depth + 1; j < holder.parts[start].size(); ++j) - wb << "." << holder.parts[start][j]; - - auto [new_type, new_column] = holder.reduceNumberOfDimensions(start, depth); - - new_names.push_back(wb.str()); - new_types.push_back(std::move(new_type)); - new_columns.push_back(std::move(new_column)); - } - - start = i; + new_columns.push_back(std::move(new_column)); } + else + new_columns.push_back(column); + } +} + +DataTypePtr reduceNumberOfDimensions(DataTypePtr type, size_t dimensions_to_reduce) +{ + while (dimensions_to_reduce--) + { + const auto * type_array = typeid_cast(type.get()); + if (!type_array) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Not enough dimensions to reduce"); + + type = type_array->getNestedType(); + } + + return type; +} + +ColumnPtr reduceNumberOfDimensions(ColumnPtr column, size_t dimensions_to_reduce) +{ + while (dimensions_to_reduce--) + { + const auto * column_array = typeid_cast(column.get()); + if (!column_array) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Not enough dimensions to reduce"); + + column = column_array->getDataPtr(); + } + + return column; +} + +struct ColumnWithTypeAndDimensions +{ + ColumnPtr column; + DataTypePtr type; + size_t array_dimensions; +}; + +using SubcolumnsTreeWithTypes = SubcolumnsTree; +using Node = SubcolumnsTreeWithTypes::Node; +using Leaf = SubcolumnsTreeWithTypes::Leaf; + +std::pair createTypeFromNode(const Node * node) +{ + auto collect_tuple_elemets = [](const auto & children) + { + std::vector> tuple_elements; + tuple_elements.reserve(children.size()); + for (const auto & [name, child] : children) + { + auto [column, type] = createTypeFromNode(child.get()); + tuple_elements.emplace_back(name, std::move(column), std::move(type)); + } + + std::sort(tuple_elements.begin(), tuple_elements.end(), + [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); }); + + auto tuple_names = extractVector<0>(tuple_elements); + auto tuple_columns = extractVector<1>(tuple_elements); + auto tuple_types = extractVector<2>(tuple_elements); + + return std::make_tuple(tuple_names, tuple_columns, tuple_types); + }; + + if (node->kind == Node::SCALAR) + { + const auto * leaf = typeid_cast(node); + return {leaf->data.column, leaf->data.type}; + } + else if (node->kind == Node::NESTED) + { + Columns offsets_columns; + ColumnPtr current_column = node->data.column; + + assert(node->data.array_dimensions > 0); + offsets_columns.reserve(node->data.array_dimensions); + + for (size_t i = 0; i < node->data.array_dimensions; ++i) + { + const auto & column_array = assert_cast(*current_column); + + offsets_columns.push_back(column_array.getOffsetsPtr()); + current_column = column_array.getDataPtr(); + } + + auto [tuple_names, tuple_columns, tuple_types] = collect_tuple_elemets(node->children); + + auto result_column = ColumnArray::create(ColumnTuple::create(tuple_columns), offsets_columns.back()); + auto result_type = createNested(tuple_types, tuple_names); + + for (ssize_t i = static_cast(offsets_columns.size()) - 2; i >= 0; --i) + { + result_column = ColumnArray::create(result_column, offsets_columns[i]); + result_type = std::make_shared(result_type); + } + + return {result_column, result_type}; + } + else + { + auto [tuple_names, tuple_columns, tuple_types] = collect_tuple_elemets(node->children); + + auto result_column = ColumnTuple::create(tuple_columns); + auto result_type = std::make_shared(tuple_types, tuple_names); + + return {result_column, result_type}; } } @@ -470,17 +472,27 @@ std::pair flattenTuple(const DataTypePtr & type) return {new_paths, new_types}; } +ColumnPtr flattenTuple(const ColumnPtr & column) +{ + Columns new_columns; + Columns offsets_columns; + + flattenTupleImpl(column, new_columns, offsets_columns); + return ColumnTuple::create(new_columns); +} + DataTypePtr unflattenTuple(const Paths & paths, const DataTypes & tuple_types) { assert(paths.size() == types.size()); - Columns tuple_columns(tuple_types.size()); - for (size_t i = 0; i < tuple_types.size(); ++i) - tuple_columns[i] = tuple_types[i]->createColumn(); + Columns tuple_columns; + tuple_columns.reserve(tuple_types.size()); + for (const auto & type : tuple_types) + tuple_columns.emplace_back(type->createColumn()); - return unflattenTuple(paths, tuple_types, tuple_columns).first; + return unflattenTuple(paths, tuple_types, tuple_columns).second; } -std::pair unflattenTuple( +std::pair unflattenTuple( const Paths & paths, const DataTypes & tuple_types, const Columns & tuple_columns) @@ -488,18 +500,64 @@ std::pair unflattenTuple( assert(paths.size() == types.size()); assert(paths.size() == columns.size()); - Names new_names; - DataTypes new_types; - Columns new_columns; - SubcolumnsHolder holder(paths, tuple_types, tuple_columns); + SubcolumnsTreeWithTypes tree; - unflattenTupleImpl(holder, 0, paths.size(), 0, new_names, new_types, new_columns); - - return + for (size_t i = 0; i < paths.size(); ++i) { - std::make_shared(new_types, new_names), - ColumnTuple::create(new_columns) - }; + auto column = tuple_columns[i]; + auto type = tuple_types[i]; + + size_t num_parts = paths[i].getNumParts(); + size_t nested_level = paths[i].getIsNestedBitSet().count(); + size_t array_level = getNumberOfDimensions(*type); + + if (array_level < nested_level) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Number of dimensions ({}) is less than number Nested types ({}) for path {}", + array_level, nested_level, paths[i].getPath()); + + size_t pos = 0; + tree.add(paths[i], [&](Node::Kind kind, bool exists) -> std::shared_ptr + { + if (pos >= num_parts) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Not enough name parts for path {}. Expected at least {}, got {}", + paths[i].getPath(), pos + 1, num_parts); + + ColumnWithTypeAndDimensions current_column; + if (kind == Node::NESTED) + { + size_t dimensions_to_reduce = array_level - nested_level; + assert(is_nested.test(pos)); + + ++dimensions_to_reduce; + --nested_level; + + current_column = ColumnWithTypeAndDimensions{column, type, dimensions_to_reduce}; + + if (dimensions_to_reduce) + { + type = reduceNumberOfDimensions(type, dimensions_to_reduce); + column = reduceNumberOfDimensions(column, dimensions_to_reduce); + } + + array_level -= dimensions_to_reduce; + } + else + current_column = ColumnWithTypeAndDimensions{column, type, 0}; + + ++pos; + + if (exists) + return nullptr; + + return kind == Node::SCALAR + ? std::make_shared(paths[i], current_column) + : std::make_shared(kind, current_column); + }); + } + + return createTypeFromNode(tree.getRoot()); } static void addConstantToWithClause(const ASTPtr & query, const String & column_name, const DataTypePtr & data_type) diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 4f13882f4b8..cc1a5070761 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -13,7 +13,7 @@ namespace DB size_t getNumberOfDimensions(const IDataType & type); size_t getNumberOfDimensions(const IColumn & column); DataTypePtr getBaseTypeOfArray(const DataTypePtr & type); -DataTypePtr createArrayOfType(DataTypePtr type, size_t dimension); +DataTypePtr createArrayOfType(DataTypePtr type, size_t num_dimensions); Array createEmptyArrayField(size_t num_dimensions); ColumnPtr getBaseColumnOfArray(const ColumnPtr & column); @@ -29,12 +29,13 @@ void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescript using DataTypeTuplePtr = std::shared_ptr; std::pair flattenTuple(const DataTypePtr & type); +ColumnPtr flattenTuple(const ColumnPtr & column); DataTypePtr unflattenTuple( const Paths & paths, const DataTypes & tuple_types); -std::pair unflattenTuple( +std::pair unflattenTuple( const Paths & paths, const DataTypes & tuple_types, const Columns & tuple_columns); diff --git a/src/DataTypes/Serializations/DataPath.h b/src/DataTypes/Serializations/DataPath.h index 446419760cf..319eed817c9 100644 --- a/src/DataTypes/Serializations/DataPath.h +++ b/src/DataTypes/Serializations/DataPath.h @@ -51,7 +51,9 @@ private: using Paths = std::vector; -template +struct EmptyNodeData {}; + +template class SubcolumnsTree { public: @@ -64,19 +66,21 @@ public: SCALAR, }; + explicit Node(Kind kind_) : kind(kind_) {} + Node(Kind kind_, const NodeData & data_) : kind(kind_), data(data_) {} + Kind kind = TUPLE; const Node * parent = nullptr; + std::unordered_map> children; + NodeData data; bool isNested() const { return kind == NESTED; } - std::shared_ptr addChild(const String & key_, Kind kind_) + void addChild(const String & key_, std::shared_ptr next_node) { - auto next_node = kind_ == SCALAR ? std::make_shared() : std::make_shared(); - next_node->kind = kind_; next_node->parent = this; - children[key_] = next_node; - return next_node; + children[key_] = std::move(next_node); } virtual ~Node() = default; @@ -84,14 +88,36 @@ public: struct Leaf : public Node { + Leaf(const Path & path_, const LeafData & data_) + : Node(Node::SCALAR), path(path_), data(data_) + { + } + Path path; - ColumnHolder column; + LeafData data; }; + using NodeKind = typename Node::Kind; using NodePtr = std::shared_ptr; using LeafPtr = std::shared_ptr; - bool add(const Path & path, const ColumnHolder & column) + bool add(const Path & path, const LeafData & leaf_data) + { + return add(path, [&](NodeKind kind, bool exists) -> NodePtr + { + if (exists) + return nullptr; + + if (kind == Node::SCALAR) + return std::make_shared(path, leaf_data); + + return std::make_shared(kind); + }); + } + + using NodeCreator = std::function; + + bool add(const Path & path, const NodeCreator & node_creator) { auto parts = path.getParts(); auto is_nested = path.getIsNestedBitSet(); @@ -100,10 +126,7 @@ public: return false; if (!root) - { - root = std::make_shared(); - root->kind = Node::TUPLE; - } + root = std::make_shared(Node::TUPLE); Node * current_node = root.get(); for (size_t i = 0; i < parts.size() - 1; ++i) @@ -114,6 +137,7 @@ public: if (it != current_node->children.end()) { current_node = it->second.get(); + node_creator(current_node->kind, true); bool current_node_is_nested = current_node->kind == Node::NESTED; if (current_node_is_nested != is_nested.test(i)) @@ -122,7 +146,9 @@ public: else { auto next_kind = is_nested.test(i) ? Node::NESTED : Node::TUPLE; - current_node = current_node->addChild(parts[i], next_kind).get(); + auto next_node = node_creator(next_kind, false); + current_node->addChild(parts[i], next_node); + current_node = next_node.get(); } } @@ -130,12 +156,11 @@ public: if (it != current_node->children.end()) return false; - auto node = current_node->addChild(parts.back(), Node::SCALAR); - auto leaf = std::dynamic_pointer_cast(node); - assert(leaf); + auto next_node = node_creator(Node::SCALAR, false); + current_node->addChild(parts.back(), next_node); - leaf->path = path; - leaf->column = column; + auto leaf = std::dynamic_pointer_cast(next_node); + assert(leaf); leaves.push_back(std::move(leaf)); return true; @@ -189,6 +214,7 @@ public: using Leaves = std::vector; const Leaves & getLeaves() const { return leaves; } + const Node * getRoot() const { return root.get(); } using iterator = typename Leaves::iterator; using const_iterator = typename Leaves::const_iterator; diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index aa8fc459aa1..4f35bbd284e 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -82,7 +82,7 @@ bool tryInsertDefaultFromNested( leaf = subcolumns.findLeaf(node_nested, [&](const auto & candidate) { - return candidate.column.size() == entry->column.size() + 1; + return candidate.data.size() == entry->data.size() + 1; }); if (leaf) @@ -95,11 +95,11 @@ bool tryInsertDefaultFromNested( if (!leaf) return false; - auto last_field = leaf->column.getLastField(); + auto last_field = leaf->data.getLastField(); if (last_field.isNull()) return false; - const auto & least_common_type = entry->column.getLeastCommonType(); + const auto & least_common_type = entry->data.getLeastCommonType(); size_t num_dimensions = getNumberOfDimensions(*least_common_type); assert(num_skipped_nested < num_dimensions); @@ -109,7 +109,7 @@ bool tryInsertDefaultFromNested( : getBaseTypeOfArray(least_common_type)->getDefault(); auto default_field = applyVisitor(FieldVisitorReplaceScalars(default_scalar, num_dimensions_to_keep), last_field); - entry->column.insert(std::move(default_field)); + entry->data.insert(std::move(default_field)); return true; } @@ -166,7 +166,7 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & { bool inserted = tryInsertDefaultFromNested(entry, subcolumns); if (!inserted) - entry->column.insertDefault(); + entry->data.insertDefault(); } } @@ -264,7 +264,7 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( settings.path.back() = Substream::ObjectStructure; settings.path.back().object_key_name = entry->path.getPath(); - const auto & type = entry->column.getLeastCommonType(); + const auto & type = entry->data.getLeastCommonType(); if (auto * stream = settings.getter(settings.path)) { entry->path.writeBinary(*stream); @@ -276,7 +276,7 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( { auto serialization = type->getDefaultSerialization(); serialization->serializeBinaryBulkWithMultipleStreams( - entry->column.getFinalizedColumn(), offset, limit, settings, state); + entry->data.getFinalizedColumn(), offset, limit, settings, state); } } @@ -387,8 +387,8 @@ void SerializationObject::serializeTextImpl(const IColumn & column, size writeDoubleQuoted((*it)->path.getPath(), ostr); writeChar(':', ostr); - auto serialization = (*it)->column.getLeastCommonType()->getDefaultSerialization(); - serialization->serializeTextJSON((*it)->column.getFinalizedColumn(), row_num, ostr, settings); + auto serialization = (*it)->data.getLeastCommonType()->getDefaultSerialization(); + serialization->serializeTextJSON((*it)->data.getFinalizedColumn(), row_num, ostr, settings); } writeChar('}', ostr); } @@ -439,7 +439,7 @@ SerializationPtr getObjectSerialization(const String & schema_format) return std::make_shared>>(); #else throw Exception(ErrorCodes::NOT_IMPLEMENTED, - "To use data type Object with JSON format, ClickHouse should be built with Simdjson or Rapidjson"); + "To use data type Object with JSON format ClickHouse should be built with Simdjson or Rapidjson"); #endif } diff --git a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp index c14b1fa1f72..8b11684da7a 100644 --- a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp +++ b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp @@ -10,7 +10,6 @@ using namespace DB; const String json1 = R"({"k1" : 1, "k2" : {"k3" : "aa", "k4" : 2}})"; - /// Nested(k2 String, k3 Nested(k4 String)) const String json2 = R"({"k1" : [ diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index a1df0bc2643..a8dda5e5eba 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -26,6 +26,8 @@ #include #include #include +#include +#include #include #include #include @@ -3076,13 +3078,15 @@ private: throw Exception(ErrorCodes::TYPE_MISMATCH, "Cast to Object can be performed only from flatten Named Tuple. Got: {}", from_type->getName()); - const auto & names = from_tuple->getElementNames(); - const auto & from_types = from_tuple->getElements(); + Paths paths; + DataTypes from_types; + + std::tie(paths, from_types) = flattenTuple(from_type); auto to_types = from_types; for (auto & type : to_types) { - if (checkAndGetDataType(type.get())) + if (isTuple(type) || isNested(type)) throw Exception(ErrorCodes::TYPE_MISMATCH, "Cast to Object can be performed only from flatten Named Tuple. Got: {}", from_type->getName()); @@ -3090,18 +3094,24 @@ private: } return [element_wrappers = getElementWrappers(from_types, to_types), - has_nullable_subcolumns = to_type->hasNullableSubcolumns(), from_types, to_types, names] + has_nullable_subcolumns = to_type->hasNullableSubcolumns(), from_types, to_types, paths] (ColumnsWithTypeAndName & arguments, const DataTypePtr &, const ColumnNullable * nullable_source, size_t input_rows_count) { size_t tuple_size = to_types.size(); - const ColumnTuple & column_tuple = assert_cast(*arguments.front().column); + auto flattened_column = flattenTuple(arguments.front().column); + const auto & column_tuple = assert_cast(*flattened_column); + + if (tuple_size != column_tuple.getColumns().size()) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Expected tuple with {} subcolumn, but got {} subcolumns", + tuple_size, column_tuple.getColumns().size()); auto res = ColumnObject::create(has_nullable_subcolumns); for (size_t i = 0; i < tuple_size; ++i) { ColumnsWithTypeAndName element = {{column_tuple.getColumns()[i], from_types[i], "" }}; auto converted_column = element_wrappers[i](element, to_types[i], nullable_source, input_rows_count); - res->addSubcolumn(Path(names[i]), converted_column->assumeMutable()); + res->addSubcolumn(paths[i], converted_column->assumeMutable()); } return res; diff --git a/tests/queries/0_stateless/01825_type_json_1.reference b/tests/queries/0_stateless/01825_type_json_1.reference index 59fad00bfae..857c624fb9b 100644 --- a/tests/queries/0_stateless/01825_type_json_1.reference +++ b/tests/queries/0_stateless/01825_type_json_1.reference @@ -6,7 +6,7 @@ all_2_2_0 data Tuple(k5 String) all_1_2_1 data Tuple(k1 String, k2 Tuple(k3 String, k4 String), k5 String) ============ 1 ['aaa','ddd'] [['bbb','ccc'],['eee','fff']] -all_3_3_0 data Tuple(k1 Nested(k2 String, `k3.k4` Array(String))) +all_3_3_0 data Tuple(k1 Nested(k2 String, k3 Nested(k4 String))) ============ 1 a 42 2 b 4200 diff --git a/tests/queries/0_stateless/01825_type_json_insert_select.reference b/tests/queries/0_stateless/01825_type_json_insert_select.reference index ebf4c1ee736..8283cc5af48 100644 --- a/tests/queries/0_stateless/01825_type_json_insert_select.reference +++ b/tests/queries/0_stateless/01825_type_json_insert_select.reference @@ -9,4 +9,4 @@ Tuple(arr Nested(k11 Int8, k22 String, k33 Int8), k1 Int8, k2 String, k3 String) 2 ([],2,'bar','') 3 ([],3,'','aaa') 4 ([(5,'6',0),(7,'0',8)],0,'','') -5 ([],0,'','') +5 ([(0,'str1',0)],0,'','') diff --git a/tests/queries/0_stateless/01825_type_json_nbagames.reference b/tests/queries/0_stateless/01825_type_json_nbagames.reference index 467d74b5155..b0112897ebf 100644 --- a/tests/queries/0_stateless/01825_type_json_nbagames.reference +++ b/tests/queries/0_stateless/01825_type_json_nbagames.reference @@ -1,5 +1,5 @@ 1000 -data Tuple(`_id.$oid` String, `date.$date` String, teams Nested(abbreviation String, city String, home UInt64, name String, players Nested(ast Int8, blk Int8, drb Int8, fg Int8, fg3 Int8, fg3_pct String, fg3a Int8, fg_pct String, fga Int8, ft Int8, ft_pct String, fta Int8, mp String, orb Int8, pf Int8, player String, pts Int8, stl Int8, tov Int8, trb Int8), results Tuple(ast Int8, blk Int8, drb Int8, fg Int8, fg3 Int8, fg3_pct String, fg3a Int8, fg_pct String, fga Int8, ft Int8, ft_pct String, fta Int8, mp Int16, orb Int8, pf Int8, pts Int16, stl Int8, tov Int8, trb Int8), score Int16, won Int8)) +data Tuple(_id Tuple(`$oid` String), date Tuple(`$date` String), teams Nested(abbreviation String, city String, home UInt64, name String, players Nested(ast Int8, blk Int8, drb Int8, fg Int8, fg3 Int8, fg3_pct String, fg3a Int8, fg_pct String, fga Int8, ft Int8, ft_pct String, fta Int8, mp String, orb Int8, pf Int8, player String, pts Int8, stl Int8, tov Int8, trb Int8), results Tuple(ast Int8, blk Int8, drb Int8, fg Int8, fg3 Int8, fg3_pct String, fg3a Int8, fg_pct String, fga Int8, ft Int8, ft_pct String, fta Int8, mp Int16, orb Int8, pf Int8, pts Int16, stl Int8, tov Int8, trb Int8), score Int16, won Int8)) Boston Celtics 70 Los Angeles Lakers 64 Milwaukee Bucks 61 diff --git a/tests/queries/0_stateless/01825_type_json_schema_race_long.sh b/tests/queries/0_stateless/01825_type_json_schema_race_long.sh index b0e2ec95be2..a119dd17ead 100755 --- a/tests/queries/0_stateless/01825_type_json_schema_race_long.sh +++ b/tests/queries/0_stateless/01825_type_json_schema_race_long.sh @@ -1,5 +1,5 @@ #!/usr/bin/env bash -# Tags: no-fasttest +# Tags: no-fasttest, long set -e From fa883f2ac390a12ae8b0a7e53bf0b3d715e278c6 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 28 Jan 2022 17:23:51 +0300 Subject: [PATCH 059/132] fix tests --- src/Interpreters/InterpreterSelectQuery.cpp | 11 ++++------- 1 file changed, 4 insertions(+), 7 deletions(-) diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp index be29804f602..1885a141d23 100644 --- a/src/Interpreters/InterpreterSelectQuery.cpp +++ b/src/Interpreters/InterpreterSelectQuery.cpp @@ -567,6 +567,9 @@ InterpreterSelectQuery::InterpreterSelectQuery( analysis_result.required_columns = required_columns; } + if (query_info.projection) + storage_snapshot->addProjection(query_info.projection->desc); + /// Blocks used in expression analysis contains size 1 const columns for constant folding and /// null non-const columns to avoid useless memory allocations. However, a valid block sample /// requires all columns to be of size 0, thus we need to sanitize the block here. @@ -614,19 +617,13 @@ Block InterpreterSelectQuery::getSampleBlockImpl() query_info.has_window = query_analyzer->hasWindow(); if (storage && !options.only_analyze) { - from_stage = storage->getQueryProcessingStage(context, options.to_stage, storage_snapshot, query_info); - - if (query_info.projection) - storage_snapshot->addProjection(query_info.projection->desc); - auto & query = getSelectQuery(); query_analyzer->makeSetsForIndex(query.where()); query_analyzer->makeSetsForIndex(query.prewhere()); query_info.sets = query_analyzer->getPreparedSets(); - } - if (storage && !options.only_analyze) from_stage = storage->getQueryProcessingStage(context, options.to_stage, storage_snapshot, query_info); + } /// Do I need to perform the first part of the pipeline? /// Running on remote servers during distributed processing or if query is not distributed. From 26257bbde6150960d403ca91bac666f2eb62bd2d Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 28 Jan 2022 19:24:17 +0300 Subject: [PATCH 060/132] fix reading missed subcolumns from distributed --- src/DataTypes/ObjectUtils.cpp | 48 ++++++++++--------- .../test_distributed_type_object/test.py | 13 +++++ 2 files changed, 39 insertions(+), 22 deletions(-) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 4c508cdcc86..95f5e38aac8 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -26,6 +26,7 @@ #include #include + namespace DB { @@ -582,41 +583,44 @@ void replaceMissedSubcolumnsByConstants( const ColumnsDescription & available_columns, ASTPtr query) { - NamesAndTypesList missed; + NamesAndTypes missed_names_types; for (const auto & column : available_columns) { - const auto * type_tuple = typeid_cast(column.type.get()); - assert(type_tuple); - auto expected_column = expected_columns.getColumn(GetColumnsOptions::All, column.name); - const auto * expected_type_tuple = typeid_cast(expected_column.type.get()); - assert(expected_type_tuple); - if (!type_tuple->equals(*expected_type_tuple)) + auto [available_paths, available_types] = flattenTuple(column.type); + auto [expected_paths, expected_types] = flattenTuple(expected_column.type); + + auto extract_names_and_types = [&column](const auto & paths, const auto & types) { - const auto & names = type_tuple->getElementNames(); - const auto & expected_names = expected_type_tuple->getElementNames(); - const auto & expected_types = expected_type_tuple->getElements(); - - NameSet names_set(names.begin(), names.end()); - - for (size_t i = 0; i < expected_names.size(); ++i) + NamesAndTypes res; + res.reserve(paths.size()); + for (size_t i = 0; i < paths.size(); ++i) { - if (!names_set.count(expected_names[i])) - { - auto full_name = Nested::concatenateName(column.name, expected_names[i]); - missed.emplace_back(std::move(full_name), expected_types[i]); - } + auto full_name = Nested::concatenateName(column.name, paths[i].getPath()); + res.emplace_back(full_name, types[i]); } - } + + std::sort(res.begin(), res.end()); + return res; + }; + + auto available_names_types = extract_names_and_types(available_paths, available_types); + auto expected_names_types = extract_names_and_types(expected_paths, expected_types); + + std::set_difference( + expected_names_types.begin(), expected_names_types.end(), + available_names_types.begin(), available_names_types.end(), + std::back_inserter(missed_names_types), + [](const auto & lhs, const auto & rhs) { return lhs.name < rhs.name; }); } - if (missed.empty()) + if (missed_names_types.empty()) return; IdentifierNameSet identifiers; query->collectIdentifierNames(identifiers); - for (const auto & [name, type] : missed) + for (const auto & [name, type] : missed_names_types) if (identifiers.count(name)) addConstantToWithClause(query, name, type); } diff --git a/tests/integration/test_distributed_type_object/test.py b/tests/integration/test_distributed_type_object/test.py index 02cb17ded86..5bf5899388d 100644 --- a/tests/integration/test_distributed_type_object/test.py +++ b/tests/integration/test_distributed_type_object/test.py @@ -42,3 +42,16 @@ def test_distributed_type_object(started_cluster): expected = TSV("120\n") assert TSV(node1.query("SELECT sum(data.k2 * id) FROM dist_table")) == expected + + node1.query("TRUNCATE TABLE local_table") + node2.query("TRUNCATE TABLE local_table") + + node1.query('INSERT INTO local_table FORMAT JSONEachRow {"id": 1, "data": {"k1": "aa", "k2": {"k3": "bb", "k4": "c"}}} {"id": 2, "data": {"k1": "ee", "k5": "ff"}};') + node2.query('INSERT INTO local_table FORMAT JSONEachRow {"id": 3, "data": {"k5":"foo"}};') + + expected = TSV(""" +1\taa\tbb\tc\t +2\tee\t\t\tff +3\t\t\t\tfoo""") + + assert TSV(node1.query("SELECT id, data.k1, data.k2.k3, data.k2.k4, data.k5 FROM dist_table ORDER BY id")) == expected From aab6ef60b2eb7babe91c709af132587eede5d1eb Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Tue, 1 Feb 2022 14:14:27 +0300 Subject: [PATCH 061/132] better performance of parsing json data --- src/Columns/ColumnObject.cpp | 20 +- src/Columns/ColumnObject.h | 18 +- src/DataTypes/ObjectUtils.cpp | 69 ++++--- src/DataTypes/ObjectUtils.h | 8 +- src/DataTypes/Serializations/DataPath.cpp | 84 --------- src/DataTypes/Serializations/JSONDataParser.h | 98 +++++----- src/DataTypes/Serializations/PathInData.cpp | 174 ++++++++++++++++++ src/DataTypes/Serializations/PathInData.h | 85 +++++++++ .../Serializations/SerializationObject.cpp | 4 +- .../{DataPath.h => SubcolumnsTree.h} | 89 +++------ src/Functions/FunctionsConversion.h | 2 +- .../0_stateless/01825_type_json_4.reference | 2 +- .../queries/0_stateless/01825_type_json_4.sh | 2 +- 13 files changed, 407 insertions(+), 248 deletions(-) delete mode 100644 src/DataTypes/Serializations/DataPath.cpp create mode 100644 src/DataTypes/Serializations/PathInData.cpp create mode 100644 src/DataTypes/Serializations/PathInData.h rename src/DataTypes/Serializations/{DataPath.h => SubcolumnsTree.h} (64%) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 94603749554..18d192ee569 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -564,7 +564,7 @@ void ColumnObject::insert(const Field & field) size_t old_size = size(); for (const auto & [key_str, value] : object) { - Path key(key_str); + PathInData key(key_str); inserted.insert(key_str); if (!hasSubcolumn(key)) addSubcolumn(key, old_size); @@ -652,7 +652,7 @@ void ColumnObject::popBack(size_t length) num_rows -= length; } -const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) const +const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const PathInData & key) const { if (const auto * node = subcolumns.findLeaf(key)) return node->data; @@ -660,7 +660,7 @@ const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) con throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key.getPath()); } -ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) +ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const PathInData & key) { if (const auto * node = subcolumns.findLeaf(key)) return const_cast(node)->data; @@ -668,12 +668,12 @@ ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const Path & key) throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key.getPath()); } -bool ColumnObject::hasSubcolumn(const Path & key) const +bool ColumnObject::hasSubcolumn(const PathInData & key) const { return subcolumns.findLeaf(key) != nullptr; } -void ColumnObject::addSubcolumn(const Path & key, MutableColumnPtr && subcolumn) +void ColumnObject::addSubcolumn(const PathInData & key, MutableColumnPtr && subcolumn) { size_t new_size = subcolumn->size(); bool inserted = subcolumns.add(key, Subcolumn(std::move(subcolumn), is_nullable)); @@ -685,7 +685,7 @@ void ColumnObject::addSubcolumn(const Path & key, MutableColumnPtr && subcolumn) num_rows = new_size; } -void ColumnObject::addSubcolumn(const Path & key, size_t new_size) +void ColumnObject::addSubcolumn(const PathInData & key, size_t new_size) { bool inserted = subcolumns.add(key, Subcolumn(new_size, is_nullable)); if (!inserted) @@ -695,7 +695,7 @@ void ColumnObject::addSubcolumn(const Path & key, size_t new_size) num_rows = new_size; } -void ColumnObject::addNestedSubcolumn(const Path & key, const FieldInfo & field_info, size_t new_size) +void ColumnObject::addNestedSubcolumn(const PathInData & key, const FieldInfo & field_info, size_t new_size) { if (!key.hasNested()) throw Exception(ErrorCodes::LOGICAL_ERROR, @@ -726,9 +726,9 @@ void ColumnObject::addNestedSubcolumn(const Path & key, const FieldInfo & field_ num_rows = new_size; } -Paths ColumnObject::getKeys() const +PathsInData ColumnObject::getKeys() const { - Paths keys; + PathsInData keys; keys.reserve(subcolumns.size()); for (const auto & entry : subcolumns) keys.emplace_back(entry->path); @@ -756,7 +756,7 @@ void ColumnObject::finalize() } if (new_subcolumns.empty()) - new_subcolumns.add(Path{COLUMN_NAME_DUMMY}, Subcolumn{ColumnUInt8::create(old_size), is_nullable}); + new_subcolumns.add(PathInData{COLUMN_NAME_DUMMY}, Subcolumn{ColumnUInt8::create(old_size), is_nullable}); std::swap(subcolumns, new_subcolumns); checkObjectHasNoAmbiguosPaths(getKeys()); diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index d781cef8997..361767d6e20 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -6,7 +6,7 @@ #include #include #include -#include +#include #include @@ -72,11 +72,9 @@ public: size_t num_of_defaults_in_prefix = 0; }; - // using SubcolumnsMap = std::unordered_map; using SubcolumnsTree = SubcolumnsTree; private: - // SubcolumnsMap subcolumns; const bool is_nullable; SubcolumnsTree subcolumns; @@ -90,20 +88,20 @@ public: void checkConsistency() const; - bool hasSubcolumn(const Path & key) const; + bool hasSubcolumn(const PathInData & key) const; - const Subcolumn & getSubcolumn(const Path & key) const; - Subcolumn & getSubcolumn(const Path & key); + const Subcolumn & getSubcolumn(const PathInData & key) const; + Subcolumn & getSubcolumn(const PathInData & key); void incrementNumRows() { ++num_rows; } - void addSubcolumn(const Path & key, MutableColumnPtr && subcolumn); - void addSubcolumn(const Path & key, size_t new_size); - void addNestedSubcolumn(const Path & key, const FieldInfo & field_info, size_t new_size); + void addSubcolumn(const PathInData & key, MutableColumnPtr && subcolumn); + void addSubcolumn(const PathInData & key, size_t new_size); + void addNestedSubcolumn(const PathInData & key, const FieldInfo & field_info, size_t new_size); const SubcolumnsTree & getSubcolumns() const { return subcolumns; } SubcolumnsTree & getSubcolumns() { return subcolumns; } - Paths getKeys() const; + PathsInData getKeys() const; bool isFinalized() const; void finalize(); diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 95f5e38aac8..920cad8a5c7 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -156,7 +156,7 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con "Cannot convert to tuple column '{}' from type {}. Column should be finalized first", name_type.name, name_type.type->getName()); - Paths tuple_paths; + PathsInData tuple_paths; DataTypes tuple_types; Columns tuple_columns; @@ -171,13 +171,6 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con if (it == storage_columns_map.end()) throw Exception(ErrorCodes::LOGICAL_ERROR, "Column '{}' not found in storage", name_type.name); - Strings tuple_names; - tuple_names.reserve(tuple_paths.size()); - for (const auto & path : tuple_paths) - tuple_names.push_back(path.getPath()); - - auto type_tuple = std::make_shared(tuple_types, tuple_names); - std::tie(column.column, column.type) = unflattenTuple(tuple_paths, tuple_types, tuple_columns); name_type.type = column.type; @@ -186,21 +179,21 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con } } -static bool isPrefix(const Strings & prefix, const Strings & strings) +static bool isPrefix(const PathInData::Parts & prefix, const PathInData::Parts & strings) { if (prefix.size() > strings.size()) return false; for (size_t i = 0; i < prefix.size(); ++i) - if (prefix[i] != strings[i]) + if (prefix[i].key != strings[i].key) return false; return true; } -void checkObjectHasNoAmbiguosPaths(const Paths & paths) +void checkObjectHasNoAmbiguosPaths(const PathsInData & paths) { size_t size = paths.size(); - std::vector names_parts(size); + std::vector names_parts(size); for (size_t i = 0; i < size; ++i) names_parts[i] = paths[i].getParts(); @@ -219,7 +212,23 @@ void checkObjectHasNoAmbiguosPaths(const Paths & paths) DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambiguos_paths) { - std::unordered_map subcolumns_types; + if (types.empty()) + return nullptr; + + bool all_equal = true; + for (size_t i = 1; i < types.size(); ++i) + { + if (!types[i]->equals(*types[0])) + { + all_equal = false; + break; + } + } + + if (all_equal) + return types[0]; + + std::unordered_map subcolumns_types; for (const auto & type : types) { @@ -235,7 +244,7 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambi subcolumns_types[tuple_paths[i]].push_back(tuple_types[i]); } - Paths tuple_paths; + PathsInData tuple_paths; DataTypes tuple_types; for (const auto & [key, subtypes] : subcolumns_types) @@ -298,9 +307,10 @@ void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescript namespace { -void flattenTupleImpl(Path path, DataTypePtr type, size_t array_level, Paths & new_paths, DataTypes & new_types) +void flattenTupleImpl(PathInDataBuilder & builder, DataTypePtr type, size_t array_level, PathsInData & new_paths, DataTypes & new_types) { bool is_nested = isNested(type); + if (is_nested) type = assert_cast(*type).getNestedType(); @@ -311,18 +321,18 @@ void flattenTupleImpl(Path path, DataTypePtr type, size_t array_level, Paths & n for (size_t i = 0; i < tuple_names.size(); ++i) { - auto next_path = Path::getNext(path, Path(tuple_names[i]), is_nested); - size_t next_level = array_level + is_nested; - flattenTupleImpl(next_path, tuple_types[i], next_level, new_paths, new_types); + builder.append(tuple_names[i], is_nested); + flattenTupleImpl(builder, tuple_types[i], array_level + is_nested, new_paths, new_types); + builder.popBack(); } } else if (const auto * type_array = typeid_cast(type.get())) { - flattenTupleImpl(path, type_array->getNestedType(), array_level + 1, new_paths, new_types); + flattenTupleImpl(builder, type_array->getNestedType(), array_level + 1, new_paths, new_types); } else { - new_paths.push_back(path); + new_paths.emplace_back(builder.getParts()); new_types.push_back(createArrayOfType(type, array_level)); } } @@ -352,7 +362,9 @@ void flattenTupleImpl(const ColumnPtr & column, Columns & new_columns, Columns & new_columns.push_back(std::move(new_column)); } else + { new_columns.push_back(column); + } } } @@ -464,12 +476,13 @@ std::pair createTypeFromNode(const Node * node) } -std::pair flattenTuple(const DataTypePtr & type) +std::pair flattenTuple(const DataTypePtr & type) { - Paths new_paths; + PathsInData new_paths; DataTypes new_types; + PathInDataBuilder builder; - flattenTupleImpl({}, type, 0, new_paths, new_types); + flattenTupleImpl(builder, type, 0, new_paths, new_types); return {new_paths, new_types}; } @@ -482,7 +495,7 @@ ColumnPtr flattenTuple(const ColumnPtr & column) return ColumnTuple::create(new_columns); } -DataTypePtr unflattenTuple(const Paths & paths, const DataTypes & tuple_types) +DataTypePtr unflattenTuple(const PathsInData & paths, const DataTypes & tuple_types) { assert(paths.size() == types.size()); Columns tuple_columns; @@ -494,7 +507,7 @@ DataTypePtr unflattenTuple(const Paths & paths, const DataTypes & tuple_types) } std::pair unflattenTuple( - const Paths & paths, + const PathsInData & paths, const DataTypes & tuple_types, const Columns & tuple_columns) { @@ -508,8 +521,10 @@ std::pair unflattenTuple( auto column = tuple_columns[i]; auto type = tuple_types[i]; - size_t num_parts = paths[i].getNumParts(); - size_t nested_level = paths[i].getIsNestedBitSet().count(); + const auto & parts = paths[i].getParts(); + + size_t num_parts = parts.size(); + size_t nested_level = std::count_if(parts.begin(), parts.end(), [](const auto & part) { return part.is_nested; }); size_t array_level = getNumberOfDimensions(*type); if (array_level < nested_level) diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index cc1a5070761..93c81b50422 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -21,22 +21,22 @@ ColumnPtr createArrayOfColumn(const ColumnPtr & column, size_t num_dimensions); DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); -void checkObjectHasNoAmbiguosPaths(const Paths & paths); +void checkObjectHasNoAmbiguosPaths(const PathsInData & paths); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambiguos_paths = false); NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescription & object_columns, bool with_subcolumns); using DataTypeTuplePtr = std::shared_ptr; -std::pair flattenTuple(const DataTypePtr & type); +std::pair flattenTuple(const DataTypePtr & type); ColumnPtr flattenTuple(const ColumnPtr & column); DataTypePtr unflattenTuple( - const Paths & paths, + const PathsInData & paths, const DataTypes & tuple_types); std::pair unflattenTuple( - const Paths & paths, + const PathsInData & paths, const DataTypes & tuple_types, const Columns & tuple_columns); diff --git a/src/DataTypes/Serializations/DataPath.cpp b/src/DataTypes/Serializations/DataPath.cpp deleted file mode 100644 index 51a007eb1a9..00000000000 --- a/src/DataTypes/Serializations/DataPath.cpp +++ /dev/null @@ -1,84 +0,0 @@ -#include -#include -#include -#include -#include -#include -#include - -#include -#include - -#include -#include - -namespace DB -{ - -Path::Path(std::string_view path_) - : path(path_) - , num_parts(1 + std::count(path.begin(), path.end(), '.')) -{ -} - -void Path::append(const Path & other) -{ - if (!other.path.empty()) - { - path.reserve(path.size() + other.path.size() + 1); - if (!path.empty()) - path += "."; - path += other.path; - } - - is_nested |= other.is_nested << num_parts; - num_parts += other.num_parts; -} - -Strings Path::getParts() const -{ - Strings parts; - parts.reserve(num_parts); - boost::algorithm::split(parts, path, boost::is_any_of(".")); - return parts; -} - -void Path::writeBinary(WriteBuffer & out) const -{ - writeStringBinary(path, out); - writeVarUInt(num_parts, out); - writeVarUInt(is_nested.to_ullong(), out); -} - -void Path::readBinary(ReadBuffer & in) -{ - readStringBinary(path, in); - readVarUInt(num_parts, in); - - UInt64 bits; - readVarUInt(bits, in); - is_nested = {bits}; -} - -Path Path::getNext(const Path & current_path, const Path & key, bool make_nested) -{ - Path next(current_path); - next.append(key); - - if (!next.empty()) - { - size_t nested_index = 0; - if (!current_path.empty()) - nested_index = current_path.num_parts - 1; - next.is_nested.set(nested_index, make_nested); - } - - return next; -} - -size_t Path::Hash::operator()(const Path & value) const -{ - return std::hash{}(value.path); -} - -} diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index 5e2acb5e824..4846646ded9 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -3,8 +3,7 @@ #include #include #include -#include -#include +#include namespace DB { @@ -31,12 +30,6 @@ static Field getValueAsField(const Element & element) throw Exception(ErrorCodes::LOGICAL_ERROR, "Unsupported type of JSON field"); } -struct ParseResult -{ - std::vector paths; - std::vector values; -}; - template class JSONDataParser { @@ -56,33 +49,47 @@ public: return {}; ParseResult result; - traverse(document, {}, result); + PathInDataBuilder builder; + std::vector paths; + + traverse(document, builder, paths, result.values); + + result.paths.reserve(paths.size()); + for (auto && path : paths) + result.paths.emplace_back(std::move(path)); + return result; } private: - void traverse(const Element & element, Path current_path, ParseResult & result) + void traverse( + const Element & element, + PathInDataBuilder & builder, + std::vector & paths, + std::vector & values) { checkStackSize(); if (element.isObject()) { auto object = element.getObject(); - result.paths.reserve(result.paths.size() + object.size()); - result.values.reserve(result.values.size() + object.size()); + + paths.reserve(paths.size() + object.size()); + values.reserve(values.size() + object.size()); for (auto it = object.begin(); it != object.end(); ++it) { const auto & [key, value] = *it; - traverse(value, Path::getNext(current_path, Path(key)), result); + traverse(value, builder.append(key, false), paths, values); + builder.popBack(); } } else if (element.isArray()) { auto array = element.getArray(); - using PathWithArray = std::pair; - using PathToArray = HashMap; + using PathPartsWithArray = std::pair; + using PathToArray = HashMapWithStackMemory; PathToArray arrays_by_path; Arena strings_pool; @@ -91,41 +98,47 @@ private: for (auto it = array.begin(); it != array.end(); ++it) { - ParseResult element_result; - traverse(*it, {}, element_result); + std::vector element_paths; + std::vector element_values; + PathInDataBuilder element_builder; - auto & [paths, values] = element_result; - for (size_t i = 0; i < paths.size(); ++i) + traverse(*it, element_builder, element_paths, element_values); + size_t size = element_paths.size(); + size_t keys_to_update = arrays_by_path.size(); + + for (size_t i = 0; i < size; ++i) { - if (auto * found = arrays_by_path.find(paths[i].getPath())) + UInt128 hash = PathInData::getPartsHash(element_paths[i]); + if (auto * found = arrays_by_path.find(hash)) { auto & path_array = found->getMapped().second; assert(path_array.size() == current_size); - path_array.push_back(std::move(values[i])); + path_array.push_back(std::move(element_values[i])); + --keys_to_update; } else { Array path_array; path_array.reserve(array.size()); path_array.resize(current_size); - path_array.push_back(std::move(values[i])); + path_array.push_back(std::move(element_values[i])); - const auto & path_str = paths[i].getPath(); - StringRef ref{strings_pool.insert(path_str.data(), path_str.size()), path_str.size()}; - - auto & elem = arrays_by_path[ref]; - elem.first = std::move(paths[i]); + auto & elem = arrays_by_path[hash]; + elem.first = std::move(element_paths[i]); elem.second = std::move(path_array); } } - for (auto & [_, value] : arrays_by_path) + if (keys_to_update) { - auto & path_array = value.second; - assert(path_array.size() == current_size || path_array.size() == current_size + 1); - if (path_array.size() == current_size) - path_array.push_back(Field()); + for (auto & [_, value] : arrays_by_path) + { + auto & path_array = value.second; + assert(path_array.size() == current_size || path_array.size() == current_size + 1); + if (path_array.size() == current_size) + path_array.push_back(Field()); + } } ++current_size; @@ -133,28 +146,31 @@ private: if (arrays_by_path.empty()) { - result.paths.push_back(current_path); - result.values.push_back(Array()); + paths.push_back(builder.getParts()); + values.push_back(Array()); } else { - result.paths.reserve(result.paths.size() + arrays_by_path.size()); - result.values.reserve(result.paths.size() + arrays_by_path.size()); + paths.reserve(paths.size() + arrays_by_path.size()); + values.reserve(values.size() + arrays_by_path.size()); - bool is_nested = arrays_by_path.size() > 1 || arrays_by_path.begin()->getKey().size != 0; + bool is_nested = arrays_by_path.size() > 1 || !arrays_by_path.begin()->getMapped().first.empty(); for (auto && [_, value] : arrays_by_path) { auto && [path, path_array] = value; - result.paths.push_back(Path::getNext(current_path, path, is_nested)); - result.values.push_back(std::move(path_array)); + + paths.push_back(builder.append(path, is_nested).getParts()); + values.push_back(std::move(path_array)); + + builder.popBack(path.size()); } } } else { - result.paths.push_back(std::move(current_path)); - result.values.push_back(getValueAsField(element)); + paths.push_back(builder.getParts()); + values.push_back(getValueAsField(element)); } } diff --git a/src/DataTypes/Serializations/PathInData.cpp b/src/DataTypes/Serializations/PathInData.cpp new file mode 100644 index 00000000000..86e8fb9d8a2 --- /dev/null +++ b/src/DataTypes/Serializations/PathInData.cpp @@ -0,0 +1,174 @@ +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include +#include + +namespace DB +{ + +PathInData::PathInData(std::string_view path_) + : path(path_) +{ + const char * begin = path.data(); + const char * end = path.data() + path.size(); + + for (const char * it = path.data(); it != end; ++it) + { + if (*it == '.') + { + size_t size = static_cast(it - begin); + parts.emplace_back(std::string_view{begin, size}, false); + begin = it + 1; + } + } + + size_t size = static_cast(end - begin); + parts.emplace_back(std::string_view{begin, size}, false); +} + +PathInData::PathInData(const Parts & parts_) + : path(buildPath(parts_)) + , parts(buildParts(path, parts_)) +{ +} + +PathInData::PathInData(const PathInData & other) + : path(other.path) + , parts(buildParts(path, other.getParts())) +{ +} + +PathInData & PathInData::operator=(const PathInData & other) +{ + if (this != &other) + { + path = other.path; + parts = buildParts(path, other.parts); + } + return *this; +} + +UInt128 PathInData::getPartsHash(const Parts & parts_) +{ + SipHash hash; + hash.update(parts_.size()); + for (const auto & part : parts_) + { + hash.update(part.key.data(), part.key.length()); + hash.update(part.is_nested); + } + + UInt128 res; + hash.get128(res); + return res; +} + +void PathInData::writeBinary(WriteBuffer & out) const +{ + writeVarUInt(parts.size(), out); + for (const auto & part : parts) + { + writeStringBinary(part.key, out); + writeVarUInt(static_cast(part.is_nested) , out); + } +} + +void PathInData::readBinary(ReadBuffer & in) +{ + size_t num_parts; + readVarUInt(num_parts, in); + + Arena arena; + Parts temp_parts; + temp_parts.reserve(num_parts); + + for (size_t i = 0; i < num_parts; ++i) + { + UInt8 is_nested; + auto ref = readStringBinaryInto(arena, in); + readVarUInt(is_nested, in); + + temp_parts.emplace_back(static_cast(ref), is_nested); + } + + path = buildPath(temp_parts); + parts = buildParts(path, temp_parts); +} + +String PathInData::buildPath(const Parts & other_parts) +{ + if (other_parts.empty()) + return ""; + + String res; + auto it = other_parts.begin(); + res += it->key; + ++it; + for (; it != other_parts.end(); ++it) + { + res += "."; + res += it->key; + } + + return res; +} + +PathInData::Parts PathInData::buildParts(const String & path, const Parts & other_parts) +{ + if (other_parts.empty()) + return {}; + + Parts res; + const char * begin = path.data(); + for (const auto & part : other_parts) + { + res.emplace_back(std::string_view{begin, part.key.length()}, part.is_nested); + begin += part.key.length() + 1; + } + return res; +} + +size_t PathInData::Hash::operator()(const PathInData & value) const +{ + return std::hash{}(value.path); +} + +PathInDataBuilder & PathInDataBuilder::append(std::string_view key, bool is_nested) +{ + if (!parts.empty()) + parts.back().is_nested = is_nested; + + parts.emplace_back(key, false); + return *this; +} + +PathInDataBuilder & PathInDataBuilder::append(const PathInData::Parts & path, bool is_nested) +{ + if (!parts.empty()) + parts.back().is_nested = is_nested; + + parts.insert(parts.end(), path.begin(), path.end()); + return *this; +} + +void PathInDataBuilder::popBack() +{ + parts.pop_back(); +} + +void PathInDataBuilder::popBack(size_t n) +{ + assert(n <= parts.size()); + parts.resize(parts.size() - n); +} + +} diff --git a/src/DataTypes/Serializations/PathInData.h b/src/DataTypes/Serializations/PathInData.h new file mode 100644 index 00000000000..04cfff922d0 --- /dev/null +++ b/src/DataTypes/Serializations/PathInData.h @@ -0,0 +1,85 @@ +#pragma once + +#include +#include +#include + +namespace DB +{ + +class ReadBuffer; +class WriteBuffer; + +class PathInData +{ +public: + struct Part + { + Part() = default; + Part(std::string_view key_, bool is_nested_) + : key(key_), is_nested(is_nested_) + { + } + + std::string_view key; + bool is_nested = false; + }; + + using Parts = std::vector; + + PathInData() = default; + explicit PathInData(std::string_view path_); + explicit PathInData(const Parts & parts_); + + PathInData(const PathInData & other); + PathInData & operator=(const PathInData & other); + + static UInt128 getPartsHash(const Parts & parts_); + + bool empty() const { return parts.empty(); } + + const String & getPath() const { return path; } + const Parts & getParts() const { return parts; } + + bool isNested(size_t i) const { return parts[i].is_nested; } + bool hasNested() const { return std::any_of(parts.begin(), parts.end(), [](const auto & part) { return part.is_nested; }); } + + void writeBinary(WriteBuffer & out) const; + void readBinary(ReadBuffer & in); + + bool operator==(const PathInData & other) const { return path == other.path; } + bool operator!=(const PathInData & other) const { return !(*this == other); } + struct Hash { size_t operator()(const PathInData & value) const; }; + +private: + static String buildPath(const Parts & other_parts); + static Parts buildParts(const String & path, const Parts & other_parts); + + String path; + Parts parts; +}; + +class PathInDataBuilder +{ +public: + const PathInData::Parts & getParts() const { return parts; } + + PathInDataBuilder & append(std::string_view key, bool is_nested); + PathInDataBuilder & append(const PathInData::Parts & path, bool is_nested); + + void popBack(); + void popBack(size_t n); + +private: + PathInData::Parts parts; +}; + +using PathsInData = std::vector; + +struct ParseResult +{ + std::vector paths; + std::vector values; +}; + +} diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index 4f35bbd284e..e9eb962dfc5 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -307,7 +307,7 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( settings.path.back() = Substream::ObjectElement; for (size_t i = 0; i < num_subcolumns; ++i) { - Path key; + PathInData key; String type_name; settings.path.back() = Substream::ObjectStructure; @@ -331,7 +331,7 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( auto serialization = type->getDefaultSerialization(); ColumnPtr subcolumn_data = type->createColumn(); serialization->deserializeBinaryBulkWithMultipleStreams(subcolumn_data, limit, settings, state, cache); - column_object.addSubcolumn(Path(key), subcolumn_data->assumeMutable()); + column_object.addSubcolumn(PathInData(key), subcolumn_data->assumeMutable()); } else { diff --git a/src/DataTypes/Serializations/DataPath.h b/src/DataTypes/Serializations/SubcolumnsTree.h similarity index 64% rename from src/DataTypes/Serializations/DataPath.h rename to src/DataTypes/Serializations/SubcolumnsTree.h index 319eed817c9..a1700f47b60 100644 --- a/src/DataTypes/Serializations/DataPath.h +++ b/src/DataTypes/Serializations/SubcolumnsTree.h @@ -1,56 +1,11 @@ -#pragma once - -#include +#include #include #include #include -#include namespace DB { -class ReadBuffer; -class WriteBuffer; - -class Path -{ -public: - /// TODO: use dynamic bitset - using BitSet = std::bitset<64>; - - Path() = default; - explicit Path(std::string_view path_); - - void append(const Path & other); - void append(std::string_view key); - - const String & getPath() const { return path; } - bool isNested(size_t i) const { return is_nested.test(i); } - bool hasNested() const { return is_nested.any(); } - BitSet getIsNestedBitSet() const { return is_nested; } - - size_t getNumParts() const { return num_parts; } - bool empty() const { return path.empty(); } - - Strings getParts() const; - - static Path getNext(const Path & current_path, const Path & key, bool make_nested = false); - - void writeBinary(WriteBuffer & out) const; - void readBinary(ReadBuffer & in); - - bool operator==(const Path & other) const { return path == other.path; } - bool operator!=(const Path & other) const { return !(*this == other); } - struct Hash { size_t operator()(const Path & value) const; }; - -private: - String path; - size_t num_parts = 0; - BitSet is_nested; -}; - -using Paths = std::vector; - struct EmptyNodeData {}; template @@ -72,15 +27,15 @@ public: Kind kind = TUPLE; const Node * parent = nullptr; - std::unordered_map> children; + std::map, std::less<>> children; NodeData data; bool isNested() const { return kind == NESTED; } - void addChild(const String & key_, std::shared_ptr next_node) + void addChild(const String & key, std::shared_ptr next_node) { next_node->parent = this; - children[key_] = std::move(next_node); + children[key] = std::move(next_node); } virtual ~Node() = default; @@ -88,12 +43,12 @@ public: struct Leaf : public Node { - Leaf(const Path & path_, const LeafData & data_) + Leaf(const PathInData & path_, const LeafData & data_) : Node(Node::SCALAR), path(path_), data(data_) { } - Path path; + PathInData path; LeafData data; }; @@ -101,7 +56,7 @@ public: using NodePtr = std::shared_ptr; using LeafPtr = std::shared_ptr; - bool add(const Path & path, const LeafData & leaf_data) + bool add(const PathInData & path, const LeafData & leaf_data) { return add(path, [&](NodeKind kind, bool exists) -> NodePtr { @@ -117,10 +72,9 @@ public: using NodeCreator = std::function; - bool add(const Path & path, const NodeCreator & node_creator) + bool add(const PathInData & path, const NodeCreator & node_creator) { - auto parts = path.getParts(); - auto is_nested = path.getIsNestedBitSet(); + const auto & parts = path.getParts(); if (parts.empty()) return false; @@ -133,31 +87,31 @@ public: { assert(current_node->kind != Node::SCALAR); - auto it = current_node->children.find(parts[i]); + auto it = current_node->children.find(parts[i].key); if (it != current_node->children.end()) { current_node = it->second.get(); node_creator(current_node->kind, true); bool current_node_is_nested = current_node->kind == Node::NESTED; - if (current_node_is_nested != is_nested.test(i)) + if (current_node_is_nested != parts[i].is_nested) return false; } else { - auto next_kind = is_nested.test(i) ? Node::NESTED : Node::TUPLE; + auto next_kind = parts[i].is_nested ? Node::NESTED : Node::TUPLE; auto next_node = node_creator(next_kind, false); - current_node->addChild(parts[i], next_node); + current_node->addChild(String(parts[i].key), next_node); current_node = next_node.get(); } } - auto it = current_node->children.find(parts.back()); + auto it = current_node->children.find(parts.back().key); if (it != current_node->children.end()) return false; auto next_node = node_creator(Node::SCALAR, false); - current_node->addChild(parts.back(), next_node); + current_node->addChild(String(parts.back().key), next_node); auto leaf = std::dynamic_pointer_cast(next_node); assert(leaf); @@ -166,17 +120,17 @@ public: return true; } - const Node * findBestMatch(const Path & path) const + const Node * findBestMatch(const PathInData & path) const { return findImpl(path, false); } - const Node * findExact(const Path & path) const + const Node * findExact(const PathInData & path) const { return findImpl(path, true); } - const Leaf * findLeaf(const Path & path) const + const Leaf * findLeaf(const PathInData & path) const { return typeid_cast(findExact(path)); } @@ -226,17 +180,18 @@ public: const_iterator end() const { return leaves.end(); } private: - const Node * findImpl(const Path & path, bool find_exact) const + const Node * findImpl(const PathInData & path, bool find_exact) const { if (!root) return nullptr; - auto parts = path.getParts(); + const auto & parts = path.getParts(); const Node * current_node = root.get(); for (const auto & part : parts) { - auto it = current_node->children.find(part); + auto it = current_node->children.find(part.key); + // std::cerr << "part: " << part.key << ", found: " << (it != current_node->children.end()) << '\n'; if (it == current_node->children.end()) return find_exact ? nullptr : current_node; diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index 51f590d273a..f58864b2ed0 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -3103,7 +3103,7 @@ private: throw Exception(ErrorCodes::TYPE_MISMATCH, "Cast to Object can be performed only from flatten Named Tuple. Got: {}", from_type->getName()); - Paths paths; + PathsInData paths; DataTypes from_types; std::tie(paths, from_types) = flattenTuple(from_type); diff --git a/tests/queries/0_stateless/01825_type_json_4.reference b/tests/queries/0_stateless/01825_type_json_4.reference index 5c4f9d3bcf4..c2518bcde58 100644 --- a/tests/queries/0_stateless/01825_type_json_4.reference +++ b/tests/queries/0_stateless/01825_type_json_4.reference @@ -1,4 +1,4 @@ -Code: 641 +Code: 642 Code: 15 Code: 53 1 ('v1') Tuple(k1 String) diff --git a/tests/queries/0_stateless/01825_type_json_4.sh b/tests/queries/0_stateless/01825_type_json_4.sh index 062c77677ac..7945ebcaaa0 100755 --- a/tests/queries/0_stateless/01825_type_json_4.sh +++ b/tests/queries/0_stateless/01825_type_json_4.sh @@ -11,7 +11,7 @@ $CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_4(id UInt64, data JSON) \ ENGINE = MergeTree ORDER BY tuple()" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [1, 2]}}' \ - | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 641" + | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 642" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [{"k2" : 1}, {"k2" : 2}]}}' \ | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 15" From 587d7399ba7afbbce421b6c8e34ad00dc4b56aec Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 9 Feb 2022 03:18:53 +0300 Subject: [PATCH 062/132] support dynamic subcolumns for Memory engine --- src/Core/Block.cpp | 12 --- src/Core/Block.h | 4 - src/DataTypes/IDataType.cpp | 16 ++- src/DataTypes/IDataType.h | 6 +- src/DataTypes/ObjectUtils.cpp | 2 + src/Interpreters/getColumnFromBlock.cpp | 51 +++++++++ src/Interpreters/getColumnFromBlock.h | 12 +++ src/Interpreters/inplaceBlockConversions.cpp | 97 +++++++++++++++++ src/Interpreters/inplaceBlockConversions.h | 14 +++ src/Storages/MergeTree/IMergeTreeReader.cpp | 100 ++---------------- src/Storages/MergeTree/IMergeTreeReader.h | 6 +- src/Storages/MergeTree/MergeTreeData.cpp | 3 + .../MergeTree/MergeTreeDataWriter.cpp | 10 +- .../MergeTree/MergeTreeReaderInMemory.cpp | 1 + src/Storages/StorageBuffer.cpp | 1 + src/Storages/StorageMemory.cpp | 78 +++++++++++--- src/Storages/StorageMemory.h | 7 ++ ...ference => 01825_type_json_3.reference.j2} | 8 +- ...pe_json_3.sql => 01825_type_json_3.sql.j2} | 35 +++--- 19 files changed, 312 insertions(+), 151 deletions(-) create mode 100644 src/Interpreters/getColumnFromBlock.cpp create mode 100644 src/Interpreters/getColumnFromBlock.h rename tests/queries/0_stateless/{01825_type_json_3.reference => 01825_type_json_3.reference.j2} (82%) rename tests/queries/0_stateless/{01825_type_json_3.sql => 01825_type_json_3.sql.j2} (65%) diff --git a/src/Core/Block.cpp b/src/Core/Block.cpp index dce737483c3..8bf7a66d56f 100644 --- a/src/Core/Block.cpp +++ b/src/Core/Block.cpp @@ -721,18 +721,6 @@ void convertToFullIfSparse(Block & block) column.column = recursiveRemoveSparse(column.column); } -ColumnPtr getColumnFromBlock(const Block & block, const NameAndTypePair & column) -{ - auto current_column = block.getByName(column.getNameInStorage()).column; - current_column = current_column->decompress(); - - if (column.isSubcolumn()) - return column.getTypeInStorage()->getSubcolumn(column.getSubcolumnName(), current_column); - - return current_column; -} - - Block materializeBlock(const Block & block) { if (!block) diff --git a/src/Core/Block.h b/src/Core/Block.h index efa5ce7c326..ce8335919e8 100644 --- a/src/Core/Block.h +++ b/src/Core/Block.h @@ -195,10 +195,6 @@ void getBlocksDifference(const Block & lhs, const Block & rhs, std::string & out void convertToFullIfSparse(Block & block); -/// Helps in-memory storages to extract columns from block. -/// Properly handles cases, when column is a subcolumn and when it is compressed. -ColumnPtr getColumnFromBlock(const Block & block, const NameAndTypePair & column); - /// Converts columns-constants to full columns ("materializes" them). Block materializeBlock(const Block & block); void materializeBlockInplace(Block & block); diff --git a/src/DataTypes/IDataType.cpp b/src/DataTypes/IDataType.cpp index edc9e4159f4..0976233c031 100644 --- a/src/DataTypes/IDataType.cpp +++ b/src/DataTypes/IDataType.cpp @@ -126,19 +126,25 @@ DataTypePtr IDataType::tryGetSubcolumnType(const String & subcolumn_name) const DataTypePtr IDataType::getSubcolumnType(const String & subcolumn_name) const { SubstreamData data = { getDefaultSerialization(), getPtr(), nullptr, nullptr }; - return getForSubcolumn(subcolumn_name, data, &SubstreamData::type); + return getForSubcolumn(subcolumn_name, data, &SubstreamData::type, true); } -SerializationPtr IDataType::getSubcolumnSerialization(const String & subcolumn_name, const SerializationPtr & serialization) const +ColumnPtr IDataType::tryGetSubcolumn(const String & subcolumn_name, const ColumnPtr & column) const { - SubstreamData data = { serialization, nullptr, nullptr, nullptr }; - return getForSubcolumn(subcolumn_name, data, &SubstreamData::serialization); + SubstreamData data = { getDefaultSerialization(), nullptr, column, nullptr }; + return getForSubcolumn(subcolumn_name, data, &SubstreamData::column, false); } ColumnPtr IDataType::getSubcolumn(const String & subcolumn_name, const ColumnPtr & column) const { SubstreamData data = { getDefaultSerialization(), nullptr, column, nullptr }; - return getForSubcolumn(subcolumn_name, data, &SubstreamData::column); + return getForSubcolumn(subcolumn_name, data, &SubstreamData::column, true); +} + +SerializationPtr IDataType::getSubcolumnSerialization(const String & subcolumn_name, const SerializationPtr & serialization) const +{ + SubstreamData data = { serialization, nullptr, nullptr, nullptr }; + return getForSubcolumn(subcolumn_name, data, &SubstreamData::serialization, true); } Names IDataType::getSubcolumnNames() const diff --git a/src/DataTypes/IDataType.h b/src/DataTypes/IDataType.h index b8e0061b67e..d8e51eb22d0 100644 --- a/src/DataTypes/IDataType.h +++ b/src/DataTypes/IDataType.h @@ -82,9 +82,11 @@ public: DataTypePtr tryGetSubcolumnType(const String & subcolumn_name) const; DataTypePtr getSubcolumnType(const String & subcolumn_name) const; - SerializationPtr getSubcolumnSerialization(const String & subcolumn_name, const SerializationPtr & serialization) const; + ColumnPtr tryGetSubcolumn(const String & subcolumn_name, const ColumnPtr & column) const; ColumnPtr getSubcolumn(const String & subcolumn_name, const ColumnPtr & column) const; + SerializationPtr getSubcolumnSerialization(const String & subcolumn_name, const SerializationPtr & serialization) const; + using SubstreamData = ISerialization::SubstreamData; using SubstreamPath = ISerialization::SubstreamPath; @@ -309,7 +311,7 @@ private: const String & subcolumn_name, const SubstreamData & data, Ptr SubstreamData::*member, - bool throw_if_null = true) const; + bool throw_if_null) const; }; diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 920cad8a5c7..8c5d4750cf0 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -133,6 +133,8 @@ static auto extractVector(const std::vector & vec) void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns) { + std::cerr << "convertion to tuples columns: " << columns_list.toString() << ", block: " << block.dumpStructure() << ", extended_storage_columns: " << extended_storage_columns.toString(); + std::unordered_map storage_columns_map; for (const auto & [name, type] : extended_storage_columns) storage_columns_map[name] = type; diff --git a/src/Interpreters/getColumnFromBlock.cpp b/src/Interpreters/getColumnFromBlock.cpp new file mode 100644 index 00000000000..159457f45c1 --- /dev/null +++ b/src/Interpreters/getColumnFromBlock.cpp @@ -0,0 +1,51 @@ +#include +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int NOT_FOUND_COLUMN_IN_BLOCK; +} + +ColumnPtr tryGetColumnFromBlock(const Block & block, const NameAndTypePair & requested_column) +{ + const auto * elem = block.findByName(requested_column.getNameInStorage()); + if (!elem) + return nullptr; + + auto subcolumn_name = requested_column.getSubcolumnName(); + + DataTypePtr elem_type; + ColumnPtr elem_column; + + if (requested_column.isSubcolumn()) + { + elem_type = elem->type->tryGetSubcolumnType(subcolumn_name); + elem_column = elem->type->tryGetSubcolumn(subcolumn_name, elem->column); + + if (!elem_type || !elem_column) + return nullptr; + } + else + { + elem_type = elem->type; + elem_column = elem->column; + } + + return castColumn({elem_column, elem_type, ""}, requested_column.type); +} + +ColumnPtr getColumnFromBlock(const Block & block, const NameAndTypePair & requested_column) +{ + auto result_column = tryGetColumnFromBlock(block, requested_column); + if (!result_column) + throw Exception(ErrorCodes::NOT_FOUND_COLUMN_IN_BLOCK, + "Not found column or subcolumn {} in block. There are only columns: {}", + requested_column.name, block.dumpNames()); + + return result_column; +} + +} diff --git a/src/Interpreters/getColumnFromBlock.h b/src/Interpreters/getColumnFromBlock.h new file mode 100644 index 00000000000..04b0940e243 --- /dev/null +++ b/src/Interpreters/getColumnFromBlock.h @@ -0,0 +1,12 @@ +#include + +namespace DB +{ + +/// Helps in-memory storages to extract columns from block. +/// Properly handles cases, when column is a subcolumn and when it is compressed. +ColumnPtr getColumnFromBlock(const Block & block, const NameAndTypePair & requested_column); + +ColumnPtr tryGetColumnFromBlock(const Block & block, const NameAndTypePair & requested_column); + +} diff --git a/src/Interpreters/inplaceBlockConversions.cpp b/src/Interpreters/inplaceBlockConversions.cpp index 2841abe757e..5c05cc06fc2 100644 --- a/src/Interpreters/inplaceBlockConversions.cpp +++ b/src/Interpreters/inplaceBlockConversions.cpp @@ -15,6 +15,10 @@ #include #include #include +#include +#include +#include +#include namespace DB @@ -185,4 +189,97 @@ ActionsDAGPtr evaluateMissingDefaults( return createExpressions(header, expr_list, save_unneeded_columns, required_columns, context); } +static bool arrayHasNoElementsRead(const IColumn & column) +{ + const auto * column_array = typeid_cast(&column); + + if (!column_array) + return false; + + size_t size = column_array->size(); + if (!size) + return false; + + size_t data_size = column_array->getData().size(); + if (data_size) + return false; + + size_t last_offset = column_array->getOffsets()[size - 1]; + return last_offset != 0; +} + +void fillMissingColumns( + Columns & res_columns, + size_t num_rows, + const NamesAndTypesList & requested_columns, + StorageMetadataPtr metadata_snapshot) +{ + size_t num_columns = requested_columns.size(); + if (num_columns != res_columns.size()) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Invalid number of columns passed to fillMissingColumns. Expected {}, got {}", + num_columns, res_columns.size()); + + /// For a missing column of a nested data structure we must create not a column of empty + /// arrays, but a column of arrays of correct length. + + /// First, collect offset columns for all arrays in the block. + + std::unordered_map offset_columns; + auto requested_column = requested_columns.begin(); + for (size_t i = 0; i < num_columns; ++i, ++requested_column) + { + if (res_columns[i] == nullptr) + continue; + + if (const auto * array = typeid_cast(res_columns[i].get())) + { + String offsets_name = Nested::extractTableName(requested_column->name); + auto & offsets_column = offset_columns[offsets_name]; + + /// If for some reason multiple offsets columns are present for the same nested data structure, + /// choose the one that is not empty. + if (!offsets_column || offsets_column->empty()) + offsets_column = array->getOffsetsPtr(); + } + } + + /// insert default values only for columns without default expressions + requested_column = requested_columns.begin(); + for (size_t i = 0; i < num_columns; ++i, ++requested_column) + { + const auto & [name, type] = *requested_column; + + if (res_columns[i] && arrayHasNoElementsRead(*res_columns[i])) + res_columns[i] = nullptr; + + if (res_columns[i] == nullptr) + { + if (metadata_snapshot && metadata_snapshot->getColumns().hasDefault(name)) + continue; + + String offsets_name = Nested::extractTableName(name); + auto offset_it = offset_columns.find(offsets_name); + const auto * array_type = typeid_cast(type.get()); + if (offset_it != offset_columns.end() && array_type) + { + const auto & nested_type = array_type->getNestedType(); + ColumnPtr offsets_column = offset_it->second; + size_t nested_rows = typeid_cast(*offsets_column).getData().back(); + + ColumnPtr nested_column = + nested_type->createColumnConstWithDefaultValue(nested_rows)->convertToFullColumnIfConst(); + + res_columns[i] = ColumnArray::create(nested_column, offsets_column); + } + else + { + /// We must turn a constant column into a full column because the interpreter could infer + /// that it is constant everywhere but in some blocks (from other parts) it can be a full column. + res_columns[i] = type->createColumnConstWithDefaultValue(num_rows)->convertToFullColumnIfConst(); + } + } + } +} + } diff --git a/src/Interpreters/inplaceBlockConversions.h b/src/Interpreters/inplaceBlockConversions.h index cc8261693f9..b3113ddfa5c 100644 --- a/src/Interpreters/inplaceBlockConversions.h +++ b/src/Interpreters/inplaceBlockConversions.h @@ -1,6 +1,7 @@ #pragma once #include +#include #include #include @@ -14,6 +15,13 @@ class Block; class NamesAndTypesList; class ColumnsDescription; +class IColumn; +using ColumnPtr = COW::Ptr; +using Columns = std::vector; + +struct StorageInMemoryMetadata; +using StorageMetadataPtr = std::shared_ptr; + class ActionsDAG; using ActionsDAGPtr = std::shared_ptr; @@ -31,4 +39,10 @@ ActionsDAGPtr evaluateMissingDefaults( /// Tries to convert columns in block to required_columns void performRequiredConversions(Block & block, const NamesAndTypesList & required_columns, ContextPtr context); +void fillMissingColumns( + Columns & res_columns, + size_t num_rows, + const NamesAndTypesList & requested_columns, + StorageMetadataPtr metadata_snapshot); + } diff --git a/src/Storages/MergeTree/IMergeTreeReader.cpp b/src/Storages/MergeTree/IMergeTreeReader.cpp index 81f10d52a79..77662f69fa9 100644 --- a/src/Storages/MergeTree/IMergeTreeReader.cpp +++ b/src/Storages/MergeTree/IMergeTreeReader.cpp @@ -62,101 +62,13 @@ const IMergeTreeReader::ValueSizeMap & IMergeTreeReader::getAvgValueSizeHints() return avg_value_size_hints; } - -static bool arrayHasNoElementsRead(const IColumn & column) -{ - const auto * column_array = typeid_cast(&column); - - if (!column_array) - return false; - - size_t size = column_array->size(); - if (!size) - return false; - - size_t data_size = column_array->getData().size(); - if (data_size) - return false; - - size_t last_offset = column_array->getOffsets()[size - 1]; - return last_offset != 0; -} - -void IMergeTreeReader::fillMissingColumns(Columns & res_columns, bool & should_evaluate_missing_defaults, size_t num_rows) +void IMergeTreeReader::fillMissingColumns(Columns & res_columns, bool & should_evaluate_missing_defaults, size_t num_rows) const { try { - size_t num_columns = columns.size(); - - if (res_columns.size() != num_columns) - throw Exception("invalid number of columns passed to MergeTreeReader::fillMissingColumns. " - "Expected " + toString(num_columns) + ", " - "got " + toString(res_columns.size()), ErrorCodes::LOGICAL_ERROR); - - /// For a missing column of a nested data structure we must create not a column of empty - /// arrays, but a column of arrays of correct length. - - /// First, collect offset columns for all arrays in the block. - OffsetColumns offset_columns; - auto requested_column = columns.begin(); - for (size_t i = 0; i < num_columns; ++i, ++requested_column) - { - if (res_columns[i] == nullptr) - continue; - - if (const auto * array = typeid_cast(res_columns[i].get())) - { - String offsets_name = Nested::extractTableName(requested_column->name); - auto & offsets_column = offset_columns[offsets_name]; - - /// If for some reason multiple offsets columns are present for the same nested data structure, - /// choose the one that is not empty. - if (!offsets_column || offsets_column->empty()) - offsets_column = array->getOffsetsPtr(); - } - } - - should_evaluate_missing_defaults = false; - - /// insert default values only for columns without default expressions - requested_column = columns.begin(); - for (size_t i = 0; i < num_columns; ++i, ++requested_column) - { - auto & [name, type] = *requested_column; - - if (res_columns[i] && arrayHasNoElementsRead(*res_columns[i])) - res_columns[i] = nullptr; - - if (res_columns[i] == nullptr) - { - if (metadata_snapshot->getColumns().hasDefault(name)) - { - should_evaluate_missing_defaults = true; - continue; - } - - String offsets_name = Nested::extractTableName(name); - auto offset_it = offset_columns.find(offsets_name); - const auto * array_type = typeid_cast(type.get()); - if (offset_it != offset_columns.end() && array_type) - { - const auto & nested_type = array_type->getNestedType(); - ColumnPtr offsets_column = offset_it->second; - size_t nested_rows = typeid_cast(*offsets_column).getData().back(); - - ColumnPtr nested_column = - nested_type->createColumnConstWithDefaultValue(nested_rows)->convertToFullColumnIfConst(); - - res_columns[i] = ColumnArray::create(nested_column, offsets_column); - } - else - { - /// We must turn a constant column into a full column because the interpreter could infer - /// that it is constant everywhere but in some blocks (from other parts) it can be a full column. - res_columns[i] = type->createColumnConstWithDefaultValue(num_rows)->convertToFullColumnIfConst(); - } - } - } + DB::fillMissingColumns(res_columns, num_rows, columns, metadata_snapshot); + should_evaluate_missing_defaults = std::any_of( + res_columns.begin(), res_columns.end(), [](const auto & column) { return column == nullptr; }); } catch (Exception & e) { @@ -166,7 +78,7 @@ void IMergeTreeReader::fillMissingColumns(Columns & res_columns, bool & should_e } } -void IMergeTreeReader::evaluateMissingDefaults(Block additional_columns, Columns & res_columns) +void IMergeTreeReader::evaluateMissingDefaults(Block additional_columns, Columns & res_columns) const { try { @@ -244,7 +156,7 @@ NameAndTypePair IMergeTreeReader::getColumnFromPart(const NameAndTypePair & requ return {String(it->getKey()), type}; } -void IMergeTreeReader::performRequiredConversions(Columns & res_columns) +void IMergeTreeReader::performRequiredConversions(Columns & res_columns) const { try { diff --git a/src/Storages/MergeTree/IMergeTreeReader.h b/src/Storages/MergeTree/IMergeTreeReader.h index 28334b9a8bb..7c5977b5cb2 100644 --- a/src/Storages/MergeTree/IMergeTreeReader.h +++ b/src/Storages/MergeTree/IMergeTreeReader.h @@ -44,13 +44,13 @@ public: /// Add columns from ordered_names that are not present in the block. /// Missing columns are added in the order specified by ordered_names. /// num_rows is needed in case if all res_columns are nullptr. - void fillMissingColumns(Columns & res_columns, bool & should_evaluate_missing_defaults, size_t num_rows); + void fillMissingColumns(Columns & res_columns, bool & should_evaluate_missing_defaults, size_t num_rows) const; /// Evaluate defaulted columns if necessary. - void evaluateMissingDefaults(Block additional_columns, Columns & res_columns); + void evaluateMissingDefaults(Block additional_columns, Columns & res_columns) const; /// If part metadata is not equal to storage metadata, than /// try to perform conversions of columns. - void performRequiredConversions(Columns & res_columns); + void performRequiredConversions(Columns & res_columns) const; const NamesAndTypesList & getColumns() const { return columns; } size_t numColumnsInResult() const { return columns.size(); } diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index f7a9434e561..d2ec15034ca 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -5964,6 +5964,9 @@ ReservationPtr MergeTreeData::balancedReservation( ColumnsDescription MergeTreeData::getObjectsDescription(const DataPartsVector & parts, const NameSet & object_names) { + if (object_names.empty()) + return {}; + std::unordered_map types_in_parts; if (parts.empty()) diff --git a/src/Storages/MergeTree/MergeTreeDataWriter.cpp b/src/Storages/MergeTree/MergeTreeDataWriter.cpp index 6308074d0e7..8831ec5c5dd 100644 --- a/src/Storages/MergeTree/MergeTreeDataWriter.cpp +++ b/src/Storages/MergeTree/MergeTreeDataWriter.cpp @@ -277,10 +277,14 @@ MergeTreeData::MutableDataPartPtr MergeTreeDataWriter::writeTempPart( Block & block = block_with_partition.block; auto columns = metadata_snapshot->getColumns().getAllPhysical().filter(block.getNames()); auto storage_snapshot = data.getStorageSnapshot(metadata_snapshot); - auto extended_storage_columns = storage_snapshot->getColumns( - GetColumnsOptions(GetColumnsOptions::AllPhysical).withExtendedObjects()); - convertObjectsToTuples(columns, block, extended_storage_columns); + if (!storage_snapshot->object_columns.empty()) + { + auto extended_storage_columns = storage_snapshot->getColumns( + GetColumnsOptions(GetColumnsOptions::AllPhysical).withExtendedObjects()); + + convertObjectsToTuples(columns, block, extended_storage_columns); + } static const String TMP_PREFIX = "tmp_insert_"; diff --git a/src/Storages/MergeTree/MergeTreeReaderInMemory.cpp b/src/Storages/MergeTree/MergeTreeReaderInMemory.cpp index 8a69183e858..e2bd018bd22 100644 --- a/src/Storages/MergeTree/MergeTreeReaderInMemory.cpp +++ b/src/Storages/MergeTree/MergeTreeReaderInMemory.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include diff --git a/src/Storages/StorageBuffer.cpp b/src/Storages/StorageBuffer.cpp index af9e4f2fc8e..eda1405e96a 100644 --- a/src/Storages/StorageBuffer.cpp +++ b/src/Storages/StorageBuffer.cpp @@ -5,6 +5,7 @@ #include #include #include +#include #include #include #include diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp index ef097de9115..ab4edd8b58b 100644 --- a/src/Storages/StorageMemory.cpp +++ b/src/Storages/StorageMemory.cpp @@ -2,9 +2,13 @@ #include #include +#include +#include #include #include #include +#include +#include #include #include @@ -36,7 +40,7 @@ public: InitializerFunc initializer_func_ = {}) : SourceWithProgress(storage_snapshot->getSampleBlockForColumns(column_names_)) , column_names_and_types(storage_snapshot->getColumnsByNames( - GetColumnsOptions(GetColumnsOptions::All).withSubcolumns(), column_names_)) + GetColumnsOptions(GetColumnsOptions::All).withSubcolumns().withExtendedObjects(), column_names_)) , data(data_) , parallel_execution_index(parallel_execution_index_) , initializer_func(std::move(initializer_func_)) @@ -62,12 +66,20 @@ protected: } const Block & src = (*data)[current_index]; - Columns columns; - columns.reserve(column_names_and_types.size()); - /// Add only required columns to `res`. - for (const auto & elem : column_names_and_types) - columns.emplace_back(getColumnFromBlock(src, elem)); + Columns columns; + size_t num_columns = column_names_and_types.size(); + columns.reserve(num_columns); + + auto name_and_type = column_names_and_types.begin(); + for (size_t i = 0; i < num_columns; ++i) + { + columns.emplace_back(tryGetColumnFromBlock(src, *name_and_type)); + ++name_and_type; + } + + fillMissingColumns(columns, src.rows(), column_names_and_types, /*metadata_snapshot=*/ nullptr); + assert(std::all(columns.begin(), columns.end(), [](const auto & column) { return column != nullptr; })); return Chunk(std::move(columns), src.rows()); } @@ -101,7 +113,7 @@ public: const StorageMetadataPtr & metadata_snapshot_) : SinkToStorage(metadata_snapshot_->getSampleBlock()) , storage(storage_) - , metadata_snapshot(metadata_snapshot_) + , storage_snapshot(storage_.getStorageSnapshot(metadata_snapshot_)) { } @@ -110,7 +122,15 @@ public: void consume(Chunk chunk) override { auto block = getHeader().cloneWithColumns(chunk.getColumns()); - metadata_snapshot->check(block, true); + storage_snapshot->metadata->check(block, true); + if (!storage_snapshot->object_columns.empty()) + { + auto columns = storage_snapshot->metadata->getColumns().getAllPhysical().filter(block.getNames()); + auto extended_storage_columns = storage_snapshot->getColumns( + GetColumnsOptions(GetColumnsOptions::AllPhysical).withExtendedObjects()); + + convertObjectsToTuples(columns, block, extended_storage_columns); + } if (storage.compress) { @@ -151,7 +171,7 @@ private: Blocks new_blocks; StorageMemory & storage; - StorageMetadataPtr metadata_snapshot; + StorageSnapshotPtr storage_snapshot; }; @@ -170,6 +190,38 @@ StorageMemory::StorageMemory( setInMemoryMetadata(storage_metadata); } +StorageSnapshotPtr StorageMemory::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const +{ + auto snapshot_data = std::make_unique(); + snapshot_data->blocks = data.get(); + + auto names_of_objects = getNamesOfObjectColumns(metadata_snapshot->getColumns().getAllPhysical()); + if (names_of_objects.empty()) + return std::make_shared(*this, metadata_snapshot, ColumnsDescription{}, std::move(snapshot_data)); + + std::unordered_map types_in_blocks; + + if (snapshot_data->blocks->empty()) + { + for (const auto & name : names_of_objects) + types_in_blocks[name].push_back(std::make_shared( + DataTypes{std::make_shared()}, + Names{ColumnObject::COLUMN_NAME_DUMMY})); + } + else + { + for (const auto & block : *snapshot_data->blocks) + for (const auto & elem : block) + if (names_of_objects.contains(elem.name)) + types_in_blocks[elem.name].push_back(elem.type); + } + + ColumnsDescription object_columns; + for (const auto & [name, types] : types_in_blocks) + object_columns.add(ColumnDescription{String(name), getLeastCommonTypeForObject(types)}); + + return std::make_shared(*this, metadata_snapshot, object_columns, std::move(snapshot_data)); +} Pipe StorageMemory::read( const Names & column_names, @@ -182,6 +234,9 @@ Pipe StorageMemory::read( { storage_snapshot->check(column_names); + const auto & snapshot_data = assert_cast(*storage_snapshot->data); + auto current_data = snapshot_data.blocks; + if (delay_read_for_global_subqueries) { /// Note: for global subquery we use single source. @@ -197,13 +252,12 @@ Pipe StorageMemory::read( storage_snapshot, nullptr /* data */, nullptr /* parallel execution index */, - [this](std::shared_ptr & data_to_initialize) + [current_data](std::shared_ptr & data_to_initialize) { - data_to_initialize = data.get(); + data_to_initialize = current_data; })); } - auto current_data = data.get(); size_t size = current_data->size(); if (num_streams > size) diff --git a/src/Storages/StorageMemory.h b/src/Storages/StorageMemory.h index 3bad2796b60..ffb474cb820 100644 --- a/src/Storages/StorageMemory.h +++ b/src/Storages/StorageMemory.h @@ -29,6 +29,13 @@ public: size_t getSize() const { return data.get()->size(); } + struct SnapshotData : public StorageSnapshot::Data + { + std::shared_ptr blocks; + }; + + StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const override; + Pipe read( const Names & column_names, const StorageSnapshotPtr & storage_snapshot, diff --git a/tests/queries/0_stateless/01825_type_json_3.reference b/tests/queries/0_stateless/01825_type_json_3.reference.j2 similarity index 82% rename from tests/queries/0_stateless/01825_type_json_3.reference rename to tests/queries/0_stateless/01825_type_json_3.reference.j2 index 24d191a6e5d..23f38b74fd1 100644 --- a/tests/queries/0_stateless/01825_type_json_3.reference +++ b/tests/queries/0_stateless/01825_type_json_3.reference.j2 @@ -1,3 +1,4 @@ +{% for engine in ["ReplicatedMergeTree('/clickhouse/tables/{database}/test_01825_3/t_json_3', 'r1') ORDER BY tuple()", "Memory"] -%} 1 ('',0) Tuple(k1 String, k2 Int8) 2 ('v1',2) Tuple(k1 String, k2 Int8) 1 0 @@ -11,13 +12,15 @@ 2 ([('v1','v3'),('v4','')]) Tuple(k1 Nested(k2 String, k3 String)) 3 ([]) Tuple(k1 Nested(k2 String, k3 String)) 4 ([]) Tuple(k1 Nested(k2 String, k3 String)) -all_2_2_0 data Tuple(k1 Nested(k2 String, k3 String)) -all_3_3_0 data Tuple(_dummy UInt8) 1 [] [] 2 ['v1','v4'] ['v3',''] 3 [] [] 4 [] [] +{%- if 'MergeTree' in engine %} +all_2_2_0 data Tuple(k1 Nested(k2 String, k3 String)) +all_3_3_0 data Tuple(_dummy UInt8) data Tuple(k1 Nested(k2 String, k3 String)) +{%- endif %} 1 [] [] 2 ['v1','v4'] ['v3',''] 3 [] [] @@ -29,3 +32,4 @@ data Tuple(k1 Nested(k2 String, k3 String)) 1 1 foo [] 2 0 [1,2,3] 3 10 [] +{% endfor -%} diff --git a/tests/queries/0_stateless/01825_type_json_3.sql b/tests/queries/0_stateless/01825_type_json_3.sql.j2 similarity index 65% rename from tests/queries/0_stateless/01825_type_json_3.sql rename to tests/queries/0_stateless/01825_type_json_3.sql.j2 index 279460a6dcf..66c74bd17a0 100644 --- a/tests/queries/0_stateless/01825_type_json_3.sql +++ b/tests/queries/0_stateless/01825_type_json_3.sql.j2 @@ -1,11 +1,15 @@ -- Tags: no-fasttest +{% for engine in ["ReplicatedMergeTree('/clickhouse/tables/{database}/test_01825_3/t_json_3', 'r1') ORDER BY tuple()", "Memory"] -%} + DROP TABLE IF EXISTS t_json_3; CREATE TABLE t_json_3(id UInt64, data JSON) -ENGINE = ReplicatedMergeTree('/clickhouse/tables/{database}/test_01825_3/t_json_3', 'r1') ORDER BY tuple(); +ENGINE = {{ engine }}; -SYSTEM STOP MERGES t_json_3; +{% if 'MergeTree' in engine %} + SYSTEM STOP MERGES t_json_3; +{% endif %} INSERT INTO t_json_3 FORMAT JSONEachRow {"id": 1, "data": {"k1": null}}, {"id": 2, "data": {"k1": "v1", "k2" : 2}}; @@ -23,21 +27,22 @@ SELECT id, `data.k1.k2`, `data.k1.k3` FROM t_json_3 ORDER BY id; INSERT INTO t_json_3 FORMAT JSONEachRow {"id": 3, "data": {"k1" : []}} {"id": 4, "data": {"k1" : []}}; SELECT id, data, toTypeName(data) FROM t_json_3 ORDER BY id; - -SELECT name, column, type -FROM system.parts_columns -WHERE table = 't_json_3' AND database = currentDatabase() AND active AND column = 'data' -ORDER BY name; - SELECT id, data.k1.k2, data.k1.k3 FROM t_json_3 ORDER BY id; -SYSTEM START MERGES t_json_3; -OPTIMIZE TABLE t_json_3 FINAL; +{% if 'MergeTree' in engine %} + SELECT name, column, type + FROM system.parts_columns + WHERE table = 't_json_3' AND database = currentDatabase() AND active AND column = 'data' + ORDER BY name; -SELECT column, type -FROM system.parts_columns -WHERE table = 't_json_3' AND database = currentDatabase() AND active AND column = 'data' -ORDER BY name; + SYSTEM START MERGES t_json_3; + OPTIMIZE TABLE t_json_3 FINAL; + + SELECT column, type + FROM system.parts_columns + WHERE table = 't_json_3' AND database = currentDatabase() AND active AND column = 'data' + ORDER BY name; +{% endif %} SELECT id, data.k1.k2, data.k1.k3 FROM t_json_3 ORDER BY id; @@ -50,3 +55,5 @@ SELECT id, data, toTypeName(data) FROM t_json_3 ORDER BY id; SELECT id, data.k1.k2, data.k1.k3, data.k4 FROM t_json_3 ORDER BY id; DROP TABLE t_json_3; + +{% endfor -%} From dcd7312d75aa4effa6cdea39e5aabbf3a29ea6e3 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 9 Feb 2022 23:47:53 +0300 Subject: [PATCH 063/132] cache common type on objects in MergeTree --- src/DataTypes/ObjectUtils.cpp | 22 ++- src/DataTypes/ObjectUtils.h | 52 +++++- src/DataTypes/getLeastSupertype.h | 1 + src/Storages/ColumnsDescription.h | 3 + src/Storages/MergeTree/MergeTask.cpp | 2 +- src/Storages/MergeTree/MergeTreeData.cpp | 150 ++++++++++-------- src/Storages/MergeTree/MergeTreeData.h | 23 ++- src/Storages/StorageDistributed.cpp | 25 +-- src/Storages/StorageMemory.cpp | 28 +--- src/Storages/getStructureOfRemoteTable.cpp | 9 +- src/Storages/getStructureOfRemoteTable.h | 2 +- src/TableFunctions/TableFunctionValues.cpp | 2 +- .../0_stateless/01825_type_json_4.reference | 2 +- .../queries/0_stateless/01825_type_json_4.sh | 2 +- 14 files changed, 200 insertions(+), 123 deletions(-) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 8c5d4750cf0..5113d94a648 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -133,8 +133,6 @@ static auto extractVector(const std::vector & vec) void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns) { - std::cerr << "convertion to tuples columns: " << columns_list.toString() << ", block: " << block.dumpStructure() << ", extended_storage_columns: " << extended_storage_columns.toString(); - std::unordered_map storage_columns_map; for (const auto & [name, type] : extended_storage_columns) storage_columns_map[name] = type; @@ -288,6 +286,11 @@ NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list) return res; } +bool hasObjectColumns(const ColumnsDescription & columns) +{ + return std::any_of(columns.begin(), columns.end(), [](const auto & column) { return isObject(column.type); }); +} + void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescription & object_columns, bool with_subcolumns) { NamesAndTypesList subcolumns_list; @@ -306,6 +309,21 @@ void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescript columns_list.splice(columns_list.end(), std::move(subcolumns_list)); } +void updateObjectColumns(ColumnsDescription & object_columns, const NamesAndTypesList & new_columns) +{ + for (const auto & new_column : new_columns) + { + auto object_column = object_columns.tryGetPhysical(new_column.name); + if (object_column && !object_column->type->equals(*new_column.type)) + { + object_columns.modify(new_column.name, [&](auto & column) + { + column.type = getLeastCommonTypeForObject({object_column->type, new_column.type}); + }); + } + } +} + namespace { diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 93c81b50422..15c8d8ed794 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -6,6 +6,8 @@ #include #include #include +#include +#include namespace DB { @@ -23,9 +25,13 @@ DataTypePtr getDataTypeByColumn(const IColumn & column); void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); void checkObjectHasNoAmbiguosPaths(const PathsInData & paths); DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambiguos_paths = false); -NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescription & object_columns, bool with_subcolumns); +NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); +bool hasObjectColumns(const ColumnsDescription & columns); + +void updateObjectColumns(ColumnsDescription & object_columns, const NamesAndTypesList & new_columns); + using DataTypeTuplePtr = std::shared_ptr; std::pair flattenTuple(const DataTypePtr & type); @@ -47,4 +53,48 @@ void replaceMissedSubcolumnsByConstants( void finalizeObjectColumns(MutableColumns & columns); +template +ColumnsDescription getObjectColumns( + Iterator begin, Iterator end, + const ColumnsDescription & storage_columns, + EntryColumnsGetter && entry_columns_getter) +{ + ColumnsDescription res; + + if (begin == end) + { + for (const auto & column : storage_columns) + { + if (isObject(column.type)) + { + auto tuple_type = std::make_shared( + DataTypes{std::make_shared()}, + Names{ColumnObject::COLUMN_NAME_DUMMY}); + + res.add({column.name, std::move(tuple_type)}); + } + } + + return res; + } + + std::unordered_map types_in_entries; + + for (auto it = begin; it != end; ++it) + { + const auto & entry_columns = entry_columns_getter(*it); + for (const auto & column : entry_columns) + { + auto storage_column = storage_columns.tryGetPhysical(column.name); + if (storage_column && isObject(storage_column->type)) + types_in_entries[column.name].push_back(column.type); + } + } + + for (const auto & [name, types] : types_in_entries) + res.add({String(name), getLeastCommonTypeForObject(types)}); + + return res; +} + } diff --git a/src/DataTypes/getLeastSupertype.h b/src/DataTypes/getLeastSupertype.h index 5444bb34d06..366fa885a66 100644 --- a/src/DataTypes/getLeastSupertype.h +++ b/src/DataTypes/getLeastSupertype.h @@ -14,6 +14,7 @@ namespace DB * Examples: there is no least common supertype for Array(UInt8), Int8. */ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_string = false); +DataTypePtr getLeastSupertype(const DataTypePtr & lhs, const DataTypePtr & rhs, bool allow_conversion_to_string = false); using TypeIndexSet = std::unordered_set; DataTypePtr getLeastSupertype(const TypeIndexSet & types, bool allow_conversion_to_string = false); diff --git a/src/Storages/ColumnsDescription.h b/src/Storages/ColumnsDescription.h index cc405f7afa1..09557b0b5ae 100644 --- a/src/Storages/ColumnsDescription.h +++ b/src/Storages/ColumnsDescription.h @@ -146,9 +146,12 @@ public: auto it = columns.get<1>().find(column_name); if (it == columns.get<1>().end()) throw Exception("Cannot find column " + column_name + " in ColumnsDescription", ErrorCodes::LOGICAL_ERROR); + + removeSubcolumns(it->name); if (!columns.get<1>().modify(it, std::forward(f))) throw Exception("Cannot modify ColumnDescription for column " + column_name + ": column name cannot be changed", ErrorCodes::LOGICAL_ERROR); + addSubcolumns(it->name, it->type); modifyColumnOrder(column_name, after_column, first); } diff --git a/src/Storages/MergeTree/MergeTask.cpp b/src/Storages/MergeTree/MergeTask.cpp index 5f566d633e6..84e80520f07 100644 --- a/src/Storages/MergeTree/MergeTask.cpp +++ b/src/Storages/MergeTree/MergeTask.cpp @@ -139,7 +139,7 @@ bool MergeTask::ExecuteAndFinalizeHorizontalPart::prepare() global_ctx->all_column_names = global_ctx->metadata_snapshot->getColumns().getNamesOfPhysical(); global_ctx->storage_columns = global_ctx->metadata_snapshot->getColumns().getAllPhysical(); - auto object_columns = MergeTreeData::getObjectsDescription(global_ctx->future_part->parts, getNamesOfObjectColumns(global_ctx->storage_columns)); + auto object_columns = MergeTreeData::getObjectColumns(global_ctx->future_part->parts, global_ctx->metadata_snapshot->getColumns()); global_ctx->storage_snapshot = std::make_shared(*global_ctx->data, global_ctx->metadata_snapshot, object_columns); extendObjectColumns(global_ctx->storage_columns, object_columns, false); diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index a10cec424cb..5f122423d7c 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -1287,6 +1287,7 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks) if (num_parts == 0 && parts_from_wal.empty()) { LOG_DEBUG(log, "There are no data parts"); + object_columns = getObjectColumns(DataPartsVector{}, metadata_snapshot->getColumns()); return; } @@ -1358,6 +1359,8 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks) } } + auto range = getDataPartsStateRange(DataPartState::Active); + object_columns = getObjectColumns(range, metadata_snapshot->getColumns()); calculateColumnAndSecondaryIndexSizesImpl(); LOG_DEBUG(log, "Loaded data parts ({} items)", data_parts_indexes.size()); @@ -2603,6 +2606,12 @@ bool MergeTreeData::renameTempPartAndReplace( modifyPartState(part_it, DataPartState::Active); addPartContributionToColumnAndSecondaryIndexSizes(part); + if (covered_parts.empty()) + updateObjectColumns(object_columns, (*part_it)->getColumns()); + else + object_columns = getObjectColumns( + getDataPartsStateRange(DataPartState::Active), getInMemoryMetadataPtr()->getColumns()); + ssize_t diff_bytes = part->getBytesOnDisk() - reduce_bytes; ssize_t diff_rows = part->rows_count - reduce_rows; ssize_t diff_parts = 1 - reduce_parts; @@ -2646,11 +2655,13 @@ MergeTreeData::DataPartsVector MergeTreeData::renameTempPartAndReplace( void MergeTreeData::removePartsFromWorkingSet(const MergeTreeData::DataPartsVector & remove, bool clear_without_timeout, DataPartsLock & /*acquired_lock*/) { auto remove_time = clear_without_timeout ? 0 : time(nullptr); + bool have_active_parts = false; for (const DataPartPtr & part : remove) { if (part->getState() == IMergeTreeDataPart::State::Active) { + have_active_parts = true; removePartContributionToColumnAndSecondaryIndexSizes(part); removePartContributionToDataVolume(part); } @@ -2664,6 +2675,12 @@ void MergeTreeData::removePartsFromWorkingSet(const MergeTreeData::DataPartsVect if (isInMemoryPart(part) && getSettings()->in_memory_parts_enable_wal) getWriteAheadLog()->dropPart(part->name); } + + if (have_active_parts) + { + auto range = getDataPartsStateRange(DataPartState::Active); + object_columns = getObjectColumns(range, getInMemoryMetadataPtr()->getColumns()); + } } void MergeTreeData::removePartsFromWorkingSetImmediatelyAndSetTemporaryState(const DataPartsVector & remove) @@ -3823,53 +3840,61 @@ std::set MergeTreeData::getPartitionIdsAffectedByCommands( } -MergeTreeData::DataPartsVector MergeTreeData::getDataPartsVector( - const DataPartStates & affordable_states, DataPartStateVector * out_states, bool require_projection_parts) const +MergeTreeData::DataPartsVector MergeTreeData::getDataPartsVectorUnlocked( + const DataPartStates & affordable_states, + DataPartStateVector * out_states, + bool require_projection_parts) const { DataPartsVector res; DataPartsVector buf; + + for (auto state : affordable_states) { - auto lock = lockParts(); + auto range = getDataPartsStateRange(state); - for (auto state : affordable_states) + if (require_projection_parts) { - auto range = getDataPartsStateRange(state); - - if (require_projection_parts) + for (const auto & part : range) { - for (const auto & part : range) - { - for (const auto & [_, projection_part] : part->getProjectionParts()) - res.push_back(projection_part); - } - } - else - { - std::swap(buf, res); - res.clear(); - std::merge(range.begin(), range.end(), buf.begin(), buf.end(), std::back_inserter(res), LessDataPart()); //-V783 + for (const auto & [_, projection_part] : part->getProjectionParts()) + res.push_back(projection_part); } } - - if (out_states != nullptr) + else { - out_states->resize(res.size()); - if (require_projection_parts) - { - for (size_t i = 0; i < res.size(); ++i) - (*out_states)[i] = res[i]->getParentPart()->getState(); - } - else - { - for (size_t i = 0; i < res.size(); ++i) - (*out_states)[i] = res[i]->getState(); - } + std::swap(buf, res); + res.clear(); + std::merge(range.begin(), range.end(), buf.begin(), buf.end(), std::back_inserter(res), LessDataPart()); //-V783 + } + } + + if (out_states != nullptr) + { + out_states->resize(res.size()); + if (require_projection_parts) + { + for (size_t i = 0; i < res.size(); ++i) + (*out_states)[i] = res[i]->getParentPart()->getState(); + } + else + { + for (size_t i = 0; i < res.size(); ++i) + (*out_states)[i] = res[i]->getState(); } } return res; } +MergeTreeData::DataPartsVector MergeTreeData::getDataPartsVector( + const DataPartStates & affordable_states, + DataPartStateVector * out_states, + bool require_projection_parts) const +{ + auto lock = lockParts(); + return getDataPartsVectorUnlocked(affordable_states, out_states, require_projection_parts); +} + MergeTreeData::DataPartsVector MergeTreeData::getAllDataPartsVector(MergeTreeData::DataPartStateVector * out_states, bool require_projection_parts) const { @@ -4318,7 +4343,7 @@ MergeTreeData::DataPartsVector MergeTreeData::Transaction::commit(MergeTreeData: else { total_covered_parts.insert(total_covered_parts.end(), covered_parts.begin(), covered_parts.end()); - for (const DataPartPtr & covered_part : covered_parts) + for (const auto & covered_part : covered_parts) { covered_part->remove_time.store(current_time, std::memory_order_relaxed); @@ -4328,6 +4353,7 @@ MergeTreeData::DataPartsVector MergeTreeData::Transaction::commit(MergeTreeData: data.modifyPartState(covered_part, DataPartState::Outdated); data.removePartContributionToColumnAndSecondaryIndexSizes(covered_part); } + reduce_parts += covered_parts.size(); add_bytes += part->getBytesOnDisk(); @@ -4339,6 +4365,17 @@ MergeTreeData::DataPartsVector MergeTreeData::Transaction::commit(MergeTreeData: } } + if (reduce_parts) + { + auto range = data.getDataPartsStateRange(DataPartState::Active); + data.object_columns = getObjectColumns(range, data.getInMemoryMetadataPtr()->getColumns()); + } + else + { + for (const auto & part : precommitted_parts) + updateObjectColumns(data.object_columns, part->getColumns()); + } + ssize_t diff_bytes = add_bytes - reduce_bytes; ssize_t diff_rows = add_rows - reduce_rows; ssize_t diff_parts = add_parts - reduce_parts; @@ -6036,49 +6073,28 @@ ReservationPtr MergeTreeData::balancedReservation( return reserved_space; } -ColumnsDescription MergeTreeData::getObjectsDescription(const DataPartsVector & parts, const NameSet & object_names) +ColumnsDescription MergeTreeData::getObjectColumns( + const DataPartsVector & parts, const ColumnsDescription & storage_columns) { - if (object_names.empty()) - return {}; + return DB::getObjectColumns( + parts.begin(), parts.end(), + storage_columns, [](const auto & part) { return part->getColumns(); }); +} - std::unordered_map types_in_parts; - - if (parts.empty()) - { - for (const auto & name : object_names) - types_in_parts[name].push_back(std::make_shared( - DataTypes{std::make_shared()}, - Names{ColumnObject::COLUMN_NAME_DUMMY})); - } - else - { - for (const auto & part : parts) - { - const auto & part_columns = part->getColumns(); - for (const auto & [name, type] : part_columns) - { - if (object_names.count(name)) - types_in_parts[name].push_back(type); - } - } - } - - ColumnsDescription object_columns; - for (const auto & [name, types] : types_in_parts) - object_columns.add(ColumnDescription{name, getLeastCommonTypeForObject(types)}); - - return object_columns; +ColumnsDescription MergeTreeData::getObjectColumns( + boost::iterator_range range, const ColumnsDescription & storage_columns) +{ + return DB::getObjectColumns( + range.begin(), range.end(), + storage_columns, [](const auto & part) { return part->getColumns(); }); } StorageSnapshotPtr MergeTreeData::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const { auto snapshot_data = std::make_unique(); - snapshot_data->parts = getDataPartsVector(); - - auto object_columns = getObjectsDescription( - snapshot_data->parts, - getNamesOfObjectColumns(metadata_snapshot->getColumns().getAll())); + auto lock = lockParts(); + snapshot_data->parts = getDataPartsVectorUnlocked({DataPartState::Active}); return std::make_shared(*this, metadata_snapshot, object_columns, std::move(snapshot_data)); } diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index 01fd64e740d..0e8db7fe2ca 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -437,13 +437,22 @@ public: /// Returns a copy of the list so that the caller shouldn't worry about locks. DataParts getDataParts(const DataPartStates & affordable_states) const; + DataPartsVector getDataPartsVectorUnlocked( + const DataPartStates & affordable_states, + DataPartStateVector * out_states = nullptr, + bool require_projection_parts = false) const; + /// Returns sorted list of the parts with specified states /// out_states will contain snapshot of each part state DataPartsVector getDataPartsVector( - const DataPartStates & affordable_states, DataPartStateVector * out_states = nullptr, bool require_projection_parts = false) const; + const DataPartStates & affordable_states, + DataPartStateVector * out_states = nullptr, + bool require_projection_parts = false) const; /// Returns absolutely all parts (and snapshot of their states) - DataPartsVector getAllDataPartsVector(DataPartStateVector * out_states = nullptr, bool require_projection_parts = false) const; + DataPartsVector getAllDataPartsVector( + DataPartStateVector * out_states = nullptr, + bool require_projection_parts = false) const; /// Returns all detached parts DetachedPartsInfo getDetachedParts() const; @@ -695,7 +704,10 @@ public: return column_sizes; } - static ColumnsDescription getObjectsDescription(const DataPartsVector & parts, const NameSet & object_names); + const ColumnsDescription & getObjectColumns() const { return object_columns; } + + static ColumnsDescription getObjectColumns( + const DataPartsVector & parts, const ColumnsDescription & storage_columns); IndexSizeByName getSecondaryIndexSizes() const override { @@ -987,6 +999,8 @@ protected: DataPartsIndexes::index::type & data_parts_by_info; DataPartsIndexes::index::type & data_parts_by_state_and_info; + ColumnsDescription object_columns; + MergeTreePartsMover parts_mover; /// Executors are common for both ReplicatedMergeTree and plain MergeTree @@ -1023,6 +1037,9 @@ protected: return {begin, end}; } + static ColumnsDescription getObjectColumns( + boost::iterator_range range, const ColumnsDescription & storage_columns); + std::optional totalRowsByPartitionPredicateImpl( const SelectQueryInfo & query_info, ContextPtr context, const DataPartsVector & parts) const; diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index 7886fbc54fe..9568a26f402 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -591,31 +591,20 @@ std::optional StorageDistributed::getOptimizedQueryP StorageSnapshotPtr StorageDistributed::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const { auto snapshot_data = std::make_unique(); - auto names_of_objects = getNamesOfObjectColumns(metadata_snapshot->getColumns().getAllPhysical()); - if (names_of_objects.empty()) + if (!hasObjectColumns(metadata_snapshot->getColumns())) return std::make_shared(*this, metadata_snapshot, ColumnsDescription{}, std::move(snapshot_data)); snapshot_data->objects_by_shard = getExtendedObjectsOfRemoteTables( *getCluster(), StorageID{remote_database, remote_table}, - names_of_objects, + metadata_snapshot->getColumns(), getContext()); - assert(!snapshot_data->objects_by_shard.empty()); - - std::unordered_map types_in_tables; - for (const auto & [_, columns] : snapshot_data->objects_by_shard) - { - for (const auto & column : columns) - { - assert(names_of_objects.count(column.name)); - types_in_tables[column.name].push_back(column.type); - } - } - - ColumnsDescription object_columns; - for (const auto & [name, types] : types_in_tables) - object_columns.add(ColumnDescription(name, getLeastCommonTypeForObject(types))); + auto object_columns = getObjectColumns( + snapshot_data->objects_by_shard.begin(), + snapshot_data->objects_by_shard.end(), + metadata_snapshot->getColumns(), + [](const auto & shard_num_and_columns) { return shard_num_and_columns.second; }); return std::make_shared(*this, metadata_snapshot, object_columns, std::move(snapshot_data)); } diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp index ab4edd8b58b..5146f2a2fd4 100644 --- a/src/Storages/StorageMemory.cpp +++ b/src/Storages/StorageMemory.cpp @@ -195,30 +195,14 @@ StorageSnapshotPtr StorageMemory::getStorageSnapshot(const StorageMetadataPtr & auto snapshot_data = std::make_unique(); snapshot_data->blocks = data.get(); - auto names_of_objects = getNamesOfObjectColumns(metadata_snapshot->getColumns().getAllPhysical()); - if (names_of_objects.empty()) + if (!hasObjectColumns(metadata_snapshot->getColumns())) return std::make_shared(*this, metadata_snapshot, ColumnsDescription{}, std::move(snapshot_data)); - std::unordered_map types_in_blocks; - - if (snapshot_data->blocks->empty()) - { - for (const auto & name : names_of_objects) - types_in_blocks[name].push_back(std::make_shared( - DataTypes{std::make_shared()}, - Names{ColumnObject::COLUMN_NAME_DUMMY})); - } - else - { - for (const auto & block : *snapshot_data->blocks) - for (const auto & elem : block) - if (names_of_objects.contains(elem.name)) - types_in_blocks[elem.name].push_back(elem.type); - } - - ColumnsDescription object_columns; - for (const auto & [name, types] : types_in_blocks) - object_columns.add(ColumnDescription{String(name), getLeastCommonTypeForObject(types)}); + auto object_columns = getObjectColumns( + snapshot_data->blocks->begin(), + snapshot_data->blocks->end(), + metadata_snapshot->getColumns(), + [](const auto & block) { return block.getColumnsWithTypeAndName(); }); return std::make_shared(*this, metadata_snapshot, object_columns, std::move(snapshot_data)); } diff --git a/src/Storages/getStructureOfRemoteTable.cpp b/src/Storages/getStructureOfRemoteTable.cpp index 84949b94f4d..8fa4d02e8e1 100644 --- a/src/Storages/getStructureOfRemoteTable.cpp +++ b/src/Storages/getStructureOfRemoteTable.cpp @@ -152,7 +152,7 @@ ColumnsDescription getStructureOfRemoteTable( ColumnsDescriptionByShardNum getExtendedObjectsOfRemoteTables( const Cluster & cluster, const StorageID & remote_table_id, - const NameSet & names_of_objects, + const ColumnsDescription & storage_columns, ContextPtr context) { const auto & shards_info = cluster.getShardsInfo(); @@ -188,10 +188,9 @@ ColumnsDescriptionByShardNum getExtendedObjectsOfRemoteTables( auto name = get(name_col[i]); auto type_name = get(type_col[i]); - if (!names_of_objects.count(name)) - continue; - - res.add(ColumnDescription(std::move(name), DataTypeFactory::instance().get(type_name))); + auto storage_column = storage_columns.tryGetPhysical(name); + if (storage_column && isObject(storage_column->type)) + res.add(ColumnDescription(std::move(name), DataTypeFactory::instance().get(type_name))); } } diff --git a/src/Storages/getStructureOfRemoteTable.h b/src/Storages/getStructureOfRemoteTable.h index 2c346b25c2b..39d040c9f30 100644 --- a/src/Storages/getStructureOfRemoteTable.h +++ b/src/Storages/getStructureOfRemoteTable.h @@ -26,7 +26,7 @@ using ColumnsDescriptionByShardNum = std::unordered_map&1 | grep -o -m1 "Code: 642" + | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 644" echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [{"k2" : 1}, {"k2" : 2}]}}' \ | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 15" From f012871a7c1a97595dd0f14911b14522df95fd4e Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 11 Feb 2022 00:51:12 +0300 Subject: [PATCH 064/132] better caching of common types of object columns --- .../tests/gtest_json_parser.cpp | 2 +- src/Storages/MergeTree/MergeTreeData.cpp | 55 ++++++++++++------- src/Storages/MergeTree/MergeTreeData.h | 2 + 3 files changed, 37 insertions(+), 22 deletions(-) diff --git a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp index 8b11684da7a..c60ad058bc6 100644 --- a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp +++ b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp @@ -70,7 +70,7 @@ static void check( { paths_str.push_back(path.getPath()); paths_is_nested.emplace_back(); - for (size_t i = 0; i < path.getNumParts(); ++i) + for (size_t i = 0; i < path.getParts().size(); ++i) paths_is_nested.back().push_back(path.isNested(i)); } diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index 5f122423d7c..e850fe2688e 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -1286,8 +1286,8 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks) if (num_parts == 0 && parts_from_wal.empty()) { + resetObjectColumnsFromActiveParts(part_lock); LOG_DEBUG(log, "There are no data parts"); - object_columns = getObjectColumns(DataPartsVector{}, metadata_snapshot->getColumns()); return; } @@ -1359,8 +1359,7 @@ void MergeTreeData::loadDataParts(bool skip_sanity_checks) } } - auto range = getDataPartsStateRange(DataPartState::Active); - object_columns = getObjectColumns(range, metadata_snapshot->getColumns()); + resetObjectColumnsFromActiveParts(part_lock); calculateColumnAndSecondaryIndexSizesImpl(); LOG_DEBUG(log, "Loaded data parts ({} items)", data_parts_indexes.size()); @@ -2609,8 +2608,7 @@ bool MergeTreeData::renameTempPartAndReplace( if (covered_parts.empty()) updateObjectColumns(object_columns, (*part_it)->getColumns()); else - object_columns = getObjectColumns( - getDataPartsStateRange(DataPartState::Active), getInMemoryMetadataPtr()->getColumns()); + resetObjectColumnsFromActiveParts(lock); ssize_t diff_bytes = part->getBytesOnDisk() - reduce_bytes; ssize_t diff_rows = part->rows_count - reduce_rows; @@ -2652,18 +2650,18 @@ MergeTreeData::DataPartsVector MergeTreeData::renameTempPartAndReplace( return covered_parts; } -void MergeTreeData::removePartsFromWorkingSet(const MergeTreeData::DataPartsVector & remove, bool clear_without_timeout, DataPartsLock & /*acquired_lock*/) +void MergeTreeData::removePartsFromWorkingSet(const MergeTreeData::DataPartsVector & remove, bool clear_without_timeout, DataPartsLock & acquired_lock) { auto remove_time = clear_without_timeout ? 0 : time(nullptr); - bool have_active_parts = false; + bool removed_active_part = false; for (const DataPartPtr & part : remove) { if (part->getState() == IMergeTreeDataPart::State::Active) { - have_active_parts = true; removePartContributionToColumnAndSecondaryIndexSizes(part); removePartContributionToDataVolume(part); + removed_active_part = true; } if (part->getState() == IMergeTreeDataPart::State::Active || clear_without_timeout) @@ -2676,16 +2674,14 @@ void MergeTreeData::removePartsFromWorkingSet(const MergeTreeData::DataPartsVect getWriteAheadLog()->dropPart(part->name); } - if (have_active_parts) - { - auto range = getDataPartsStateRange(DataPartState::Active); - object_columns = getObjectColumns(range, getInMemoryMetadataPtr()->getColumns()); - } + if (removed_active_part) + resetObjectColumnsFromActiveParts(acquired_lock); } void MergeTreeData::removePartsFromWorkingSetImmediatelyAndSetTemporaryState(const DataPartsVector & remove) { auto lock = lockParts(); + bool removed_active_part = false; for (const auto & part : remove) { @@ -2693,10 +2689,16 @@ void MergeTreeData::removePartsFromWorkingSetImmediatelyAndSetTemporaryState(con if (it_part == data_parts_by_info.end()) throw Exception("Part " + part->getNameWithState() + " not found in data_parts", ErrorCodes::LOGICAL_ERROR); + if (part->getState() == IMergeTreeDataPart::State::Active) + removed_active_part = true; + modifyPartState(part, IMergeTreeDataPart::State::Temporary); /// Erase immediately data_parts_indexes.erase(it_part); } + + if (removed_active_part) + resetObjectColumnsFromActiveParts(lock); } void MergeTreeData::removePartsFromWorkingSet(const DataPartsVector & remove, bool clear_without_timeout, DataPartsLock * acquired_lock) @@ -2789,8 +2791,7 @@ MergeTreeData::DataPartsVector MergeTreeData::removePartsInRangeFromWorkingSet(c return parts_to_remove; } -void MergeTreeData::forgetPartAndMoveToDetached(const MergeTreeData::DataPartPtr & part_to_detach, const String & prefix, bool -restore_covered) +void MergeTreeData::forgetPartAndMoveToDetached(const MergeTreeData::DataPartPtr & part_to_detach, const String & prefix, bool restore_covered) { if (prefix.empty()) LOG_INFO(log, "Renaming {} to {} and forgetting it.", part_to_detach->relative_path, part_to_detach->name); @@ -2798,6 +2799,8 @@ restore_covered) LOG_INFO(log, "Renaming {} to {}_{} and forgetting it.", part_to_detach->relative_path, prefix, part_to_detach->name); auto lock = lockParts(); + bool removed_active_part = false; + bool restored_active_part = false; auto it_part = data_parts_by_info.find(part_to_detach->info); if (it_part == data_parts_by_info.end()) @@ -2810,7 +2813,9 @@ restore_covered) { removePartContributionToDataVolume(part); removePartContributionToColumnAndSecondaryIndexSizes(part); + removed_active_part = true; } + modifyPartState(it_part, DataPartState::Deleting); part->renameToDetached(prefix); @@ -2860,6 +2865,7 @@ restore_covered) addPartContributionToColumnAndSecondaryIndexSizes(*it); addPartContributionToDataVolume(*it); modifyPartState(it, DataPartState::Active); // iterator is not invalidated here + restored_active_part = true; } pos = (*it)->info.max_block + 1; @@ -2891,6 +2897,7 @@ restore_covered) addPartContributionToColumnAndSecondaryIndexSizes(*it); addPartContributionToDataVolume(*it); modifyPartState(it, DataPartState::Active); + restored_active_part = true; } pos = (*it)->info.max_block + 1; @@ -2910,6 +2917,9 @@ restore_covered) LOG_ERROR(log, "The set of parts restored in place of {} looks incomplete. There might or might not be a data loss.{}", part->name, (error_parts.empty() ? "" : " Suspicious parts: " + error_parts)); } } + + if (removed_active_part || restored_active_part) + resetObjectColumnsFromActiveParts(lock); } @@ -4365,16 +4375,13 @@ MergeTreeData::DataPartsVector MergeTreeData::Transaction::commit(MergeTreeData: } } - if (reduce_parts) - { - auto range = data.getDataPartsStateRange(DataPartState::Active); - data.object_columns = getObjectColumns(range, data.getInMemoryMetadataPtr()->getColumns()); - } - else + if (reduce_parts == 0) { for (const auto & part : precommitted_parts) updateObjectColumns(data.object_columns, part->getColumns()); } + else + data.resetObjectColumnsFromActiveParts(parts_lock); ssize_t diff_bytes = add_bytes - reduce_bytes; ssize_t diff_rows = add_rows - reduce_rows; @@ -6089,6 +6096,12 @@ ColumnsDescription MergeTreeData::getObjectColumns( storage_columns, [](const auto & part) { return part->getColumns(); }); } +void MergeTreeData::resetObjectColumnsFromActiveParts(const DataPartsLock & /*lock*/) +{ + auto range = getDataPartsStateRange(DataPartState::Active); + object_columns = getObjectColumns(range, getInMemoryMetadataPtr()->getColumns()); +} + StorageSnapshotPtr MergeTreeData::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const { auto snapshot_data = std::make_unique(); diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index 0e8db7fe2ca..a8b46c0c297 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -1223,6 +1223,8 @@ private: MutableDataPartsVector & parts_from_wal, DataPartsLock & part_lock); + void resetObjectColumnsFromActiveParts(const DataPartsLock & lock); + /// Create zero-copy exclusive lock for part and disk. Useful for coordination of /// distributed operations which can lead to data duplication. Implemented only in ReplicatedMergeTree. virtual std::optional tryCreateZeroCopyExclusiveLock(const DataPartPtr &, const DiskPtr &) { return std::nullopt; } From d5f2312c2f72e9ec433411c5447ee8e19ec210ce Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sat, 12 Feb 2022 17:07:46 -0800 Subject: [PATCH 065/132] add func h3PointDistM --- src/Functions/h3PointDistM.cpp | 129 +++++++++++++++++++++++++ src/Functions/registerFunctionsGeo.cpp | 2 + 2 files changed, 131 insertions(+) create mode 100644 src/Functions/h3PointDistM.cpp diff --git a/src/Functions/h3PointDistM.cpp b/src/Functions/h3PointDistM.cpp new file mode 100644 index 00000000000..8aff1d7adec --- /dev/null +++ b/src/Functions/h3PointDistM.cpp @@ -0,0 +1,129 @@ +#include "config_functions.h" + +#if USE_H3 + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + + +namespace DB +{ +namespace ErrorCodes +{ +extern const int ILLEGAL_TYPE_OF_ARGUMENT; +extern const int ILLEGAL_COLUMN; +} + +namespace +{ + +class FunctionH3PointDistM final : public IFunction +{ +public: + static constexpr auto name = "h3PointDistM"; + + static FunctionPtr create(ContextPtr) { return std::make_shared(); } + + std::string getName() const override { return name; } + + size_t getNumberOfArguments() const override { return 4; } + bool useDefaultImplementationForConstants() const override { return true; } + bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } + + DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override + { + for (size_t i = 0; i < getNumberOfArguments(); ++i) + { + const auto * arg = arguments[i].get(); + if (!WhichDataType(arg).isFloat64()) + throw Exception( + ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, + "Illegal type {} of argument {} of function {}. Must be Float64", + arg->getName(), i, getName()); + } + return std::make_shared(); + } + + ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override + { + const auto * col_lat1 = checkAndGetColumn(arguments[0].column.get()); + if (!col_lat1) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[0].type->getName(), + 1, + getName()); + const auto & data_lat1 = col_lat1->getData(); + + const auto * col_lon1 = checkAndGetColumn(arguments[1].column.get()); + if (!col_lon1) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[1].type->getName(), + 2, + getName()); + const auto & data_lon1 = col_lon1->getData(); + + const auto * col_lat2 = checkAndGetColumn(arguments[2].column.get()); + if (!col_lat2) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[2].type->getName(), + 3, + getName()); + const auto & data_lat2 = col_lat2->getData(); + + const auto * col_lon2 = checkAndGetColumn(arguments[3].column.get()); + if (!col_lon2) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[3].type->getName(), + 4, + getName()); + const auto & data_lon2 = col_lon2->getData(); + + auto dst = ColumnVector::create(); + auto & dst_data = dst->getData(); + dst_data.resize(input_rows_count); + + for (size_t row = 0; row < input_rows_count; ++row) + { + const double lat1 = data_lat1[row]; + const double lon1 = data_lon1[row]; + const auto lat2 = data_lat2[row]; + const auto lon2 = data_lon2[row]; + + LatLng point1 = {degsToRads(lat1), degsToRads(lon1)}; + LatLng point2 = {degsToRads(lat2), degsToRads(lon2)}; + + Float64 res = distanceM(&point1, &point2); + dst_data[row] = res; + } + + return dst; + } +}; + +} + +void registerFunctionH3PointDistM(FunctionFactory & factory) +{ + factory.registerFunction(); +} + +} + +#endif diff --git a/src/Functions/registerFunctionsGeo.cpp b/src/Functions/registerFunctionsGeo.cpp index 0501b603c57..54fb79c8b31 100644 --- a/src/Functions/registerFunctionsGeo.cpp +++ b/src/Functions/registerFunctionsGeo.cpp @@ -52,6 +52,7 @@ void registerFunctionH3HexAreaKm2(FunctionFactory &); void registerFunctionH3CellAreaM2(FunctionFactory &); void registerFunctionH3CellAreaRads2(FunctionFactory &); void registerFunctionH3NumHexagons(FunctionFactory &); +void registerFunctionH3PointDistM(FunctionFactory &); #endif @@ -118,6 +119,7 @@ void registerFunctionsGeo(FunctionFactory & factory) registerFunctionH3CellAreaM2(factory); registerFunctionH3CellAreaRads2(factory); registerFunctionH3NumHexagons(factory); + registerFunctionH3PointDistM(factory); #endif #if USE_S2_GEOMETRY From 4218cbca200f6ed6b9aceafc376b4173100c0e80 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 08:17:20 -0800 Subject: [PATCH 066/132] add tests for h3PointDistM func --- .../02212_h3_point_distM.reference | 12 ++++++++++ .../0_stateless/02212_h3_point_distM.sql | 22 +++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 tests/queries/0_stateless/02212_h3_point_distM.reference create mode 100644 tests/queries/0_stateless/02212_h3_point_distM.sql diff --git a/tests/queries/0_stateless/02212_h3_point_distM.reference b/tests/queries/0_stateless/02212_h3_point_distM.reference new file mode 100644 index 00000000000..c52f38d0394 --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_point_distM.reference @@ -0,0 +1,12 @@ +111195.05197522961 +111228.91103262542 +111901.0753744776 +111901.07537447763 +111901.07537447763 +157225.60925091387 +157249.55851177874 +222457.78082261496 +223528.36944466401 +223528.36944466401 +400900.66882205213 +2223901.039504589 diff --git a/tests/queries/0_stateless/02212_h3_point_distM.sql b/tests/queries/0_stateless/02212_h3_point_distM.sql new file mode 100644 index 00000000000..7011c50bca0 --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_point_distM.sql @@ -0,0 +1,22 @@ +-- Tags: no-fasttest + +DROP TABLE IF EXISTS table1; + +CREATE TABLE table1 (lat1 Float64, lon1 Float64, lat2 Float64, lon2 Float64) ENGINE = Memory; + +INSERT INTO table1 VALUES(-10.0 ,0.0, 10.0, 0.0); +INSERT INTO table1 VALUES(-1, -1, 2, 1); +INSERT INTO table1 VALUES(0, 2, 1, 3); +INSERT INTO table1 VALUES(-2, -3, -1, -2); +INSERT INTO table1 VALUES(-87, 0, -85, 3); +INSERT INTO table1 VALUES(-89, 1, -88, 2); +INSERT INTO table1 VALUES(-84, 1, -83, 2); +INSERT INTO table1 VALUES(-88, 90, -86, 91); +INSERT INTO table1 VALUES(-84, -91, -83, -90); +INSERT INTO table1 VALUES(-90, 181, -89, 182); +INSERT INTO table1 VALUES(-84, 181, -83, 182); +INSERT INTO table1 VALUES(-87, 0, -85, 3); + +select h3PointDistM(lat1, lon1,lat2, lon2) AS k from table1 order by k; + +DROP TABLE table1 From 8549bc1d16f6d6612ea92ef75389cbcbdbfee58b Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 08:45:43 -0800 Subject: [PATCH 067/132] docs for h3PointDistM --- docs/en/sql-reference/functions/geo/h3.md | 38 +++++++++++++++++++++++ 1 file changed, 38 insertions(+) diff --git a/docs/en/sql-reference/functions/geo/h3.md b/docs/en/sql-reference/functions/geo/h3.md index ecbe00adfd7..31bf455800d 100644 --- a/docs/en/sql-reference/functions/geo/h3.md +++ b/docs/en/sql-reference/functions/geo/h3.md @@ -1026,4 +1026,42 @@ Result: │ 41162 │ └─────────────┘ ``` + +## h3PointDistM {#h3pointdistm} + +Returns the "great circle" or "haversine" distance between pairs of GeoCoord points (latitude/longitude) pairs in meters. + +**Syntax** + +``` sql +h3PointDistM(lat1, lon1, lat2, lon2) +``` + +**Arguments** + +- `lat1`, `lon1` — Latitude and Longitude of point1 in degrees. Type: [Float64](../../../sql-reference/data-types/float.md). +- `lat2`, `lon2` — Latitude and Longitude of point2 in degrees. Type: [Float64](../../../sql-reference/data-types/float.md). + +**Returned values** + +- Haversine or great circle distance in meters. + +Type: [Float64](../../../sql-reference/data-types/float.md). + +**Example** + +Query: + +``` sql +select h3PointDistM(-10.0 ,0.0, 10.0, 0.0) as h3PointDistM; +``` + +Result: + +``` text +┌──────h3PointDistM─┐ +│ 2223901.039504589 │ +└───────────────────┘ +``` + [Original article](https://clickhouse.com/docs/en/sql-reference/functions/geo/h3) From 982e6aae42e63294aae6071620bf5a6616ed2db0 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 08:57:42 -0800 Subject: [PATCH 068/132] add h3PointDistKm func --- src/Functions/h3PointDistKm.cpp | 129 +++++++++++++++++++++++++ src/Functions/registerFunctionsGeo.cpp | 2 + 2 files changed, 131 insertions(+) create mode 100644 src/Functions/h3PointDistKm.cpp diff --git a/src/Functions/h3PointDistKm.cpp b/src/Functions/h3PointDistKm.cpp new file mode 100644 index 00000000000..ef4f9196ac0 --- /dev/null +++ b/src/Functions/h3PointDistKm.cpp @@ -0,0 +1,129 @@ +#include "config_functions.h" + +#if USE_H3 + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + + +namespace DB +{ +namespace ErrorCodes +{ +extern const int ILLEGAL_TYPE_OF_ARGUMENT; +extern const int ILLEGAL_COLUMN; +} + +namespace +{ + +class FunctionH3PointDistKm final : public IFunction +{ +public: + static constexpr auto name = "h3PointDistKm"; + + static FunctionPtr create(ContextPtr) { return std::make_shared(); } + + std::string getName() const override { return name; } + + size_t getNumberOfArguments() const override { return 4; } + bool useDefaultImplementationForConstants() const override { return true; } + bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } + + DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override + { + for (size_t i = 0; i < getNumberOfArguments(); ++i) + { + const auto * arg = arguments[i].get(); + if (!WhichDataType(arg).isFloat64()) + throw Exception( + ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, + "Illegal type {} of argument {} of function {}. Must be Float64", + arg->getName(), i, getName()); + } + return std::make_shared(); + } + + ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override + { + const auto * col_lat1 = checkAndGetColumn(arguments[0].column.get()); + if (!col_lat1) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[0].type->getName(), + 1, + getName()); + const auto & data_lat1 = col_lat1->getData(); + + const auto * col_lon1 = checkAndGetColumn(arguments[1].column.get()); + if (!col_lon1) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[1].type->getName(), + 2, + getName()); + const auto & data_lon1 = col_lon1->getData(); + + const auto * col_lat2 = checkAndGetColumn(arguments[2].column.get()); + if (!col_lat2) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[2].type->getName(), + 3, + getName()); + const auto & data_lat2 = col_lat2->getData(); + + const auto * col_lon2 = checkAndGetColumn(arguments[3].column.get()); + if (!col_lon2) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[3].type->getName(), + 4, + getName()); + const auto & data_lon2 = col_lon2->getData(); + + auto dst = ColumnVector::create(); + auto & dst_data = dst->getData(); + dst_data.resize(input_rows_count); + + for (size_t row = 0; row < input_rows_count; ++row) + { + const double lat1 = data_lat1[row]; + const double lon1 = data_lon1[row]; + const auto lat2 = data_lat2[row]; + const auto lon2 = data_lon2[row]; + + LatLng point1 = {degsToRads(lat1), degsToRads(lon1)}; + LatLng point2 = {degsToRads(lat2), degsToRads(lon2)}; + + Float64 res = distanceKm(&point1, &point2); + dst_data[row] = res; + } + + return dst; + } +}; + +} + +void registerFunctionH3PointDistKm(FunctionFactory & factory) +{ + factory.registerFunction(); +} + +} + +#endif diff --git a/src/Functions/registerFunctionsGeo.cpp b/src/Functions/registerFunctionsGeo.cpp index 54fb79c8b31..fa73cb7e2ad 100644 --- a/src/Functions/registerFunctionsGeo.cpp +++ b/src/Functions/registerFunctionsGeo.cpp @@ -53,6 +53,7 @@ void registerFunctionH3CellAreaM2(FunctionFactory &); void registerFunctionH3CellAreaRads2(FunctionFactory &); void registerFunctionH3NumHexagons(FunctionFactory &); void registerFunctionH3PointDistM(FunctionFactory &); +void registerFunctionH3PointDistKm(FunctionFactory &); #endif @@ -120,6 +121,7 @@ void registerFunctionsGeo(FunctionFactory & factory) registerFunctionH3CellAreaRads2(factory); registerFunctionH3NumHexagons(factory); registerFunctionH3PointDistM(factory); + registerFunctionH3PointDistKm(factory); #endif #if USE_S2_GEOMETRY From 4bcbb301720e6429e3e0707cf0fcaa1ab9112228 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 08:58:04 -0800 Subject: [PATCH 069/132] add tests for h3PointDistKm func --- .../02212_h3_point_distKm.reference | 12 ++++++++++ .../0_stateless/02212_h3_point_distKm.sql | 22 +++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 tests/queries/0_stateless/02212_h3_point_distKm.reference create mode 100644 tests/queries/0_stateless/02212_h3_point_distKm.sql diff --git a/tests/queries/0_stateless/02212_h3_point_distKm.reference b/tests/queries/0_stateless/02212_h3_point_distKm.reference new file mode 100644 index 00000000000..2d0cc817236 --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_point_distKm.reference @@ -0,0 +1,12 @@ +111.1950519752296 +111.22891103262542 +111.9010753744776 +111.90107537447763 +111.90107537447763 +157.22560925091386 +157.24955851177873 +222.45778082261498 +223.528369444664 +223.528369444664 +400.9006688220521 +2223.901039504589 diff --git a/tests/queries/0_stateless/02212_h3_point_distKm.sql b/tests/queries/0_stateless/02212_h3_point_distKm.sql new file mode 100644 index 00000000000..5f684349d62 --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_point_distKm.sql @@ -0,0 +1,22 @@ +-- Tags: no-fasttest + +DROP TABLE IF EXISTS table1; + +CREATE TABLE table1 (lat1 Float64, lon1 Float64, lat2 Float64, lon2 Float64) ENGINE = Memory; + +INSERT INTO table1 VALUES(-10.0 ,0.0, 10.0, 0.0); +INSERT INTO table1 VALUES(-1, -1, 2, 1); +INSERT INTO table1 VALUES(0, 2, 1, 3); +INSERT INTO table1 VALUES(-2, -3, -1, -2); +INSERT INTO table1 VALUES(-87, 0, -85, 3); +INSERT INTO table1 VALUES(-89, 1, -88, 2); +INSERT INTO table1 VALUES(-84, 1, -83, 2); +INSERT INTO table1 VALUES(-88, 90, -86, 91); +INSERT INTO table1 VALUES(-84, -91, -83, -90); +INSERT INTO table1 VALUES(-90, 181, -89, 182); +INSERT INTO table1 VALUES(-84, 181, -83, 182); +INSERT INTO table1 VALUES(-87, 0, -85, 3); + +select h3PointDistKm(lat1, lon1,lat2, lon2) AS k from table1 order by k; + +DROP TABLE table1 From 8bb108ea6731bee665afe9a5d23347131d39d51f Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 08:59:34 -0800 Subject: [PATCH 070/132] add docs for h3PointDistKm --- docs/en/sql-reference/functions/geo/h3.md | 37 +++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/docs/en/sql-reference/functions/geo/h3.md b/docs/en/sql-reference/functions/geo/h3.md index 31bf455800d..000f4d176c7 100644 --- a/docs/en/sql-reference/functions/geo/h3.md +++ b/docs/en/sql-reference/functions/geo/h3.md @@ -1064,4 +1064,41 @@ Result: └───────────────────┘ ``` +## h3PointDistKm {#h3pointdistkm} + +Returns the "great circle" or "haversine" distance between pairs of GeoCoord points (latitude/longitude) pairs in kilometers. + +**Syntax** + +``` sql +h3PointDistKm(lat1, lon1, lat2, lon2) +``` + +**Arguments** + +- `lat1`, `lon1` — Latitude and Longitude of point1 in degrees. Type: [Float64](../../../sql-reference/data-types/float.md). +- `lat2`, `lon2` — Latitude and Longitude of point2 in degrees. Type: [Float64](../../../sql-reference/data-types/float.md). + +**Returned values** + +- Haversine or great circle distance in kilometers. + +Type: [Float64](../../../sql-reference/data-types/float.md). + +**Example** + +Query: + +``` sql +select h3PointDistKm(-10.0 ,0.0, 10.0, 0.0) as h3PointDistKm; +``` + +Result: + +``` text +┌─────h3PointDistKm─┐ +│ 2223.901039504589 │ +└───────────────────┘ +``` + [Original article](https://clickhouse.com/docs/en/sql-reference/functions/geo/h3) From 7d691b649ee2cbd98816d76cd56a2b196b8a9afe Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 09:50:59 -0800 Subject: [PATCH 071/132] fix file names --- ...h3_point_distKm.reference => 02212_h3_point_dist_km.reference} | 0 .../{02212_h3_point_distKm.sql => 02212_h3_point_dist_km.sql} | 0 ...2_h3_point_distM.reference => 02212_h3_point_dist_m.reference} | 0 .../{02212_h3_point_distM.sql => 02212_h3_point_dist_m.sql} | 0 4 files changed, 0 insertions(+), 0 deletions(-) rename tests/queries/0_stateless/{02212_h3_point_distKm.reference => 02212_h3_point_dist_km.reference} (100%) rename tests/queries/0_stateless/{02212_h3_point_distKm.sql => 02212_h3_point_dist_km.sql} (100%) rename tests/queries/0_stateless/{02212_h3_point_distM.reference => 02212_h3_point_dist_m.reference} (100%) rename tests/queries/0_stateless/{02212_h3_point_distM.sql => 02212_h3_point_dist_m.sql} (100%) diff --git a/tests/queries/0_stateless/02212_h3_point_distKm.reference b/tests/queries/0_stateless/02212_h3_point_dist_km.reference similarity index 100% rename from tests/queries/0_stateless/02212_h3_point_distKm.reference rename to tests/queries/0_stateless/02212_h3_point_dist_km.reference diff --git a/tests/queries/0_stateless/02212_h3_point_distKm.sql b/tests/queries/0_stateless/02212_h3_point_dist_km.sql similarity index 100% rename from tests/queries/0_stateless/02212_h3_point_distKm.sql rename to tests/queries/0_stateless/02212_h3_point_dist_km.sql diff --git a/tests/queries/0_stateless/02212_h3_point_distM.reference b/tests/queries/0_stateless/02212_h3_point_dist_m.reference similarity index 100% rename from tests/queries/0_stateless/02212_h3_point_distM.reference rename to tests/queries/0_stateless/02212_h3_point_dist_m.reference diff --git a/tests/queries/0_stateless/02212_h3_point_distM.sql b/tests/queries/0_stateless/02212_h3_point_dist_m.sql similarity index 100% rename from tests/queries/0_stateless/02212_h3_point_distM.sql rename to tests/queries/0_stateless/02212_h3_point_dist_m.sql From 9646bb0c91b07eb508c59046c47119afe6d72ffa Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 09:52:59 -0800 Subject: [PATCH 072/132] add func h3PointDistRads --- src/Functions/h3PointDistRads.cpp | 129 +++++++++++++++++++++++++ src/Functions/registerFunctionsGeo.cpp | 2 + 2 files changed, 131 insertions(+) create mode 100644 src/Functions/h3PointDistRads.cpp diff --git a/src/Functions/h3PointDistRads.cpp b/src/Functions/h3PointDistRads.cpp new file mode 100644 index 00000000000..8b2cee2ed06 --- /dev/null +++ b/src/Functions/h3PointDistRads.cpp @@ -0,0 +1,129 @@ +#include "config_functions.h" + +#if USE_H3 + +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + + +namespace DB +{ +namespace ErrorCodes +{ +extern const int ILLEGAL_TYPE_OF_ARGUMENT; +extern const int ILLEGAL_COLUMN; +} + +namespace +{ + +class FunctionH3PointDistRads final : public IFunction +{ +public: + static constexpr auto name = "h3PointDistRads"; + + static FunctionPtr create(ContextPtr) { return std::make_shared(); } + + std::string getName() const override { return name; } + + size_t getNumberOfArguments() const override { return 4; } + bool useDefaultImplementationForConstants() const override { return true; } + bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } + + DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override + { + for (size_t i = 0; i < getNumberOfArguments(); ++i) + { + const auto * arg = arguments[i].get(); + if (!WhichDataType(arg).isFloat64()) + throw Exception( + ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, + "Illegal type {} of argument {} of function {}. Must be Float64", + arg->getName(), i, getName()); + } + return std::make_shared(); + } + + ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override + { + const auto * col_lat1 = checkAndGetColumn(arguments[0].column.get()); + if (!col_lat1) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[0].type->getName(), + 1, + getName()); + const auto & data_lat1 = col_lat1->getData(); + + const auto * col_lon1 = checkAndGetColumn(arguments[1].column.get()); + if (!col_lon1) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[1].type->getName(), + 2, + getName()); + const auto & data_lon1 = col_lon1->getData(); + + const auto * col_lat2 = checkAndGetColumn(arguments[2].column.get()); + if (!col_lat2) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[2].type->getName(), + 3, + getName()); + const auto & data_lat2 = col_lat2->getData(); + + const auto * col_lon2 = checkAndGetColumn(arguments[3].column.get()); + if (!col_lon2) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be Float64", + arguments[3].type->getName(), + 4, + getName()); + const auto & data_lon2 = col_lon2->getData(); + + auto dst = ColumnVector::create(); + auto & dst_data = dst->getData(); + dst_data.resize(input_rows_count); + + for (size_t row = 0; row < input_rows_count; ++row) + { + const double lat1 = data_lat1[row]; + const double lon1 = data_lon1[row]; + const auto lat2 = data_lat2[row]; + const auto lon2 = data_lon2[row]; + + LatLng point1 = {degsToRads(lat1), degsToRads(lon1)}; + LatLng point2 = {degsToRads(lat2), degsToRads(lon2)}; + + Float64 res = distanceRads(&point1, &point2); + dst_data[row] = res; + } + + return dst; + } +}; + +} + +void registerFunctionH3PointDistRads(FunctionFactory & factory) +{ + factory.registerFunction(); +} + +} + +#endif diff --git a/src/Functions/registerFunctionsGeo.cpp b/src/Functions/registerFunctionsGeo.cpp index fa73cb7e2ad..8de5dcf1ff3 100644 --- a/src/Functions/registerFunctionsGeo.cpp +++ b/src/Functions/registerFunctionsGeo.cpp @@ -54,6 +54,7 @@ void registerFunctionH3CellAreaRads2(FunctionFactory &); void registerFunctionH3NumHexagons(FunctionFactory &); void registerFunctionH3PointDistM(FunctionFactory &); void registerFunctionH3PointDistKm(FunctionFactory &); +void registerFunctionH3PointDistRads(FunctionFactory &); #endif @@ -122,6 +123,7 @@ void registerFunctionsGeo(FunctionFactory & factory) registerFunctionH3NumHexagons(factory); registerFunctionH3PointDistM(factory); registerFunctionH3PointDistKm(factory); + registerFunctionH3PointDistRads(factory); #endif #if USE_S2_GEOMETRY From b02f3beb86798ad0057f7503692c9023d8cf7017 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 09:53:23 -0800 Subject: [PATCH 073/132] add tests for h3PointDistRads func --- .../02212_h3_point_dist_rads.reference | 12 ++++++++++ .../0_stateless/02212_h3_point_dist_rads.sql | 22 +++++++++++++++++++ 2 files changed, 34 insertions(+) create mode 100644 tests/queries/0_stateless/02212_h3_point_dist_rads.reference create mode 100644 tests/queries/0_stateless/02212_h3_point_dist_rads.sql diff --git a/tests/queries/0_stateless/02212_h3_point_dist_rads.reference b/tests/queries/0_stateless/02212_h3_point_dist_rads.reference new file mode 100644 index 00000000000..f5f934e5cd6 --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_point_dist_rads.reference @@ -0,0 +1,12 @@ +0.01745329251994332 +0.017458607073268143 +0.017564110696598745 +0.01756411069659875 +0.01756411069659875 +0.024678297290546682 +0.02468205639176644 +0.034917207673048706 +0.03508524839120321 +0.03508524839120321 +0.06292579139178688 +0.3490658503988659 diff --git a/tests/queries/0_stateless/02212_h3_point_dist_rads.sql b/tests/queries/0_stateless/02212_h3_point_dist_rads.sql new file mode 100644 index 00000000000..ba841174f7d --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_point_dist_rads.sql @@ -0,0 +1,22 @@ +-- Tags: no-fasttest + +DROP TABLE IF EXISTS table1; + +CREATE TABLE table1 (lat1 Float64, lon1 Float64, lat2 Float64, lon2 Float64) ENGINE = Memory; + +INSERT INTO table1 VALUES(-10.0 ,0.0, 10.0, 0.0); +INSERT INTO table1 VALUES(-1, -1, 2, 1); +INSERT INTO table1 VALUES(0, 2, 1, 3); +INSERT INTO table1 VALUES(-2, -3, -1, -2); +INSERT INTO table1 VALUES(-87, 0, -85, 3); +INSERT INTO table1 VALUES(-89, 1, -88, 2); +INSERT INTO table1 VALUES(-84, 1, -83, 2); +INSERT INTO table1 VALUES(-88, 90, -86, 91); +INSERT INTO table1 VALUES(-84, -91, -83, -90); +INSERT INTO table1 VALUES(-90, 181, -89, 182); +INSERT INTO table1 VALUES(-84, 181, -83, 182); +INSERT INTO table1 VALUES(-87, 0, -85, 3); + +select h3PointDistRads(lat1, lon1,lat2, lon2) AS k from table1 order by k; + +DROP TABLE table1 From babcf4da3d559486d37ed1125f264c8ccd1d536f Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 09:54:42 -0800 Subject: [PATCH 074/132] add docs for h3PointDistRads func --- docs/en/sql-reference/functions/geo/h3.md | 37 +++++++++++++++++++++++ 1 file changed, 37 insertions(+) diff --git a/docs/en/sql-reference/functions/geo/h3.md b/docs/en/sql-reference/functions/geo/h3.md index 000f4d176c7..50730e27111 100644 --- a/docs/en/sql-reference/functions/geo/h3.md +++ b/docs/en/sql-reference/functions/geo/h3.md @@ -1101,4 +1101,41 @@ Result: └───────────────────┘ ``` +## h3PointDistRads {#h3pointdistrads} + +Returns the "great circle" or "haversine" distance between pairs of GeoCoord points (latitude/longitude) pairs in radians. + +**Syntax** + +``` sql +h3PointDistRads(lat1, lon1, lat2, lon2) +``` + +**Arguments** + +- `lat1`, `lon1` — Latitude and Longitude of point1 in degrees. Type: [Float64](../../../sql-reference/data-types/float.md). +- `lat2`, `lon2` — Latitude and Longitude of point2 in degrees. Type: [Float64](../../../sql-reference/data-types/float.md). + +**Returned values** + +- Haversine or great circle distance in radians. + +Type: [Float64](../../../sql-reference/data-types/float.md). + +**Example** + +Query: + +``` sql +select h3PointDistRads(-10.0 ,0.0, 10.0, 0.0) as h3PointDistRads; +``` + +Result: + +``` text +┌────h3PointDistRads─┐ +│ 0.3490658503988659 │ +└────────────────────┘ +``` + [Original article](https://clickhouse.com/docs/en/sql-reference/functions/geo/h3) From 88b6fc6432a6b4233c02de6a3f9b98b35ce53cd6 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 10:35:52 -0800 Subject: [PATCH 075/132] add h3GetRes0Indexes func --- src/Functions/h3GetRes0Indexes.cpp | 80 ++++++++++++++++++++++++++ src/Functions/registerFunctionsGeo.cpp | 2 + 2 files changed, 82 insertions(+) create mode 100644 src/Functions/h3GetRes0Indexes.cpp diff --git a/src/Functions/h3GetRes0Indexes.cpp b/src/Functions/h3GetRes0Indexes.cpp new file mode 100644 index 00000000000..f9bbf7f9175 --- /dev/null +++ b/src/Functions/h3GetRes0Indexes.cpp @@ -0,0 +1,80 @@ +#include "config_functions.h" + +#if USE_H3 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + + +namespace DB +{ +namespace +{ + +class FunctionH3GetRes0Indexes final : public IFunction +{ +public: + static constexpr auto name = "h3GetRes0Indexes"; + + static FunctionPtr create(ContextPtr) { return std::make_shared(); } + + std::string getName() const override { return name; } + + size_t getNumberOfArguments() const override { return 0; } + bool useDefaultImplementationForConstants() const override { return true; } + bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } + + DataTypePtr getReturnTypeImpl(const DataTypes & /*arguments*/) const override + { + return std::make_shared(std::make_shared()); + } + + ColumnPtr executeImpl(const ColumnsWithTypeAndName & /*arguments*/, const DataTypePtr &, size_t input_rows_count) const override + { + auto dst = ColumnArray::create(ColumnUInt64::create()); + auto & dst_data = dst->getData(); + auto & dst_offsets = dst->getOffsets(); + dst_offsets.resize(input_rows_count); + auto current_offset = 0; + + const auto vec_size = res0CellCount(); + std::vector hindex_vec; + + for (size_t row = 0; row < input_rows_count; ++row) + { + hindex_vec.resize(vec_size); + getRes0Cells(hindex_vec.data()); + dst_data.reserve(input_rows_count); + + for (auto & hindex : hindex_vec) + { + ++current_offset; + dst_data.insert(hindex); + } + hindex_vec.clear(); + dst_offsets[row] = current_offset; + } + return dst; + } +}; + +} + +void registerFunctionH3GetRes0Indexes(FunctionFactory & factory) +{ + factory.registerFunction(); +} + +} + +#endif diff --git a/src/Functions/registerFunctionsGeo.cpp b/src/Functions/registerFunctionsGeo.cpp index 8de5dcf1ff3..84daa2a0eb6 100644 --- a/src/Functions/registerFunctionsGeo.cpp +++ b/src/Functions/registerFunctionsGeo.cpp @@ -55,6 +55,7 @@ void registerFunctionH3NumHexagons(FunctionFactory &); void registerFunctionH3PointDistM(FunctionFactory &); void registerFunctionH3PointDistKm(FunctionFactory &); void registerFunctionH3PointDistRads(FunctionFactory &); +void registerFunctionH3GetRes0Indexes(FunctionFactory &); #endif @@ -124,6 +125,7 @@ void registerFunctionsGeo(FunctionFactory & factory) registerFunctionH3PointDistM(factory); registerFunctionH3PointDistKm(factory); registerFunctionH3PointDistRads(factory); + registerFunctionH3GetRes0Indexes(factory); #endif #if USE_S2_GEOMETRY From d3aa98570bdbc1650f6461923eceb88017a89fed Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 10:39:45 -0800 Subject: [PATCH 076/132] add tests for h3GetRs0Indexes func --- tests/queries/0_stateless/02212_h3_get_res0_indexes.reference | 1 + tests/queries/0_stateless/02212_h3_get_res0_indexes.sql | 4 ++++ 2 files changed, 5 insertions(+) create mode 100644 tests/queries/0_stateless/02212_h3_get_res0_indexes.reference create mode 100644 tests/queries/0_stateless/02212_h3_get_res0_indexes.sql diff --git a/tests/queries/0_stateless/02212_h3_get_res0_indexes.reference b/tests/queries/0_stateless/02212_h3_get_res0_indexes.reference new file mode 100644 index 00000000000..fe097fdceb8 --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_get_res0_indexes.reference @@ -0,0 +1 @@ +[576495936675512319,576531121047601151,576566305419689983,576601489791778815,576636674163867647,576671858535956479,576707042908045311,576742227280134143,576777411652222975,576812596024311807,576847780396400639,576882964768489471,576918149140578303,576953333512667135,576988517884755967,577023702256844799,577058886628933631,577094071001022463,577129255373111295,577164439745200127,577199624117288959,577234808489377791,577269992861466623,577305177233555455,577340361605644287,577375545977733119,577410730349821951,577445914721910783,577481099093999615,577516283466088447,577551467838177279,577586652210266111,577621836582354943,577657020954443775,577692205326532607,577727389698621439,577762574070710271,577797758442799103,577832942814887935,577868127186976767,577903311559065599,577938495931154431,577973680303243263,578008864675332095,578044049047420927,578079233419509759,578114417791598591,578149602163687423,578184786535776255,578219970907865087,578255155279953919,578290339652042751,578325524024131583,578360708396220415,578395892768309247,578431077140398079,578466261512486911,578501445884575743,578536630256664575,578571814628753407,578606999000842239,578642183372931071,578677367745019903,578712552117108735,578747736489197567,578782920861286399,578818105233375231,578853289605464063,578888473977552895,578923658349641727,578958842721730559,578994027093819391,579029211465908223,579064395837997055,579099580210085887,579134764582174719,579169948954263551,579205133326352383,579240317698441215,579275502070530047,579310686442618879,579345870814707711,579381055186796543,579416239558885375,579451423930974207,579486608303063039,579521792675151871,579556977047240703,579592161419329535,579627345791418367,579662530163507199,579697714535596031,579732898907684863,579768083279773695,579803267651862527,579838452023951359,579873636396040191,579908820768129023,579944005140217855,579979189512306687,580014373884395519,580049558256484351,580084742628573183,580119927000662015,580155111372750847,580190295744839679,580225480116928511,580260664489017343,580295848861106175,580331033233195007,580366217605283839,580401401977372671,580436586349461503,580471770721550335,580506955093639167,580542139465727999,580577323837816831,580612508209905663,580647692581994495,580682876954083327,580718061326172159,580753245698260991] diff --git a/tests/queries/0_stateless/02212_h3_get_res0_indexes.sql b/tests/queries/0_stateless/02212_h3_get_res0_indexes.sql new file mode 100644 index 00000000000..171d1b93bbc --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_get_res0_indexes.sql @@ -0,0 +1,4 @@ +-- Tags: no-fasttest + +select h3GetRes0Indexes(); +select h3GetRes0Indexes(3); -- { serverError 42 } From b4ca0dc20d4c01825be8713c8eaed95e9391d923 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 10:56:23 -0800 Subject: [PATCH 077/132] add docs for h3GetRes0indexes func --- docs/en/sql-reference/functions/geo/h3.md | 33 +++++++++++++++++++++++ 1 file changed, 33 insertions(+) diff --git a/docs/en/sql-reference/functions/geo/h3.md b/docs/en/sql-reference/functions/geo/h3.md index 50730e27111..60135f80249 100644 --- a/docs/en/sql-reference/functions/geo/h3.md +++ b/docs/en/sql-reference/functions/geo/h3.md @@ -1138,4 +1138,37 @@ Result: └────────────────────┘ ``` +## h3GetRes0Indexes {#h3getres0indexes} + +Returns an array of all the resolution 0 H3 indexes. + +**Syntax** + +``` sql +h3GetRes0Indexes() +``` + +**Returned values** + +- Array of all the resolution 0 H3 indexes. + +Type: [Array](../../../sql-reference/data-types/array.md)([UInt64](../../../sql-reference/data-types/int-uint.md)). + + +**Example** + +Query: + +``` sql +select h3GetRes0Indexes as indexes ; +``` + +Result: + +``` text +┌─indexes─────────────────────────────────────┐ +│ [576495936675512319,576531121047601151,....]│ +└─────────────────────────────────────────────┘ +``` + [Original article](https://clickhouse.com/docs/en/sql-reference/functions/geo/h3) From 8654691b96f5d1bf7fbc92cfd03da2c819256ab9 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 12:12:54 -0800 Subject: [PATCH 078/132] add h3GetPentagonIndexes func --- src/Functions/h3GetPentagonIndexes.cpp | 114 +++++++++++++++++++++++++ src/Functions/registerFunctionsGeo.cpp | 2 + 2 files changed, 116 insertions(+) create mode 100644 src/Functions/h3GetPentagonIndexes.cpp diff --git a/src/Functions/h3GetPentagonIndexes.cpp b/src/Functions/h3GetPentagonIndexes.cpp new file mode 100644 index 00000000000..adc0e7e6759 --- /dev/null +++ b/src/Functions/h3GetPentagonIndexes.cpp @@ -0,0 +1,114 @@ +#include "config_functions.h" + +#if USE_H3 + +#include +#include +#include +#include +#include +#include +#include + +#include +#include + + +namespace DB +{ +namespace ErrorCodes +{ +extern const int ILLEGAL_TYPE_OF_ARGUMENT; +extern const int ILLEGAL_COLUMN; +extern const int ARGUMENT_OUT_OF_BOUND; +} + +namespace +{ + +class FunctionH3GetPentagonIndexes : public IFunction +{ +public: + static constexpr auto name = "h3GetPentagonIndexes"; + + static FunctionPtr create(ContextPtr) { return std::make_shared(); } + + std::string getName() const override { return name; } + + size_t getNumberOfArguments() const override { return 1; } + bool useDefaultImplementationForConstants() const override { return true; } + bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } + + DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override + { + const auto * arg = arguments[0].get(); + if (!WhichDataType(arg).isUInt8()) + throw Exception( + ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, + "Illegal type {} of argument {} of function {}. Must be UInt8", + arg->getName(), 1, getName()); + + return std::make_shared(std::make_shared()); + } + + ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override + { + const auto * column = checkAndGetColumn(arguments[0].column.get()); + if (!column) + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, + "Illegal type {} of argument {} of function {}. Must be UInt8.", + arguments[0].type->getName(), + 1, + getName()); + const auto & data = column->getData(); + + auto result_column_data = ColumnUInt64::create(); + auto & result_data = result_column_data->getData(); + + auto result_column_offsets = ColumnArray::ColumnOffsets::create(); + auto & result_offsets = result_column_offsets->getData(); + result_offsets.resize(input_rows_count); + + auto current_offset = 0; + std::vector hindex_vec; + + + for (size_t row = 0; row < input_rows_count; ++row) + { + if (data[row] > MAX_H3_RES) + throw Exception( + ErrorCodes::ARGUMENT_OUT_OF_BOUND, + "The argument 'resolution' ({}) of function {} is out of bounds because the maximum resolution in H3 library is ", + toString(data[row]), + getName(), + MAX_H3_RES); + + const auto vec_size = pentagonCount(); + hindex_vec.resize(vec_size); + getPentagons(data[row], hindex_vec.data()); + + for (auto & i : hindex_vec) + { + ++current_offset; + result_data.emplace_back(i); + } + + result_offsets[row] = current_offset; + hindex_vec.clear(); + } + + return ColumnArray::create(std::move(result_column_data), std::move(result_column_offsets)); + } +}; + +} + +void registerFunctionH3GetPentagonIndexes(FunctionFactory & factory) +{ + factory.registerFunction(); +} + +} + +#endif diff --git a/src/Functions/registerFunctionsGeo.cpp b/src/Functions/registerFunctionsGeo.cpp index 84daa2a0eb6..9cbe1ed96cf 100644 --- a/src/Functions/registerFunctionsGeo.cpp +++ b/src/Functions/registerFunctionsGeo.cpp @@ -56,6 +56,7 @@ void registerFunctionH3PointDistM(FunctionFactory &); void registerFunctionH3PointDistKm(FunctionFactory &); void registerFunctionH3PointDistRads(FunctionFactory &); void registerFunctionH3GetRes0Indexes(FunctionFactory &); +void registerFunctionH3GetPentagonIndexes(FunctionFactory &); #endif @@ -126,6 +127,7 @@ void registerFunctionsGeo(FunctionFactory & factory) registerFunctionH3PointDistKm(factory); registerFunctionH3PointDistRads(factory); registerFunctionH3GetRes0Indexes(factory); + registerFunctionH3GetPentagonIndexes(factory); #endif #if USE_S2_GEOMETRY From c29e16fb744e7597bab1e40b12a72a93e69a04ee Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 12:17:59 -0800 Subject: [PATCH 079/132] add tests for h3GetPentagonIndexes --- src/Functions/h3GetPentagonIndexes.cpp | 1 + .../02212_h3_get_pentagon_indexes.reference | 16 +++++++++++ .../02212_h3_get_pentagon_indexes.sql | 28 +++++++++++++++++++ 3 files changed, 45 insertions(+) create mode 100644 tests/queries/0_stateless/02212_h3_get_pentagon_indexes.reference create mode 100644 tests/queries/0_stateless/02212_h3_get_pentagon_indexes.sql diff --git a/src/Functions/h3GetPentagonIndexes.cpp b/src/Functions/h3GetPentagonIndexes.cpp index adc0e7e6759..bd084e3b41c 100644 --- a/src/Functions/h3GetPentagonIndexes.cpp +++ b/src/Functions/h3GetPentagonIndexes.cpp @@ -72,6 +72,7 @@ public: auto current_offset = 0; std::vector hindex_vec; + result_data.reserve(input_rows_count); for (size_t row = 0; row < input_rows_count; ++row) diff --git a/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.reference b/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.reference new file mode 100644 index 00000000000..c73c2a34e42 --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.reference @@ -0,0 +1,16 @@ +[576636674163867647,576988517884755967,577340361605644287,577832942814887935,578219970907865087,578536630256664575,578712552117108735,579029211465908223,579416239558885375,579908820768129023,580260664489017343,580612508209905663] +[581109487465660415,581461331186548735,581813174907437055,582305756116680703,582692784209657855,583009443558457343,583185365418901503,583502024767700991,583889052860678143,584381634069921791,584733477790810111,585085321511698431] +[585609238802333695,585961082523222015,586312926244110335,586805507453353983,587192535546331135,587509194895130623,587685116755574783,588001776104374271,588388804197351423,588881385406595071,589233229127483391,589585072848371711] +[590112357393367039,590464201114255359,590816044835143679,591308626044387327,591695654137364479,592012313486163967,592188235346608127,592504894695407615,592891922788384767,593384503997628415,593736347718516735,594088191439405055] +[594615896891195391,594967740612083711,595319584332972031,595812165542215679,596199193635192831,596515852983992319,596691774844436479,597008434193235967,597395462286213119,597888043495456767,598239887216345087,598591730937233407] +[599119489002373119,599471332723261439,599823176444149759,600315757653393407,600702785746370559,601019445095170047,601195366955614207,601512026304413695,601899054397390847,602391635606634495,602743479327522815,603095323048411135] +[603623087690219519,603974931411107839,604326775131996159,604819356341239807,605206384434216959,605523043783016447,605698965643460607,606015624992260095,606402653085237247,606895234294480895,607247078015369215,607598921736257535] +[608126687200149503,608478530921037823,608830374641926143,609322955851169791,609709983944146943,610026643292946431,610202565153390591,610519224502190079,610906252595167231,611398833804410879,611750677525299199,612102521246187519] +[612630286812839935,612982130533728255,613333974254616575,613826555463860223,614213583556837375,614530242905636863,614706164766081023,615022824114880511,615409852207857663,615902433417101311,616254277137989631,616606120858877951] +[617133886438375423,617485730159263743,617837573880152063,618330155089395711,618717183182372863,619033842531172351,619209764391616511,619526423740415999,619913451833393151,620406033042636799,620757876763525119,621109720484413439] +[621637486065516543,621989329786404863,622341173507293183,622833754716536831,623220782809513983,623537442158313471,623713364018757631,624030023367557119,624417051460534271,624909632669777919,625261476390666239,625613320111554559] +[626141085692858367,626492929413746687,626844773134635007,627337354343878655,627724382436855807,628041041785655295,628216963646099455,628533622994898943,628920651087876095,629413232297119743,629765076018008063,630116919738896383] +[630644685320225279,630996529041113599,631348372762001919,631840953971245567,632227982064222719,632544641413022207,632720563273466367,633037222622265855,633424250715243007,633916831924486655,634268675645374975,634620519366263295] +[635148284947595327,635500128668483647,635851972389371967,636344553598615615,636731581691592767,637048241040392255,637224162900836415,637540822249635903,637927850342613055,638420431551856703,638772275272745023,639124118993633343] +[639651884574965767,640003728295854087,640355572016742407,640848153225986055,641235181318963207,641551840667762695,641727762528206855,642044421877006343,642431449969983495,642924031179227143,643275874900115463,643627718621003783] +[644155484202336256,644507327923224576,644859171644112896,645351752853356544,645738780946333696,646055440295133184,646231362155577344,646548021504376832,646935049597353984,647427630806597632,647779474527485952,648131318248374272] diff --git a/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.sql b/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.sql new file mode 100644 index 00000000000..65a6dfb11bf --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.sql @@ -0,0 +1,28 @@ +-- Tags: no-fasttest + +DROP TABLE IF EXISTS table1; + +CREATE TABLE table1 (resolution UInt8) ENGINE = Memory; + +INSERT INTO table1 VALUES(0); +INSERT INTO table1 VALUES(1); +INSERT INTO table1 VALUES(2); +INSERT INTO table1 VALUES(3); +INSERT INTO table1 VALUES(4); +INSERT INTO table1 VALUES(5); +INSERT INTO table1 VALUES(6); +INSERT INTO table1 VALUES(7); +INSERT INTO table1 VALUES(8); +INSERT INTO table1 VALUES(9); +INSERT INTO table1 VALUES(10); +INSERT INTO table1 VALUES(11); +INSERT INTO table1 VALUES(12); +INSERT INTO table1 VALUES(13); +INSERT INTO table1 VALUES(14); +INSERT INTO table1 VALUES(15); + + +select h3GetPentagonIndexes(resolution) AS indexes from table1 order by indexes; +SELECT h3GetPentagonIndexes(20) AS indexes; -- { serverError 69 } + +DROP TABLE table1 From d1056e1147bcfb1426e890cd52232f67a6bc1812 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Sun, 13 Feb 2022 12:22:55 -0800 Subject: [PATCH 080/132] add docs for h3GetPentagonIndexes func --- docs/en/sql-reference/functions/geo/h3.md | 36 +++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/docs/en/sql-reference/functions/geo/h3.md b/docs/en/sql-reference/functions/geo/h3.md index 60135f80249..6d3f510bffc 100644 --- a/docs/en/sql-reference/functions/geo/h3.md +++ b/docs/en/sql-reference/functions/geo/h3.md @@ -1171,4 +1171,40 @@ Result: └─────────────────────────────────────────────┘ ``` +## h3GetPentagonIndexes {#h3getpentagonindexes} + +Returns all the pentagon H3 indexes at the specified resolution. + +**Syntax** + +``` sql +h3GetPentagonIndexes(resolution) +``` + +**Parameter** + +- `resolution` — Index resolution. Range: `[0, 15]`. Type: [UInt8](../../../sql-reference/data-types/int-uint.md). + +**Returned value** + +- Array of all pentagon H3 indexes. + +Type: [Array](../../../sql-reference/data-types/array.md)([UInt64](../../../sql-reference/data-types/int-uint.md)). + +**Example** + +Query: + +``` sql +SELECT h3GetPentagonIndexes(3) AS indexes; +``` + +Result: + +``` text +┌─indexes────────────────────────────────────────────────────────┐ +│ [590112357393367039,590464201114255359,590816044835143679,...] │ +└────────────────────────────────────────────────────────────────┘ +``` + [Original article](https://clickhouse.com/docs/en/sql-reference/functions/geo/h3) From 8e26cfbbeac3633d08c152d8d834396e7ba94b01 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Mon, 14 Feb 2022 22:20:52 +0300 Subject: [PATCH 081/132] add test with github events for type JSON --- src/Columns/ColumnObject.cpp | 5 ++- src/DataTypes/Serializations/SubcolumnsTree.h | 1 - .../0_stateless/01825_type_json_btc.sh | 2 +- .../01825_type_json_ghdata.reference | 22 ++++++++++ .../0_stateless/01825_type_json_ghdata.sh | 38 ++++++++++++++++++ .../0_stateless/01825_type_json_nbagames.sh | 2 +- .../0_stateless/data_json/ghdata_sample.json | Bin 0 -> 14740550 bytes .../data_json/nbagames_sample.json | Bin 6381971 -> 4914595 bytes 8 files changed, 66 insertions(+), 4 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_ghdata.reference create mode 100755 tests/queries/0_stateless/01825_type_json_ghdata.sh create mode 100644 tests/queries/0_stateless/data_json/ghdata_sample.json diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 18d192ee569..76f49013a97 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -703,7 +703,8 @@ void ColumnObject::addNestedSubcolumn(const PathInData & key, const FieldInfo & bool inserted = false; const auto * nested_node = subcolumns.findBestMatch(key); - if (nested_node && nested_node->isNested()) + + if (nested_node) { const auto * leaf = subcolumns.findLeaf(nested_node, [&](const auto & ) { return true; }); assert(leaf); @@ -717,7 +718,9 @@ void ColumnObject::addNestedSubcolumn(const PathInData & key, const FieldInfo & inserted = subcolumns.add(key, new_subcolumn); } else + { inserted = subcolumns.add(key, Subcolumn(new_size, is_nullable)); + } if (!inserted) throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Subcolumn '{}' already exists", key.getPath()); diff --git a/src/DataTypes/Serializations/SubcolumnsTree.h b/src/DataTypes/Serializations/SubcolumnsTree.h index a1700f47b60..1e30c069839 100644 --- a/src/DataTypes/Serializations/SubcolumnsTree.h +++ b/src/DataTypes/Serializations/SubcolumnsTree.h @@ -191,7 +191,6 @@ private: for (const auto & part : parts) { auto it = current_node->children.find(part.key); - // std::cerr << "part: " << part.key << ", found: " << (it != current_node->children.end()) << '\n'; if (it == current_node->children.end()) return find_exact ? nullptr : current_node; diff --git a/tests/queries/0_stateless/01825_type_json_btc.sh b/tests/queries/0_stateless/01825_type_json_btc.sh index b189f16c16b..7d95046bb75 100755 --- a/tests/queries/0_stateless/01825_type_json_btc.sh +++ b/tests/queries/0_stateless/01825_type_json_btc.sh @@ -11,7 +11,7 @@ ${CLICKHOUSE_CLIENT} -q "CREATE TABLE btc (data JSON) ENGINE = MergeTree ORDER B cat $CUR_DIR/data_json/btc_transactions.json | ${CLICKHOUSE_CLIENT} -q "INSERT INTO btc FORMAT JSONAsObject" --input_format_parallel_parsing 0 -${CLICKHOUSE_CLIENT} -q "SELECT count() FROM btc" +${CLICKHOUSE_CLIENT} -q "SELECT count() FROM btc WHERE NOT ignore(*)" ${CLICKHOUSE_CLIENT} -q "DESC btc SETTINGS describe_extend_object_types = 1" ${CLICKHOUSE_CLIENT} -q "SELECT avg(data.fee), median(data.fee) FROM btc" diff --git a/tests/queries/0_stateless/01825_type_json_ghdata.reference b/tests/queries/0_stateless/01825_type_json_ghdata.reference new file mode 100644 index 00000000000..c11e9c2dfd9 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_ghdata.reference @@ -0,0 +1,22 @@ +5000 +900 +String 562 +Array 134 +UInt64 63 +Tuple 52 +Int32 47 +Int8 17 +Int16 15 +Nested 9 +Int64 1 +leonardomso/33-js-concepts 3 +ytdl-org/youtube-dl 3 +Bogdanp/neko 2 +bminossi/AllVideoPocsFromHackerOne 2 +disclose/diodata 2 +Commit 182 +chipeo345 119 +phanwi346 114 +Nicholas Piggin 95 +direwolf-github 49 +2 diff --git a/tests/queries/0_stateless/01825_type_json_ghdata.sh b/tests/queries/0_stateless/01825_type_json_ghdata.sh new file mode 100755 index 00000000000..87bc8740b46 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_ghdata.sh @@ -0,0 +1,38 @@ +#!/usr/bin/env bash +# Tags: no-fasttest + +CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +# shellcheck source=../shell_config.sh +. "$CUR_DIR"/../shell_config.sh + +${CLICKHOUSE_CLIENT} -q "DROP TABLE IF EXISTS ghdata" + +${CLICKHOUSE_CLIENT} -q "CREATE TABLE ghdata (data JSON) ENGINE = MergeTree ORDER BY tuple()" + +cat $CUR_DIR/data_json/ghdata_sample.json | ${CLICKHOUSE_CLIENT} -q "INSERT INTO ghdata FORMAT JSONAsObject" --input_format_parallel_parsing 0 + +${CLICKHOUSE_CLIENT} -q "SELECT count() FROM ghdata WHERE NOT ignore(*)" + +${CLICKHOUSE_CLIENT} -q \ +"SELECT length(subcolumns.names) \ + FROM system.parts_columns \ + WHERE table = 'ghdata' AND database = '$CLICKHOUSE_DATABASE'" + +${CLICKHOUSE_CLIENT} -q "WITH position(full_type, '(') AS pos +SELECT if(pos = 0, full_type, substring(full_type, 1, pos - 1)) AS type, count() AS c \ + FROM system.parts_columns ARRAY JOIN subcolumns.types AS full_type \ + WHERE table = 'ghdata' AND database = '$CLICKHOUSE_DATABASE' \ + GROUP BY type ORDER BY c DESC" + +${CLICKHOUSE_CLIENT} -q \ +"SELECT data.repo.name, count() AS stars FROM ghdata \ + WHERE data.type = 'WatchEvent' GROUP BY data.repo.name ORDER BY stars DESC, data.repo.name LIMIT 5" + +${CLICKHOUSE_CLIENT} -q \ +"SELECT data.payload.commits.author.name AS name, count() AS c FROM ghdata \ + ARRAY JOIN data.payload.commits.author.name \ + GROUP BY name ORDER BY c DESC, name LIMIT 5" + +${CLICKHOUSE_CLIENT} -q "SELECT max(data.payload.pull_request.assignees.size0) FROM ghdata" + +${CLICKHOUSE_CLIENT} -q "DROP TABLE IF EXISTS ghdata" diff --git a/tests/queries/0_stateless/01825_type_json_nbagames.sh b/tests/queries/0_stateless/01825_type_json_nbagames.sh index 6abec0a92fe..b332c89f9d6 100755 --- a/tests/queries/0_stateless/01825_type_json_nbagames.sh +++ b/tests/queries/0_stateless/01825_type_json_nbagames.sh @@ -11,7 +11,7 @@ ${CLICKHOUSE_CLIENT} -q "CREATE TABLE nbagames (data JSON) ENGINE = MergeTree OR cat $CUR_DIR/data_json/nbagames_sample.json | ${CLICKHOUSE_CLIENT} -q "INSERT INTO nbagames FORMAT JSONAsObject" --input_format_parallel_parsing 0 -${CLICKHOUSE_CLIENT} -q "SELECT count() FROM nbagames" +${CLICKHOUSE_CLIENT} -q "SELECT count() FROM nbagames WHERE NOT ignore(*)" ${CLICKHOUSE_CLIENT} -q "DESC nbagames SETTINGS describe_extend_object_types = 1" ${CLICKHOUSE_CLIENT} -q \ diff --git a/tests/queries/0_stateless/data_json/ghdata_sample.json b/tests/queries/0_stateless/data_json/ghdata_sample.json new file mode 100644 index 0000000000000000000000000000000000000000..985b4f135b808dac8d4e8a3483a6a641f623b636 GIT binary patch literal 14740550 zcmeFa>2e!MvM%^4d05tcq-uf4ePOLCiB+xcBBhe3uHD$VM3O0j02&F9qIk+|o?(96 zzjuC(*?oigf8J!CU>;#UkI2X!KxP7UPG4(Qw&Wm|uG!*ZeNDwH=h%y{ljV7O>7z|iz?fx+zUJG883ei$hc+`+ z(=_$ii8aSHEhA(BsR9s2$;FgGVokBx6yMW>qo04JVdhE(ny_Fu2_tT;|3F)B_Hg0{ zY?6JxPA1S!X49Nz*{-9yeh}(z?CHL$JE|XB zniCk7?mDjSqm!3RXk2_bVL2BX%2B$!n?P!hmq~Q@cK!ydmrp^Aw_1M^{LrIr+6NwX zA#;B%0KkUezPe|j39l3dIgsM~7&%xE(cVrT$#H*wzmye0%v(fF#$zLYnH{J*T zhu1gZ^y&jNX6@zkAI+2JZ$CpV*_m?fK{BRuU5|q&S5fGIknM9^m3t5<4+4eTUd9h9 ze!JOd{7<3ccRjqWGZ?|L#`1%j)Trax;wl#hRV&Oe(*&dz(cF`Q#z}$X6}#ILMWS>+ z#^2dtIK+9~4`vG=2Fg8EQ6YH`?X{?Zv}ArH*(`Fps^a2w1D$j>+t-M5QfQ?xR&_bQ zc5Q5?&r4n^jt%>)M9@O}<Z$Owy&w=O($|Wae2<% z&(KI}IDyak){)er0(5^zDpay_-+BqXVojZR{t%6{2T zN3xx&t+vcBxVI_cUdD8M|0g(!E=h`_(z(Cblba|bHog!1l>K&icz93NE2@T@Zuis+ zK?_9vMR*Cb_kJefUQ&Y&cw^T+jCE?&&h$bnE3s)U(hPARBi~~4{=Va zOglGd?`c#DdgWTCvt<$|VHfvI*A1aU^8Sl7nTG5MoaRr!1Ll6=IOoA4dm21R?S3pAZV{VLW_R3NzMtlo2%_Ui^pUQgsos(09cji! zkB@$&n)pAxGhd~bTiiLcXNXfGJ|W%$f6G{l!VbRX07_n7)RLyssgCbo76gvE5`bfB zT9+{enNqaJmUi4sYm?E32s&~(yJmA}UGgZMCLi$G(w&Od6wX$NfH_j19Nbbo0cj$| zBdKY@LGTxN$lq``Dv|cnb0I$tj+ToR9QX8OzL>p32nk$R#j`?sl^)(ES4sILYGqzZ zoX(3jTqldg3@&DhqshE%LW~zt1Bl4+5gkxGn9bQVYhbxINr*Utd_2V2oqAq+y)qK~ zOT=P-HCdjEV-H5++J|HFH}YwMBe`*s9CuYu3x9{$mV7JOm(07UnvA&-+&8+xJWq2h zEshM!^x?r#H7~?>%MBdzE42#RZ_1{?>8_`@2XBf9TVHe37(aMZ+Ct#R58jmOod7yVKX_AGuS@Wu z;m(=da4r2Gwd4CRe>Lg-JfiTyn^M220%QJzH)Wk#9;ccvD&~&5a+tDP1lFjvu@!B_n=Uj(hN?)HJEm7N{lTShpRBn%-IaUf^(ML+O-7X#%6-;TexDcQxX^E*H&D~h6cOB525lMK z@jH+&?kl05+EuUpRVT-NLv8!6OpaL*5|9lf6ybf>Wf(G+h-OP3()L%2q}cuH7r7+; z)$$U~QrItMVZy^8;D3Di{ps;*_!H?4KB8af$~7(|`YGMV7amn{QBt~O`8RT?%AXgE zT%F}7`77ttPP}-qnqEy2_=0K#vGV};Js<97Z!%&w4BiiSvwL7=Jlq6p0T3B<6HJOt zt{^n_1H?yA0K*c0aMM5Zr{~u*AW(q2tCx`vjx>mvC`$O1s4+$Fs{ZbfzR9Mw?m5~|C| zpI6t{C|L(|kPyj#&1YzKKaS+C;PnV;30fRWY(_t#tl-mY9hel*aW*kP5Z!*vD zT`P2A-3=|<(Ok<5Od}>Zo}AMIfN|K&bsRfTHPs6=*A4v8(?CiO+`x>Dz;cX`0HvCo z-lM_>rx*IHjZ`C80eS5vJo*&F~U;pHJ)RoOga zcqInUqP+tcuzl8Yw(H#AJ+Ymuq8l08VJ~7!*1Gcow!-ra!ugVn2a6W=DO_t@{)|7r ziovLGVDSci9KwYK0a?W$c9d;zu%oU4T1~Z7s7Dz)UNc|=0b^_oF&wTYbYT;1@4$;~ z1*?oGcG99tQa!$~F7xR@Z*I39Dv1ddfRI0#Wp=BCCoAF|3Fp(BTS{&;Jz-Qvv40QCiDQtUG*bug_eJHZZoA7eA z@FUXNq|CKl*N;@!RzuCUSme7{NWN-Wk!u^C>FAafTe@XN(5&7cq9g{jP^;qPz4DQ! zQx^xw+VW)O61HbB`%*a{UVeK%u^ z=*FL3;iffhXZ2mK@xl1%1~obew8^jxeks@5^BFv%$ZG@h-pqcAt)^x)Wz^O!Sm=l<`Dfk}{N4E!~)Us?|- zj%@)dSuJt!G47Z;uBXuGBrg*z)Rh`_{wxQ2BSyWE>8XzheET#$jk zlfa4h05e>oSwhty7@XcH!v(3ncV>!`+$Dg@VWaPeFXkOl7oA`LC4`!k!lUU-uF(BAn@PM^xk;ARMhE`KFlh0a)Ked_Fude(>d&>K5_ z>c|3-Bv%hXLhDnVs0Xu=U%T1&lFJDXLr3e=nO$(w`qa}GF|7}6#KY}y+ox|$gHhD_ zRz#lY{60iyJhi^H48IH1rzWT&JKPHDQHO@4k%Hb7GhITR` zH}I*78rP%!+wkN1liGqL*Pr0VTTng7VR{O5IZEmz{4cf!e?vt}EMVL=qRWX}2xU~c zEVg(buyPqGZqg{B!TodIgsO%^?E*5=M~!FvRhZ z7v5w8Uuy!-8rg7qAg*+J|FI>HK7(>Hyeg1YkP0Y8ia zBl1HthMy-wD5Pl^wqb{Xk03k8S0gnvjL>e6(&w2{ra?(+W)0a{@e~%QCqz@eD7FkXSBaVBrW?7GlOU z)rb(+9O)1$y3R~cX^*e&QDH-vl!pinlEOswBi}%}X5?G6EadAA5MzxC6rQSuh;uL_ z#EToQtD5V=8AJ>c9S8>qh;p0cgy)i?b7u!hiY6C&rQqsUxOsEjcB#om2(pIw$bt)R z{bY%S8eWMZsIXx9w;}vjEb$5 zqUs_1N%OwsQu%O-z>)dnPRhRs1krW-ko*U;g=hMz3u`fQY z1i)|3EN^O#s#|u6U5^*Z)t_gp3*TR4@sbset^GWNX=@|~@vUrk3*RDy$1qDb6U)`% z+8;tdMz^!YggVz@<6K+1%B^`ec|z{4WRr&gA-hx0Wb*5(&2q@o43|>KyL1n;6yvig zh5QAT-4dEmS_0(}6G#(OeskjZjg22`9n-~cqtZJ`{91yU{hK-_Q^RA{$e~47J84Go z%bL9KXUQb~&;REgTPjO-mD1^y-()EP4V0_J&opgv^;Tz1MrM8Y{`AAsyVJ8D>A<2n z?9Sm@Woo@6w#tS1c^OMUgi!RJe;MJiTWa_+%faH(KNW439RB5nGD#x3&AecA{J)y` zbkP~z8)6G?0tbN3WQIG_JZF3v_@w?Ib8Cux@LA4@fBsDGm1!vLymAwh8WP5{2J*0Z z-S9Ow?nFIHf?g%R2kPy<(jNZcGS8HUM(#y?Y_itVP6S!m%^$Xoup}~8eb;mhm)W}M zgv`dpHQ&`416qM^0`wq`d`Dxr0F7A@HbG$KWcftOLw*ErNOa9c4EP#!x)nDICce+t=qMp7h z=W#DdMu?co-HA1F4zF#$C{Zel_a8L!JSABR*X6oAO#r_@0S##L4!V}ggGSDwr+Sax zgGS!t{8_eGV9i!ZH-w0>!cJEg)-}EVJ%x3Y246~8M=;aNy|ww{LX*+Q#k{iob>IkhuGGB+1gTL)wnD zD}WfQPFq@4cAPO`hA9W$a_P;DXfUblL_OOFWJ}AH$e8w>=u0941LHT$A|*-REed`e z@j)T)>xk_szI`3}fx+zS$cg1pUIpDF*Vob9HB5aS-F?NRucQCF1fZ|0Y^P}Rbwqa! zEni2sa~!$u9qBx?cs-81E{*{@X`Uvd_j2MyBR+p4E|%e#XcDP!%L1&wW~q>!Qk)naRdnOZp_I&6GSD)KasZj z&3fb(?~x=jEW3C4fLNBx;|GI(kcNvSU<(dgR0`PLZMI5;u=iyK^_@u8jq+qe+6P@) zuXWn=y)%T)8q-l8DOt9{J{bIwdF#R8KZ(W<2LCB-5rzIzG1KoPDJqoqg*da0%O4E> zxJQ;=W|svHa5wzH;D3SpSq}#PX_^m%2qHUzPb~O-{mo)8GQtqm%>}qCzCxD01NL2jj^rC8>Ex#n+ZmuhaeWwt`r&r6jn* z|GF*}pC8T^(~)y%9uj&7-jxaWe)l|lUMb1RTDTBHL#i;qyA*ICA1+tOy5>*skQQ`$*dry4vptH|IeoWWRyoNbXo=F zCb!V2E{HljnCk(BtRHenH6M{`$4D=#=`rAZ9NhW?0#D#rEc8PS&^#dka5P|tIK=Qd zjE{z-!$|6a+l2wJ!~$gd(=-E_yi7N;%_!1M8wrU*4k?pwD|tfX9u+pQL&`&i21ytn z<`|x%JCPRv#UwIR*R?~-K=T}?p(iG?Gy~$t(bvKF@H>tJAVSK`Y0jK9h>Sb;xIadS z(~_VZ*>*5C+YtDW-^J3wodt8wfy;860A8boGt0jXVasy)K|Cp&+u%t9h%u^-oQ*k8 z=5--eX>!Z6RCc)k(I~Zz?|Q=WRS|oT&Q*^Xz@|dm^UWY+foJI^Q+3BD3FG^2909_o zg2Wg2h_gYYO&q#`5qh2vTlz`N)qV1#oqM4@3Wv+|D@^QF3A}_RSHN zw>Vn@IV*M^hJCRjg+XPk_!>EjkwpEt4Oz>w0Vj#P(*-wPC*eGqEf=%f^eW5WT-ht@ zzYpQcI*mb`DVyHHnLzBrlw$wScFQ*zpyKFwdXY>SBfN#tU;K-NfP1EiKOM&lcELu; zG-B`BVl+u8rCkT+9YVOu-#Nz5d=*R*GR2_gEM%0vLDr~hT>tGDNFn;FHYe5to;59S|Lxk8IT-ko8tp^su?cI z@y)qb0ST)#F(t}2S;VfIkgPRB;kGD>Zi}2-o1Pt8Z?nN$lSE3ji-2+ zu1~y{^V9IeYxQ<-9?tsP`K91`%jZdX6^M|vO5x!MKW$`oi7%?s+X>^RN(v^3J%Rkx z=$3qaYXRmt_eR9r31861u19=TX8FXJk93tg04OX^c%Hrbb+Sm801)Ql8&sl& zA20L!#`6V0g~U%snf+)JsE~c68v;B&+j}@fP~8pS9O+Q^<^FJR^z*OO_(k9YfbMtN zo-*>e!2FQRf6wYN@_BU`QWK#D!#{$t31wcpO`|Et2|Pf;oP;(op$*HRGlCTDTlWwQ zbU&4fSZ>^f?51sDtxZDq09sZ9ycH;qw2trQglMpOW`@~@pIrW} z-#CbUpX^X2QL3sCHVrL1C2o(s&%eDrU`1VZY||*=vWEV0l+p$7whRcB9|!Sbnff4R%o^Or zivR&KN-5im#*U}#HXX6|I8xEj&&l(^8h+qF~&rZ#|U3KQo))5vurZiFkp!L%rIbuWIoamgev92 zX!2%{3LCunbQ&$#o$}XJw7BzcmMObI6_QDPm^-}yqJ<$dgN95Fs^K9`ykUBPS9Wcf zcWoo^*;+jFIC*~rrG~KIKy`pcbln8z{Mfnc`{Kuvr|KDcwrsb*n5s&)r&2!lH?t{> z5zzgbZi>=RL)fuYd=N9rwzhDi$Z%fdC6QH)=Li^2{;^^sN-7LVyTNJ5M?wSX`W}ADm)2eAJ*s@ySs>Zy+cs*N=r}OJ`e;S?N`HSiJmIWzt z3a}-%k0tKBCbMZeg30EPHrLYX+NYbd-IG$vP4Xg5SL~UHX>GOPnwD!BmQFWyXE1L< z7oW!vI9RCZayHEbYQ=_I|9yxwsnZxHQnIEuM2coZRn;*O4> zV(@HD;@h>qTqN(6S@4d9+>OgOgOUxm&L7msf>X`` zts~3GQg?1ZZZTkXgqU)YT#qpS?Uid;Q|8w`VV3liUfH$qhTF4kEjV zpU$992<=N}8Z^{z6&Kl)wM|@3vsi1A=v$;Y~ z?iKt;ALw5+8^-n%?T^Z}_DSubj)!{wQ2t0OB?)PS*<$&KTA+OPnWEBQ$S-KdF9(4i zi3d0SWW|0tc$`yON8t;!Xu{f!EXuUVuL<3W%?= zSy6JGHXD?U1>EHq_=r(KE6^VP@lU)#^s&~9a-q}L7*J6NALXF%24`Qtz&IT#r9sQO z{8|wepqT7aeYh$WJu52Wqg8Y?`?{{8XOjLiS>v;!B3efgi_7cj=!hQDLdpN52l*hh z7P)5E=hyxeX&}Wp5_ur14>lK{_;<4vASm;SOAj`eG`)WzB+&U=FRczv&u}P=;1Vc z^q5u#N{i1#6dxC*$N0Q%q5dZ8sdh~9=g8ZoJmO1t@k9|z_;J<&S*Fs+BrYw($I5uj zaG`)LP~>`^Oz`10nM{-!5D~AFlnD_9-V(<`D33^A05Lk7^7mv7)cZ;;^Z?VbT1=IN z@+rD1din*8P1Xt&o^ZPgQHHJz|DRj_FO9kMo>K`~Mm zIPlJ{6+aB|6PKaX6#6e8Li&Q^1MAZGFl#)`UcK>8Lf(A*^k3Ncycc|`rwauQ6QcZH z4!9J?DsQnE_&;IciBGid_@_^5q{0rQXcz%K2Pw0WA%f%|DS;GbvDS^=$t6quCr%^$@lv$URIT{{UX1l6-B_ zhnrafJqh!4j%prN8&IZ6TG8jwpgzk^v@i~(*o){O%YS-gJkg5{uURr!U(!TLfCxDcXm>V4j=g!y|tQ*8Tz!R4T&<1}Y)cS%k*p z`r0)vINl`wxwsd0jtxO5wXg_fs(8mxyLK~#ROiQzMIH~srf9m&=jL`oWQ_QTo02k; zqcTPQ!){g~w2K={WILVuslyI)Dm0cpC+2IujEouhVjv~7_7S?nBZ%@6ibZd&MKe&}FZ$SepyvN@EN ze}@&}5<76B-1^hyAsy*)yib`A69Orzvqb`D24c+axYd=kB>Y^M8@R0jZz;mUpq$(( zI8=i*w}^c50`v^&YWnN6Qh5C!8-L*~RXSUtk9rF*foQsVXSyv{CKChN6m&_upJh5ox$am!^4q?p`QE&vH>w^JNQUi$n4}JsnFZaM^Yh$Wwxg{_sRr~vm6^diN&Be_bR#GK9Wi& z2lz-T<@cmJRA{dCk$g3y;6S*u**W5~D87J4mP3SR`}rHjl%Jo8j2^!}8du~AjT#9; z8He>)f$a%z~!^)OE<{SStqWF}EE&XHyTh;WJ>4^UOWh#QI;DoqSe*QGM zzEILd_}MQI(#v^zG)CajEIO1hO`P*antM4)Z!Ug0P+)XVE~a=J+`F7z|8g+?T>1E8 zYAfHCKmPdFN0LqnO5~O$oX}%x#rZRTN>()m*#zgx6@yO0Jry$;bd+?qT7+KolNq3<~dsky$Z*70eV6}cig2`{2Z@E8CHpH@McMr*RRz7Z3e{T* z8*bOAsQvQpm}c6pX#vQl%8JMJEXVIppZ{o{K7Xs7zB}fTZDPYIozBZCj*Iq{Uf7!4 zI4|`eBd)U~+4+z>$cUp{>u$As79+LuA*>+vuPY-u?s;YNTtj~pxrOso~i6@@`1KgkUwl$RftaJZ$zB4CDai^V7ED=*gUqm|slrqM!?)?b~f zv>y!Yu`FITKZr1m?3aObGuhlmo|Zw^dps?JAd3%61>8z-_nZJNWQU~xZ6ULt#J??s zrD>U%Tg=u@Q(ay_+yXa{8ZTQWmft-Xx&;&j%491j{R7)tp|K~V|CX7mUxbs;X9HU; zi{Fovh%|^&8s32vOB6_I^2_46&0TXxsyi~YGu1+d-XqQ1V%^u(Ba3?g_*LbcOc~do zUg5AmBvOUyk5BNK;BN_=-W*5rq@sCiQ~0heu_bx$+H&cpw7tzzXj=|{Tfy&#^MMdl z^4%D_$Z87Px<)`462ZRmP^tkivp)ONpNO!Z=CJp_Z{l7ZVItQF{0SL+o49(zV`6UL z8jzq)h#DbC@Ztfvow6p%uIRYen5XW&r*jti<6q1tBZI>>XO4+)PTwj|f$OrEDc`Uu zTlf>@6_1Zmz7=_Yl^gMXI*;C;lY#i)={K*w&4_F~IcBw|<8rOI<|C-UeGf;>#O#87iQJ-P#n2LHqKi_n8s`+4jc zQK*J`V6f0K4bOJH*n+D{0~Ssk>jqGV5fdTBa>eO$bO4Io}dHehntneMZ@w9yvrZemuDyD>AQ>VmTziV z$#%8X=8g9s`1*mbrA9F|hZ&qJ zw01EyR|xerGFJ-Y#I}QZxj|~MVYxwRm`S-oX1FoALMqJye1;{bt&ox@N7@!ZHnacs zUW!Fg&?(z}ds8YGrZx$cloH1FCRHk1Q0ihz@fwf9iTf@OUDE10juLC!3t<9FfTNXwHXFJ*>4e9FQD3v3JY$*(WQsC3G&{QzRy7%QRf*caiS<% zv?pUNbwrq3$!__-ldTplub65}v&2(OZnD!3OAK3HM5W7pu=~%IR5V8_~c4xz1DpC^7I(uYduz)xHluE2>-U16s|>zAev8k zhxp;bBu@_|EOaz5`Mu2HUWqm`yZ9%n^mg)8R7qi3?ZajA|Ru<0K|^3}8ms(sAPw zWa_8~l^=&-A5;iz@~*DA5WX7Yq9AW^6Z`=APLLdukO(rDc~%+i(T7MDwV0*IFL-#y z{A;rNbg)uyB7i-ol!tjolqsivVUgQ-FBy@jQj~P={~BC68vM zh7gK|=hT`ZgB{+gsMpw;mSq1_%2F? zptF-QAxP{`iOA^fsyqlXeU%1Ls=u-z%I!x*x5)+AFYD@76QC0$i( zZq4TwJ^6bs;Er%QuLT&EBLe~Wq;0cH5hxT-2Uvm+$fDF%%S*(qp>eY?;n?|PlX>~= zw@<%%`TFTLcxe)IxT?T$l<35`+cuin1-RJU%>Ug)?`9OA4m3Jq`gEZr5PqO1WcVA; z2sJ5HJ~9b*a0~iXZlKu15Z8PXIr^y&!^MEQzy72v_B8bt59; z%cre~h}j$pO_zvE)v`)k?v(^Tab=voJGnz!hV7NIf*m%?N~1f?p6Fk%ZL_Fk_} zZu?$W&ZHpGkzk)$GGHDNK(7+45+qJAEZ6V~(4VYNhnSf$e<2-zBtB5cnW4*vyx3z% zi7i5&j*vYe4te5d+7n1#>5gu@t^rwCJG`Uneur~fYvZhYTcq3CgSl)C4(2UJ2?J!i z8YMJj$1w>FNOlW&$fFfSdDiU_`49cND=d(C;Z4GPZFjRqHp~zjG70ORvNvp} zo~z=0Yz^DVcC<6BA;e7#VnVnw1Z_ySR1yFcWvI=@pr1TH0TSa=N_!@444_mP8D3sb zlPH0#ri2K%T(a=5=X{Y83JL^HgBPgEjHFFi?=8m=Q%%I~5dWrTLpjWQbh(~Bg*U3H?2PG5Z}E7o5Z$_nmB56WBd&uM4C zCRId?xz;=vmR|zt3F-kPaqC7j- z_dfjh3R2d5WOx=Cm{TBzBF7G;{YoO{E3+7Q!Iaz+7@3pV?Z+RBT|!AGuzy7&+s-ZU zVmKh^Vg^S(WoFIk|J%>HitsAFyzn=)JntOY?$!62>Z<1{95l;9*(M!rlw4C#&zkKa z+kD2FYUrxxISAbHROIDW)sg9`(MZ!+F!EF_9$BWT8==o4BZ?2_(+i$@quCmBpRI95 zsvj9Kb1SWJ^>`F8U~c-Z%EG`{-x^)tXKTEX8hTNvSH~ta*hsSiEwUri4q|X&(y}A;nja2+!KSOkJu3&AkcWufXTJh~<2Co-N3O!*$aM;r;{EZwRUw*wvQgwy2 zhxPrQQ~>Pw${a?rRN-4YHvDV<4hcT7-vclSi9w>-^xv1trGEqObb?Ht$P9A1RHn1r zLomx02|mCU)?#I%(`{yDdbLU~k6ZJ6xTdWF^SUrEohDb8$>h#QvL{WY3=(xSQ{#mp z=B5UbO-JH2D$fdPsAzq|?quk;t{WzW@?>_WYK7yk{qz#**y!Z+#hbGcoKZCK7x+M4 z$~ZyFFZy+r(!=M#Ngo0Jd@<#(oStG(Iyn0FT4UA5MKCEGkHQ98IPg|I6;Kmt@&WPW zIKyDVmdP|+p65>ldIViy8xvM@I==P+iH~g@U*PVv?7)j{*Jqv=`L3&Zre`}qk8oY) zn6?*$p{i;Tqs0&~#FA6ky6dU2VHujMhZ?g?iv^DFLh}rL%XU$~*G<k*Hr z{rUbt06+JrP=vCQ&80Gt%8#@_L7bs0gq9JhVWioSYI<=PL$~uCOGCto$KoK;Rg0Ob z8n6C$jZz@&sIAmh9No3dc7v7k(gLXouC%UUVCWgRygdmP>FWhi6G^G9LF$6Sh%D z2T%;NJj-%QwiQ25~W zNOc_YMKpQ5M}-X@f6CVk$V%>pYzhEn!?eKGeJuz=-!**5C&yr>2GND~g%CRCmv=sH zdLIJxslv^-$sEMwsP$mn)~U)luyYsp#eoznk#XSn{xWRe(s8H5)DZevupo>F7tt!3 zCRbtG2n=Jpti=ts(@gk})N&N-gux!aKqBCDHa3jWyL5yLp&^@hbs=pi zUuD2NhLudfunWg%6u(aFetv`vP(s^!9ACgtNP6pvZU#L4GF=1i6yG+n%X&ACFh zHOtY+{UWg3c^zXk-d`cF>c#Z#FeU`~4g#{ZWOaI)8W1YpMLv4A?P-v47V~{W_w>jy z15J(8ShE~Q)ocyA5tJI@z(PL8AxtznY(;(uG3nUQJfQWcEOJysRSg2+aw3QHrlx%C zQDIX)@<9dG8AcVvrIgfs!&FtOB{#n!pS=yJDV7RinuKQ zHiYxa<%e;fXl;Z4po-%lU}!iAWDJ;BHGa(?&PIg_+kpqy72d{%*meXPBFI{px1dr)R;U_wXkZ;{nig1=>YJhA`krm7S`eBZO5{u!*q-GZPGtBN z!?qWho~PP@tA%Rp2bODxmTjxC6{Ad(387NNk!^;y2W`fT4cz<0SqF^o!&vQ^A&xb^ z@5RKy4JKStTEKLYTv4uZ{}%8Riv)LW3wE?rH-N69`hgl4u@(oAkg5w?FJ>vWeKj`S z$kdqK@kqk=16UhYU{SI&q?FMsox!v)_roh3TMpl)Gd!C3AMRkD@FV;M4O^7>Wf~{% z#RIfZPD~F?Xw7=aIlJ>n(xxa*ftqH;Dh`WApt-8*GT-(fp~Bd)yg+sR*w)~Av0e3_ zVetJ(4kzv2$~-}6^H2%7Z74gBOEHu^80Wuz9n(+-42H1;3FpYM27B2Oo-ytx<4g8J z;ns=YVU>0sr+w`|U2Jf+t5dQ$h)1dN2|+cYEPXud4o0G~3DtievJus34BCuj(;K^y z?syR4x(iIyY&Uuz`u`ZyUts4B`%m%umK{gi@n8%^&2??n(|v3_k!Com1v`>s$1zUH zI2FT&z7Xu3hcX<=&(#faK@JxWWH{ipI`nJ#0GHO zx|zxuuyY^x#en42-)8Wz$&KLXC8II)+evhjq_7&pt3hUi`WD!HV+b2IsSM&o*?|Tp z>Xr@rmF8lP$~duBBhZ^y;nnCCAoj3iA!-R-?XWv;rLv7P39G1=zo=?W)^!9IF)MWN zf7`ag*oBa4Aru+r}g1Tfof*2t!#ROX$|CH_Mj2cHF2?hz5!Iit-oNSW14Wr z7UT&2i+_=@$z(Q7{OLGeunRUyrV)FONIl$9N6$O(@esmQ))p3(n{!-$N0s}%=_&S1PVw6MwA$`+C`c~FO#!z_1Ud?dyj=m{d|^yXmD^%Q8{5PsqiIEbd#Q;@v1-~4d;A^QF;0fMM6pC8|4X-MRS z9hx!dmdSEL@hD$|ZB`3d<`%R0Eal-l3J^lD;Es+E&BNuI_y+Ua0=CduAdnRyr%9fb zF7?#egBmGUJGO+23%=R3OG^WpUD#e4K=6E|sVLz!d+JKTn@w|n!v)ZflyIX5qh z76~%^%1@;Ydx!?D(%b0*P?gmF?g7>4?s^@lO0I9DXti|z%R$xhLLl6acgw|6r8(rf zbQ>f|zEkWClmxP8ZJerwTxCZlk3roMr&!I>JC+tt}ptmS6GDQ?in<|hO$mFj0DemCBdi@0g zV|fd5LLmCf;uqY!!4({GK7WePa>ak2q)!x5WJv*6PPFnD{c|b+pW7;2DrnpJY_8Cg zdjMp$?T^Z}_DSubj)!{wQ2q!OUnU`qFk37iQ45sMK2ua04EY7k_yuXY zBJtqHpRCv~2aj_~>nMDIb{rj@J|lW3I{yTs#WP+<_5-i-Nc{LZFYuaL!3*$bMFH_u zHY-Z5(`JLRvA{v)0v|CdXa(BCKmLg~h(6YOQ7&})8Urc{;iDWB-r(%(7Z|4_r8H<+ zmtQNQ0u+;dst;GCqGv@#e6)&=W?$D;^i0x!CTo0FR7C3tX20@!Iy$0bqWIl-~@Rmq@0_BlK3BU8r-;*^^?<=*?15C$i0q?r< zDY`0p`UQ>T;t5)a?(2^hqwEJf`2jl%ZYluE0f;N~K*5mE(<=HDS}qZwJ6 z76?e3T`PVV;wLUcsVVedK7{mzO;XmS@nP0@n!S4CpM<>m`02l}@p&)!R8JQQ8YV>f zy&P~Uj8)!ZG4OxFaEnj0?)axqYNWyrq-Yof0s16};?pO^;1=5yNeI3no4s0&git1AL-k zgs-(H+g{V@HJ#q#7h!Wgms>zf17`D2B-Km`)LT89fBtAThg3a;MGkTg6UaY+m#8FP zoAlvkmOxL!Je{MON7V+DX_8j-IW(xxvJ)+ItQ30@9c1}WkBldJvEemK2J1_jD5-p` z6bezZbcoVu->2&5kNhV=QI8x1Boh(rT;2Wh2$GOr+(Nwz}DTp7=l%laS_hTb=wJl?*Y{$>Ngy zCd0y7yMkB}OeU4m9MlNzWT30j z+Mk84PIy-nU5#E}8(pn&eC2K+9-pun44<>R-=xBhkV)AzUU zPd~iGq@HGG{iMCx>}dz70MGc zRlTqWzx|4^4A`MaAK3LlSvAR_Pym>~w;1ZWY6$M0W0zcNqWo$$cw zK>|@$u!BIXG*iOQ)L}!13uS|4Tp;w~SSKyV3_7`@g z!ut_)C4xhQoCG~bJ}KOOmj{P}=mW=AQlt!zZot89b zaGgI*K5$3)mbAITrCXx)ugtLplcoz?0-VAk9Nl>o%|kn@jsSLD<9F;@cGedkfGLVF zh2!BntE^y$oweTX&6{ie?Oyw9rSNcuZ6mYGE?cFy(?(k*wZFZ#Mt9fkwo0xq|5i)) z-*l_x_p|R-X%5(W3r4P`MU?B!3?3Tx8jbYkO|<(0cZTY?1Ryu&u&~@ zv*W%TT`S(7rE3KC!_zgQ{h1oa;|*zoHbvxUN9ym9Ca7Ed&44UHb@OaGmiF1r+j+fQ zUTiZ~Z+o$h5WQ;(*O7TY`bc>Ro9|7+Zpm@<>A#Ie^zZBAr_Ys>W991?uiu;<(UVue zT7z%ipQeyM%Exf9Tz;(Z6iWo4i`XT?-h*LAn2BLjjuos=#IDcbBS)m?0v>XTOFBj< z572)B-~Np3$rHe${TtDL!9jdQ{L*v=|1wgMrt=xlso-JfehNhxvY(J?dV)ZB<#ha1 zxrNCSF;7b+_3u*UXZq6zmIu})j|k;O1iqfrfUrFG|-^&D>}eTRvz(5 zN3cge{&Ls}-Z4dh{u7G+AdmzqCz?^JU%s8UP>z+L|wM2*+9SzF^efpGU`e`n2;8x3~^X86f)dY4VfoAHxhe%G2| zjE_XgTTb+)ce+ac#QyHuL#~Vq_2hY|oj$+XmXLE@SbZ|Z{-=7{4yS3^>O4F5*11B^ zS}I0#K(et$b;D29>qvo_2kYWZnme7Yo8nXcQvaep=q|jeAZ_?P0cHX4B zRzd%Y=fh5+L7W32f>1nTA0dYb0$CdpFQA)wxO<_K&DARz7HcVfr&Cxl}GO<|6^K{pWiw86i6-9gq6-{u$ z_4ude8~yq%4AV_2gN7h$edEdzAxe2IMa=P5t6!1LZ|?zWSuPGtu&T4OCRhVJ3H&X9sQ}{JbpQ_(gt`klzN!PFBnD=7fcwaZrqT)3w*jSq zvBF~spb)!}6Z%mY=|Kq0QV2WK0N8e{1#S#f2-EOQ%{Fy+9m>h=0y3F&{0lJJ6bW{w zX@Y|-j&hLf#Es<0k^`E@Omtw!ty7xADs&!<0&A_ugtd)d!F~H0#uLE%;^HfgZ8$7( zI|*_Y8JQg^4lK5v%oeGs4uwPmwjF5^(EdZqiFAOPhmHea zHXFFNK$Qt&*Y-R@8_1=m1xPjmhq5E!plbl<^#J)2BHw|9uQnthE}@&I6`~A<@ z#k`>n-sL%qEaY#@c{i&G-rpcu`jb(_0;HruhdQwAnzB_+g~LN)1mL5@cj6`~j)8-! zx&cT{p?s3DWFIh5O)w>cOxj(qX#rl&R!dNV0sIFStGkwEQ2a7v85E@lEd$Za#v;H* zg(UWb1)Rz6teSBO7X@7u#F44n0%$8(o&DS{ks0kkm%9KudNx`rke8*nMX6XuT^tcD z)X<*pSGHQp7p>Xp-qvQyw0V#-2aOeG*nyobHCE68!OcFQjqRejgz?FARmZaoujaqW zv6XKnnYGQ!J;4=>ni{&!OafJWS1)gCS@&=b!H4$b{OSA zNw=qGKi-H$4Ekby)d#|f8UENxgU>&>%N;{9dL`9(mxFdB7j|di)xl-ipeUiB$^cKv+UK6*&)vlF=L&Yzdf&C079Wjml^i zrepKaAjMo9?$hyHi0E`IV{1+sixBeyw-drrmJFUR3Xz%55i!%j|J66vp>4%vK?QP~ zlrawuojg0q-?HXYY?7^^51c5kaI>7{d_UgMTCTs8;vbwETWySgFiynw_OMHCxVa(+ z|6!M0ceh85(9RcoB%y!BUGjGgN01^ui${13uOosdBZ|5F`NlZZv_tjRJQ`1g-f_t- zC#1ZwE=1vU4A|yzR`@X@6=0R2$Ty%1O?WIF#V*h``)?4RTO!ryu-7wsp?UN+$$qlU zS%S=IWp5Th>+*$lGgf)xO zgZMIQXM-(mVDiJAmop_0>eI{DZ{CdM2Xv$ZL&~>{VpV1=EMk)xBsqxY1`&kOkUT|* zN#X9ChRIi2@Xh--KmG8v_R|li>gm~c z`pJi)m`EWJB4GcS1H%5Enyw1SvO(Wv7a45UY~}Lj?!WSO@tl z?ONnINyY63v9+@I{P=~l5v``0jmt-@D9x+^l}H=c3E8;bpFY1B8nwI{ z8-o50My|ZMn-@v`TCRt0J~;^sl_)hlGPzQI7Xw#DXeawtMq_{GElF@!>sCgmuiBm! z>u=l23hu|WmA4{fi0z8bbDMUiOKz}iW$N@Z62YnR5mFgTYsNE5xPxZ`<6mgn9Kp35 z`^2p#RAQt+Pguv{q@=@wvLf3(zxpKWcm?U4hf(qSHFR&RM3gQoiMvKZ9RLb&nj(ZI z6?Ois;Acp2+&`Hjdljzukk^Jq#jh(MEoApsZWqZC*xCxPBA2)wgPUr=uU#Tj(Is-6 zm+lr-S}L^}+2Wre$P!t6ifcENUliADLfmWu&UZXp;i_DA53E9{^>EUZwaW!#W8nrI zbE6Y35@k1L5W6>4&2t(vxh9KEHj)COEksg~S zDZbLyC>^HqduDsgv;s6Czq%xhlEn`co0`2{v)iik7njL z8KUV()9v%}qK6Il2v)_b^avfy&O4PCl;US;&P9Upz@bo!+?>l}|LJ=iwQi^E#@L7I||)G2X7mBtM)z1Y_H_DS&$ zo6iXyDQAHbRnogqrfw6_`>_zPzoFss*)Y1LlO`XGtjRRVI1CLO23dOSAruga24gRX zb>zzi#<63?5%OY2mg+^wONrFYfy0B?E^&#CZvZ|35TLpU4f_Zh**Jj%aIqXMae(C$ zg`lp3=5wL(^r-RS2)rJ7Ej!=jdlbf9eC`~F7;1b5wPGCF;C znygs=jV3F&pM558MgJo(wVZgJt9GUdBYqun?)diQ%ufSQN{OA9rzymiM zUH<3)3dmeSv1J6)(!&MTtepsSQiEzm!96I57F@BrLFK93{TP3rCy~(eB&rR7kGd#( z^#&ENI3REjZLgq5^tt(F2wh?Kf$f4UEkg+Kf+TqfrzkU}4xy9jvT}PXRAljF2uV>A zZOhGJL#X71@5iKc(r61%p>7IxeIjMq`?2`MXV1SFH1>$cphX%?X2GEHi2E4x!uMk+ z;M5X4IVY+^28yUr*$OdS-55-a%I3t#(mR+EFPxK-C!8Ujlx4^F*@#VG_Fs{SeF(L@ zFovEq+zbB$%+^CF6{SH6H!hK@B!D;_Myy<(S|(Iwh~;5TD~cDyxKCkFM@xD;?<&6x zJA_hZhRBx%t^FRRi8^D`@~@NZbG)z9lV!{10wH9xUxxHKld^5JY0|qIPnvBNWykk_ zf&=}MBnhejE*%@v$gJr2K0wIYZveBqC;I{sYz^D0y&=8X_!8*j@g=VL_U!}gRMM*Rp*OiHq41^pqs#08R>r7QC+n5K(N{NF_+1 zi*T~t`b#+Gu~8O}kNk-^^c3}9Cj_@D#wWWJB4i*;w$eSCq=ed9JSh1R$~^&)>NLd&+|$8`?7SEA z$;jY-!OVE`&FNd^X&ke~O!o__P{+l&W=AjK=hnA#nH5s`cs)E{v~r3p9_T?EfN6* z2fu*?Z9!$rwp@5e**hc@$fTWr6_#vUbAbR5t07~msd{>7u>hf~v8%bTocp03y3ADr zx;|dFWXl@x6Ah1N0y3eVKaTErcy~YPU$6Wh=9keolbhh(m3nga-QCOQZ$CrHO#zPU z04Z1FtganGyGo7UY$+(cnA@pqEZmw^M3x(F->OmA#ln@7+R4J5Qz3zZlpeTJN%l>y zUd(5-?^Lc?^ctl~Nl=2ls$b@nym5UkU3tO&mhQZ$GzM_{Z+IuR;EKh%*I=x5s=h3Z z3JrJ5mBzBwy9oF#NuP$%8_}>YaI5i(!cjIGyz~Cb4=AzK8Hbq3b6WX_VTSU&c>ZBWQ+ZA&|FDa(JSUQW z=xZ*|3+5lN&+K3@&&lK;h~8k6c}^w&K;(uQ&2tj@2i`QYx##v#2%~+36%8_+=grDL z$Wt{rKuRa^A<_`&qtf&aVrAp^X7zH7aD^4PFuzml3j6mkdL;q{xy}ake8ln(In_b{&K#PbiknAdY6`G*}1>^YtM!)6n^KGM{YuAON% zfXt38b<1@j-8|B{{d}E?UF4wPR(O)3YfS8U&q4Vrh2P9SUWyo7KfrsRO|N+O(_}M)aKx z>w;9pu5OsP@VzI?x?vzPKeKNC?`B))<501#^WMn$LRMlvf16C~=Rkf(uoavNbn2yl zFNIBgjm2S|+Ev^PAlpBk#9L^Ax1_tOv0VA>cX0_F1i0vLp-{7btZPlC9`IY>peEIX zy%6LI5)bwVJ&3B)AsXNjVkO!9GZI%?e--RHb zkw6luVXmDVpM13ibd9T2aQO&v!@rUFM_%e&0AV_1 zxn*J^`rWgoY0p(ql-}f@&SEcU7PF%;MJ4Lkrcl&3nT?U)9rcEAENZI#k# z$qxCH+~*cR_k4~PA-ieAWN&|~-w23B*-mNDXaFXRccy_yghXg2t`sS z9C)Eeg$>ZKmT^KI5<$#E%}73_vB=Y+Q1u)wH1sf1S!|fd9uXtC0(xVc9TCLda_BH+ zf>!v88RAM1=u^sP1^JLA{E|Awt`jY_t8wQc+83S}UG3k--llFMv6lx)DA_wjV(sbG zDh)4DybdN-`Edv{R|pK^VcFsa4{NS!n5t?OsA5HBF!2KmY=jehc!h3tnA0_7w{dOn zBuK!Lp=&$hHt>NT7~odsA{xwhO~*yLAY^y5k=5HYfo-BOgh&OZPDpV%-(vQVCB`*_ z*ayU)6}Wo93@r|w2*iMQLTG`GWwTCUeon{o0PE;tK}pV>T?Nc<%gdSnFoYxX!h^U`wzA2M$Wp0_pidd* z_;U1Z^7Zlfo7vYd&d%RF|LZx@(=TRFnmRG$H*1Smc{0cRBaNQm%y-r3kd4SNEgk!@ zoQSL`Xm`H>=Nes6c+h~$)?mP!8l6Q^qM68lPI@joZbOfR4y36TRAbqpcL~s~E&xN& zl=!8e`gK+)Z>8dcx|=n%vAiH%kO$l~io`0irZMEyYy_LtY~E2%Yb{w_RKmDM7cWPI z@x?|QNo=HrAtW^td=j7(-jNx1;Gf0=Znj>?XEYu|)?&*ncfs&Q1g+*eaRnlx=LZ#Y-f#bPPd7CrZ9^_8fMa@RNFXQ;pjeHjtCSMUF)#BuPt4j z_J&qYR_A_Nd3Aqx1L&=$Y6BKGj!hd00x7wn<9aHfK}^@6oMEmL&~nQ6cinQdz>e(L z3{|Fk%+`>{(gbRVANe@8MED;w^?)X|xxe?Qu(7|F1_`v~)(+%eN@Pp<6@4%u0@eXJ~upNUW`mRQz8j_mJTn=>!ipV6!i^y0S3x?Y{Gn>}k8V zN_zM+=%H(bvh5h2<3XNDp?rs%0C!R1f1p2NEGkJ#>%R}-**c9uT${DL!L-QmY#@%` z0?%YjTd5BBXJ-)At7Uo!_(62A1K(~UP-R^qvDx+PT{4161c{DP7=2JnNlas!}I zY}&ZYfc00wzoo?3N(i7YZf-&~K}VWYF&>`$>)8cBn)C zXlVRo?2>C~vPwR{#Ffn12ig?t!oT+Okd;&;F=!#lb~jd%?rH!{LdN%eC6Vz7)0ZZb z@$Gaq<#|v$teZ)l9{2dQ;uI0x8!@12?eI$a@Jj=&z7CUe?r1i#e4Wd-FREKon zT;RK|hyODRXE~gf@Qx0{jOy}4;s!H)AG=1N2P7X`1b+7l8v?&Jhf?Buj-k8A$7@G1 z(|rR;cafV&MS5N{axE)XZR9L>fkhNZ+1*SF#2O3YMcbCS>dbyb`hWZ6O8 zluc~N5Sfm%F!Azw#$Ua7b*hn81iP3>&&DD(3k#VsK*z}sgwc>}^SY;yW$|7icXUKwRqcd!A zWZh^k4i&l9U`fWx&Qz5~ouo{rvyMl~wWX^|rn%ih)BFH*9Kvai&Zm@Bny`8boB?v{l0m{EnxL%<9jlP&?#t zE`tsijV5QSBHv^>kH?@*rYX2>5?q-+_>4O}>2GYGt!!){&4J9#N7{Kz4%nvWGPH%$mwRv>R|D6QW?~teDt$Fg{LO;3S zd0x3Cs}vzqooFI1=dDWo#QyHuQ%^p;)lbe&%#(LpZ(XlT8kpnZQ#vUGmbLSa%X!!gXAPb35TJE0U?>@!E^*uB%ce}BETrR3M6n@ z4Rob$@@oZMshI`&J3^PJg$tg(JUvDoS-z1st1tvK38AFk;dn{NF~~5ooFNGxCDE8n zX1CxSgE2YjwYISrayym^f9O9#Ih*XQ>LO33o;__M~OKeqHkV?ZdETd%0 zf;BJlM~E!HV6gbZ!q?^!{r}l}*WSpI^i1rp9MnLV=~j_>?iXTuW~z(qnv$Aibroy+ z4$irf*-U2UnHem zBTk$X=aMJSC97Imv8Cx|W}bK>PDH#B@AY|WAL=8;)Dr3?%!oIs2s64152MELaZ=?& z>J*U+tPEvK#iO=mQJl#fq-+tFm#i*Y+Dl6rr>>W5pd-WbG)>pZQi<%=xE;29JCY+# z5R}(oXg?}l!2HW)8V$!n;CQTgC+cs1PRsC^rP>gFMzf^WOd6iR(QNr<&o)Ol~vKzsyhVVw&?DgiLXjxMW?bp}8T7LEUCqV8x)=tlk-W-4T zoOv4k3xNvX>EOW;gqrkeBJy|%NiPTJO0T6(^osRM=8HJHVnmEK^M&Tfc??`nQwf02 zRDr=q*@4*=wW$yomj>A_!^?BwH3C2ymM(_c1SDxy^2;l2-|f)8AI}GMnzrxOX)5RT zlE(_(3Qcp##Un+UNi%~*=q5HXcSVsv(|xlsa$SrH;!=(D*vbuRTb^e+QsCC%?0Woc z{M~(ACo&d(?Do#wZ&4u7@14^TS42buLEMIC+qnZY?`-ty?i%y`)L;6C4A~NPK46c8Z66>sUnobfvXe2yRPNh9=z5eUe+vFsA189 z+sQ(N41!5L6*g(a$R@E$@h5)Z8g>K&cVN{!L_2g?u~5?_O~=1k$4a(qgn`;ZRJsQ1 zy01m94NJL=0)tv?#*t=t2!@H_D}{mDaDKsC9v(m0pH3+LEBA{+G*+VVHS>dBBUW#L zmFp4kvUw#lt90u**pXG*G4Lv>a<@6c6@kl!L(w53O5w%lhqx22`7{(fN%=2*7&C9( zi!0M{R+tizPbT6LoSZ3-7hkNu8zYo*bZPA!&SndUh3(j}wq=nKGrg^EV5|ET_Fp*( zh?Ra64us9oNv4a85?hK+im$Iwz_98v5a0J%C(*XwD)A9kRtatb#L**0DRULDZbsMh zyOyZ{((}a?VIJQ{h^v|GVdkQ1@;FGY->%_BuTb|3$Yn3?R+lLEYA8=XeXj5loUESp zA_hQxd_zX7&lj`s|NhVXTjlu0?<=bX%8)8PioyoChn6UI>reJp9@bq(N{N^ zgC|UQ26Nxa;%FQfOj$rxKV! z>BgxwRCVZsqD(5C?5K}4k_5noIfSbCZg3a*U6)16;63P`BcXOMc|m9tctK<(eqsi` z?IHWdOkhtyI5x{*i73b!f!av5LFeTPy~SlXfNz*m3iLg?Te&Jw_=+dScj%9-NDucj zCiCHb&Jnk`X|cHV82IXLz-r2bAMWR|>^-iX{XX|INgBl4q%vue!YHdu)e^vG7jGbM z-=FYMxzr0&xMGM~q&mQ*nW60seCeV zpwOWP6GjDtqgn}rMaIDe7n)ufLT+A-cu4Jq#!fnyVQ8e*w<1F$(Nyjiigd17@NWjM zA}51Ak?D?uNoJJ#RX1*&jv>_>8VPqTiIR(u^3Jk=A7+8p)>islF8?8fg=6m+9}!$|DHLCM51FNq-r9IH&hXT}QNq$UZi> z4?(D3wTZ^r$G8UnY8F?+f?zQMO(Oonrck9pwL(cqp3Yc zUQ-f-wIJjmsmQcuu}TWL6e22O0N+%USCGCELJ&foe|dKNDfJ_jneJT-Lu&XwicAwI zgD5i1;U~BnT&dxV2gM|GuHjr%aWVkFf42cJhgdhmHjIXNR@6Y?0y zRk?)+Vely=2+2m<2cJit5k)iq;PV)l1dj)w2W88R9(*2I?OkRVDl18aII0ZA;=$*! ziXVI)xw-$r=Yd>}tv-)_MYT&-iy}iZcQDIUO#?D12E0^i8p4Mtuf3I)AjRZ|8d}}c zhthZn$}zWvT7IMKOMiJI9=I=UAZmV*Zv0Li&XntH(fN9s(GSp{$aQPDxy3E;LC8O1fojCnT)eDb4)k}5WUy(~kOKv9ma*AoWY@)RSR))r-~ zd87|8N)4GNOoxq-4&ogu&?truxO@CBFUec(a&))8Ut^*g_dC~o>YLJ9RvK_gX&)lzMrgq_*s-=$nm` z@{3KCSqxNf)>SHuC{VQCy!4lGU5Ur+hdz5HYusyxh*8$;5L-h<5{V4)X2nhkqO+tFw#8at)mK;uX?^$U+l3% zhZU&1Y<&g5o$9Gbir0N71QKIp`?{5&Ol2HJRQM5ppq80#sD9A00t-I^6|tf(vjyD; z)MziU zEX7~@FmaJWFHRPNu5hxZIjVyyU* z1I19FIuwUNCe}40T5j82tB_moCKOSo*e4FL^&S_TUkn8LbbN8Sx{c}I3QmqS)q+w` zFCDSn?9b&LAczRXl@QnzNQajS0H}GH5mftKFM!F2`mjpqPnG!1JPub%vY1^f!T5rG zo-W5Xv9g>^)>L?fj!HW09v$#7@)pOYJU`-S1BF)c6XmwxRkXwy+NMxf2n-G(s!-fj zs&s{L=k(|bg}&iI6+)>QRxnJTH0TOVPK@pv5xmoUaC0@QLMCh7FWtF9Z%DXLg;>`R zp9%qT{Rfj-kf#OXoAb8eN44araUnI6B5-<5Jq@m3_)h)67A$}Zz*H1sB`mr~@S%dLu4vM`=kO_ zi0mf)w?ejG_)CQhUtW33v`+J_&>EQ9TcNk3(3T3_cag$d>10USZiU#uRNV@_#`N57 zH3y9Y-9E5j<4GaZYtnN~lsi2zO?re5O)jwGuVQ*`d63(}Q#L%mB@K5&tH#vZavQuy zUAk=?M|b<<8C_ej!xD;}Nd@ln>sAUf5oxBD( z&Cdeq%iHnQSbk{!K2mLA+{#jI-;#<1-_FH+vZwEpy)U&cJv(`=Jd3CC!k;KF)&UwQ zpYr@%<%U1FoJVhX>C9&@K1~}p>Un9W%aPQXWcLc~vuBgvoTwj*>!_<4GR7t3bQFt1E_){m|`2xqmln-0MZfC@Xea zVLNrR4a++k@$wVrAN$iQSlP~BF|)?DHQ_pABZZQ0)bu|1=Ug5h-)^AVOelg<<8r@v(dBH&%d0lSL*;ZSSNU~M#klvWMk{%2FdDK zWVPQwKC2zqss#I{p0fDZv_z@atwd>ivVF^xcJ85DsnYG_VY(RIX!~>!(vi$7xoS8n za(`j%zNUx8Myhvyd}*8>ex{uqeo3^OHtJ^Qhv;B{^CO=DjH1~tTzIsT>mzU3-}6zS zF~sp95gX+9km!)uw;Q*IOmwK%L!#By=^-^`#})Pmx1Tnv|NN?!8Vd{VF!Tk9U>}c% z>=dml6na!D6q>R;S_1=ebP(dSD-J^Vk{^!KEa02u7r0>2x~v|` zzxB}$<@QZ7_hxfRI@}uN&_ej1q37XVSzn{idqsyHL((_X=5ne zVl@%AK}H*1=I0Tr_8MlSYl)#*j%6d#GDPq)Di4RYi~s70=J<%?q(#o6H3QTx_H{D} zEZ@-rgh%R;t*f4$puTa8K+eRBU4Y$@?SMQ?EISCI%kt8PxvN8mx%QO`V%ZdfvIy8j zNn}K{yPg#rQD7o+)Y4tY592ThoY*nrL^ZU?ciff%o9Tgr4tmri&c;`_lEN=IYCQwH zippeS@79of$97@(P$i4y0;$N$%P{h(EL53E3qSVZ(gJ~AY$`@v!=^U2qal?j&O007 zomP0C7K~YLRAfbF(t8xGudm5^Ct39xV(gh#QH-;Cf}p8q&(9PZmJ-6eO<_py%$`Rv znA>f=7Fge*Lrz#dF7|M0Bz|4}c4Kf_4q}kqVjz5+y?RxFW)oq(=Sa4hKn)Jjj?wil}TPUx>#dy9_ zj>KCir+AB3uL#!lo$aDF85)jeS*oK-CShbV_&~0&D|jsZ)Mpb(&3kPkG1kg1BCmmF zBb6cZ8i=k&FV^?>6UMA+0r^aPds9Plqzz_-mfaud}_ zLN5p?i2{sa29Bj`CMoFIoeowB0?joYm2v%=^7IUU_SF8cB=$nN&mGqJ0? zoox9n95i$qnlNaK1O4h6_0vOma;q1+^iv;Rl$!VAMLyD6PSg$4g#R%W261u5cY9C$ z)p8G6HG5BxΝ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 z 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%0AQ8WLY~EE~I~H#xmtZEvyAi_KEw8vf$fELw7M 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

qH4BFrOy@w}7yRTwdIoe3V{ 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

y8Q#?@8o(9X$Z%{0EQj73S{UbZX33F8i{afZ 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 z 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

AnmLK&bz3;U5oySfQeJ#OKJsjc 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 z%0D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 Mz!* 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≪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

xh{Q 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

t%_2-<-6bA`kjKvq1?=f+$B3WYUU&y`2tlWEb&r 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 j_Evddy?UOjvK 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 z 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

NzZjjb#05%AZDoyMyoF4zP0DE8#9 zEKxddgktaX(71k`y+iu~dnZ#uDBcLFgU}&qi)6e`Ye?aWd`ZH^BNQDhTc*^|MH0{P zAL4#4Pw)!Ac|vFT5VN}tZ^tk5xJ2Tv#seBep-Z~L@?!{x2X703wPJivW4B=hq}^b+S%%Nh+lYn zf}Wm1fuVae$xw`eZ)BWrS##R;J4sNf@Vq^C^+pq15YqNVzdtPm6MW9UgJyV!{xH9s zD(~i3-rk+}YJbm42@97%W*=P8X+oW=_oCR zSP?yTEGtAEEi3GDy7kuH${GJ={y^U;@K{SAUi ziC|I*?KpsTic1Q%FmrW>*^X_%w8KJ}XQCiZG47lP11H556_H+!YqBIZyci(~5%W>0 zD)Fr(*8R{=O{X~&p+|=`9xRqja-Wl?C^T$%k?G?aZ6^TeaSRUuYf!dB#CREom&CYz zb>zNxyc&k~4Pxbn@twMGIiq#{NW^w%rruCDih)mD*5sOE0EHV^)ef_|o z(cB=6QG9&qXe>V+!f<5@gP2YZy2f+{g=KoaT?AjQZ^@U$R>|}w{^eqetM4qFkK1g3M@bZnc>hc%%a#t%&hx@DR zM4){QhM`fZjq+Hlgm8B{kjuJ6b*#@?CDzwzt+ws&wN_ihGR^DSj03MyDGtd2=)A|P z5}=GM{|yUQ3joWnHrnge60C=;s>KzVM%Hlcu4ge_G86497-SHkj@V^*f78|Smi(s_ z*n0$qC9&4SB(8pWRfv&ScXt$l2qJ2u(HqjHmC$HNn^ww)g0yMvpf{vVE2W{3HmwA+ zY)8pLLm+KhX$zus3a!a3(-DTem0V6`7^F=r-7%0htwj4m+O!fv1i=VMo1J6_L)z@5 zO35fWPzVR386`jH`-el?w2qXFk+{tR0DB1Zd@EU*LB7VWr!%`d@_Z}Ff(&S?NHn9S zRV74Y?FVVoKG=dzLA5ia%|5c65TAw4kT$I(Gs{xGQ?buDHVn?$Q4>r1wMv`*CKY8A zVM(M&y3R7*`#{>XPDgeQG<71;Xhx162764wFi4x$VPm`mT0aWXrjvZX+yD?St%SD z0sRk;EYBke)eOzv8T3ugOiNc1Y+tu!(0eA*USQfT?6ruT!EJuEe0Tl=%UyMjl%EbU z!<8xQvIe$B%*sL6?6npW7ZDp}VwYtxvnRI zeG}qa)>SIW)6O$;D9;Kl%)VH5I{-(cXhgxO->~JI)_Jo> zhc(_TmQnJhh5q5tVg_8PUYPiSOOfwhk{X7YxVjFPElZ6sC?cB6QR>eDbCGDzw@8Rt zWkntXk8T-BT}JI}_U_>y8oa=x6;-ykLn&h|I# ze#Rb7n%tkrWPm5kP?!|1&((GnUT2=)lJir2HiS{t_Jdee4!6dtmf>P^V5jG-dWV{g zoB8zZ`RVhwgt>#6>2QM9T9p~JNVrB+3cyf6R6rF`W-R#?9aneZ{S2!9PwRaCr4fDo z;q8xq{>u3A&u99(+waWq`|qr?iyt14qpP1@+>o=8qGQx7TXn{`e>GpPCcovWasKiL z`|Rn2!oqeB!K>g%U0TK4x+7Hy@2Wt@+)pf|)rndOs$y~NpvFn)qa3MePcHUO=pJ2vtgY%g^p zRL6=O{IBjfDdX_~Xa*}W)LDp*wq#dcB@XM)Q47O6B#xqh5E}00q^jH!ke-I2e?}%F zip|A2AVk$9mrtgaGoCW^kb{x(ulst?sD*5da?SdjoDe{oV(F+^e3nVTg%zgfrb6frJMc}}4VK|;m z5u4)l#Vys*E1(-PYUtEBeY!EuE}nBD6B6 zZ_#r20bHXo<^)!VjXHuAI)^)hRia}LVTD%TQ&?%*{}@&pALblZ2#z?2KhxfBZxQ17 zC=mu;b4&ojTOiB>%4QMICHR5J_~nWJ)a0|zG+YunS}1a2US(z)N?p$25uR^9%;qz6 zfQzHB;ZXM973FDB>X%CBf~3o9Sc_%b3DGXKL(^*{0zU!ENEfE0K>
1txqIx*ch>BT~yQ3uKWQ9zi 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∈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

F^blN_a*5%T_aNiSsEl|!4Oj_*duT)uK;E_ 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%0D7Q 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

;grc;>CcB*=}pM2 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 t+55;-j3X5CG+h;uB9EiGPI2h(Mzax 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

1b}y7T(A6OUR7+1> z6*2BksB4xHIlc;9_rQ$}A9!(|4g1z-TLSkyTHq#nGrv#GH&o)Gc%cig@W8Q>W~M1G zPo6wIJvq8g?GAmJv-W*vtl4=T_QjfAY%c&nb5Su{VohKh1~al#M05BrtEXi7_aO{g zrZI>|#n5Yb)Uk9xtK-Z{m8(L3Q$Hfx<1!&cO-!%@qqel)#jWHAX9aSG9h|Usz)}ME z@!0o0*Rm4FF?+Pxsx}wQMJj>^Qb*T`V;U z91CSm>bbQ?hZSxuER)2vz;FcKUgD^6XhYTnx(j0v7*=z2fn7TU3r5KV@yIBVJ z*Zz_(Nuk7j{>u@4n<)Q4KH2G3)`n1q5RIfj!6227DX=1uGOi@8q2~R zCS(&QKZ9kfwrT1*#Gahtcw&?>?q6U3LHED?gK>8L{oUD{Z`9K_&*)&J!$tP8=F3FX zv$rGD7AWhN_oq)^-<>`%h_|*yZAMuat2#V;G9PbyI!FFo<`iv@fM=)fRJ@w35tgi1 z3R985m<&llX;jjZAVOA}{p3Vu6vrk*3POF|q@o?W_v7{OREIt!@K5-qCCU7hdpsy$mWPtzSL%_7*t%lzLmbX?c zV-agXoj`M7ZmCX;!^9bjYMR3Jq5qmfWK#TLE|4afB*I|mS5eiY{Y~&xAhC8NGezhW zdI2SVGG8F$WEsv-T9P789zFl|?1aKm@{lc>1BtOxXpv-)uXM3{9wdsTiPX@q4ZN!K zv}Rqw09`|{!#UqXk4M0u$cc$NkPYkvSxBGM7dd(Qjdu3*`#Y@NkhhLz?UhX`LuE7X zSk9!Oaqk)?1v+VTJ?&YHJ}X>;k6@WJ@QA_&@nb{Tl4qzrG6Nz5=S#vFR8V=uRKA$4 z=P?5KP$9xc>+(Sgi{Ty0r6H)09Bg!$>b61d!s2@phv_r@^x@>)+4;#XD1zq0G^IbH zWJz(%?K`CSY<51jb2~p&rKZCX2&zQJ9Ii68Q3tF{Xn%)nf$G?URwmZ>u$9~PKXB#N z`#E%FiX)1XFovG3Q4mB|z~6>K7Y`Jcxb;^ve}U>1Dbs(#OA=rkc9bh&z6LZME{lYTpr_E`SH4_H7(x7cClX0BZ`5(!D)dvad$NfuapRr4_EYleMX$UbBZTm+p%!Y@P#>2PO+~d zs;7e2&fa)9hiasJlm@ob5LYqEgDhz4#Md{Qdu*-s=3{I{zI7RC#Gxr5v|7Q94Pr+) zpvoapK)uo@2I@&$$EtB`wWD6~ToHs#fetGI#&l3QFu42$iwDnYWtbWj*bD>2(L})e zLDj-g)g5>r%pmb1+d>6{#5a8k$q}i?BCuF|Mu6WRf1=CrKW%a9mTG0>LB!WscR!xL zp-3G%lTn+)LcP=aGx_8W@Idd*9(I-yYla6(>5n**~*usG=EMJU~}rZavOOAimWxD*xKqd{8Crn_0?aIITX!KwC5cDU9p z37MvlFw%F$3XMSwr$WEllM)N{E-)dt?SH7qt@m@R$Q1h@EF^UEqBXi>S(c$XWe>^S z^ZD=R;aA>+|J}>maPjv3?BTU`c7A$y_7IX0CUv-`ZXCH_jXb*a=bf-|QX9}dn1jeA znii>%mS(sDS|u_@1(m6dQbJ`y`%^;;RL3f!GO@m@sNDA7g4}4oV9B#h`My|;<_Xz2 zHZT@lGiwbQk?0;y&oa}@T3Ie&5RQKZ5rC)O_Hg#s^i33Y9L!uxEw}9r0aqa~8vCt6 zabKWs6~evI-YOJ^!n{=orHZ#WBDphy6bJrIyT;J)DtS}T$P6Ka$YiaDA-YwjItI$E zLaZ-_TZI7JfFnxD)RG&F+Ez=A($%se9Smu0&|9Q=4##P$j4Zp@4JsK^At!)Q=vGW; zVfSJ&6;gR~(2}9l1}&RRfX2p8)L`eer-3D<_Bl0XbRIN1`C`Ck+ZlbWvTWQLknc3? zm-H?@>>Q!}R;DRT6@%s~8q0PLCN+gsW)Rg>?$!~fSKrl$QnQ@A@vyQlHRQ%)s#SZkAtI%sjL(|oXYEN|cT=k9(@7UDHHB~O!!d+bIxdt>e^H^^! z+G3*c3jon}prMrqxeErZ;rSi-XAP}dfzQfqupBw!S(c7>cXxM0mz5*(BeP?g$9tP z&fdIMPtTvVo4v(6yPCYy=MOTVxWlv13@pqcl^~ED0b+w4WB|{BnhtS&wVSZT67R`; z-MyemspHPJYq?!-yLF-QXq$C`+P>`71){xe)rHnW?bHP#d$3U#=nb<^7f6h>O&4g5 zu}c>S^|eVC8jrI_S4a)EMOP>dvqM+N47WiSNR6{U7f6XaX@A>ufy^kobAi%0n{$EG zID2y)DQ2vOdXn09yI80SWYTt-N28~mxj<{Ijk!Rq&IH`szFeTVC);v?rZ7qmvn!WK zjkhTm2oA9)7YOXfmRuk?%#K_jF~Wvipfl2bT%ffl+i`*Bhp-zLIv8U!E)W`NFD}q( zwH0d~RnE|jb5!@%v>lZ*H2c`lk5!Wl!3+$nHrxzOsjS%~vg>OR#kw_UckPcgb?d{qF@b>2b``eK81e-q#GI7p*)_9z=@~{YX5jq@C}kT}nV;xdIi^ zBPffB=U&HjHG0&pC@gGgzyk|b6i8<3edoLZa%I#40(|lO>#v`D{`}>W_A(Vb0Y3oe zipaZi+M6~}@&Eccszn0#$lTSB5BLVgb8JJj?R<{>t*!re;wG!NW6}FKa zkR#Bi0v}+qG4Q>O$kyS|iY(3dJir_VNs@%F7Caa;l#%h0Ec1XyvN1*C64$|aha zB!;5_2;Ou7nivDFO|=ZmHwa=az40IkQ6O0N=&*u5C9M!>3&=*_O9I0JRyhzS4a@QM z(DcGMFk?SV3=;^FCgu|u&SzK44Js(itEf{86yk~e4Z#%*z?+grmA`Tk|1<48-+e(% zb%9KE0IzB5uEd2;R_m+Ty+1*gHNjz)fm2IA58=ZSi9w7g#$91V)MC&8PH%!6Qbv@! zn<9@Jz|@<`dWMQRotUw?`3{D3p-^O?`(ih>;;7CDWFv)c^lT$C)x^+&HtHlgz|#PC zXvTUHn5JzzdJkAlUO(XAhH=ixM=``9|_0|^}oW7=^9}yf)(vV*EHAi02`S&zUzgK z5t}GDrW+^{007v?(Lz)UaGTKgc_@lL9qfFfNx{Xk99SSd;sKXTHxrYxuC_WZ-lz#bp*QPDEy?40Ir#3dn>=z zm1MQNRthWPb518lpQa1_;B%CG&Hb@cIqS^kWo#8LUhvVBzLh7 zP>0pzZ5`fT;m0A8us~pt9JJFBSLC1$<}y8(YWk&eFz;-d|0&Q?XEeVKFE(#kPh^)& z#BjzaDFB~M0ym5d3o=9_U_TTM2@{j#qwo6!JRO9FRwzxPC!S}!zyPzgKs5kKZEN_- z)Br;Xpv~BIdR=7Q1E07kv4lN`KHA4*mUmNIvE&~Q{XaO2qjUqsN z>QRELnPtZvc^wLi0!zm>QZ9j2p#TjxjtH$H7nhxRHXm;7tIcF)=Ox(}=XSxi#o6MZ z4w0L4E)tJ!mYWTQqm^|S>8BxFD>Wa)vtq0jp4D(6(rs6zL`;5(5M2RzZ^@u&P+O3& zb1LG3fK^#Lh(Hu2|X0D?Y3Ubmhi%fUXp`rv1 zBJ`jdI57~Xfr4uTyBdsty@-iqN9%n4k}DlA8K&(Q9GKyxt^`~Lo+?h;)cV2Kg%$~gG%ukQ zA3w@}8N#u7>p=`FKv*f(v?+p&^Q&yW!7MuPXrV=sFKeJ}>43uZh3sBEX{W}=l)!pw zSt_bA7%Cw{ld713QKrT_ijd0yD|wJ=)&$~73YdGQHX-SLqkEg++dpihr?0isrA$%pL|L|bPOf&3I$E^Za@1>ncxPhnabbc((noXQScS`Pgw)0>E_3U!v8N`MEE=V zNDs_zmKP){Kf(PNVFCyaMQ#E0`ce2X%^`idGzS_m zLrO!L+zWxQc0mYh>vV8<>FlH2A+|&D*}u)-=CO>bA~#YL%pEv#1h&Sp)*crC-vmX5 z??zZ@@USSr2}`lv)_fO|Xrqz^qzWtlpcvW2=!I81@E3%*h9JozxEz4xlpLCkQ0WMN zZcPWy23T#ZtMuJm5`xfc)<+WX1VwXn>>E^F$pbP%pg4GvtSx8a7e^cI%=nv z7lev)v?Bbnn+)$7J{PG;wGdm!vKk;wYKo=Dc z^M-J|N#~UG9e?!E%V%Hx?wnVS%vJW`w}BM&o9X%ol=Lj_qJ|OVunAm$w$}hZ0ATq6 zCH-b5Ovqr|Dqa=DM!PhV@^0~Lmip5kQOnOisp$b0YX?3>b;U+&4f68$%_WrEGH%1W z=ZO$~U;KV@3X9_zTAt()!;Z$K?|_m{i?BJMq#sby4=Cwx4k+o%JD~h^k?c8Ic9!`2 ze!3(N`~{t01O>;?Ci~GE1yGp}iIn#JlmwG#js>U8N%cL0^OpTj;JodA&flC~|BT+B z$SEU=8XQp4p@rAnU-(5{+^zGV=R5+uouz6>N>?K0dSoHm>>hkTNv{;2Bk3g@dnJVv zGL0_ahvHY&+vDL{cevKgZvF6{4*t@~&@Qj4_uW!+5KKcBUK49lSQ?y%esoRY1}r-Y zHa(Jh#I=k+4=Cwar6JK5MOk++2W{YLqz#?wlYKYx{?t(E#Y_+8APHwjUYH?rqw^jY zHLwxW6|QC+Rp9v10VRF2+*MJ9E2Q#^qWoJZqH`ozQw>2-cwhKPEXS?~?F`pIxHs}l zWoSduXDWnJ#arCG4k+o<+H}&&y7fh*sSp^4N>fX2FfvUowPENqwWNk4)Ktjfz+yMT z=>a8ubF)64cHFMxP;07hL9#SK67ry>9oLHnS(vsRie6J0+E@ge3c)%%2a}oyl=OJm zD<6VtQ+X}>LAI%o9fodGA;XVV*)+zCW`nc^)>0;wL)8qTmp7M*7O-jt(JfFoprltK zxDF`kIIbi_k}}iaAgMvZIiRGY#Ik_(QUA(-a4?<%4h}v`C^*Q>IH088erjT44>5J+ ziAL=vfc&{$5lqwKt9TgXc-CVd@H(rYeq1s=mnA7nslym?`{fXuS5=!%03NIj`yA@*;=7L*St z=`f^77U%Xen444NwJR8?$Jnb2M0?w+3$2IRsS8B*V52V3%TBKh>%8|;XDx?S@GK1H zfRfJ3Qq=5dGUg4lLl;(<$PBkZ7f6k>KNm;|cvey=>A>n=7+Ew7dkkgq^CgY2bAH-$h1+cgPiirTYbGMu)6YiLUvR(l=tUNKqnNjU$ z5PF)JKn3m)P|Z4^E;WEQ3b@1KxTo>WRgB03e?AFk6F)E=&1R^9t!728*_8(0KnlBA z!c@n#6(HBDI>QwS!S816cLQN=rXywS>ukCWUfxAP80mWhF?E z*^@&!jNU;u2A2-(1>h`F;Jw;yWU3B;+FkNSrjUA1=JC51t0i^@Fy&THPipp2%_BoL zQVp3wJ4wu;vXcOs>3FJVV|M9Ix?V1?)#dcb!e50~_b2ae=F8dU%h@}ICEa2Bw6rho znGB?loT@RwaSLz=a4d;u0jx(-cvQzJf}epdQos(!F#v&Ea?HFdqw$@ce`B0Igb$}r zzbBx^cBe%1ygAei_0F*Sic^t71a?w5qV^yI0I%?>bgAt{hY_IFpkgQ`LbVa0EkjEW zX_}t&{>X9!gcjy7$1n3`_!h62r-y*^W}7+vify&M0TLRLM;NAjDb=fH_tX0mo4NS< zzOn!C-Pt^R^UdAa!&~k7`Q;t@ZDSUru~voX;J3rw*)>CN-##@BGGBH38{*EOa{J*4 zU=5VUxV$SQNBO=h)W|5fpY-A?>9OAM3dO$3#uWnWl*ZoXhW$Z%gExH-9NaNEVl^Wh zjQ>F}jU)%|KT)FP;_(J3VXI4$3Hw3@1Jw6A1rOt@1?zy9Sd+eBmx|fuVtwTcd@14m zD1SzEra%59XHaweSKPSEKYZ}i>K5_L?>Pp$nVIVd`3Vz;af9fFX~>#3*4T4eiy<@vE113lk1;>7Wy$b};B1F_pO z97olu_!BQ;0&Gh^h{;4zX0l_hKC|~oI(PPw?bt^>dScqNgrZsQ30)jc+e*s8;j}%R zwzvt@dZ!xp#$VBCOX8faQ^eS0L{LprD_?`|p3i?j55Mvr{O?}ghKsikr*FQ$KYjX* zdV2oNrw|J1J+c0Rn9#jVJW;wPH{2;x9PR9Ku)JFo5g!hMX}-K8Lw@n*Sh}b+Y`*Lg zfj8GH;I+K!>4oBO4Imw=cTj9)H4oQ-0$xPF%W;DwDHsqRC9`)*%*|J8Ww}5p5oXas zX@u1+!>ynazM@!XD{FBjxbg}cBp|5nVAbyQz;vL74fi&_-ycyT_I`?gr*I0r1M#{n z1@vhtyl+H8d8f{L2kv#EIy9iK6Y=!oA+&=b$>^Q>;T>QPiHq$1Hd01$SYTkM;g1Oz z?9@TunT0o>N@NbnAz#=3xdM}Ham84 zjp|bI^nKv3<3ArA9la-09Z7a(N#37a=j1?_)KyeJ-`fk>4~Rgg#Tph6+KDvZR`T{` zChonh5~C)Q&!a&1)<;fK?x+wNy0^XxRQCi_(CI~u2}JGG!784kKwS(Ki=)CtF=7?& zsmkB}m{FohrwR);;!dMSsJp36RQ$hwu9?S{c5IqI;F*>(HHLR=xbzGQYpEe)AJZc? zJwoatzm(#yB9uUv#UbA|sI1o_P5_@j!#`JBmVR>Fg9bcji?R^PDNTD&THh{8+qx$m z%qRy<;9k45CbB{0k#p^fl~{XpEM@4+paTBla_hspc>L)12oNBm{`!K;mCOoBU!ipD zn>d8i?3kAVrtfmeCVhD~dpnaKx&d{xVqlnLb|Z^GKBVi}YPAF`_X_?UK8aM)=K&H3 zOY?)d6fq$I4@i{KKvhA88w+UG(&L3yU?2M66maj>4yTjtN3P-fwr59)gW~jdY&oW? zX;xsPXe|mv>q#8As)3a*JDoUv{J>mIE;Uo_hQJQLkk#;a5up=9A zyTvMdEVI9sc7Cn(mbV%nx>0C9#!{OS8WpCI(jczfPjH4HC~5kGY_Tbwz82WD8M~ol z2XeDYkGCoeJ>!BdvQhL8wV;s;=Z_rsCsm}afD_!Gy}2}=pFgqA-aP5${7J`IZzJ95 z^5LxyVu3q#(zVP)3D%{TE2q%@AQl>Y`sphDyAumt4zhhZTvDy5gU2O(BlR+bYgMDD z^!Bba4~V=e<9sSDwD;vnY3ZW3|D=W1P_Ib~$vyZ=TBr~6khBmS=@)6CJjNT+Lbk6D zq=gi&bR#?;I|vWRl2~9 z*lSqtM$%8uin?xun_y%Qg3K^)L(8gT%%gn_E#!xI7Fx*d$Dh#BL2heHeN>(7x-A6x z){r+|XWu~!)sY^97Rr0_6SVa3A-n@E-Hq`Hw2&R?3233*ZvST>$7KK4k5%v3+G+o{ zjx}|M{oguPnTr4dIF(ZPt7!jk9_}uy|IU^>Z2ddiw_5m{TjQwhW!FckcY(Ystl{`d zXfXA5{oI8AAth5B}4hnk)_8! z8=BAo_DD8Q6T+B_nNDnd_p`1oz3gEw{N;(o$&W+Kh`#KBP_g69uBUn88HkI!%O0j6 zNOe!G`ZEULZ#P%)yy1Gj3}^mkwnW9cM_)WYJAe7?^VjFkUqTL1RytxXC}A1-=l+@= zk@5p`7adck$Vn%DU&Ry|B7c)TazVo-f8%!Xc7gl`^uvCOE`oc}T)YnEqN{8y`1G#* z*~EJHi9O9QVYw0)O$zO;N=r|3NL;?`Es_H`}d$y2IP=`8-k!9 zw{LSAHYS5>>2Ryi36|lSo=LzzX~GMF|CVc#(VIBDnzB!m&B|Y_=k)gB{3MTWQ}PfO zZ0#iIW%>8>rH^g+o^4gOgVV4C^pFYBv0VuqAA)mdBb%Wt*nO9KQ~M0)ltyA>Cq=%M zQZ~S8S*H|?Gi0`XU4~NJAAjrpe=yCLCK`9VSA7o3(33p+J5!j z*+ca0YoJ;@xqtrjREKAedG)r}0p(m_D+_3bZ%~MV#D;>JaNCWtSS}_}4BQrEZOrgP zh-~fkcFq!tD?a_%+xU99nr$A^;aGqeaWoS;iaZ(t*zlVCiw2U*2-T;JMVkQ|L5$29PyT+1=xCpRPOGpFM)+!k9wt6RJ0f_8%mgET&&~o;uF3&{ z>O|8gnsctX$EI^^>@oaohA{VM1bqcqiE89_08^z9XtJY}}HB}sk>b$4;8Y}fQ} zc9`U&=S3 z`|;85;`w~3+$~r0=vO~JN{4X2+^&?HRZOFRP8%uEXQ3AyDax04eJ6{{`D}fqO#VT6 zxm~Yk{^Ap5MhGEzzl$|!{^dXa<-h*(fB4J)^_Tzqpa0`O|F8J>|Mr*vru^l<|KaF;1df#?b+x<2B zJ7tgwG-FS5HOqy?Sy??bvD-dwY#>@m@~<@#|x}_ibE5?5mU0Q${K90im^sjukvzeU2Wxc%|8$ zA9X8FDj#j#wM#sSmB$Irhg35`8u$&3CQ_)|W9;MknvFeORT|!@zu5ZoIo@i#VUp)( zBsgAN-QN(aA!z$k{bynbdS#&yA+fHUr`ILO0Em*iH68%}V5|E#;Ib7yFZq67hf6R+ zzD?K`Py7EJxL*0S#=iP-^ZxN>iIrPFK34wt`2YJ)|M4&X`SB;pU6a-!9R^h^L!BG%W@b=$IaMqk=Huf&%5If(u1 z3kvc6RQvg75}DWuP^{L<p|Mq7wU+EZ&E(w|>ZNJcQ3ksbyC z#KW@`Wr_*YbdS*)cFy)R=JcS)BcvzOE<|s)kSY9}iQ-^;dC3G4lRsP@ zVN?WV#Sc;@;`03}Hb3l5;FHRU3^yPVx%5-yc?KwxE@Rz@V2hhbBFrAv`D|`7DHg;X3(S zMR}HBx}T(H8xt19@$2m>@kt%Q5hD7&gNYe3q@>OKmS!?hov>`g6vKcbd;X3W;DSwJ@rR-3K$~B*JQB`v^(_pUsdu2h# zH5X~K>zg^#hw;s>iD6anB7~g}+b7?DX;WFILNk~`p0Z<`@AbNuhEZJ2F0bbJr~de* zH^^9s&6^ha96J2l^{=2)V;90paSg-b?aaU68pZ`gHdmTqwn~)(GFy$lLZljpP{gN> zWtg7jY90pCesk|;L@BBBBeH+4<$W=ihuvmK(Zd(xTRxQi-;(UKU9U)5{4#n;NH2Pj;nLsJqRh!?7}D z6K(tZlb`Hmc*zphKckC8bF9rJ zC)L;FlDF({amm~6$KaCF8)9!M8wj$DK^ri(>E*vAV=#NB!5;AS*H1ow{_+WTU8UFl zXUZS_H7V!ZayyR~mz%2#-1PkU=AM)x66EQP50}i<_WGxfg#N%j9+9DBalJWO#6Xys zuA$lBbc~}3w4-f2!7~$1bdnOCnwnvL%&xvT|JKXxB3iSTovH~5E?1My zmahDu1O*|QL60IGNcit@xxh{Mh#3OlEmNL7zE<9Bp>+wp0-fNrQjc_4AZAd5xL!os z1)b(lKH?Ql#KebvnkKtYRGjfZ{}huaXE;9H_&B!MsNX`5qN@hf3_6Bq;fz))!SlH3 z%x<8x;13!tCX)?wovVi!AX#uo|6?;{=LGb=JB5@@-2QL*Pnq%raXma3jhM zDNwwQAWe3hspJdlLmYN;`!;Vtv+B9DZ9Uh+N)@| zh1;rStEO$(M_hoSOYB9qxWYs{;AM)a*JSlA#zqMRcqjj za06dDLKtu%#rjvD7{ZoSDub9)OrVB2c}WW=W6n~K#X1y8qI;3%l3Sp|OYTOhosDf3 zawB6}vC~@En5Sw?JkN0BFrjJ~DMyD8Lm0l{XqFm9YM^Pqj4K z4;e?RE?7ARSF47ldsY%@j^#N{5<7_(Vj&{iR4qLufn4S29vxOVy0mnlFZkLu%?NTP zQZZuPi44_OV^dEwQw_Dq*D$8oG%U;bZ0#e~1d=I?$tF?cW@2W-{l1QmHt)z4Bo?*@ z3zvpizfm&2?z|ZL;%f)9+I7TQmT9Yw3y+fE+Ry#)YWa#(SiUF)mM;7_gqsTl1~IZ2 zafOj}3tQ9C9h_|Gp^$erjg}i8dDMw*>l*H2Qp7*?VbTmfJLOHBj;5)rF}TsTvAccE zaeY4mqsEr)#G0A-QD7ycHf6jSCpb*?01+2@;Kew1%_t01JFuB$H0u+R}a((_%HpFs{FzBN#Nl)bYmwBoCL0nKo2!~ zy&2Ocx|Z09rW&S>Q_Bm@#Pd)s%-4X;4=#z_#11tmu4q$b+8!NNm^ND`P!_xzdzx;8 zC!q(pkQ?})5eHV}crnU$c~BKpP1p3WtBU;kCW1p6UVJ!G$)LtJW?#)X8)#)eWE|Rg z9rnbbtU^M{q2E#wq*^7}#q~$Nt-_ zW$6+6=4OdvTyuYVvtE;y)IsMhHYsvoR(gx%xckE6@9gV3jyKJT}V>?5Zs8Z?8+*d42LF?ZFq7ZHh=0 z2rlJ(7TqDfP1>!o9fo){df-NWWNMlkC$=7YzG1``cB*g2U<5mIJ|ih`G+P$+?o+CJ zrBH?rwjp!GE59~iH&c=o!n;zzaSKg+O2wU5_mi6$MdD0S9%R<}?fNcSPw1gZni+{W zmBknAdDydA3C{$@b#5$HO?K8e3$hPo`maA(8({9w$&=Q)z zC}xV+F0%J%OW>DM0J+GRd774Bh74uK5rn_Mr$}){RZB22mmIcH8XZlHf;X}P*77#U zf;aA-KRvlSeRD}^Hf>zl61*YUa(M7Yb>!_K9M$K01#*;{4-e<4Cp0FgqfBvBXh)gY z{sKHIl*fj7lnM3?_9(aSAM#PAKvr`?#TkdRS*AK9{38v?c-liW>?>lVl2Vdp9QzxQ z$-=&1pgaHS3Z9nVO`+Vq@C~MAzcq2`f|xAjRhQ1UTBw2kUD4*N^tJDK#JJPHp2M3I5n)!4@2OIrYy~fy7fXHfT0cDxCA{p~ z^NH9;DwkSWh?^_q1FZb{B%DpenT9qy!Lv(*(ByELC>`zfe3}WfOt9fT(0-V<5jtEZ z`qxPM6Zi=y`c#kyO1`|k&R#>MIqGgxZLHJ)F|D$mO|}B zkc_dtYN2+cIvTjUTQ~c{@b1=IZ#eI6WQQVqccY$OHiQC@-)s0c?d;DOecG)fP7l10 zVLj}Rc1ChoNz`r=;FlPxe8vBw&MZ5LT7ZAJ~Ra_fJV1sw>V=zp3_bw=2Kf_&S zNZr^(ZjL_t%-AI1IJC^EMa_VBW1KX1pfB(xXahH_H2gHSgBfFog4NwE5U~JH z;;DBcgh|yyt5Y^xu9M}}Nd>0309MCyLXQ)UL%Cck4-Wh5ua=51j(S*i%#Y$avih%h zP%J_3YN@3+vZHKjkDR`P%jw{95*Q7gOxeWR`$1tX?Pth?Q5Akaqe9YW;b#OTyTu#>wQ3ylg*A6bHgUhL-Q{~`t zVg--t{jOnx)_4lbwVJV`HU z4LpE5$%xXm<$FkN&;g3UEH1YIiaNNQuqjc0t?5q%bOdniMh09c*r8~Hsc1iey%ZZ_`_t{hjm(v>VnvzYk&jKD?PIS1= z0jW?rTDbziHe@H=Nw~mn7b6K_JO`H(vg|&H%V}68-%cAq-%a%k(~{cPEjH`g7s5fhLIOBG#{piJpYXu=_$XPg*UO3xV_FPMFME)aKAI;{fX7f zV=OSwRKflb{pC5C=ttZO_uG-6+C8bTu|n|kZ_iF%LaGrq#J{TAz-dT-_97vXM9~l` z{!7UKS#eVUY@jTCsS1)m%s@Zdp#MlN7~dZ3GGL7)RT(X?WVV7Y)R4*XLyQ2jtN0{{a% zfvLJWLmSV~#iG!$O+PR#KQtWINOT~^#x5YNY!AqkJ}|=o3$FPM=wjVFtiU#vRt(E5 zP{#IxXZ%!T`g5M+yS6X#Vrh)^8$?9HPCGCEAaJEBaFNluW`Lms)<^Jjc!fd=OT#2s z>oOl&f!#=fBjgchE0r0s`# z9D-eeWb6fr=R`XGYaDtWh-svJt0SAY;YO%djt2G_Ynn z@lY+@&^4@J&Wq04|x55mOE^RqzaZzZ1 zjiVNi&LC;9OHD)74q*DL5>CAj7?SAPr_w3qtt9=_Z=yU-Olm%8wqmT6t%N!-kZ77l z_2{`qCb}X2&m#CYeq=SZSG-p?IGKWt-TvswpX>0ZL0p{^EMM@B#13SDnqNl4D}@ z6*;D(0+a@z@Ekj{*x~eZRL6~1=T!X|Q|utqTH5cDZvb5Fr>_>}8-$CgyHHqx3Sr%2^ zsmiw=9ab3jbG~~(SBN(p?xBm4YKE<8iHd9N|IgmL^~jNAX<~oH!N#JiwwW1zzoe$8 zi$x}@*;ARUB9qPP>S|^A#XK{ZkrC115lm)s2N0kKEd(rteG&u#!fIaxJuDz$UZkDX zQ|}*XU!Jm#FGOZ*&*Q%m}w*=4N(|9Xprrkh1CmUE4P?Y7?b*Js^tv z_Gj12<{~%<+(a>0RC`YsYk)9oU%X7Pb$;nRai`g(_Kj}AIN-Sj?nM1@e|9>LP|K{Y zRg}IQ!j&ZggE&%-xXzI#zS3|!XPQOc*(5;?a!B5Jyy(V^%}sakA>Fvg@S$eKO!t`& z+l_C!R$zI)>j85e1#NJLP(ubhYhaHPPi1hJu3`68$jhj ztVdu37NAX?4|{Z2<6`clX|H0hY}gLczD%tL9PII_WlP+BT_T^wg+m!oyV|KsDC9-eYGEEgd9sLV%4J%H?R#2`N;Rm4WrmRKAwzKun1)TwhozVfb{l8A*P`ur z@35w2@L44@ztk`^(=}OWq8OkX!$2NkAU1>gZ&?=eQJNFw4`H7%f;J5!Ms@2o)j>f# ztl08>9YlLv=uGkGye4~6JgkDf@s+4L(x`bDj%7l#%uk!wHaSOY3J3pmh-eV>1_^_7 zY>l!2P6iK`;#9x5nO-4F_QQm2P?F^;O`Yw+()D&_&diL}ynYuH19H&FDlUjj8Po?N zig_8BWP-{~nx-4186eGsb&KDwzigf0M34jB&2qNzqe{$~_%JDA>x!Vj9<)FHiYEUt zht?p3wC%}k+Xy4MW1=0a$21Lur7CBoX#14Pkl0TADYoM_U?2kI|JhFxJ*QU4 zvY_-7xO4g?&J&To$@0{OGY&fJ0;8BOpm=(05e3nI$PhObT?&#INqWh6Lsu8lBi8H^ zC7`KVIgeO^ge$U4XurArZSw8g=MUdroM|sFPCuNzJNrOn{Hx1UzDn-Iid``YJ%+N6 z`9-SoV6^gM#Av1wQm9jw$xInE#V^CrCDluKM3?^~760iMntcNB8p9O8G{Fp=;ME$Q zB5WE2L`lK<=;Zf*pdqgUA4PRk=8$yPBbM}t$k9?W7Fw2-fGuWnR998_^LjH3TQC~rrB+T=nn zecA7Q1^bl<40>ld;<{!6Q@ZN9I%5A)hR8chRl)SFI_%Kqre*!4c5^V%b-$ZK*;5cZ zTIj$w2|GW^KZXo8e~nohltkSPZB)4qVS99flBWQb_guJ9Ov~{c#HabphTqgDXE*(m}E4j^SwCNbTa}o;CnsvpVu^-!(&rF6wD;gXx&4K#SP3K*zP-K$L@H zAZ*RobokU_!+?E2GvG=dXOo{W9*b-`Nr9FXpfN3P-F%(WftFnOFemz=-*x=_8OGRk7nl6>B(@3ON@N!}E1&PSQ8d2x`k+~JvZ z{_OO_`MZ#gg>5U;4i}Xz(eN8{Y0%p*&ZS3t-JkQ8!>`db8e?wL1!AKv)df2HyIU8D zj=f?RX!X5m7n=6Ja2Fcy=iXf)xPRQI0`ZDyC^?-TU0gF|3fIOoR9^q~i^r%nJ%>Nt zpGV5m*RK)kvY6d)3pfd@9#MPk-4mfs2oo(NdY2e!qcggwNE_jOl@V#9-y6lLjnL3i zA#L>1Tu;dzLyCj6krp)RROy4w)J82MG7OEWjjT|fhn4(jqe+-Wcx?`k)WsszMu+f^ zIFS+-3sE0Sm1vZR!UaB>DACA>b}rqq?d69T>u95zWv>n@&(TJ8I66`rMLNbsSr2R^ z?!}%48$`5>TBIT!kS)~57_*-WWOAaN%WSkxKtbi;Q_vaZsEuNJUCnkVxT{YojW)8x zq*c=NJEgFXnN~?7PaPjnE~9PGsnl=kgEq$Vj~py7zZvGvvE0rBE`Ja#2B(Ul_KpD%+DC|B|>{DQPDQ(V~SF=(Ug$| z1Itjfk?o8ElvRvqEj(eJ7|x0AHWZ#vk2LK_w=OjIM8#7oJwno1m~HS=x$s2GSjkaE z2T)t7iS5mHApLA_ytSM}OH&LrNAp1pg(&4qS2Qdq(ahESt9kr{`5;rP=$({5RE?&Gm$K>%HB;tdMwy)5>_+s|%+qV`x-%ox?QNH|!%j;5c z9wZcsyY^@|uZBcWM1|)j+UL1t6Ytc|49h*eWdhrbe68NzbWn}XUZ;>Q-RkVsJjbzI zw~#H3wR`ZF{w%qnIPI$Gx%_Rvmlp2cGKFDpoesKge1_#$vpkn9zarPQ(A(s8db3C# zj)DaVqz=aCmbPWnbKT>c<-QW)%rxQAjy>>25EF`UP{4_p05z~;%Rvr`s{8N@#l9XI zYHS-(6owR>mAQuk&sE{@^{f~f%Wg!8SsuBEk*4K4$a?i{%V%LsUSd)%0Zdx(`1a_q z<{mo3l+OHjpex-%p@sO+Fb+J!MjluUGzCLvs_!_+!_^U&YI%;%OigbK7rjGL2879& z)Uf7tlh=Vs=l9*02dEHq@z!65%~2NyI8pcXf_%B2PH*8l`|$1xMc=06>Z~$j{fQwA zS*J3HDdh{)m{LRjfu|Y;ro4XYFEJ1P)IA`EGsi*|%9K_QvlB+f1(OpfU_s*YUbm7y%ap@fdiWOgqq!42qob z2nUR9s5(RTHe$m<%VYq@uuTdh^NlbfjiRm{^ysjr9sFi`tGwNStW*vhEA$WtW~ip? zAqWQ0X_jFiw9Segl_4fZ1Kx)hdg^C?{3E|-VLESdC}0Y3hsZXI@&yNbSKcgFp4*ijY+}0Yh)c_9LZDYBq20H z&X?~4DiF6g#0nzbHwqBKYpNPxG$7CrD;qgnI%g6+LL#86MXq6LfvehT-~|>E2}6ih z)AsZb@q^Ie)EF;Ym*_n@tV#4&_rL~t`Sa(LDKaBWFDcm(aOFfmMeuFireh_<9Tcc0 zt{MW3P4movMhtXQ?BD}%Qka<(<>3T-rK9jJwD@NGp3KHEDWet{A>OtS6hR_C*r)Xt# z^kV2BXZzwdkinp*cQ2ov-krU>dcfn`PRsUSP}#w+h6jVzN8W1}V(7iXLMz=3j}2`m zG$uf_N^w+_Xq6b5ruLJDS)*JC-k?Y*+z9%mWL62%l>&4)+imB}R2i>G$o`R|)e*=5 zIUar;-c#OlB>;5TxcaAXrs;&wdWeRwJ?ApZrfl`w+8mmRXI#QbnxsjY!h*!ZCPbEI z;e#}+<}$hVr2|q%?^S;%_rM=$D!HNp+CtF5a#H<5L{Rdlh5uYUkc9RW%h7* zSBrKvpJ<1}TLjEh6!YfE`sp0rbktO`$M`+9cqO}gIs45l{K9+izj^gOoZmd0z5Ct$ z*}FIT*~L{Md#qHbRmweLAG%OVTVX{HYHPDIsjMOj(aqs9(P`^tH<3)R;XbhaFm2w$ zg3#eIakxy}PMUW}#u4)Vg)EucWnZz4cCE>qd5HLR&ZL>19JI07KH-x^*Oazy_5!-96rAGLpkm-@3iP zm_)d4J@ieB>qZp@()nh=N^CnP?q9qr%dB`FpyYr@TxezU)oPfxt29{Z&Bb(=j&aaf{X*FMIl{dMbUND^Q- z%KJ$P?AF(?1i@~!#pWvRVr~!L-|pq)iu5!4{vL&6PP5okDFbkSZ&V_?r^Lc;i!~_t#pa)@7>rm5arcH6<_ zlok{@#IGG(PW$p<9b8UGh^!rKje!Z1gUg9W$G7+{4=$(0EZ&|2ad0_Nc16qnA=CH4 z<#e}m6G>CW!R3S<)4rV!E~k#C8u1;uX8?|q`L?9HX1o2Nk0Vo3ESk6vE~n~+x>@hQ z+>J(>?AFu4<+SSvKe(Lu4ZRQRA6!le+%*-;W1k5;xSS}SW44&H%6TLdfbQA4(gpT@ zK9bPE<+Rw$Q8DocaXDSirt=#l+%0%xJnSSquBHQkpME7@Hhjp-#N- zp5lq^NGAtHem3lPyyCbKS6Ygpq{t*4i*~=ABbW0y{ zP{*HAO!lSOD?;ijk|h_(}H2B@LAD12*%U`QnZM2KaZ;WdIOe(OfPM zcSzT^A3XUSUkDgOK!^+d`Q_~bkPB!n%ecygghWDJ#VNfOL9k&7Kgz%fv?1n7>gNGXDmD=dojZ6QY>Vgwv2q7;^{NlIEbV^}1qb=i8 zP{O4M4CkQ+KP-@736o4#m(5Y3@^ZEP5TH05S>AXXszodMu^de!5}8*hy!RqWHtea$ zqdt8PVJldC!6Pkr%ADtDu1h(85~m}$_TNv}@9%wJuugCAd=>Yq_CUY)7eNa(B7^1u z(6M~%|G;i$J-<&^0Z{GlX=#6pqa0L_^Q7dtCi_mzS99S&K{1h1H z^uv0EEumabqlnEFe%_(JCn5WS>BJ!mT)aw%)2$!+LA03>JS~j{P-41jdq7ny4n>0D zywJ`cUfi9(yP-|8ja}M<31kN&z;KFV-ahliC$pHO?Q1S%L)LIO^i7q-m^{^-)+o4} zoD6oyo`7x&G{-{RD)U<4~?1K!TZ*<-z! zShO0>!KL5a4grRbo#Pv+N?jnrVaPQtl22~bE@P&f@L~zVAZxP zWNSLT8P`HGWf62;j^R@K0|(YD_@!C?FN_2Kfa^F}P}Z=?*DW{zhps}rp{AC8qJCTSLZL!PeHKVc$I?Gy-;vMqx=PmtSD@^%C0P8Wxl>vX8t`2 zv&5^#t%4FO3QSLIrrfcgub4u%3-HFV0@Bd*@%?JCxw_`heSf#|mzVs)d5KJnJAV~@ zuf&@CK;^eoiQ9=^8DFRt#-p8S&VnMh6* z_0*c_g*uRylrnv(ubx`x52q%uSPA5Q+tpKV)mLQ)BlOkUz_+hg?eXj++`b}0u9sU6 z*JB&$j5$p!1V`z$6xmI>bVtqeNWp;^Zt5og}{FF-wM$o$u!ktwvsp6CH<5? zv+Yz(&ra=AI^+BVM;7R5iU&L6tXfgl!T3OOo|9-hxVBaG^ z4}}-8#UAr5@N;NFP=g{C``B0tJwrT$b}UnU^iP%7axcUy#vT}NBlg3sKi~K>XmZ#g z-?I-()Z8SWCz}x;D54;Sa=+LpiT|EqD}cY)^y->awiR(3dWU-I=i^eKQ*rtU#`!Cp z<2%$W@^@?kBoxa8=q|Dbf|*neVa!%FxL^SAFAZcVSEB2F9wU@h3VsYsgZ6xyh`__;W#wW}@5|FQBUWQywJbft{~a3zztqt5byQ`6>TkrF zN)_Hnedm!NuqTP!^&TD8%EkQC|M5Tk)4%+0{^|euKmYUp^lw327K?FR+w&sFHiFnQ zW0by$bzgN%HHf^}jlI}oy2ntItYfhl9fjVGRQzWss>)%}E#*J`U;q7o`VapGeab18 z?Azg{R9#XT!7}MQ6?-Zi;}zm5S_?JV;78Xqu$v@9rX^I58Y?!Iz8u1mB?7~EG97W9 zCtcGuQFAIU-?^OX2#6dQOU`Tb;m+E zq}cQ|LpN2!vm!4t8C9mrI93bQIB>(rutJpeQ*Cgz7KE{>`=;mneyDjy5E@!@fu|lF z);Knws{+6JsvU)zfkMKzh5~q=>p3ih9C6hs@=>lRicz`NvROxdougz5`IRU(NudZN zQURe2598K+#Eq+)F>mKt*%$M=c%L+K=f$r069Y96^#Tj87Qs=l5;0=cz?0&4Lm0T& zeh~kP!PdCf!X9;T-ew2tbAJ{tbXC>7$!r?}; zUD+I03`z+fUS9kTfhnb+6hw~5h?KY2_gvdQefs*@6D65m%~8@~#TEamL9oad)Vt)# zrXZ9vc&*>upMA|Oi`$sUXw^(pE*f5ssW{&4b6tG0m-R1eINb18B{9b4m(v<$?#s#S z&(c?*Io8ORlj>{V%Ukw0?d5IvW7W&)4Ke67g`kKsMqayO@(`T=X!cIBAc=Cm!YZe@3QTb=P?H3nyPv~=LWUW*!fx@? z^y-RCHNu1mHyaE+G3s&R0}O-AD#{anqQlj-n9&$uq!hEMAbw8_gol@>q!UIFf!JKA z38eU8$d>EMgO3#o6x`e*cpgG~p&&**f^x`-q@*KdlhCNRF%?S1%3s|dE7%h|tT=t0 zW!p|Cd1hulGctT^7r@)dSP5Qv-H?lP zvHi9?KMi(a}2H)UbSy7THD!H(snR z6ShW$ZAvmKWF4i6Mzn|tPJNk-#E*mlOIu1OGEGm@Y!ml2X}e4Zj3M+}5$+tx8xL9z zIU1}-Z38+gMaHBXu+*>e= z@f=gntvG26F=kiOj*XaUrW@*h92*YIP)2A5%<==<)I8Tg zmHNQ3X<0L~Yv94=YI#~5v)D9sEA(8Z`IZ~1k>lvDuorhGA@*hVKS&?_dzBuX>RmGQ5)!bu_y^<>h9T{C0BmpZ~jm z{r~+h|LXt!hkyL1fB8RZ$G7DF8Q?ByUE$31+IeR7V|v9><4sat6>r^mSZFGp6(nY* z^wCuMKS2*yxi$Z02)E{~2XU($XpLJ9-PU1vw<%Q$?rf+_X-|{W*IyYr59WByR_~`F zd+`!))xlY^jX;@W`N<)Zp0gy?+;EEi>ba^MP#e?Bl5jN@HA+q%y`EAqit_Xqzfhjy za8uy$U)=F)-U3&`#rr9JwhE?5E?eE_uKYy#1i?3x7{RCO2~I||_*6lxr1JTfr;qs$ zZ@+wU{>j zA0f~RYkc2rzc)86@ATT)WaAP&=4=Y#kY~E)c@EYiw#>kZbd|--b_2(YG{dwkH;$u{ z6W`ZdAxI%K(F1y&sSdTiU8ss<`;g!H6sDYB4|I@nAnc#zJ1E3;A>OIN)4rT-oeQ>O3R+I+F~%#qKl7F?7#{ z&m-s2Fa4Y3`gW>&U#+J1hO|=JxaBGdoAeNP*ud%E+sB{OiCq1aj9Zo)fa&h+L z9BEsnsw%dP$Q~6+xs=?I zKcBK$#5U_Byl&VO)$fPwi7JgjTOu8KZAa)P0#|fI0%bd*)ZHZUVc4J~5)y(PHbrae z^1jI3#xsQ5lEy2FPr^Qm*(FFG;Jxs5=$KZ~)-T6HN+ym>YPU?saWs>wYS3{m$t3&e z?Ahsum$T2c;ENBhzy0R9_U$+4>iNajNVX3@AT@TkVR>usqI2NG#1*e@Aw+l=fn#cp zSwf6zcs+s)Zx1@1P1>yk;}p_~Ev_9!l+c;d<|dLJ;U_#yTlwZrH7C#p|p z7VOG`SCBV^C8E@LxSzO*3>5m06Ygueq`v+h6UrUG{f9NmUtAvA{(Qz2x?}yuWpaHD z;^o%;{m13@aP!RxM|T{IL7CUxVCfAXP$*YfbF_R1Na_Iy0ug%e$f_m+I z1a-G4*!EJy*+OHsT*He)12zfYQauZnL|YF6+hGXw#pw^rlWvn5DLvdR9`E!3L*k$S z5JLuraE0ez2nc`fA1}JvYssw9%8&7;F>cN*yH{*yKM^BTUb_4+&yGc@h~srCFlYNC zPkXRNe-Gqo-NgRRD_6_UMv>3XHa~w$V4+$M2$O$7uVx}c^WeV z)pG;eh%`Uc1N>x1%+%@3zeXM`&zK}EC2aQ+@sk-_ksVYh+UYN8wX^PB98O#5Bi>nO z_;A`n1Ney22+IX20;S?)+nKIu=1R>$4#y>KR1YF3xj(tXY0GfWqP5BLo(lK7;(h1t zEaDH=-dyaK>@d9bpzaxz~H4o$`20n}FT9$rM5<=x$B3Cx(4v-#K z2$m|Re3#mS?m?HQ!V$$%V@0dNL6;W}iX8{pdq?^k2`ExE>xUNWLSFj^34~g z6gufEX%r!HRHJDK69Pv?p`=wTEcY5kxXjEJOVao_DhLo$kdzG3BK$mz&`89ONPJyQ zL!_XhAPbrzQF@7Tx#$JXCB!w}`m6MWAy*KhXl^o5HO9atNbOjJ9a=dJhE!$3SJ{60 z?I1)1K2GpA3|w?fhl?357z@nRVl|F(iPA?X$T?x^h~H>N4PD%cp!Oo2e%w$w1&m1; zyTo01)X>se9ir^jGKU*3}_+{00%(;=jKSNMM5-IVIl%MYiA+BJfQEHH$#%h$B9s#3+1jx z%}jv~@iUJCjWP#@3fK&QQeJ4@2{Hy$t101)qgHC_g=XLZ0Bq1R6cYsx!!{=e32VWO z_z9)I@V7KKw9PC<7lU|$;GeAJXL-Am9qo1%$7+!wve&Kkuv*$;wAaX&1F$1GpK0tI z+{JbX=Ox!ILQyEnK#;*5xzgzfFMK975|H@n9`KSBwSueTrQmRhT|%EA-0&U34dKyQ zuQu?>&}X?=DSUW0y_pstq7kB1Y8&GhzH9`PCAnH51AtGui0MovAv^$S6T}@+S)2R= z!URu8C@Eglw6_G{zr|h(Cdbge_+s|%+qc%kw-+ydNdai$wtIqLq{1rz{1Jnfi-YuU zELDnIRV=o`16ZkC4uOTWdq+fg5#Cq$N3vgqha?Q6D1yJwF_;VIierXOgfKo^2gF8X zsey@@KwtML5Sh$Nyc+_oY(IENh)L6HhHyMg4$)4TU^+xQaZsr3>TZ*mKloqC|9bF{l#1$;osQ4 zt#&vz4jvLVIe172Kx(Y5{NN!GwtQUc4<3@SMx%p=BzLty&L2D^#8u=U0Eq9X^A2V-&~bWDXvZMm-)D7vW|(ct{Q&l7ok&;O_Wo zdPpu&>jP1R@B<}m7Sq3gvBJNwQ>>Q>9D)^B&W;;6_e@hxYij9eAeeg!CuRG6AykXV zq*SYYq?2jtf!gwkW-n)`2HM$o$r&~JNQy+3-^0N)ElPaov>ca7) z#!6d6-i$^QmxQ{fPLX@C5l-*r+w;>`&=}g`UPbPp^xN{^$muFG{Z@?Jj>S*1M=oic zvhw4-UjV)nPAftw}K)km9orDOQz3X@~<+iqS_W z2v(?_2KbC1PuBPYq(*=?Q?0CN4E`@?@FKbaLI^+z+}(o62TP}52f%7lO%9Z8cOjbr z_IZT}9}d5ak4UJE#_@F2LRE~n6bN(L1mme0t_$S80*+#My_zORR|^i1S4F@neK`c_ zq(opFW)i^;`TPfx)aTh%wA6;&J2V)*wI zkw~&VLp8w}utEw8oqxU73OMI=fEuj;qt^;5hI&1!qZLY*-1^skunF8|OtJjCA?sA6 zJ!qNI(biT;w;UAWaf}?FDC-J31pw%dH17y%VYkIMqgg1Q>y$yom>KCTiY?y;@RX`EN7G|G$NV^S%pmlb$y`*I z!h2`BT2>jXM~5{~u`{ttKv!ak>7g4kz#JJtfYN4xV?-!c7cjuXn#?fWNY_xkOx69* zlEv&jMO)V4#8Ui*qsU+TD62dtcrl>zkug*OI{j<>`3=&t6kSQdku~Mb#Z!)miGd7) z7)$qaX_H7Tbkcc(`eTeWGc2uBiZRwMTusaIJS=w(CiQOPPp=64rYcyoFNQE{)_54F zrlYL0s^)1nc112wp8*n?3L8w`PRT-)BwzV6|0(5QEI6XiY72O~kgi)Pl-c$N617xO zdN(?prn)G%Oc3|Y)Nl|id2U!b&A~(@AL57{B_!kUdlDWzd#M2VdJUSbykpm`akCU&fFGw#p+Nr7uIKTA>MyUk6yv zwielrW`}{N0~;MkEH>b#H3Id_K&m5#x|yyKN1+|5YOMM|LPhgXvqI7U(2Ut})Kbk8 zh}fY4%wS-Q0{z9(4PAxC08DHX)d^KYvx2~k{D_pd+L`@?KtNFj`s`2tVFth#JR;BT z$kBbxqQZo};X8ipyOyOnR_N$ah?5&H=ouO_^fnyO=hF{Lu$iJD4Nsjuddnyp{g=YU zbd)eEd9%K!BmFhirV)>_`THpVLpc%;YQ>;lG!?~W(-o@Bhz3eLL-ORY@_d21#Vtfr zVlnVZk@`*DpHM&lLP?_8<$4_-hbM+%o@nlg!UuIi(k5UuTD=de)rYs<>{+eFJHap+k@hBqN7C|qX5x~QrWS} z-vBIgK3zYs*?KX*&v)bBVlPYXmA1DI=Sqvv$n?L?%tm)Fkr~iKAk_HtHwzTE!>wI; zn#%S9heC(f8AJxq|Uwdg#t`_jb=1xs2FW>eL1C$kE-=g1+)R`oa*pAI>LMaw}4 zuN++M{mu_q*aAY_l1!Yuu8q?5t_m(;q3c9;jMLc*aGIeh+SD(_ zJvyv0@b6GZ9Yp1+8vDK(1;G6dJqX+&(6k7k;JW6kVQlEWiyFMhAo9apj*;CbN7p8H zyPdP!#T?b^2MM@*oidr$`Th39M|zjKE4Hm;Wyy#sHC$v^@q|6Hc2v2k_}vhmDz+cQ zS#r2F&Z1k8rU6GiQ);umCcc-c6SnXsZ7P4j}DaWV>ma53oy*054tJHGy#-LNFQ(NpX(K=!%lDr{>cC zu>Em%G20Au2T!R^J zPpnq91U=6pA36w(=M81Nv)a^{b8bRAl*(=l8reE`lMH%kd*aSkB3JRbS zo|EdE0GPMr;tO0Pn6ckdi#B6n&WmH|pHf`J@0KAzZ8Z>N>X8g5lE1^{zoS$(RO>2o zh<2pnKmFoRD*LahR5q#neaf{qx+S<%;o#4*P51{SaPc;OmKVaT5OUP@4jS23e^y4S ze0LMBhzy4WzsgFkS%KGjNu;J~eLt)}OSd43(~YymY=%&Ug3)Ysvq_pNW6944Y5pnA zL0Z45(f}K;_q^^=wkh}s2`Cfy`1uB}-eL7CZOY4B^H904CG@$XrzNw}`?;sNFgzKE z&CpCAI}~;57)snaMr<1_w3+Igo~P?2^BJsWo(CHdc!OG#cOX9C23}sZ?2g^}efM?8CIdpsU+p0x zaIa&k3JzmH7l)hVYBOCo@mcxXA>3A`Fo@^UF*h)srJ06DMZr@^9NbRlizJy&p3G*y zMQzc=SBo%tj>6i%_QM;tdO7b{a;yWLGIRbgu_Hz&3n>`ch0!~=kX}s@QF)ypOvb;t zX)=@69vHH)H6nx7)=o!XTU>52L@-e9iYRwDNwBllIN^A4zYfB+y?J>lYjV~>uxcMU zdv$#z5ZN+YC?ry>`Mz#>@XSR~2%o&k%vfcv=Ib^X65)7|tW>iuw}r;!^HMV2J5o6M~5|8Tb?J7m+}_j3wGqHmLH*3k)t!$Fk@Ip zbp$0k5VMvYz)))WPMb~i%@Waj0IC}#WXq!}EPf_$JHPXujs~(K%_d__dN@EaXrX#QMC3YW5^cr@q{=NddesVFrWv|(4%92Ut zcf4c=?yNMb5!u0`ZqJhPBGTg+Ar{A*c^Y|ejNk;mJ*9?ZtE#VSC?~7Jb7O|gWgeUt zER1~^^HqfR#L$;is;883EnFI*sYgx>Z3OYQIJw}L4-B{q>=3$&>sukBk%Q(k^IrE3 zYg}7h^NeXt1`mPmBM=zXp<=v>6Zt+IjZ87VAGW$e{95y(d9fP0K`NSHor^ zeUF+f(vhEF>#m0bI#mGgSTLW?-=Q?eWF6lMk1Cxw9VAe5)9rExLUOEbpay}jv%oVU zQW#2vtB3?p;b}wwpck8=9~*&XdTJ@QU)Nm6Qv)w_V+TjChuHoYg~mNYbrDeyoG+K49RrYr zngIF(giJoZ!t!ULrSqE)5-kl(TDXz5T09W1>6y5^=0fOVFWNOPv!2b zYC_X9{X~`E(k42CcvQYdjYqL35q*k?-i$|UeNN`L;e2^}gm9Qys2`;`$aw1xT-%k{ zc0RUqKE^`Gjdv-uetaTKZ1}q^+LrDh={LX53#kb+3?|dbqSQxoLJpwvA?vqSbbe`Wlz_Z65_;Hp*gmMZau<~=jGr2E8-6f*aMcg~~e=euLT-*lJKYqR-n`Bi!7rz@Kmy7KO$>Vgi zHF2!NqT(Uu2ug3NGKsDxFHvIyk@m+==2x4UzxvH9jn{#VyUF5G_@Ml_EeIv}MQ4 zriIP~aE~^*8ubTyv7TPE(yasWwXWvizA8-uVhS;^ejA0~HL|wDHi;NY;|+snU>*E? zI9oGL+3K8gEN0OazZ=_hBUR=h&J#cVyfv=i>qYqEwiJ10qryXS(JJ)j%7 z1vLXfp#^5}XCK&XMO=$#t5UV}Wj}5a>TZd^AeNCMt_fB{GYlKIG6=6!us-=pS9KL3 zUb9K6(jF1auK0_zx(?!X2aWOu$(#^W`vOn_7|Di^>@d%`AyY~RD$Mc4APdOo-qV8b z7U`ILF-;0pgZhYm3q?9kKfIiMt_5Fwc>V1+&$VyAIakjwzBbMu!iTeGzoS*&9=5f8 z2KX2zd4ig>LItudx>2i+8oiob1f zWo2v-EjzlKE#T_{bH)BFK^d9#bWJEj1PX#2`SJIlp?o%l9Ms%MQYlDM z;+8VI78m$y`?uem&%$?a^z(<`ndk4W3=Co$bLp)%uZ+9i|B`mbXcphTwMy^TDLG{Z6P955Y!97e2N9pI^i}8-f|j)p`jXVdfi+n*BLpSs0RoI{ zMrLsBX-3HW$d<>YVxmnP;XC0@E7pe?4Lh$Z1_$_uqacWDqXN~-27!M*aubp7j1pgf&H(OxYU zx14KMH<>UQZP`f)?n9M>eE~q>kEvelKFAT7j}!cjVzN}AAzaL$@GVw8jEei9U!wOB z>TOP*y5skhJt)xPz5}IovFKL3tRN2>Hphh1!T5xwNifD9hMDU5lF@|CiRNK%JqSXe znB5uoFzk%hN6Nq8g*=24bT5|^N$TT7{KWSKz^L{x@HNO_E`r%2*atb7KPQ~l#|f@G zG){cdxiHs`El0#@yd~NcA+d*fAlgJKqfIyp`y$L~Wt8Pra}T4Iq$VHJ*_Nfh_c8K} z7FLlof-C=l3XP8z^^=?!C{qoj)ieOO>RxCU$y$n33meb}Z=ssqpaQ))* z(z)!`4z@{cR@wd|j@+Leix{WcgR}+hVOAumqFG5CIq5fh=p#LIn!1t|y7thEBsHwq z*X}i5`YSg1NEIFa{`mO#BN?Yi{&JJ*J~qD~1d7Psx}Lt@hj;0tBqd_wISxQfgN|@H zB{=eZj60(Rx?-jGu$Y2SaZ_@8?j9&}Iz_^nMS35TkrOL+0rbgfJPrL0^^&=Drg&Fu z(hW=WKK?41&O`PXPU*+kqw8rng_jZrHCkw4df&se2|{=&|CSM9S>0<7q$R0=g~E1l zZp4(vGha{4TnON9^brZ>~#Ln5nBn(X+^w$T0Ul)zoZ9Hf3R zA)9koJmOiXz)$`GdF;~>N=lUcK80^S!CZW#YcpO4DED}q)V6r`;zIc{eFBrSj6UEl zjEC?!9@?r9ri1}jEC?2CpP_y6#q8a;Z>@)KFHRpQQ(D~IX|4;SL_v{!?)gF>dCK3+ z)|cWkM1!S_Oe!ftrynit`Nz92ZwKk zlZ9wIIDEGr>vRy7JR=A30`YS2$TY?sBM#%>ky*TB;kp=&Jvn$}Xa_cx38&+QB0;8KQt4 zJTeE5Ob@RTRD**@=C98qb4i#g@Oz;o9h=4U@3nBj$Q;)pqDAITkTWX^)HRKNC3JJXP;lS=y7p8Aq=y``(Y_9Uk&k55SFZ@T8&Xph@R zYRNQtxB>B0vOT?vB-cHijNF$3qvsN)i$yr)(HL-UK7Dz9@#@9rZ!TWGf{dhud&J&Q z!ZmUmeIV{i|Fy`S%p$V+ujKlb->(>XM~k0ik6hAl@!+G){AP~O8}uWnT?X(43(vA# z7w&l@0tl< z2B5;suMoWefJuO3B3wbI$r*)!B9qs02$bA4hPUmP^-Z?!LWBaX$`G_gIi_YT6mmCb zkQT}HX)~6ErRpfNo4?f=0&M&<|KWjfwyIbbr7!!vvat7;2n>2>3mAPg;sz`W0O+WO zfsG_no~HNy&0;mbnY@^XvrU3+fAl5XGKBbwm)q)|5K&6YZ4_un`S%oLMl4@LVD>Vw zApB4P3&JPj45NVItQIo|g-)S?EFdE~j%9hF7rUs4YO1D%y39I?GOMNrOydZ^ErCj4 zeHk>66vl)Q+HoZ7Rl}f|XBO^vBW}v(QC^FRX3kGHaDAG6Ez}W=VBS5&$5ZU|rW{o1b z2?umV;LjY@j-!a5QjQ2t7n;3l^gIx*DMbA}UQfzQ-)4dB`F+fK>`i#h8+^>pb0~!x~T5ms|2R za2o;N=tQdSq0VUp@G_N|daRkK`5pmL)dgO>fjYvUB|c7HcqvhYmC&z)yuU;IqKnY#{P8)#+#$1i|MJz1S?UX!M^ zp88G2m#g0o;pHlgL7Xgy-oVKg5PmH)M>sC^H$hEN{(nqQ2U*?HcGv0K6XQ6I=aZ*z zh{7;T$36yvgYSeWni`uH>Zk&$55)ou9d!;+2eowi`lvD!quzlQg`tKrsm#_*hN1^y zpt`7o5U32Oq=DO9rrGM=VU1Ittk&#SIlE7;Z@2~_`4nT+OxH48!(k>0M5`EnWZ^Vs zC^gMgF9<>-3~j&d{PkxGahM>~Iz#}g2s|CUVi_NHe%C$mp+$&`yZ8_lW^~813Veu) z7YH@y#e1r1aN(;V+*fEmi1FlD8yFAuny~{Bf1Ikova88-o-849BcNpZ?}0VaiS=4r z?_xe&$@&x@sUDPm}%k~ppEl5@)0g7%G`fHy%N{>{0`BB6WbOrZSlnrHq06iV#0KgH6GMaF5R_(p_uWY=m+8J;c5{r)<|x> z!mD(UqfHHWaGp!42h#^wV!B>B)0%qe!Ka0B2mtK}Cx+qak?IE_3W0#%`4A0{GD2um=e!;r);Lehj{=}1 zHeFHbgyg?a4RHB&1Km{t5ggPj?v2iMYUliGZyST1N&k@LOR^Vf~IP@wplD{cs;#c1Wh)f?292h zm^B{6gL0HLCe#cUAgwqGGbR)r0druTEIIgf2mY(H*}-}qK(xlN9uUH8+h@2`IUdUJ z@d7uvV);lcaSYghn5_k_ZmocZ@K*IyAZ)T82eLl~~ueh|;e z;nsMLn1-SU<5u+gb<~#f=K^dx=XQPM)-nf3`_2{t1 zciH5CvSd9UwZ51h!P1Mel4@Z1j^>y#M(Fse&K!q|@u9$n^%;a84x(Az7?UDxDr@fB z8Fa#B154LBol-)J@Kn&f%?IJg*2Gd!@R>1~2>J1E7{&olp zmMIKkLNVkT3u-P7ZPm!Z-+9F=6(2p<$U1Gu-Yp;TUvk@Lm8IgbXgv=u&*Q zJ*c++F0HtgZwOSD&fGd)r2u%&-TjD4=4sx*zx6_9nW%h>vQnt~#B3B?(@=B@-pm+s z0+nV7-;&5~P{(+^ZiXH()f1KDKFe?eI$hxldpM3uE)e{k=kw-o44o@2VY9!GM z@76VPrLDhYLhtwYBGe+EG9ueS@7qpQz!h6mtpR1pVB9DQ{nly?AI=}%e87wk-x_GV zy+%XZuxTzjR%X~rqIW%pCTeLYnb>}^3Il!vyQOhE+siOKpMKy)7vKn3Kn90v1(8D$ z*+)>A3y>^;Oj#qH6O&avwV(RQlC54tms;XqdV-(ang+i_Wfild`@`AAn}?UrPIn#M zMk~^^A?S|)ny!y~`yQ%4-|GyoG#`GBHxn9jmRBi`I?t=b_IIY&D33kYs|5R=?bY`E z&-W^Y{haYts>9FuM;F)AM8SW)f{M#rK&5V1@Q6<^L#(t3`dtxw4aU4?ln;4=ZjNwu0_o(j)o ziqwz-8js+;ib4ahsf<4RBNu85Pv@!@({*I{3-~WNG zjJ&iHv^}AB(GgMkLL@o=fMqta&6nSGb9GJHG4Lv4gfd5M$K9ZVCdf%sB3h01I3+XH zi3iuwXqt~)fhdlelm{I6gQr5apY*sN2uD?3GNU5SPN1q#STiXnmnF?a1YEX$ogz7P zzo;BE9jVbBG@WUxiIQoR!#5|B%D&`~wfnJN)F>Y`ooad^@n(GqhG;q@$E8IRZfpZF zLMlSbO1IBy1&$Br&)z(oKip_%&(7!$Bg4_9SpXju>uyxnGn2n~ZfD7jN@FxR+^;%t zVNU)nbQ2(Yz9WP4}x_wuW47 z#bz$o>JE0Nx)Q01*iLges8c)L?2pLpKNy^+=)|fucw=FJdunhvjsN)Jw%H#&u94wWm55?Ta}EaH*Z@ z$m$pEgtr#H(A*={J<`<+748u8#N)jZi&>7unUq)-m2geZ#j5@kLz`_wVn*|&YgRPi3tx@*NoD9i~ z{rF1?G{<^Ma#DSxLGqUU?UZ?2X+;?q<(boK^@zMIM8R@lUXS&p_sBdWdEj|5)Vt;w zdHL*0KY#Y*;pGz^m%YO=l8-a{31ivm5-C1>5FQoexr6Y?YF6*KR8(hbbSa%|Urr9f zqvN5N>zZKvAH}tis)Zfy-1%~5KVguay&74g{2hDyGn#0O_GB~>Ejlg6_%NDi_x4^i z5gF>YXri?Tk3|#NVZMqcN+Z1#O(e(oCz|N>^-MI;80V8{qd3?b(ME8XAEJ%ga1TTi zMJUlcKyO%e?2dypW{S6?JqJy6hxiPd=kfRXO0_O%LHKPh8Bf4g%1YZ{|m z2wexzMn+@%nc+eR<3ph zF;y3MqOyqW;2AjeK@Fgor^eu2E7?M0#>|f>nt?4HjHh4M(C`+ib~&E996f=KgRZ=o zj3F#(bk82zQX!#~eBV|gVRR7z=~~LcX0i0p4hKz{0?Fh}cp`5g4O3M)eOXlw% z3*eSVnrXw`W&uHsa9DOh#W_H9Fbt}?AiZ~D(;Nlr8qKSajioR9y|J*!mIw@bXF1{; zevYB39+Daf_AYfzR=yiZi>CXrD%Yo(K$K-zft!h-**{-z%mm!j4C4> zM!@V_ZpZ@5(KO)h>x=;5GW^Ea(L%>Jk-4dR4xl-JRje^fvw+>>0y|a3U$*B2guf}? ziBdFW*?=A$*1)WuO6YHiWaa8^;Hj1#yTH!^V4Mz=079_}eG^cyh7ZhC&j##&M-aL2 zda+_BibS`1b^7Gl+3E3ZBz9$ARO80=Om{^x={yg6g1NE_&~joP>2I86r%h!(3}EOQ zu3jkf@ty&eefIlcvHn8?lZtQg#SjK9lODvOa=dj8MY$J%Bf2@d>eJUpv+3qtJdr=h zRJ!f$0w#`xj=2B#oX=^*)qy>4^C89)m;@N1g-ajllELvVB-gpgXg_zV+0zhd27!#hH2b?#(XXk2cJ% z>3rfEx;G+lLk#(!S)YS3{+ab`=d$?AWirXQrB?t)rK{m#9L0*iXPmm1=9)$LAaxw+Y#6xxlB>yjB>B@?~|w08w-; z@g0P0Nm0K#3M6pZ7C4Ixs-haa*#u|N2(5Mg^86Hi2yn7TuQy@Hl7upF?-gN00(b}j zHwYahOXpPHy!tXZ0T#*ppDVwQXZOcq4v)d`fA~aJ9xQ+UsiI_0hlx0qTAMXIP-uUI zEAbJqI_Jj?&z1V$`sAmi)Wf6|z&s(d_IA&7!##koyR&;h1yl3sHofBjtywT`v|1(T zMqIcRG(c;nhjmBQBfC`Q_ruf>lhR2hfE;!`7s>)wwuk|j;;?WA&M@#q5N6h-tQx#f z+WGv!EqtSZ0I9;32_^4VwK z&42N;uT~3`N&<4}iSjoTQjBqN(4b@fO9t#Ap+1iP2K5X9pYylJ&o;NW_gU+|<+LPz z5Ha*Ge)ip(iVubB1u|d-w$F(&nGjut3JQrY?qHJ=NIm=;UP+MdgkZ?`G-X`mA$c=d zCzCvD7Nu?0{v;jhC1OD?=?O|L&qka`3YkC!oWNo=1-!FAyUfKbJ}t@8?!Y7&v4QQY zYFq(k5^v7cxRkAnN?eBCb^u<@4w3C%Y+=qQ%x;QNytv6`d8wUWEy1;i-yI6 zG5bV3_UP4%FMfT&^`^p#k5-S!EtD!d2c%iJ>Uhdm0v~thZBX#9K~3D;BFP&-?FXdU zWy35A1)!3AhyAx*F4mv#Wp=7GA8vMPCNxHQsZt!Jz*LEmklByfsYZFMB2y*USDC4{ z@2}8QDeOn7sZt%G*c^~%Q;hBJVWt9*EQKZ>kY*1^vw)lIpvY$aCLAv1xRh}^veZ-9Fdb_NkRrhGl!V)0N3u{d2zCX_7fsAlBk2DQ0bN zznARVr$tI2Tu9y?N4G#IC)+s-e9JTxY{z^ecry36v5K&dd~<>0IAAMMZ^jWO)~yon zWA16621%u8NaEuBfHXTgU%Y+Rhh&YnQ`=AOcsu=J8RYHsgt}1NaomMHjzu_$BF#J( zd>rANPLX;k9ei8|B~k~ZS*jnDYu4Ly%@0VkytIhSbUz@?GWhTTTf00U%|1FgAk7|- zW($%ui;X=X&B`p2N^F&Iz2s+4-)NA$Wqkx5hw`ZI<19)Ila)zsHoYX;h zY3I9=C8waG>Y|0Dz!M=PLO|*M^FPex9^;H~WR==4}d1?$umos_*&N#e>EQxzd2jl6> zxyU`)=>!ot?A}IyK$;a56J^#=wlg6J`oTJq5i#H5WLMZyS8*89tfPT!hA@>}pEjXb z+ODZNx`ir`@|^+zRNTNGe9ipzt-l0~D%@=SiGJ@cOwe^IgQh^fKn>PXcU3@M8ZH&M z1jrDidZoun<#)X4R$(qoI+aE>B4E1$>=Z%Y^V7oCUCXs}M}zNn3>dBI_+jLEj%%5L ztvMzjDV-?vG|zVe-}G%4Kx~m45cp*VMjLsm=Ep1wqfIu^;?{p4lv@c$YsW#XX`zO}MV4;|rfPe(W~n|vboE%* z0zD2L*H%Bf0#w_K5>`mk-vV3?j(@D7W~-j90!52JC9pC3BF^quJ{gNQ>HOMz!k%>u zyw6T%)ofk!^a3pOlY4Bi*Vof|#9UX*$a3c2UrJ`Kem{g!t2BnOX*%>8n;N>Uqse=BC?O5;)9#S#rvYD5Fp_ZO9-Dv1ubUj$AK_4Z{d*7U}^r zLKC36vFC)Y2?>iA$QaU&4Lj6;6=#R01AJ&d4lL7(T^F1g1PuHR6z8MFqt!fcQ+{To@o{Cix8?Y}+%0clx zEY~|@#Llm~FGeK6vXc>Q!*Em-e2{z=A!n1#BDPs4;kB5C5+7E-AHs)K8pHTdjJ(E% zI`HW=9VKToHY{~FNqitwtri;y;ZB^`+Il-PI{L`-(b8fxtKEwWABCTW|oV;DwJgm#X>Tt8sIYj>i+ifvsD{K!%RGqy}$_X4!3vty4AYwY-p z?;7P8H4-;}LZ*YrC>n!#nUj>%WA)e+cxR#|gX|9TmTw5ZjGE=(j)kX1ZV?Ik0mpjVcFV*_=VjWH7;(EO z-%wAnA+h777+Gxq!A5v=Rh2vYVu;|#8V`~f=^$$o!_rOQpc{Ez2hq(WxtRtFj(ObS zz^=5}E*xwR5?3hCK;4(Sjq^BYv7j zGj>U-JuE@<+vSX{E^mXy2Ry;+^&r+%obGyLG7lOv6;KErM~z%&x>oG?26S&T@Z8vU zL&Gbn+o2m;HcnAL3Qb=lX%qw&1d0*cM&PQE?M4C4*RWBXgeKEsKX$@E^*ohnIwK9; zcXUlvLr~Ui$MFnd^NoS^eG;Z@v*Nt92Px0h@VbVe3ER$hGdB6+MNfQx18@8)bBeyaE@MjZxB5#x%EX`oLxh%uV4 zfyB7J281L2OBT26j(~txet56=^N52zE`s;d#U{aXm;^$yeavOnck{egL6-#E-SrgH zGMxkJ@lKgxtTQoI9Gn;{!^rSNc&$VWhSwCBw)A*>E8;$(pNt#^JpefJMUD& zzD}-vuqLi}CJLswo*rWVX^z8U*Hm#S_B8{WUiV!+v|WC+`wMOE+r@jPeD(6}=_{AE z5wCD)71OzewmA5UUi(GyC-=KRp4-KT8k>nX57aegA^36q`j#vOzYzFZzF zFXvz#K?$3ZVY^>l{}fiV^YRo{G(d41Tz`Okty_@|<%;QM?1e$-Sj>)1IAH=@e@JQk z3$3V7R`_D3tHjq62$y_`Xp!aWaZxj!V^LuOQJ@Pc@n#;9WFyf7DKcG?oPfp?foZ>+ zukRKLw0t1n^VK7!rA7V(B4-98S_F}C%|bxFPUoDPA(sSc&eAI`1-OivGme)39i%Cq z2dhhY_LJBZU6(lD6$X@TGqfXEm{4HI)WQgQcobuM7_k`!xc;IB5^O$ysa?UjTrQWA zo;L3m0n8@h&0}RThqR}aRHm^qXH?n1U)_t-jcqP+kifuLgJpH+~NH4vFm8J%KjeH zmb{x{FN>W67ZS#GM?H!?`4>JTI&Xx0@AS~P{vr~EbVvnzCsjhY4ymL%ByEwD*J%w2 zXam(RR#?S*C^}fSRH->uB=#b~NppFEN4SiE&hjB-%QbJuHB!kEUA zhx{1A;lbNNV67P6)7Who0V%h%llktsngO{Q`(uG)iBu=rfY5OQhN~=gpO3L$&8P7c zdkYFvxJcGq=-@Sy8SU)idx%eX`xX1+2EhIxFz2!rW8fTv^DUhP+VxvW+@Z&;J$Ch4 z5nSNY_C>$n%>@%Y=I=pT`V{@if$?ts!rQy^UftKFlFSynY*U8kYB+ZbMq=_nwpAsg z??80OwX#Td(9Kegw05%C36O@Tz32D{Komo5~|p6Ol2W1<@C2{Vp3spS9NB3e&`ye z=>@Q={iu_K%8R%r%-EWJ3Dd*hvHRx)O8W_w1laeKb$7&?G_s8Tc>4;*GKH;HI9G9)EkYQ~*ue6WO|l{1VO`%npDy@GLX=W8 zQ4!E|!Rvu$n~r68j%9_09fuHUv1bP4VfgW;3pdR>WjTEhO#{Vza7@FBqTIry!BEu# zs_hRld7Wn>pFCUj9oXSR7~JE~igZ0754UaW7B(7;U+{Fp7Zm)s>O)*M<9DKfV(?BjUk7l9vwl{?Q>KD|B8q#ti@$|GVk{Q=}% z=QrMycIJ>3c$apDAP~rgf^vp~_dUC!t1#q!$!C~ko#F5fESt=3$}L>V0Eb1MuJ?@7O* z-rP!r_~L`DiYkxdD-#&RZE{p#HmZ6jYmFb8&XWxRYr?Pw`xB|9(UjZW z#kTG1uL?*O?$i|y^7Tw=Jlq28qqrmm`a-m~ma_ci$J+b&2dlOpBvKVCDM3dJ#4sl_qTh=PCA>~$&=klQXpkMIi>NU=UDGRnrN>F-cX^;p7kK9mXMCmk7IHhJj^5h@ zP*lWi$47{;9YWhyV+z^}LL1R>j)UuegwP~};o+JeQQTf8b8H6^CT6i1ne&u3m+~~*T2kV`PU?Ni+E@4G;P)JF=*jOhMZCqR)} z>ueyCD!2miHFnNevXTs56mg^D=?NmBwjHdk{-Wg8pU`}h70Pj7*fbmiDe3b<^7`qA zm$T2c;ENBhzy0R9_U$+4>iNaj#`(K9+RJCBcW5iC6yrEtPuDZb+`C9O85LZ|Zjk1; zzgx@~f45kWIe~Zh|Ficd-Ekb*n&4mYW}ZALF%<}(2W09cDUxDRPXHtWOiChEI6eYF z1R^4100{7CTc;L%YEj)?i{9j>7yS?V7rpN7`w9JBGdFkhAv}BtW#y|x4iduM?b>+F zuHE6gmgmC58s+5rM9RHTJ2|^hPoBS_+hY@pY{!QMC$kFvbn_+M2l{ZS)a2&Dl|Ian z8k^THKhZ_G{^|8f6rdmLjSZWT8iekcQQ053V@`4?wqr)AE3{))knK%aPHkAXG{?Ni zr|~dUSg9ppJh_RZ^K1i16-{r5@#t2zj?ew*8j=skV8sT`x3oux?|#O6@@NCQ5&{K2 zCqFV+hy`4$0Iz#=IKwsp9$b<87}Bor!Wnjsc%SWRhqzIvXTrI^2K@}4MLW}+L(@Cd z)SplvEEA|dDt)7$Y4)M19;yt&C7jM-wPv5Bt=OzD=gV_6W*&0yOH}aeDkF^5T=vqhWo{x!#Q__9VhJrZFqPD%Pmg9zULGXS+Q-ic}r;6Z=*?)ly-+)Gc(>+ z@PLY;e+z#dUiK)?%F$&rm`4PCLZsp)?Ag~CV(5L&c^l6C#exqQK22w}_h6-mx>y`z z_(+(Z0M3qBJfgbZBl3s1C3sd+?(vZDsLndU1DhHN6jwzf8Z^ zy>;;RFPrFjs2$yZZyldq+#TJ1`6YTqJTISmX=QlBDGLF!{?I%6KnLH`dwkw>=;>Q= zA~M0S|Dl(+xYZ1yshy5IG5T4di~!EA=IP`6X_3H?15Z#IblwRf`#bJ3ibGF3L8$9t zC(3m{>qN=@9Cd;kg0VWEboED2@px%-1o8WL>BKpCd;Efqnsg_8k<~mDWQ9BJvwq@ytF8Q8>$b%Zs4U?q(vPnsP*GEW}%QtOW+xM)rxiyzr zQ&VwAfZ{OIN2UE3FD~bkD{`i3aoNmTC`!>(_;*-dkas>|R!Yz@h3QB& zf!q>%zZ~ze2BCuw;GF zU3>|xR)4-Ud>>++?;`>_F*I0}><9{6vKaxMMZ*!J0jCI#`{+Q%m*k;}Kx`|H;p7k^ z)Xne=cw9Md68ReZGVnTzRHxq3)SiOO;f5$c>7T8FZau6!v$Q z;^c;2q!^X1whRVL)T~%i-fawE5&GP9wqcw+w7<-yARvBarIv1lROQ zUf)2SlSS_{9r(Zz$msM-4AaomA^Bk%$aYO&-#`jV<^dV(cMzs_ei{RUhSoi5g0epu zy7Z~RL?)xllFtuZ0YtQa68nZxAfpb{q^o{e>>CL8Ph;Oel+O9ydF&hL4off7KzLY| zncakYB%5gh#zkDH#d5BwHH=4Vo59aME;xLQ&l zCjg^Agw+9n0{E5588}1$k5ovkEFMc<*JrOzj`0~=9o*waR-wt6 zY@phMvXI}9DNTJLj}3m`l9vi1N7+zE2uR*c*XR6tf;j}_KlvQV_E5yb7Jlz!Cuo8T zQ3e)FZk{7)c)6w%A9YjavLJ)3Y?GF7tCBEn3iP=(x@sxL;5oyCsnu57aN|{FY^RH5 zumP6bidJ`7X)V9&)>-aSA(!vf;k30C1va8SEDOLp*~(iZeNTM!?HCX^%Q**}Mt|BU zduj?6wbdM~DF9646-eUOd1?_zS6#ZVF2!T!sWWuZ0ZB*$_KRfSOMBRF+2w_MO@nAn z{laVII-nVdVv>=nSNHc3*{aKHPCW0k-bC46opjPBRu&uVctAw6)ErEV)iY-QOnLR7 zZKz6p(c+4$I1Z5abT+CRYN8lpn(EJ3eywmEv=Jpn2&(+VROCE51^3dOR#G^YV9;; zcFNY>-;bRV!ByzRPL~0M7sIeCdGB0JfD`FouPMr^%!cy2KCCF0@5hd5b1Up<=m^ua zT`!L&%jz1#{iCJtPN~ce2Gp?;cVj@=a|hAfL4e3_;IIRf0pMO1)-oIf03D~BW(WxQ z5K&$+?W4Je0CK?qyU&g-+gCLsMgXV=0KXtf93ymWfVdNCvPRAxRrc#pVTJv&fdOT~ zf(}q=Ov0B)V$(JOWdlSB>?lcOV(aj1Jq!)sGvc-m0z(49v*xk6&N!}hkN3rK6hD%2 z+;sYydwwzdQ(xIqGAmMK}-uBuU=t>~CKS)WDvqoz~p!wcl8}rR#n(4eq}$l%Xv|=2~*8`jZc4 zVYbM0K=*4Nbb;Y2MTCg(u6HyYKO-!iWEUlY7>}f>0$CKmqK8?CKa;TGJtACgWOia6 zB^iLNe9JttzrXg>qx&oK=#JbC{;lO#g+ANSKZR^C11zQ;d*Hm==Us4m(p#c7Z92!KL=_lzfr*;$Gq(0tAiHm?C# z1GL;VGDC8B`w{&Ixm>u0RSE8tcYmB*Um*WW_~rXtCAgeN2SO9aIB}%8m!s9q#rsDJ zQeYv14PS$s*YoT5kH-I^Jbp}VW=H(v$3K52REv^M^ERF^LM(CC`7?l^-_1A5WjtLd zX+8i%=acdaDIYdV09zsc=LX530l|tWv_GMScmMvk|MuUN@0ccASuKF>4hYdh<@3Bc zpeL7`y;zRYPd|VB_#8{QLAPvpP#yOOsmmktieVAV4%8f&$397IiRV1!OKT9$+>b)2 zSu=kK9$T13=s^R{lQT0dB1J6bFStJn3uDYe8o8GuV4XY!KNuS15BXGigDl)%PkwrP z`|MAWO5Kr~3bss6|Cvex9 zBVz1P9MOMKCRLVZ8s~yX6)9zZ!BAwTA2Ei}5}5i~ne?jBeD-k1qOF{~l35w;DrL&v z6Kyi}R)`OzO}#Ihkj1m!q;tWEZEtD2Noc}JwBvAT7->OZ+<||1$}-4RgmQqTvqk*k z3eij&>&&KQ@vTq|=8Qx*KrQJuuD?ZQ6TY@DG%%Wee74iyc6$`Rs9=B)S8jLnHK6=; zCqb@IxW6D*M`nm1SEM&ckSmhfpCDJFJJe&hNUp0OS1jFKkSmtok04j1xmA#Rvpx8q z`XQY8HKeA{Rgciy&>boPesVd;UE<>ipQ_lqseKH2HFUnuvm zuPi3QR)I5X%&$3xA$r(XChaeX#gQ9)K`fGc*jHjG1UsCkc|xCpRQu>D;sP!%*SKuq zpI<0&`neme=OZkBo)aogkhcn`i)-cC?|+}h5ZtkwBJNIDY_28VIdY(u zO5d1)T4JdrFOKCt(E_z}IYEqAcAxD%Y8i!o5dyW%8xk8(OR#HHKrIodS_Z@eY$e${ z5@0LEelY-B$@TaCuO*pXBR{3l55kqL)y=e)WJUoin&f=$sNZ`@=OjQ+cF^xlQ6@rd zFd*9OOtr8Ot*`^q?V{4AiE~Bowti0e=X&7 z|E{Y*xZd}kEkU54?|yA_(aynM`?ZAo`0Lja+K;DxEoq^QCmkQ3x8763i_6Q2G^qV~ zot2i!WjfXVG;fjcD+dpi1< z|GWqsq{edT^C(JCKDia#mK=;8Z+Fx(4C9LbYvWmBT1?SdwKju zc^SikjkL?(F=#J%La;*04gYYJIoQAa?%T9*;|(;ebTyVLlfX7)5Bw|H1E0Dsbpr?( z`Sbv~gJ!G737>hNlH+}VC>!diuqYIaLb*dny+xsYKHIWIp->IRl|gs7fSYn0av7I8 zE-VVK%%cxi*71Ev*uzauA=@nqdRoB%i$b~G%^HyM*PSd1g~I(ce|2PrSQLu%23Zt} zq-d+zk84PY?of+Dkz7~JU$Jy|i$bxyP+bgj4JpzbY*CO>c}t92wJ4mNy}E^25J2KD zc3BjPEzC4=J1q)@au54TokgKAL=XE)2a7^+_-2Zm6Z(&)iT;YM{BHmgW$1LoLCs=7w4#!^{m^ zN%l53Y^B)G+_05ge{(}ENl57fV1{Z*3cUeo3MG9*&kb~(lK?&0QqV^KR@*?C2(_`B zxuKS%L?frz+T74YvWK~$mK-VBfi~UO+)zt%sJWq*Xq`2H?Yv#g4Yich{kyILVJ#T6 zrpS}DpShv7x%)6T)DrGvZm1=+A9F)3>3-&hT2ced4Yl+Jnj30q?#bLxOZ(R_H`G=% z#N1FzaG<%NmS(fL!5gXeNVCpV=g_hbHK#Ec11LV~q0USaC7_?o+`v;HF*4XJ)7=Gs z6@h;08oJBe&`@TFxuKzCqq(8391go$bAw@Pl(;xQyM;O)+TgOW0gr^pP-|*PQKJ82 z;`K<{e-5?(4`ga6TNSx^=W zQ6U^6Qoz?x1IwiO&YJ_)hy>g3YiP7@Q7R}D?k9s9E{L=b%^_172WluK3_3nJet}JIdulo! zb0@IE*e|kCis-IoOcpx%N%qM(HIw4DH?yl5qR&tbCw3mdX!#I)O#xCOuCv6;+_#<> zAdB(tuL-XsGsMDHq&LXIRwPBI>wYY3CAvc`Y(;WiHQ~k5-7Rdz@kdGXX9X z5%wJat=k^XD;A|4owF!xe53UNKb= z2D`%y2Gy%sI0TuLA@{5<>z9pY00+jy*b0o1U^AIU%lUjg!ap1(X-J;1pmkJh_NCntVN42R-7~?|*!*-rM;W9k_ zxf)Y!@@kv~9rIA-N62QU#%OU4j^=wRHYq#CUkRb$X%!BK3PCc@g6Cp8|9~uPYg#cyW)>S*wV-1y9vF`vV z&jmJ_PDpwcWUZG-sHA)aX`baO7uZ^UY@4xeAyt?cnYNoy7BSs3^gsi1yP@U!g#Q(I zPXZv!Mj#Qzgafgn{eeVMm>t(Dbk`hNC)_VwgrygF3e1i8q71Q?piXYWa^T_6N90pRkK&4>|N&y^cE!()$E zkb_x0(A4*j0AnG9A?&MAy|C>oTM-91b@Np*9*vRbYc=)^*VB=U${teK8B*A#F*v0J z)X`|3B%|Q&P?4rd`Qrr!{2*X+RyP6vQYn1~1%$s+z5~X{{r!A4QT~X`(s**P5Klk{ zxwa-V8liu|I>GVN6@4%pS7}VsGkM&4h0@l@WA{67QDss8=+9=#iv#88^V;o0Jk0_%i>ag4LNDKR^C54NT&W( z>>et~=eg=wGjs(e-_7-G_5Kk}<1;3dC=Mw5u?}cR+fY7hRsM4Y!Va)f zHenno{`(mra>a=F1KP@D26nkscq^13zVvUvK|zd=LO`RV5)W91ghaeav=xA-EaWrA2n#Z^&K@njW(dXd?w=e{>a=9B*yPC7-7{j}qh-fRPz*{%HQ;Lno*@0&gZ}6tD34fZ3 z{r;4u5D-Pm?`Vzig*)O?{5xg2p~X0*)pDoAGkCDzpbW%YiRt}BcqCU|l)iD<;xwS%?z>&+75vm^*8KCsdnmRJXE zWDRsx);=r-G!K)2Z6Qu3I9p@XiG6bolse2tI_i+KW&XoTLfhuIG_RtkoD!NjUmhGB z&??V3=zulwEnAMbM3Yy!f>RdDVUE$K{;~}OY_$SfJ!f-bGFpmk>0tQzj`4oxW5I&I z)4>20uopn?m1~^(X!&NgVP5Jisu^52h4_HMXOnV=y^B`X`x#$sa76;l+3W&f4CyN5 z(}a}I3z}CnYBpyq1HeAq1gI%AE;HJO*r&7!qMcBdv$oRq${8V@W!5}th4G1+U=O2J zg%Q4{zm@oUGo`d+;Qj;y6M?B1)2G~;5L?jNFU%P>Pl5@fRx;QxaODiGSdg}h=%m-a z!W7*S(=zsFEjhiN0Bv3gz@aoBe6an}jIuA!sGHcLaB88e)sqOfP}8%*&~(+vH(X73 zLetjt*o=ISS5*{33dgGQ$2;t#2j~T)2F>$aacDyPcorTiPnWYf_V2%-yVyz>i+GA2 z{?TVopI`)|gCI^neLV^NC1&}^Uy{%_Qyb0CSE_K)m~=t|2G2?K-#;tFCK0W^5rvyJm*~JVhD4 zvq9CDA-#8~uyS|Eh6a?yy&*wLY(PmPmA!83hNt>ok_48i0{S}CfzBKGx~KcD(-Q5y zlq6o)+(Aj=vlgdIK-h-Ht%sr4mQiIzjd1r{s6TZVCyvC6AHs!yk0YTD@?Cz{hZp7Y zy?9aMt*v22Qgvz$V$V`m%&HorB1i$xd=eBW^-K$n+*Y{Am|XXiCX|sBnpxJ5sxp&d zzW*InnVOWIydmWac3w};_!8a$%V4reGanSRm(r^~D?lpVYXR_|&)J--gcmCZn{))7{pexNgTygPWKU(R62%zhPCM}5oX-iRC zw>e+}Kwh}l45W>zJ^r;en)Ck&!0rvrL#`Urg~w33-d^FpH#_oYbf=E|F)U&?{wkP5 zq;0qM8p;>fVMResqG6^E7n;Hj3UbZ%aHz+&9t4){nNCE>TnyJTHPf^$JBq+rw#819 zTpkEx-^7|kmKUU4aS|=DJV!T>@(ejBpgqSLF}xrlzN^XuP>OqYs3w*k$4R6GhGhoO z#9LbE*|4aXs-6Uz>C#fF$OA8Zz-lW`p>w_U3FS7E36N$&3$4h75DKzS>+UpZ&(rbOy}Kzk0GQOVE{XN805C&8wT&)xYr7!T4vXe7h z`_=jm_wIug-l3afT7{QJiz96Ng32V4))SHIfjcag%G^B-E^z_}%Io=^G;_8Y>Va)T z53KqyjCgvOxCs6?k^Lm}d?WN-S92p6H<&bkFoSMpF};&;3X5vtQ_{u4VGnu%e|g3A zK(~}kec_W{iLUzb^|q~*BpyX ziLQkdT|wfgUZjOKl<+FJMkd;aF;u+DhTDeRwoMOT zeL*!ba6?w~%v! zS!N84a2OfBf!!hW;gA4Ti-WwD5ri#YL%spmw-eHtWqXASC!WNQLdv`q*-l8?hLv~` zKa`-!2g-O)mUmR9(mB{VrKYy96<#+chVDFy6873c>ez0 zY6cBKrgCr2Gl#nsZml-5mk9~*!;Np6SLFRv-s1B&eKz>Kbg%7QG_yCjWv93#L zANVRsYZ@j9c1xq7d~rRH3qAa@4jI}N%aA1RWBv+5 zJd&Y&YICw|uQ?4dVXIq8JLiz4K}NXwcryJ;3toOa{pp9VwV!@C2C~if1|X`Cc8+p?QP%LH^S2zAav*FcjSmw6B6Srics1ZalNZ^=XV8a8o) zEra|(IS-^zhqOw(p=lGVxHxM9Q0)8LqYvM!C(nPR)3}LC^sTPHqJjZ{VtI>OEfzGj z6Ns3YgRD?S08&_KUDd`&6bYaZQn!(l#yJf=frPX8gf5f@1vH4}>@Sodqc}8(K@g%l z1;&NBRd*Q|RsaRzqJX&YE+u)1Pvc=B3!?p7gB9LvPcV|EibLxgvXznC*d|*U`-bPD zJomAgb8quBw5jxf#rPvombpo$sE^1A0C&+Wf+~YJ8I)t}XZZ0>pb}iecThB`cjm2Z zs4Hh?cJc^8n60FnNqj5N40fyxwu;7WE1;EDsiAr4wXA@yH$**;`r}ug-D`Vi1=-=j z#whIqogCPbhK`OPGgcj6^>AT}RODFKeAQ0E2tMDj4jsD|C(zw$5ggL#)=*B$l@9(P z+`!q`Qj{zIn>+J%ApLN@?Fiu$3;p4I142OK0X`V6P7L)wXZ- zh>+Ppxe+H*R|zLm*UsQRqUl@A0P0B7N2+tCYljy8XEvqf0@fyycd7IVHsEw>@mCQi zb9-}lp=ItYxdStEXZc3t%5#}9h_2faSv6ARi#QpgWfK`>Q0$Q0<3LVgc)AN2a; z2faSzzp-Q?z(rN|8XCCDWKy6^T4x|s41^aK7Qcx&gg(9SIG|~_@LJ>1u2am^!kA5X<+pSy*@=Qi)2FE2TE8J zZe}GGZB-il{h-$;6kU<`>sQh1_e(;xea^FJ4GNbgO#%4`m-1S*ntn!z!r?%NZP7J^ zO5WW&@8f){Pl=LDM27f%(#^v!(CSKxlFC4IZ9g*>qxlWh?4dWj7BM`z@fcl7<;cBN zl6HmCvVgj9Puc@{L8^Vw%GPvMCvT5myvAlk!L~Q?IR#)Ms+Q2cMbHzE!^#rPu%B{z zs@@5!xb;rV#L&DqFo#NcZxFT&p-jqqL!rDJe>=~6RlS)ONQQ!i>7M+9~~rI7trI4?Ejij$wk|MSpL zP|YI8AuP~7-ZB2aTBA7639d(q`zMIMwsHU86Zbb84Yt%f)~H$n(%&vXZZFz0&cA^` z=lK2_T0-Wap2)L9ClqBW%%*NjWdCy(GFkSH5EY485o{yRiHPcdbANPpg{b~l6mr$H z)YYx~oLK8OUlK15wb85Qz`-cOdo zoaE5h{)|#r6KGbDiR+kV9zoG*jzuiTu<(AVC1FhYE6%fEj#OBAGcdm2@D44jF#$Hu zZe5P=f0V;ZooUi1QpA7bCj|_EM=E8?()7fN9NP``$T2kll>@sk_FMxZ7qWu^KHVoT zEMcS)qOJH%=;=R`fWgpYFjD+-gJ{C?3my!_zUB^_{DaIJRZ#AY6p+nYcA92ql<+!7 zM@pBk=GDb7j=Ko6%VL@GAi_ej&+l0LibXZ`B%B>L`5iI8SoNftU8W-2b0aJxQ#B3X z>}m-BuQVsJfwbru0EV-5C(wL{Kz7Rr0O5Q-kGIDEcOYCo2^nEjNWzI@+BQMR7G)E0 z4u|leok1rbC$Ya{ zFQqs1%;RLb9(cS|_tTD-+s{!a+R*)+qjr-*hWN_>8YdEr=ya=Xit~rSNpb!!2u@0h z^UpSH@Shys&l@Md-5Jx*iac;VMf3B~%QgxcTZH_wG+xd7J(rv1;tyQEn526@clu<$ zetd-fxwyW?=~U2W6aw}i{oDWbfBt{}`~Us_{+Ivf-~NyP{BM8zuWU&!uR1`*^C6da zgw_%JrJ^_v5$cZ?v<=fQmmloIS0=cxfc!Gu&QbVf0)1Wd%5+i@R2*D=;_b^MvwK-~ zA8Fp&xIkZ~k`?Y3SzjhMB%HoXt7{B>xjeb%1k=6_c6HQxN6Xg{>*q>WN2z~Ye3@Ey ztLYUCU#8aIQ?5*jq+T9Bk6lZSRqwOp}LF?s4rn_t%ZQ+X6udPGe*vgGW>juZ9mudD1 zL@(3WPxN`2YCqSsG8I0t@>*dA`971$3d)o+EnF-0Qn_V$X_;ohTdYqj3k3EQMqY0E zkl67ut$_jKWpcZ`$uw=Gxo4VjsH=yXQKw8sl(_s2Q#iAnZxI8FEoq8%_t0dYV4F*) z3x5@(#7k|YI}vU8tINE=6Ff^@zz*v_-w_X9U#Kw%yi^2Dl03vN*XzX!-4JSAagm$M z^P9?;dNH|&-OY7Ok22?Ehpq6kf)|7cik2RU<6UU4<+$(^lZ+lAXVwQ~Yll*Nz1+lT z9-ig9g7olqay5}ZTKE?+N~NUuWhX>VY+(KVI)UMz=t2bZBT`Ev3HL}pAPwTM2RlM?6=f1MU-bYV!t&{u%rlxvYxN1=W8a{A$?x7PhnXRuGgyv^@x zdyQ2WD`KnqIf3390RCnK^x7o$LpxFv4<-}OGZGWoscoc#v;Bnh#%1-hpp93|JpN#a z6(iDL5nZA%L@Sk%8l;ZSsO(Q8os*QLVA4}S&xHK-_daEI*l|j81ztv}tA;8o*j+W9 z6&08K|AB^BSwSuP-blO5i!u=H$D{kF+VR;N>*VZB3k7x7U0EZwQ%5aIJ!}mkYFdoQ z!`6_>D$SlOa(LLo))05MT{Ua5v(+ebbvs3Ndl=fTG>iQCFlh1$925Q^fm9O zR5L_nUPEr6*1U#dqvBk1N2)o}^)n4xbM;WSwU2#sy+Fbes z8)B{pFDlNf&D^Cs-&$ga`h07-Mh$wk6#6qniS8oMC_k}<#vB1$WhFYrbosN34HVtb zA-|+l*Rm2l*O&hqI&@UNCva70<1=v8e{>x>dR@SKl}sCt4)HRI6Mr*ZpQo{chX^BN z$$}~9vtL|zb$MmJ`R(Gtw-BH}Ff@wo`E8?vYe=Qy0VgJ8kbTh0o$b-eQs}_|`s`Ff z-y6serY?pd7sb#8dPqUp)!6-##%ik+Uub&I`0kn+%&so2BL?;m*Uk5){e^XZs*7%Y zupTjI+icEzJ2aOlJXnu}VZ6k;57whN-RU?A2u{b!&P}#=e==L+|H$tg`m^)vIl_@) zI8Qae*+z+w2nk$4Qy~^f;0m^9TPEBMD)kZ8%0cL&y z41mK&D~57^Px@7qF2gGn-}Z_5EmCNTxJrFBXi26Q?G$v`GN{Sb7<<*$RKukqO??)m zy2fu-@o~H!9mlt;i{*T?SdC5*Y`q%Y80cmTrBq8=SUnOD1Kk^#e}t{OmTT#b4GD|; zn$TL9tk#oRh^)-a`vgy*9>f%ol5kA1a;tGFd_gS6PrUMVGmca%HVg+C`iA2;wh`;_ zTM2y^AQ^sa2fAk_6p$Unuqd!#^3b;2Fww#QAI7Q`Al5SqT~||8BaE$3R}DKbZ3@uK zR_?n`k9ZQ^4i);F_2rzUnXe8%Xvbh00RKEPLse64FA5UX_1rkpqreVa11<6lH+Bs_ z^b!Y6eR4qsXv#^-yN*{YeoJ_>h!7;N{HOl}nqmZn*UaALQRueDt^5DW&ouR$02cw# zn%z0RfBAyPP(9L2+fyCOb`1)+O?mcfL@CtrEJ7;rp(k-IKna$Ua57&_rZ+xMqFiR( znos)hZw;AVOf33PVPjoYEzL9ui6&h~A1D6oZsKXCHeO7^D?ggw#2BR(lU-Y~$f9I+ zqa^5QFdKttu^q7Kj$k%KjUIh?qaWWh1ckJva`WV1w(_7A`mxhzpj;Y#C&5sRV6mwp zuoXeA_ZRoaAFgikdD9GS4{Q|`3_P+cT8mj2*x6nYVum3^=$y6C87^6>^UITSbmd>Nq zYH~4)0b@C6b&fMS{et%znmWY4p@D2yKZgcV!~7j~5bo{wu!C+t|A!q!`};vO5YCi} zy&?e{2n&NpcfW`RqIC54jt^|0JIqg_f$%VYiQR;Iq{VF@n%;~1`cE`a9_mNYK$;p& zTC7}&pBhWLL>M;EPtS_FYJ_9N!0la->E~b3&~&tUa0p@p`9A&@4dnLYchOKmKmUsc zf_!Pn3y+z81}=wz{umAI-IHHNLk+)%e?~)fL;N%v$PV<^XrSEax1nnz75{_Zh6H=J zVS2zUno;vcD!F%@QADJbI%SmnHjrJ{8EMFzs~_Tj26O*t@Y~ql++F?~J4^2HGp7wsM0VQv4-@%F{b-dER~mzD zDRCKmvaJ2xlLg1cjP0`E=(b~c7G_VFaH9F_VrAH5{V6MfrB{8Fzf$ogmEu;*P1@9o z&e!(H2%!RuJXNHMipCL;)#D|4(&D06E>u+XR%|gQAOSPWi?Aegu*F1b>^m<0X=%P6 z8EUMlW?~yoq(w;>nU)cnn&yW(8lTx>BE!&)*z*9Cm^gOqX>sWKmZl*wweA8(EisZL zOcKHcPGwFYWeQtNhYBmU7%?^=EDSM8sD`jR*sjBu4F~+3$=UwdQs;=v3SWANa?pGVYHv3cF_r=t|Lw*2mT$Nt+VLz#OFZN5D zT46sx__?NLTRA#8(lvqaW~*C&F}@*xFm$E`2Ud&i;6WQE@@_oHcG}b$>cCbQMp|gu zk!|~C5NeSgV@1O_2D_bYd!FMUf}1Rx83$@%9NKXhn3m>hkq<+%6*w;JrU{rAK)A8( zs~XIuC{yLY4i#27@Y$t5hpB(Ayv5-O>Vge5$M#~~P!q>>E$j%E5d>;%CfHW2IMyNn z^+tZ622WttJ4hz0%OV#(-K^)xsTD^G7l;_!F>xtlNBe-b7B5Ygz)a2^n6Waa89TNf zjb7}?qMn6a&Os0_Z0G=(7px>T3xnB>o5=PsE)wX)Poh;|sH!E`B*%hm^B}u$tu5EE zOjWa0>G*ycTw<2vs}ab1piw@<%kR7Ootw$ZGl){Pj*iEQ4sc+FrfdXA>UWkamT>Evb>PojBxbsd z?39RY(+N#Ok2KqbK&RWP<-ju~wsp?|zZyyCS&^+#nd&Lgp~A{3kqsLtixa}MR0w5` zqZ@FVaRJyKxh6W}__mSwUSb+nU;>*Ye6m1Jl!M@6bKr*u@U_AC=58~|WJbG6q=50( zb6C1iK@ZU^Yv0!8ksS}MhoRT;P~C7X$#v!#k}<90+6~vS9TyiSJ7-;ZIxQ#ua?W$G zl(*aB+dk}Dq|l3jMWbsNm~sl?2AFNNQf=ewyHNu7{n2e4tR~1T(u#AN2ozbCxvOyv z0R9wNhL~Y~vYs#RP#q31fj3E>#>dZKE9 zLuo1!Jwb*F4e2Vh80h{qztwHHLxq)X_-J|X7Z4RYaI8lrn&=~ufZ>EOJkesLC5uc` z^Hg~FBDoWMGI5vQ=CerN9U#|ZzZJ8S?W(PNwWnRxAc1C=IOJG{g9rKR@XTDE7fitOekEfg(Q>}tR=C7>r6Cd2-j(z z7DRyu1(oY-K5oQ%V%oj|cVHvX0%)4RhK3y%uE@Toxe>HLng$Wcii{|NKc*J=f$#f9 z>;wURX$e~xRj%t$VTJ3mk&;-?v|=1@P#l^rL>v#Qwj_x4B#zCH?)Q*iNvD=X+gQ(E zMRb?%!FpM1>gFxu$JYJb6F*vQoccA*)?6@T&W~J=I+{-4*s{DE1#{BqltrD|kNR+E zEumhlDtc03Rb4k-6At9rsaLF%REOkY(Skqg3hv-a3m3mGT)8ql^&?u7-bi92j^Vx? znwG6=dSHf@5vlOu4^2OY7rY5+F9g;g$+Ou}7zb{oseWQOstYBTZuv11?j)XS+OZuO zmSy<5hMNM)RGG3vg%zfJ&NT1&ACXrB$KPi{%{NG;mza9m_$>QfZ*!j)edZ z*ML-%??0#hBs%h;Mws95c`L}&#kbvh&J|ik3cdO*8eQ3Hc-~fbW?T0xt>^-7?H5hz(W8VP)Gv zOwvg8yy;M3<-DO0Qqnadju{Aj5cjkw3PUS)eKb3WqgYLh0C|DK2-is8GtsgqVm=N& z-rX1VU++%+wW8|GQc0FcMYWi%(o()VQl7my`&r?EWs!0nM-yK`keRO}lPTlt9_LK$ zL}w>W>jCO@(p2|tyUi^QF=(dc$Tk-L8qOb-)VwMyhSIw}>?)V<$F97!6?WBZT<>sk z$+$JEX?zOLn2A4qj;TG3fn?BX!`@ze7uOE-FNmQeaf}2uLDxtkEeUiDhCxd=q0J60 zO-)?Ku^hV~B_e{*(~Q`Nz!o~_)xUC!ia{h z!?dKE`MH@_HvZ-tI4PY>M$f-$$A$GpcW@xZwRbx=W$yytG!r!nq9`$JJ@V{;V#{>{ z`V`>5BRj4aKriB&g;UdjhQx%n1=lwyNDRxiqr{2eY@mBCbd^vYMi!2$dj9KBVTJ$l z@xgcs{xieKL3}qa&ODmj zAbdX^fx>+zf76F2^U}Q-QZ%%NA)#)tu`IKrF|BDF%-eeS6iV!3zXq`toXKxF_~$mT zgV?id11b*>X{eziu@M1oxv&7Z#8#0S08YU$jF?25Ol(aeRZBw03rQh@T-IKMB-g&` z#BQvHwh@`oeTGR`&ww2&tT5npwipEW!9HMFP?wsK8(6U2I)-CoXV84tffhD|?2OZ0 z_3S5q{cH8;d;Q|+^CPn05?Z+PfI?899r# zQCYSkwTnGr0`GP@G9b82i|Iz8m5`6Cs{&vIf}WwPE}UB7RpBJ26Pg6|Vpn5yn+^eV$H;!dqS7TaFaAuUXCbx%Fu5iJzT< z6@5B=9shL`uhz9b7KZ0)&^Aa{Ns8Th2dl%+H4IJf@VE~b%Vc};uV`tNe_`77Ow-Np zk+0wwF+1{Sgx3`LV*o$h_^V*nv zU-H2x_sBstr$~%C2|x^N&IF_oxmu!5IakWZlj&Dl@bcs7Pd|LE{q)1JdVKc1aeN=% zA3gt(+&r4$3%2*1)jwv{141h)1&Hw@fNA}AlQt5nPazU~uHaxoQJham9N4ZX({O*TK&(-&as5}K7`TSh z)xrDO``L*8^M1zde325|DewL`xxP?V%kazh*z$R5Mfj6Ou+QGkrgJ}HJc-nlm!s9q z#rsFfjXwp@2fhYhBTnJ{qw&8ej~{2d)8ofKe6_~ zXS$3tX)cZ+TELiji%b~h7aY2Vea*v*S!f!aF1Y8wp%%FjNm!D^hBrv$`1Rzcx3_o4 zXFuMboc(AVpS>XW`e8B)uYG)ooo#-5PCgabdRa=%!{6#EEiP1%Ub^Z&QqoW01WkB_ zk6=o|e^DmIzRnKeijV3q7^y5)T#RJ2^b@4yEP{Uy6dS08D~YwyxDpQOJ}Y2Yr{x;< zQUP6u$`};l*}w`i$%<`%X%|SWf-KYuSEylQ6=cR87>xV&Km>zrl5j5T#57^pPcPD) znYb+G<#k|z5GUFW!uUKJmM57HU)-Hsd3QhQUvK;$7MIb>=}qwAN8{-1M-4nls<1vX z-)1Z-8zA)+I?#NHD16#U=F3a=7x*ePhDdu7u|cAqL}!0;o=kM8kSEdVD&a{*yNh>H z;r+;V62Yy4-HDW>6+BfZ;ZaXSNTcq+o@BWOG~oqaEvF>~j^~ki{QQlH^rTW+(y*X@ zkikZ!wiZ9y2{f9QeArG{+VIkCpP9+V`6xYXCrdi%gap59wB(d#YE9+)LvWkIZc^mL{G%pP_KXdQ22g()|j$r zq#x_cSOJ7%q|6iL8VCWC#WY3{e~r83H5FPaxG^BgdUo*zf)3*qL^SsIwLkMg7vz>o z{1GK!MaC~&@s`RY!i`P&_rLwG|5d>P0gbCnux@c@kk&_7+#cIvnATJ1j9Q9Am}%;He=O21t<0{Xy>Ljk5Eb}cbPChW zfkTH5=z2~B6lKuR0W@VY)Xr`>TDSCEqLR~Wou{>#Xb;TMEd;q0IbWGrS*hZ$m1biL zRa&2A%3YK(TgVC$GTb9KouzLEtbufoud70UgASlBNc6)O-98+Hu|>C#?t?43h17m9 zMYj+a)&SaG_zVu1Bu+qHTueDSfFdg|6U=052%V0Kqvg`m}`jQrFLM2HkNI~39T=QcIFtN+1)@*5)EJKH~heG(k_@3P@;!~DzjB52)=bYIEIvG7laiU<2%Co`d`-}AO zc5*e5KUyGN6iTIL8M;cY1gI&+_wOn7D}hL6D54_wE7D}5KdA-k=+zm5XG4JLu|Zoz z9~sKgBRt1PjknsAFw%f=f|6-1glTR1;itFO{ZD5vSf~^0;iE(9TOq+KwNT7MIxS5( zUISQ6Nku8l7)2{d?r~CU%80_)H{l6F_?B+$BwB*-6JXnEDkAscx{Kfw1CHqA)mb)W z6zjnU%&@2f8bqf=SF(y!q&RwYcXSr&N4rxT8C%>|He)o1RWQJWQE7OyR;KcKCsRhT zbbtM0Egc*npT=|Ob(ZHeJG4p@}&aQ4x&c0Vqo?mkADEPlAt)KM%A(hu9sL<;;F*K&2XRnb(;r_=c@wu~OTLss@-yP4cGWW^m9 zkJ{OI*lzskiqiFVIdK1Dn?hQL5)`+$Qm45r+$ednv#81SkV~6iJR*}u^A50+)L^T~ z_Rd1xHH9EMC)|-G)M@fh5^tDgV_@?;TSpq2+t)(UKr+>!3E7~Jm85}sKTAmi!GYG2 z2FgP$CJkh}T1^^AK_M`}ae=nYg%2UDz)M9yNlDtYBvQJ2MW! zzhWT$^sK0>Mwm(l)*#6Av$!;jI@&zg>e4{IkL9I-+R527-KP$P2Hv z6{dmeKub&mE{JwpnL*VmOyR!3Lb}QuwQAo!Q>pT^5?1C3je9c9w6n)NC(}{_e$EliLV{ zk%V$vWNF^ETWV7K%CBXrf$D!xmKsp{hceWlJq0@reoJPWEEuT*ollwNfW9-kf^iF( z!QyE`|Gwn*m@TfjJMZ9ZBc?d)RGm^o63mpEE1UEJL@1@hj*J>YB{$)nZA+yR-Z&wf z?2|4N*H{1%dS42&+Cx2JY#XZCTP@n{vifm zIzPBMqc})HK{?ELS){qucDX$UUu>W((QD-_AZY~Q3J8&(!AK61d@LW|;Qoc;vx5`oBEz|Dvw%pU5rk#)&*Qx9b4P;hmM$_zBl@bbkC z&NaRdQm8Wrz60nVaZ~E!U4zww z)QKiAPBOFc`gSy#jXtc#YnUio;`5Zs(1iGR1ZqIzmSOS`Gb7s~oqS#As|WyZA@QH5 zN@=J>{g{AmBTR-sbd>j)Ci?~exA5Uu7ItFxaJ6-CowPj|+$umK1M%9qu1pn>Pw@W9 z*VT*7;&SP)CJ3~r{j_FjRln%gcfOTWsq`8H(Shm$vs{37YPb@mZVB*xh~m+5HU7ZS zkxOH}DA>}ugj+1~E3Yn1^K8rTq^S_q_gh_3>0To%+Ecr_TnU_-gN@W~TP9*<4d7Si z%PYK?_%rBX)|7{@ylE9)_E}T~0=;@IT3lUEI>Gz`s3TiYd1d3baR8r4+>%(D*cK~m zOWEQQEBWi;r%1HM4PzKVjwV&PaMIDWVosWS&DB*M2!HDtN06vp5#UGz z+kUy>Auc^p@_JG=Xf#V<`a3r%>I_Sl?#MDj{jK@-C>Q zAT?=R)}9J6uXpog;({1D&ZXGBQ01gRv)R36SJ!EBA;CB}m|Z|qgIQ!(+Bf#;56Ab> z+cyC714_vABlYC$in-ryt^@e@9b!Jgk0}`4pXc){>`DqJ!aOqR$RllM!0BzmU;T$o8WjVNP}&IsF% z9j3~qPk0P5VD2({1i}|#wx=*1P5)>bx)^2?OM@Zdf z2z}YZtmCSS1dgaR>o|8~EKci-k4Q4E`0F*nL;z?4qd@2qbkqKsE15~k>9dbX#bczCbF62H% zJunaK1M~d-^8M@;hum1t6>=2>(BTK1kq2a_J2>*!mj}R;{0#c319mQdk^KccL!>oY zU(Ta1lwh+4kjL~6r}heP8`;VI1;7+JRa$^EtiD+^jlYHd<2z(zLNL{5pC3>Ygb)zT zV@%O}4M>pnW;p})Nz`s{PiTww!X?Ld%Y+V)jSfW8Lq$Y;FbmEtSN=0h+fCPN)Tug6nl7a1o|-mH-b zas$1-0`Cz2dX;y9ed?!_Io=8To|sSUDZC@pa=5z^O3La0iw~TKpWyfNn~8tU)tcu3 zq~)s%qISBxNCxW7XsI|YR_YizjZ6m<@NizK@Q!rw5`DdCY!m%V5fUbre_R~2X@ zlQ~73i@Oq`(M|6|<1f?ib#EQK{mUkL9%@JT-&@CL7k9@`za-J`L5OTzI%UZslRYtX zS#(A7RMwMt5F&BPY_X!3N9>DCeWFk;t1KzU_9eWGea+g{Ir>RyDn7 zSG^+DK*Q22!1fGd$Y<$VD!KPSDNktz&ipy@ErypO)nOsqO5tU zbA~`;&q4xZy1M|ZpwN{u>cwa@?xOrO%Nxkb(8|f}KICu4;WEUAVqrgR4JS6h-W8_4K2CXqG8yDajeN3hB}k?0_-YU)iRs&R?09B^ zRC<)|$VRYr5QQj1=Q{KCcn9Agh7sMN!b;W@$nqC!HjW}&3NkwThLIR*U?P{F7rB~d z#-6GteuU&$f$E!{9wXFyTRL_KQ*?JjOY_7=t)rTXGbOyN$E|y~r%Wg=31Pd~4EYT; z6PYw}HuE7auH)4e?|XsCq*r}dOe)@s!9-iD42DFnu7Si=8H0(c#^1a+JNQ6A+buY( zTxb`Ip}HZ7iI80qYK96F>DLj`&=Uq^pJ9%WGog2b{J{8gFLy& zNEDh#{h}wTs`{RlXsYLh;QYvQXoIa`vGx^KSnTw2a~V&RfA!(A?E}Fg&)%m-FyNWU z*%!pRrG>Z*havLzMJi>xRXybLM2;mpvbM2W5aTkvWEZe66r?V~MTv}MJl+)b^kBf! zMCKgWb^!Lpft2(#<-i7uAu@~_Ob;YZx{DFC)QMl0&sKWXhXtkLy;v}9YLx?#auUuO zQqDe6(-^KD(R?{tK(fJTv|z*9l0{w=Rzj8sv%ih-QQ9cxt-Tb6Mv@2m_)Q2k*CP!X zid6?WZdoqWojWkOG`Mp5@%5cHHApd9wiRbD`b>RRxYxv+X)7x;&$7;|z)Q*YUS84o zXb$zwj0^dkt?8X6-GTM|G%tbm? zKSHWC7ea%P*erEZwi{cKY6QNcslJV5$BAVITI@LhlyNOU%0@=wqKp#~j!eyN+`huf zZhUq(Wtwv#?jVC>;zCe!VjLk68WXw5Tn9z9VIjvIWS_`&Z6sE2nL(BBRSHk;cyP^f zPQWh)U|yNBd%#TQ+i}|w*w=R4CV#383%3m+Hy4PWt}c;4^ls1wZTY=-DSDuf{6i`1~ZOq-Sa(hq$ee7Y!Hw%)l^l-#Qj-FNJtcq|JJ2l&ENFl!@P7a z4ipWo;Xv}FvhCcHDy?b!;`BR1KO$iAQ=T2_)d}Xc#rE1npvaLuq$MU;6)j(PS0)qzw)=^;P0s7qy8EO1wFoAt+dB^P-F$DXSLYAJ?$gx^4ajX7Z!4*^a z>f0Azus_~@`}Fv;qwmkocw#W1rOcHTfG}dhZogKbK?4*!%x$m*!Qe)C?y#%*Q{`(o zbzCZ+oqqS~>#t8gKTuw+(I%8l8$$+{1x#!(yhikF4G{$97-plq*Z^vSnePZvKJk&0 zD{T_9oDj6)uOJS3k^|vZy_ZdD6(qOJ*E-*zMr5^Qhkp6|DZlTt?#ncKt$xw;%Ie3Z zRE6!{&F|+QL;tU1`bWF9o_}6k*;OeJrsW}Ljhgtj8v3SV1W^FV%>W7@^j}({8F1@# z4G(#}p<61by>REn#XC%NKL|r3c0J@a!#6f=>PQqE;9g|JA+l-Lo;4jRteiFFNfSp+ zVCn&UP)$Ed?9d9$Kt)sVOm%%NL~Efr2twOeTS|j(77-LeuyrC2U<_%HSft0LJe$Mp zv}xVce+Z@m?&4#5}C66_%qU*938y zvz(}EjCL+A|2iF!O@4GW39neJz(_n^A+%+7F$(7MmLg#v!bLXb2UHRxDcUj~Tk1zj zHBJsQFm;nN&wv~LOX}?R-?EgG?C%MFoU$$|U&GXnB<{;A_*LaAt zg5|ND$8a%(i@`D*IBA5GXoF*F4x>8@;hU`Qe$@j+(kE>_Kr~!hp#hYZ@AZ5_!9UfT zOZEbD&x0|@9{vblHp(B|V3HN?wQxl%D+^b%P2`1i$m1owtMH1(PdDrN%O%{5b~TTi zODd&`ORjoy3^bT{Vc_^lg00_(aZz#I&~kknCkd|PhL$7&l(f2Q(kYPLQdEn~6OnHD zj%hl+5vqn~_?l%qz8*yu%oGW3F($=2@x7irg@nPRLxq)-Bbz&MWF)>9LJO&*QmQb7 z1_7DnRUL`NUB}lvs5D|XN&F}C&3X#ImTGGGr;x13rUR)f^6yvz)D;ufE+)%qvYbE* zsQ9-&BXR;0~H2k3O_8-{3=tb5iovW)8*>czZmgX?KpNfnIa3bQ$vJ7XJI0Y`P(d-XikzmwgsVfqK97k+!(HK46E!_NV7jXnAER z*N%9@8xI-2i`N$|u7k=}t_@TL8)1wT#jtiGTX5th*vFBoRP%gT#9?m3zp<^8SdWRx zwsPHzeBXsh+16qcCOtJy=thtrVkV3OsNZlQaP*ii4!lqDR^Fk)%2xi2?YbZ3#Gyns9S?ZhzYqEtRK z<#&C~Ou2l&BQtGo^~i+1Nwrj{ z0B5g|oqSL=MDS%v0y_>27-V!iaGl7|VDzA=$apb`p+yTlBY^ouvvfq7Xi!DLlA}jn zl)%oa+FpP^QKouKcBrtzi`meCvN$P|I95H}*4!9z&V~mk8gu|~2L=>*I!^z{2l@mQ zcP&rK-{4SHur+zMYT3{g+U@~AHBn`c8&B5abO~gqWb0wr7b~_oC3P6fRhDB%2(VYa zc70dpMV7tj!-QGkUK}V|S;v8hbGNM=nuAv~p3H7yvV4;(U<(ecl-j|8BqjIfKnR$z z?SMBpBK!#^QL?V|;Is0SWqj7UvwPw*U2=e&XSK={+QJpy;o zD6-=~gn{O|MCiRml1#3ZXpVN_x87#LAlDvppqW(O#zD{ntt+7&g&`QW3rub^8d4Xs z@Z#pkv$n0pICDq>$24ryrlX+{w3R442w@9Z z!LN(?3^B8t3m(z8jIZa2p#?I*0-y!q)x{FY>1fwxu84@w6KCo-uK}?EyL;L+cw>51 zu!Ibwz&v?=b$|T)iq7vQ-fh4rNGlkScT8$>^R!4GW?^E@%);#uqFjH3f)WKB_PrDS zWTXb+6J%8O2Tzcb9EwhmQR*63mK9`djWx;nwbLB)B154Gq?QaoCioemTMDtc_jqpz zU$D2sU!|Jh6OxVtVW$p>x)|TagT(;&3{)OQW)I=szxj>wJV#lgIBWhhh?TqfW=VcF zh+@9}6TLZtodZTxa@e7uIP%>=5p$+g;;6tZO)~p#n#_aX;NyJ{S;hY315s<0ib7e8zAh>MB zK75t15BN(2jiaIbHG;z7g2dWE)?x&X`zu7DqeHyDct!xMyy=Xd++sFHY2Dc8$(X#P zf#6p|RtPC6$Upi|j~~;=f4p4&3;mn^|M>BDynz%2zlO(E9Py7}qMl6SBY%c~_vJf6 zXM~Rw{r$6YqaJ7nCY8oVfG`Cn7GX1RLhmRw9e={UR1a+aB_<04qP%3TUC-y?hR$i` zBlYf@y}FYTARH0iuZ+Bg#Prv73TznhD{ z*n9Ip;}n?;_{}`{GklNd%e!}_-}qQN&{SUk}iI)YVTo78MK-j`J3`nm;tPlV~jFA}f>;zy{Yw?kW-(A{YxwgXCgCWPf6DMscWA zEC_WKibc8ZGO;MRACXv4+loc~W;<5bR#BC~EO0S2wI5f-S?L?DGAtqFpS(SO@fzzk z!&$hUZ>AA>qfX%vKAl`K|GQNT^qvGFp8~XN;O}HoAe@d8oToy5BAJgw%vpRZjvGSc zxrW0!m)u4~V|B^u;8;KkU@cb@2zbo1uNhQ_)Jq-V9LiCHWD7xeGpqD;`a1sW20G~1 z1blt_jB8L{)B$E&mg?A=6v}-KK%~1DufGF5$Q}iqp!BMbQcx=1w0UmDhe(@RQ3~n+ zFosqz*9k)Exn4|SxP@kap*Jlw@!986!JXQ_^k{8)T-Q`FCS>;&Qz4U{Ym9y(xW_e_ zuz**{?!YD!|EAewkPR>vA%Y1?dwwEjMT!U4EA?dhl@`4Gc>2>1Uu!@8aIC(${)_Iv z{fm*q6TQ)no?j3=k$S}8i2(YZoL?dV1iU(*JW&7_=6>NQzlS*Uh2|-E!dI(uGsg{O zxtSf$Z$JC|{Y-hke!m`%(?6hmI!J&d|Jg;nK8D9EaIb!^ynl3v|KkrlJf({Qj3gl- zu|EF;EA9eO|(Ven#2jnSD#OBB%4gvMip$EPDd^y3@(Vw0dAJY;-W+&!I zYdVqVYEf(ii0ap43!!IGtm`m~!uSbSQHy+ntcaq}GHN}`moB&pgfMBgCdGzAw zD<(_!%S*PcYqiHcL=74!k|atw&!hx1+bA{-785aZL87LDT5r8=RjpWEluUz^*~>Kz zO_p6MJCv%g_!C;C0gdogi|`mTGL>KL8P^srfxm3!s&v5 z@R`~%iKBK|I)t6`6zFWx2C-7gQ}{xyHjBl4$u^~g$-T4iPN9pkz4^ z2Z>59D+1J<1QX%5k}trAy*;4N$uX^%)i@uQhrNAS$O2c)zf&14Sj@9jPb;h`?9cuz z1>N0|iKjyApL%Z>+{&ZT9{9BxQ~QBmmlNj6)0M{___b!s?=Fk|Ope4%_JT(jw;q>CoB4FZ)YPek9dHn3=T)Kk4b9^ZSNaJz7Bm@h^sSa0LYuJN0k^1Pi<_@e z#cw;^qokt!58En{AvYxnCu?S7q-OYi4CB~$Fq#7KrD zm=&IN05ZFUc9;}Er1StRif5`NS98IwFAO+zt1$8PS9+xM2e50g&CTpu{I(OjN=5s# zYn8|lc9p3OVpo~a{@ArZbtt>a#JaMpT(&#A%BA{>W;*D;ba@oZhC1a%1D z^$fuMmRL7SZKfWbJ%zj3#V!8N5(hQici5=qehboHX?D8Lo<9E^iOrra7Dye!ymayF z`6Q%cALxtNOwy1l`cRQRQwkr6)Mp`V&85$OO7IJ$`%5Nd!hTNnr40UzK@tH5EtvyXHYFKho?o%{hdFgy}YF*sVj$ zJJcQe29S{FK!fs zG4#7fJqmJ*PKP#=#$2}M@HS&!=m7SR^2^aFv4A8qQS^p)_mlqh#{Xe)8NHm|1Rt)n zQ+@#TGxQfYu5B;i6;B3)0LH%>VNVT$`84yri2FFQBxZGyPgVy zLvN-jovsI5TCDqhG%dKFt7z7WEn&wek{t_d0(ay19H`rr{*WCGI4h_J#Enc_gq#BS zA9I(N+3)sb`pqD~K3yuJx%S09f)ywceJ@0r6)dU?uZZB#{Zq37xIw3YJf)Soar zqvp4>hfSgRq~nIhbS$%tgob*aW=`l_{$W!Xm$3*7qx?_1DYQAxaxD_pU_r6-=;`w` z$VT~UgGA?)gYR^My+=Xp(D>Qwqw&$#FUP0Pj>g|1Mm8eo67u!=%D?v!@C{67L{}jk zA5s2@GebG%S>XRHoNmYy`jm&l zBOaF}1w38E;RG=vt2Kh|Uy;8KiLc1r&Z>Dai$-tAk%A(#;Kzd~m)1EtYxX#z&`KCA zm&K8fl4!#fz@3|!nv3lf0#xwR82?1v2$y&fsvOJ_MvuPsq6p>8-ux$3z!aIi z2y+!EbV5J@@7FX|5^Z2&`8hvWdo?AM>&4NWUl<0^AER5Lmh~jq%NmTlSfYBufy>e z|GeCAFX?ipNiztdtCfh8!tW>f_lH})hr)eUX4JgYcuT3(&8)OU8_J+nm-Fj*fx{eH z-P_ySgG_sJFpF8Efnf^&9_08yHl4zO9RlnT+JA(U-%FJBt zXRl6<@flkqya}?dIkeASPCxwg*1G@c?CF;jS;%i=hiJUikVl7Tf*4;m*r~6>ITxtW z9^^5Lr}G7ig`^{c>AX`teKwni;wxg`L@I?Tz4YSYUnsoU`MfU_`Yqp z$iopEiLM$k{-Pe06zf?fc*oUyAZFDdBb9aQFYb;%9NizEU44m?{dDU0k#!4|$eY(yy_T2ku6EDMit9a7L5Fwz;4J9RyDgoqE?^y%?-Eo^lkWYF z`D}tck1iN!*$&-%-tX)$OxjNMyZrIP)-g#p)y7f z>GGen>2-$en`HM!?VE%Q1@4<AhljH*L>*D}uk~G2x&?Ii88=y(# zfjj|CqJIcyK+}81_yd~cjdTe#iQMfKuqG-}j<|&QgM-F0_D9GYjDx1lD`10$@RYL* zVtLFKD|{+@1sdwP&oR(mWRGv4z2HvwKtnNXLLEH>wuvjirHx;}@dmh^1%@qXEk}!424k z@_{P#`7p?i(Zv=?&X4oqldHY?>>&x3uMap-fy7TrwfBMX7;qA99hj{yu zSo=dwlX&}IB2W+f(8R&dnChQUC_%>HpHbz5%ReLezW}d3v>!PpIcNWRL*L+O5Dele z5att6KbZeHaKf5fj2Ox8m`x6to>hI-GgwSmMMi(=>HneSAybnDcz>wo|?OlzdX;;;TiOsHmRM8 z+YS^LHZvN#+u}R)fk)WUJYf!N6Kuzk$Dew-0U?-LDpK)`F{Y&+I~apLEJv&j{Jg)8Q zBZEFX2)!f2r72V?jmen7xjPPwd7M~@hPx1Yw8f4YFF@Hd=oUvYi>9Mvu_akQVO#7w zaxxwn^hJJvUVE)fd!84}H*6e;c1M?Sz_>1C%t=a?HtHxP3p(6csw8#nVM-R(SA*rU z{f|>}>BF3-WQhYd-6MnkPJ}me%@oN6hTFz6r!3d`G3qKy8>OzYpu?$aN$Oa2m4)?H zSGjC|b(KpWMqOoz{nfR!=kkjvr+>hgJp7TF&4gAS8T3ydojuJH1{@jm;i4~sN2E`D z-b{}S`c*E(cF$fBEPZ6q?-@5%+e~5c?g@1$Hs0Ji-phSed(Cmr?nHDTZ%w1m$g;4X z_MTngPB}8@S7VcRpLN?;;v!<8hJs3$CnW{2Wp1t)WCbH9?tOFSKw73r|fZ7lzr8M@H;k4_exo zmp(G+OOaA7orNck4Ej65pIW+2T$}IDvs0V(Wae`Me$0HCAZO6zmjytcM2|B_oK(J$ z)|p!K_4^SE@BLBr}w&%h5TX?JkG=v#pdj$`B~ z2 z&SB91CdtDb08Nrc_yC&3jdTMvi9C=eph@%(;S6Yc&yhhN5zs`c!-)8ip7+S0PdRpv z4EjHAs@)@l{_+L}cH4!;EXwN0pkL>2O!HeXg*O_+pIKPQVW>ITD~OLDf?>(C8z*BV z3mM&St^7y~`Z)pTX5}fbLwP=%#COInd zVv9CK@W;gSDBf<;@QP5sS-P70_ee-^$(S*#zxT@=!12_oj6vxGvYP*zC%Y)FA?U~< zpy{rQJR@0t;L_`+sSobq^>T~s@_T5x`6|>}8Y-|VnDluD^Le}uAr^nU&ipu8N_0xz zkkb8`>}%=>#>Kx4kj!1=kl(?IY^tZ4`VESdQzc-aExa(3`dON8<0m}xS>tdUnud(( zMlsyi>xcNp*Yt*wmVO#C$Wrk^&kF>%qsi zv1EB%8!{xYJ%|)&;2T657|mrE`mtUVhL|?r!&L6_N^NULpNyvYR zGCa%>CNfesZDyM}W$O53_Eupj8qzDc@)agK!xa$;qep|31h-3 za#5pPqPdjA1yd9v$Hr3Rl3?RdFa}#CQ_<3IF5PU!j%A4)=$nUalJMyj6z#sF#}#y)>HoCSQ7flKUz))7%@v zQx_JTDPX3P_7dTHoX2(e-SubytB)wm3t`vU}DQ|!Z z!><2O`RwO6lml*qVyBd;jsE#3|Ky+0e~>|L9x3qOC=uY7_04P%E8x(;UobMFcoELx zR9Pm<#!s)6pPz=yb$t3Jy+C5QFZ}S@zl=Xe_Q#)}kf>iNg|Ky;F6Xzg;?L)0QMmZ4 zz#E>-F1Ksshg&YnLeEz>T$rLLvbGkZiX!zt!da9lnC+Z}KH$JNi ziYv;?7|dK(F$$v7(58IDR$w}@m#3^d*u#o4Q3O>zZ8;}5KCq}0f8|5O3AAL&zR;(L ztte_SE!ARL)S~>ur1;@vwY;I;s=YKDt&?E3*sT3~7Aktkcf9})@(k(6l;B=&wW4H6 zf)zHn==HX4mim|)K>vKPOw(B~j}?qI;~3_WC(6?}ocrroVVn01Sl&Io=5`jbnTxSN zqQO~$`Tn7j#@UQphT9uVSUxNKO+FgYGE7f!7>wq89KtQKs4X^A+Bhz^vnZZM>}?Q@ z98VcifoXd}CqSxYHr46lMXo#P3Ui*#^jVSss9uDzg6VS?L&LJ6U`n)DE+*pdJO7?^ zVVjCpU~-TSoG70mZ`i%^F&{eCYUMN5vYYLEGh3mDZvFMlN8VfIeKE_Td1DS9yG-X4RuM3meGWFLthTiR5*9S*}h9U^g&D1~&`r>OF=NH=v{j0XrQNs z*0$aPc-0PkRV{ES6ym7mcro9%<5k$7gzq`I{in=`SK1+Gi+t$ z4jDl|Q||m!SkBB?h}UZvuoGAcp-vU0&uUL}pniWj(RJX%Vnf2SF7cE zvt7(K_w?oze<;f>H>KEmuG}HfQ@$y}Ah<@mPO=`RBAcsO$~u$I0dOpC6kZNqT8M3x@1ra5q(8@bGP+mdx3d(@&25GgOo_Xz zS;!w!0(3idN@id#k&6}soziHC2}egUw3v2NoSjxAe+5r2d^+DgDxDU-ee`QGDt@K# ze}6HLeau%sx}Aj(`Z!hQKB_|JGz{QpKgT&O1kDg0Ntc*Oj7O1+-(YIig@1^7k8*j( z;84n@!v-cYn*gw3<@a+1`!K7_Y`G!8dyiE^PR{YJXEI+h*Ygv0s(;oLV?ZuvRd*$? zbA-dv-Ey8xxU~f-wJ?L)6GL29_4n*@p0)bUL<4HRXhXMk-Lf60h&3qJdm68_(3&_%3k6AEOyf2$LUmz}`aoV7-9LF%xx5DM}c(K82)^o#ZKO&o3}x`Bpum>Vr+%aegdk0qeDb=Pt&XrNAx zum||LG}e6pt-{Ug{2MlTD0U^C5;JfLR0bhGf+qNp=O%$2g*HT~uB~fGiJLf@>4i~Z zxsDn*T3~3AM)5B}j1v{P)7(V2G|LL(*jF9f@`F$_W8d=-{xKcX{Bda^(xR`dI8T_DtmLUwNAG{x2lagU=&NoI4PcsMyKTkLS)Q!aW|MD+|F zPZ4c5?c5XJf7f?mZ`My5kbU}zzQmAPg?jq)`0Zp9Q(RS5H>ID3D5g|=kXB|@ttqAE z*@mqn>LXXmhxPsD>SoISgNAe%yK<2|DyRbh=L&~~0KFuuAaa%0R4~|H!T^a=RE4v3 zKXNqBGrZVL99uK(#MM1BMy5tTv{m0T9K(fTTA?1GM6QN z`9TsV&`8Y;?7*gxtE-`r2at|1=~Q8e5va^+sLZm`$XVs zH2>oy)-(@0ofhg|V4I=kM5bd0j_<``q9u0Y1jU-gpxqRwsCXGIH_NRwS8X-4Bi(U) z7aE{Nv6Dnmta-Ys1&J40u5Uz%>L%t#d=aQm)idDe1l8XxH}M41Fr*Wk!i_KG=h+BO z^ZEI69AI!1lC=JCJ=?jPik|JU*3?!12ku$gqUjX7_2;MP;0e1BM+dgs8P=OzM0m_vRFwTeT-OgP#Xp3e{Ib_}t7;EVc4pcUF5@8tU+f~2KmHgAi zRySy86?MVZ+F<5Op~+vsMN4incsCoZecQB5*VQCz|KT|h{J&f;uW9qZK$XJKOF#B& zHM8xeB>{t)E^1t}DsU>)Jjazzg~iLJ=gZem{TtYiug{ibEOuEa^Ny&LF54PKq%w1i zLv|jbN{9XV93DK@{~a9}ZIzy~`;$`*FJQ9~r!+^kbvgq}akJ0fKA(TA1)sis`OVj# zXy1H&uAX0f$zy2Wd`9NwZnwwIm$P?A@GVyS8&aUtp7JMD8kGRZ6J8CM!irNrP~3e* zOoii}J6l?-#U!MxVbZA4^%y#6@K6W5s1lbb;*RMc0>f>!Twsk$KLk>FO<@Lf>qEI) zu7RQAXbsAv1%HU`Gl(&&naJiK{i^4!H3~_iq8f#e!v!Vh z6350Q3qgHDr$jlXW|)dRytvQc@)BbMl8buuk4MftCci<%1OeNGMblCXdxb6Aq^dhS zHwd3HSzJ^X&y5s2Rk`z=JAjxy#iO)17|6b0+zm5;MugC0VONM#xm@7bU-_G$obTvJ z+ms``^g~l3Q#?=$Ba7C4f}pW1C_6i;?jGYk%Wk%niPHyqnC!>+PEb_r$(z?hIxWmK z@dv0o^#aK*?tJC}3*#y;b|ls}S?$Gj%~AChLZ(S%YJlM)UkwvObps;^0bu}D&;mO# zEfs(3NnnwcRLxYDso5z9vsu3;*eCNp`N6Qq3yyo>DJ-%b-gmLEQ29*Hcv`lq-D(uyk1x$GR}0uwBop3m-{&p)4spL!4e*Dr3v#r4D4o8P~EesOts z{&2}|=D}Z&#h`l9O6Ulbxd%iSSD#_Gk;vrE_L$|};%FNm*M;@>?-(b=_gM5w(MNq2 zzEVL5f_nGkJ{FVqr?@V3I@eX;5uiqOmo{a`>fx9ZeO_HCNK7aDs!>4i99_*)uH$>y zefT%Lyfih#wEZV6;>xR{}N zyP7MN8N1>PSfr5Ya*o{9T3#N#mS0vI-sD`wuryxHE$6O?81smKVk7Kdju@E@N~6KS zd>M?80xWOJM7*2An5SCdo7W_Jcn6Y9l28&!@eboel7w931~}VDc}zquP#l+r*HK8A zzRP+t&($?tW-bB)1Nm9LuHo_u84xH_dJY#UOQBkFXevNp$8edFkV0hV>|f0qDBA_B z@tsqEHOtFzk$eJ?-t@pqnuU_;R0Rv@VR&~62{L%WvGnYh;i9t@z3B}!F$mBYE?h{M zzWc`%Cd&6-mfvfP%<&1rn#Ya-ceEtal|3Yz7+%N2kcBqaau{7`vn)RN@~mP&-|&XB z;Pie!amw)x1-EACRt@*+pd*AzR#K&c)cL^oT|Glxh9tUS51EC+=$OPzpCh zu@u3Zd9jc1-PJar5X946g@EfXs`_0No$e}{-YzPgyRRTBS)>``z5pKDhCsGrKgZs) z1@GJ`zGOH5X#Xv~5_Saen$O`rB$0mln(J?l!q8VDz)76l=(}RcINhwbF)w>JyPnAp zt>9~iDsk-ixxwWVDWE_`|oq>5ZHU3F2A6+-b?)ZFWt?e8G z4!cS-x4Ncu#^~E*^oHqM1&v1PTP4frJWxpaPX^`2{!OQoSnCUVflL{Y-+eCHy|iPI1C7@Vm*nB*q`LM)_FLO8$tk3E z2KV=g9gzI1RV1O>xGOsp;%}8p`dXDO5cH8FR*zC-t2gsZ0E{0cJ=+IFO=UDyAoZi< z3n9bc{?^_`eOF-Qn7$)8=KGVAlXn#6NV_&i>_^pk2OzDFS|-H&SK%y zL7oMj(f`&ej&uOD$~}+|pjG}4;Ra}Z*%(hitI(0ofL6KP{Q)kp{Qab)s!q?e`vVYI zuQIm+7THX*@u}<&Xshf#m%yHKd%OaBO7CZg9&9O6uU8jMpy2WjDAVh zpF7@hpjU`)DfUschQ4GZEr*#E!q}wQAr3X8t1kp~zhBatQ|$ct`7^9!?cCAK$|^jA z>`!tQin~zjm~1=woBWa2R8KtkXuG&xz$+rmzUXyuFN%vXU=F?7Oo9iH7j`d}Yr1D!5wT)ntrj`P0Flt7 z>csa&Q3_IRnHe)KSy|(RFuM?cAqlHz+qm^1=naVeCsQ4;?3$bTRO-o&z?FR7@1-{=)mH) zAdXvrVdo*9Y-bbfa9B}fYNE(8e9uYT#73Av;99n)> z8Te&pF?_>qc*3_E$^9ZPvc1sILF{FKH7O2=)zXSx-3MtOc*=b{4r1S+{XAD)kof7K zL~>O_*G+JbsZro1fdL9HLk$B}1;JPXt}hQ|8dSIY3u~(TDY5YW#=oYOQs`~ytFhzR zo*GA>6!fehF&#?{v;ZV&j;qIdV0w|K1s{QUm(HJc&0R8t)}Mo#bq%K(qsqX^5=5%m zDknO%hvM!T(?V;z_Qrv<)*=qleFT4&hhPA5rXij9s&~A^|XKfD@flvx9GCfnH#kg0{UFA!kr_B|=Orqz+Ku4#SwMaOVyn#&PFj z`y|dyHMXFKnuAp}@~tRPL+nbb1r}Wsrm{(~uDLq;us|&re6(?_sfiJ2P)9FxHIRMU zF7`Op)guS{F3Qx^(d+)gnmXqF1Ia=aW7Sb(-S%wFM_pChvO%`!7_bo{RmGU0ioO6pw(-A? z$K7tC%1X>^ULMsi!6FPAW_hzPUUhVYQC>G(9RHyp5u1qg_D>rd3aA2VDo~NfIE&vl znqb8*Lss#k^q@6dRJ6W^XJq-rB*)kA>`l`Uq`lV!l1`9gYenAR33oztTF&=MIl!bK z%6wX*WIh4%($ADtd^Mkeq6@SonfLDpfX!^m*`1r~yNNU%%K%dl$PDuAOvKXxwnl z&2pVP&otCHzooD{z=_A$ORpJzJE|^Z%>4#g+Nk?cvLM2w4s$`OBz5c!DOp(GI}UPL zW^`ff86dVNysJL&ywq53&T@VF-;&DsIp2HlJ>{z_Wdedva`HUZ~@>4 zUrCTU3!8SfBp~Av`Rv3GDbl?#Zt^Va)Ezc3N<6%r=Zgg#EbDv9>O}w0Tc6Sk;aZ@S zR7fGFyw6feeZX^krR?43OS!;fFo}Xj6#u5j1F+9yi)4JFNK?f85enQBV(%mn9{nxS{(@Xxemk;j5r^q-XO~x-D{!(S{}tspR(vFd4Jmm; zfXocM`lSo;pR>Y{%3zB*QD8q+i(=pMEm? z=BvB=vy0yw=TC96e)@{CC3bKp$U`lC&LN2@4~w6E0V0yqpXq9L7KHE&(_lXcs}En} z4(Afs!Xw1M*eso17OtDe^_5|$mq;oKGYZxtLgiUftSoh_c##O&&^34<;Qw3=wI24RdI&lI0z?o>d+xAB}}U_WF~HvGe@ zt9u0|*wr?j;bsXk%H811v0WqK<_uK0EalvPqRivVC6aTJ-x)^tY#zmHN?%2cJozc+ z07t7##;z1@%E^QdW|K4hkAq(0oyf10cUV*rgHiA5;llZ|TLY<`3 zWs97mrE^|@PNIjC3hfo2AB6{H3)m}O-0AO6GPGATxzI2D2i&BCX388v2T@L0AmmGA zK?e~p$t$FHCLh}0H&P$~>z&R?2KI{1f{*i=4!zC1rH9!@X&tD(LqJXk>3Shd#;@2e z(ubUAZ#QN8Qq#)>ztDkN!?POp2v1ihH~~(4GWc+LBr7WjYOV*tKsj3nX}4 zhLv)C`d=RCd_krW=||&_4w|EbhVF1S&X4KQL4&Tz!yu+d2aUM$TlC4%K_kx)LY0pW zn*3&XF-?vRn&uVu=%8uadyWnomY9{Bsq*BJKNkunygf$;4dbLJI_Bu0Y16QygQn@A z*f9+2=%7JXYW+exI%qa*7Gb**`36dd`hq4WUy^X_K00Xjq`v+^95lm{Q0yDd{PtD1 zY!scu5kC&tf|z^0YwCi%g0ol=E?Pv49A0{HoeC|eTthq9+t}WPUfS`p1HVgjSP^W1 z=FyiuGFR*!qEfR+Fy0|T=ML5$A+Y&%Zi<_5$nKKd@XD8XV$MDhn(|l}r}e zVKQ0RUD#H^R_552M7B!2?UPNMvCo#cR;8bYkgiF^cM(9fX0ynuT4!AIY{S+q7af`1 zPJUS5Z?0~p{6CmL9m4j@MW7f`4vShA0xRb&r=cwKmcz%-I2`HUg10=okw9BBvgP6G zpQCx6;l*Zx+s&q(xVmS?;7IjDTLmdO*p4;butGgRiJV*2z%6h!0#mqaqrF<}YOWSJ z_VQpM4K2?|RQsd5IG_vO zC%8mM%gs%krnpm%F1T3xipqN^0z^}6@ z3gEu9C_l$F{cJYL`I5pAnXH2S4U^poX;_fQ;7g8Ne? z?;YhY7GMfm&F|$l|LWUCUYE(M7r#AK#I4V(CGilQNc}SvIl;1tEB+J3(*sDkoJ&%` z;&iHfQ_&JJk^9_sDXEPJdBx7zakkMle}0Qtk5oUh)EM(AQ6mi>p&DT0N7PCZCuZzx zW?%=5d9^-4v1IuR@NlNe#Z|nFmYd~Pnya=N+7VKD_%1X+1N(mxMKMU5RV_%o&~kkv zN>n#7KjMw4PgPvHSF*7I9n^ZZ+MME|&^36fz$KOca)Z%Vpm{6Q25&!HZ+7mQqBjFq zqtzr%zhPMhpWpLP zexB*WG}rc@gK-(;5W)76h!JQFI$Y0o?xvz=d#v0)de4$$9}{!2_2;MP;0X&!#{7(L zXIQ=S1(Z>^z3+$NEW*l43}|dLZsX{KgZ6Ict{OyU&G@9qYNhMFmhQNkYGXGR)B;?W z(Vl*m3f=WC?1n*Ril__h6v1Nh2%EeIA_j1glgj0+xGkw?bklQH%?96#XwA#*+J9r| zl!*$nzhsn2KlN)Wj}(!L4{EKbYt1Utk(U8kz9b%8@v3Q>wI;LlPG%jGjqMV!&tmJD zH;Uf_MR#WgTWDd&@UVS&i3{d?Lo;CCc(BldNCQWq4%;atl6;iN4K~ZxV@vZ)7;J`y zWE5s-#%h4AD6vBoNuqp@R^)(qIqC*mj~CX~8P-pbDvUMD^6exvEeC16tT^)G!1S@X zMu~>xH<9C8whg`z-D}H9!I|%)jQXCX#FSTI9+um|#@;c0x#`fk-Gdg528EOu@W0r$ zC?uVb&_T#Bg2y3u;~Wdc3fvdwJJL`sbOR<|F?^68e!xN~e2R zOQ3VeJQrg~EVLsu4C5oVB%fr*2(db%e&v(Xd&rBa5MMe{9oec2daM(E!vU`>Y@^Ov znb$a*0=X)7?uJ9DBBce%_QqYwC~OsJ*<48(pWWbS_!98K)#G^+UwrlVAxc@5F-S2n zXsqfDifQXQ@;VX48_zRPdf)VA3=eEaqWH#=Wd&sbMc*V76rDpeOwK33W&BWSCLB`F zY(jkHZ^El*w=h`o9RNXMo8z{hfs`{E^3fEF^PA<>)pF64q_6m8$Q&q24;p<@(c0*n zrtZ2b<;f5k1GedAvRy2bgn*Fw6r}O!eB{CH1ZAz;N|z@=o*{rP=KzYJMW%21+>#NF z)Ll9)O2t4_YJ%$b>vm?1*M$t~eNj8~e%%Uiq=Y7|R)C9~fsQ=SqF}qezVg=*&B>}2 zQ2Mc7v$^>6DV2&EqHd`Z>Nv z!YcN4w^`UvWO-`Rg7TWqb+!)h!ot6LCYIay>GhNnK!8UaDPR5hYd_d7B7YH*l^|^T z&piYkG%E!`-6Xv}ehL#<`#6Vk|5O}QVBnk2n zhXxX3T4oS?aTG?L(`Md3hB+}``rx}^nP2~M9?urwhL4o^El6}`#FNMpM4&6NHxa}Y zAbWSDZ17WvBoS%mE9jdcw$}{Ft&+~2cp$69Ddn+gIUvB2M6O*63MCE*H_O#3T>*l_ zOsFmm@^3>{2D$v8g+WxewlW}Dlc%YM2OuTeit=|&^H0Js?Rsp_3pR?_qxrN*^*cIb zc1ot?l+86tkbTj0-O%x3{MSgJE^!dx^oE@`@i6nmoAo zA+<9Uo64Q=*@o^cd@N&*1v^JA*T&ARJ(M<i42_r>D7`y9U|WB%0qB?$aJP)!i2$3#WkHu&XNv59 z^e2z(BW0o!J=)un|LcYpS9_HcIh{Nl6Wdv_*(#NJ)1^6vRldbHR6U6dTYgV$t? z*~2Aaqjqsg&f)fPS?JiET$0syFPDn;-_51MhuP01fg^VG3rbW+y8+@mSOOZhtxGyi zJ3OD-X|C@xN)WhI@^yi7*-aGgfZ(55O26~vMtKphVt>QG{3?!-u7rO+Ltfh}@yG9D zf6YHXo~KI%;U>$w6dcXSn+GfjQ1$Xgd5UdcIgj5$L;tk3E?RMV1z8y6+eWHT4o-g}*V1 zA_s7WuLp>x=QkxeC|~r;acy7kO=2ST)@Z^fN!Cw#Z5P^_mJ$IL zy>rypqrS$gB@sN8bZ++vx3;>K%0gCeRHc}a)1R=uen;?WQ}Vw80F5WlZkO{dgA1}` zH7){0EBLB7Muq12n``~~<6rJOM(Hhf&35WA@gq)AkZhw{rMg4eNfmgfgYLz z?~K}_t?-IGy;jejUhdP@c85hKe}uZ0>%3cC%g^>wSE=Z5b*&2-qpq^FQR*rSI-I(e zq>fcrSy*3nmCN>5SGn|I)K!+)UtLRkE+?5g{R6(_q#Dd@CdEZ4G}w<-qoTTbW?A*@ z;<0u1aCwJ+NPP#w-B~8x_a8s~0C{8|uU5F+$b19%>**|{ZQoy0+TJYSf*w?)$CT1T zBFStBw@O03@SRC!2^|o@ZiwbZTWuE?A!L+2Z|+<8XsM|>vIviFuBxGV@#2aiuE>>B zv`^KLic9`pGzrN{k+-x@lPu2x-fSBHyBnLNJ--Oa?W~_YgyWl}>1fg?0KB$q@@Qql zrRhrXooGrD02d->_x{nryv$P#jBu*tGEx9mc=7I4zR8u4OW*?dwB3DZU`s_2Ng#d7 zg;8~~WYVY=Q#;o}KuyKhb8TOIHBTvOAkeKj@yi?sF6h7L< zubHzR{sMKPx)aU1P@Pj%#sBE{3IhK<$v`6F$k0Zqi z&<|n)yyNvMy!THNZU{`@d--Gn&-vsf_nael`h@&r6Zpp_FUUU@0p8&T5Rdj4P>?eu z^r$nf%d$6z*BO(FHek;(4M(Tge>vFV{`s|c|Be31*8h5S6@5Ct4c=U9=TFa!vo~k^ z4zKO3``Noj9A5LP@3v_2$MRil_oU`K7cVvZv|1`ZX4A_AjXI-dG7fh<6#~beOfxxs zH@K`ATYfNg`N^`!s2=7hn%AO*KL5ECZHQW?vrYWkk8WlN{Yrd9$6&9Z7LYbFv|N6ykxVV0M_U1E<{qw*AX0p>pzEx_Ry-~W`(3)(OdIVU%H;fH7lkg{S#h9-mX_|_K6?B#y8(b3VYo*HRxRb_7Hf}! ziw)B!FV3cCpL{xf`Q&W+#q*a+v_z;4#rk~gKluJyx%2PA<$ya~3K`w(Zr66<2MEH6 zl*CW3aF{+(K3O6-M?nD5a>2?zK}_y;G20*>@Cy7}vqd=HqE2{i@Fos7${D+(s=Qpq zbY&HsXz7Q_XB4kP@XvCcve!IYM3YxAPSPT?dgpuU4Qm|BuCaSd;MQxkEVlghH5tNP z6Q|b%j82qZlX$4a=rzF{0tF_tTwZrFoofvvkn5D)?Bs~2F*5E0Q9^E+ES}oRyLn$ zn8;b&KbfWH> z&>@MrYeEi_=bVpi$d16++ro(v*O?t92~Tr9;~xU^3}IV93IOJ9ji z9$4|`xCTz|k#blwP>6pe=zbra@-q-URxAk8mv^)4nf%a-t}W!w2Yv|3ssz8ufs$Ag zjgLrT{f^E_bd?N;NaBFX(5UCxpXn-k%Ws69KY#r4<+B$TpFKavV{F9v4Fwr%4(*Fi z=Wo9G%6jN#^;&?wUdu<`FH3Y0D_%88i?84sfS+Jj4mvI!r-(~CGqZJA3@nzz z&PaVR0gF$4!TO?P@o6+(Ux+F`9SX89Bo?1~qxMD7;?q#zzK~FSIskTG2rE7fgYS#- z(x)_?T`uAnI5O=Zbi@`Qe3$dJBq*oX66N1b`6rUu6*O;>*B8fcl7Z9n2q?cz;$Sqt zP2ey-G{&TORj~q5A5%^870B3VZ@9myvIj!^n?#QT{hKA; zjK=+&;X>z+%9KR9SCVwuvjirHx;}@dk)z1%@qr1QvZM42EVeLE#YiA)EvNwh!he zFrB{#M*(X<$yLCrAvzlQz^IF}%XhE2=`I2PoH@GEGlLnO# z3A`I-T0vP!-VnBuH^``9KRmLnNm{n|Ggd&z6E@0$L>3n^AiHu)Wy~uow_wOBqTVRK zVf+h3Zxj|+)q5bPb-~ofY1crO-9<5QknC72Jrj|hhxRB+{oJs ztdIt#1Y?WamwAh@oc1HtCIqqst_>p97H+b}v>&D9Uq?1^d8`IPeVBPt=Hw%rIJTXg z*u7wGCSwCzN97zTZ5z^qy*#j@+;A^SMZy^WYc6V(`!$zBILVPsJe}qpav0BRF0R$_ zN-_MHu}!y~j%?zoI0v;Te!JmT*bwO4-5YpezmBvxcao&jYJOxB2TOXsGfJPRX9V^8 zkxiV@a^$SRM>g>?0#dLcLbH4A-$lvcJ9tgTm_1w)Hfk4_g>zo4By)q?1{pUdOeaMP8)SqD!X7wY`Op`p;r*&u_gR z*~E7OUOXgKn%21um+L%istS5j0qk339Br|FJ^vH7#l9nV$dOH4aHZ!u*hTMT3h2CG zU*)X}8Kb?jv{6SXS3ETDogCIuBAQq$R_?_=H@@LiSJy* z+I>7cgm8Lf6R$E-w|7|)IC^9g?-@hG&z#Z<2#a@5oI!~#J>Pn}nAp;5hWje&LXLa( zkxhJd3u+T?4qygTMq&ik?1(}r1&1El#4AyhgD)8r0SZMFXf;H0_e#;e%5&NE@XR8B zb*N-19#*b4Oz$I`xDf=gtH)O2xlyd^h88-Sl|+W++m4PTGtf5LLnypcM09c{9sEG? zo<}xuM2GNQHe(pdw@ma9|BMZ6_tb4DKW5X*Dl+Pfn#nla@l*&Ldos=B^gWbj#rmH| zvx0{?isrRAvWXv43>+7QX{HaOX-hIWKiNfL_mM8^ojisS8`F_ZoTYIoqB+@S4Nmag z8#T9HtNn???vYJAt>+kP>8+upB(-kO?0T^^AKAp4A+=h+^<^Qc2|)1E2nv!$afA6s z8l?>*A88adoOz@sP8>L=M>g?BHnW!XVjR^-eH5e<2v&Up9B^54(7Kv(SHn*Tas{O6F;(v<8tF|mC8zr`K~GrHj<89AxAdxBb)eM=*xFm#ZSi;OvF0QBZp!=5T1cBvUeXkCedcc-k5Q_Pk#z&m)`o2~Ggh zEkc=&i3l>jS+)-JTgi?~$7(0}dw-8zvGxgM@XsL;!ET7YsB`}5A23RPWE0Ovx$r;$ z`I#d)bh-8^UFy5ipNw}p_HR1j0!^}yY~sxc6gcGA)MNS0$RnHhs@1pC)Nur24o36a z1P%lA+oTQ0^qVA(gY}yv3UbgRn|Kw1sa&aTS6?}#pdZTLG$2(_9&?=Ku-|Tgvc|no>dmm`fk&-y*Cep_&3*i4Cvo1@yI5AWD{TR3z~1A?LUMwplPBW*~AgV zPoz4GlpLu_?b9QhxMm#L#KU;OlX?CqX-AK2;(+nmSHo=YKeCC#VIiH?+pepCGBdLl z$8(iapNoJH;zAcEjWLpijOme0+y{Md)gr#7FH_1+0lt3nI%U~zDp+?To4AXEMs_vr zi*0)K>=qU`z5)sMl3k#o`!c$2+W^dw0AhJLTVVftJdfXg6{njR-Uok8Nrt0Yx|;j< zuiKyK$D_`DXZ80CqEpZ6|7%Xozgi03cSE;TOLHBxEX$W#dExYn-+VE7IlEcSKse>G-hD16}xk^|%YFl?L*V0{^vUl@j-mG^wvqiXhoqxl#LKDI; zy^8$^bjm(P1`d7vfdL9kU(-F!aO2SM4KMI4%`pvCkDb`D!YGU_+YBv_sN{nfk-&5_ z(Qxc2)YQ<^97D4rH?Y*eSFPA~T{BYkz{Vem=h!HdFBX4z_lW1C?(ss-5lmwsb-GfX zPBEH;loXFl)Amt;D9}O`)k3|IG~a2AZ{jpXx^a|$ zwTh5nUP=8V-rS$8u2!f#rYh@9ku0FYo%sF3DOS8`=Z^UPJDLI8erXH7&!`L@X{PO| zj%9nUh9+eS{Dg%C(!Zg^jhbv&HYSCRq~$_UZ?Rg$^FIX3&3C+SN@~o1#ScTYw=8;) z=8F0@sjg<3jzek7{TmwUkGJ!{Ut{B+F514O21XH8-0f&-sa-bbrb*=3ZlIfvZd#7&IfiPfUZg>>{m6**#PKmH)gXC~ z>Ob3Lt(Zu!r$t`;S;+(c@cjDxHuy?gMbFrO=fUDj_59+MdG>I9cYeo`P19mcozgs~ zNVpisvhXwe%NtKUdw8XvU7VR`Z(jWpU9oGP=q-EPY%z5WeN0+;K39KceGEnTne}w< zkoc=rI?c7CS3pSRRl~zVngxvs4yj5U<>##mJ6xbhP4d`qk*dJHce1MGnGt|F#C^F{ zbFImDT$OMbFK|_AYZ%GLOEUVJQX{OE_!b#5ADu2h9glruw!mu3Kd=1FmH5op7G}ac z>bfA|m0dFRY}qE>n8?jkvqWx9>n-7r#*cP})f*u&*a%W}O6Lt2yBve1g^ByY~glZjVAAC`$c3eZ)6D z+bDIi*mkIG>7ftkz;Fl?#lRqBCdya-CTu=rXpZKpo<*72vQq|j^DBR`3H(Ls&mp3E z#;E>2#73#g*tPq#Y(5Ak%Bo(sQZ&yoEklJZpIIsXb?Psc!91RB;&~h_m(ZY27D`jW zvUQT@Euw{X6GvnTAHcpei@|F>AUdX|8HR~wim~I%!6Z;=U8xRS>Bk|XRuV91$V81B zhD`NT*VVOr$cmR`23OXq4klo8(ekj>PJWKj_vA+haddNb_S0fpjhw`bJLS9p4EfHwoj=H7%P??fKcy4P9S#HCy$4%?xm`io!tGL)CGDDDr$93xmLS%n)UG zn^MNT%+G#3URXQ(Jz*v(#EKK2tGj`xT6*HDn& u31Lp_-g2zfg2mXtwo;gN6|+N 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

`w38-i2xB054sgP#JxFNJAh^4s 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

x9udny|4Y3>9qBUdG&%wcytq8nTIU}+IQf7$K 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𑨽S?r`$qKPt7l(+{((V28_zF4HN($7CHN%(_k4oT z;ZI1k((XdED&tQFXErY?Q3;!IVIOm(j&)<&9(PQG`tn^`CIhB(y#ZOwc^(M3UeC;r z#Z;z$n6XlNNZ24FGsyjcQJ~W>prMcpgn~$!v-Q=Sd@)MSPFs&ksT8Pmc9CL@>gpcF z3bD%os)QKbh^C;-Bmex(m<83wx7_u(1n|9e=Uc;wpA+lQ)>sc8j^+t`JGrkY-=DZ2 zry1#b7~x!}hsX(+`PlxVjCQ&(G$UjS^YqYiv90i#!U>d6{wZ%)0dG;h5!1z;Zk1FC z28aP@t!IrUp~F={1~Tq>Z;@(5WEkL*W|WHKtRF#si)*cIiOhMZ4kWkG zA`}|4&1$aJ8hM3l`^QeKMF&YPo^$ur+`YNUve{at?BsV`-BG68bAw=WB?&`s2SE+o zJ!UrM6eNq77EH!66MMwQ1p$hqrxZRfJ)PfB7I1IDy%rj zaC2qfF%|ktxg;e575fbiFGJUmGE4FFmJn4Bkl%gwvlX%nQo`bwxW^(p?dlu}#jjV( zNy2g-$2?Cv(od7**zdiUEL3zkW}-gdtuZv6!uFNY`@L7;KxIGtC%5$2SjQbLGNVZ%A5J7Y2hN7 zL=kSXS>R@dof>rYl!4Up03m-1;ML~zKi|;BK;{K%f@#GEc_f*n+#3q3Rkn+bN!~uu z8-9q8jwD-oENn%cj)OJwm3^eqc(sPQI7Pv$rU7bU(3iBtTY$sVCQ0spwQ}R)m~HgEk^l z(f9anuQb{pT(M}yaemL$9l3h_b-copWelkkB)GrNSy_8RaMdBqm#{2+EYMcKoaCX^ z!K_fJj{A3QalKZ{L7UnQB&t++aIi~>nu-R6^PT#Wl!IG?LzRej28Jq??h6W4A|g(g zQr}seTene|avfcXUcL+Ew~lQNz9kZQ$$mgkC0av3ph|?g2D6k3lf!*P&{4U&J)Ue0 z{!}B?8~CY4iQFUdHf;_1R3pRHn<2dEJqvxeCgpu7yMKopi9xe+n;G_?;rZ zsu%h2d9&QW%#7HGY(2EyFhPDZ(@f#tY?C>qs@hd+!D~_m0qZO9f~sp$LpFmijHA~V z*74?)=z6OIzNl+}XHlgC>#yULk8|7QdI?Wswk+{xe~%-z1%k>D>t~7FAP=MxB|3rc z#uKSbRyp|69ig*FQi)nu>u9NPcMqjfad~qe=BZR7+3K-$tUy~~(3(7#RMm3f>8MDo znr7KNesE?TKLD^?E zwJuTH3l+~Q2S_H4#=pQYInKS*qm;(Gm7-d?`5+PkR{lo_}bTNPC#tzJ(;q z-7rXf-$=NR8o!ayZq)gWr2DD$8%YgN?>EvLsOE2^xg&LdBkdnU?cZ3@5cPi}!GUIg zMw;u*0p^Iz0p5w>A-jS|u)ss#>!DM~3~U*P21~-Q-Wem zfi)%9nhBc9VPmS83rL@!ep#^>*tStJ!pn>ej;$kbS8AoD&A{M~<%t5ZY4>v5GT4zKkV(z-2 zRH@5IuBlSQn$QF^gw}!CWD=BCDk5kQMA#0|K&7G=TXRbnM++YF1&Z%=&9fUs(v%W9|yNXwhepr%VA+lNJv&1{P()E^DY zDmRnKAbfSqAg;TG$&=1evL1sL0EKmd`Wr23O^8;33#vKFLmNVpZ5Wnis|ZO9R%aCH z1b$V;c%aobS&5h3`YhDnDuG^I_C$+opbwUz2fFW@*a;=TzgCerkoTkp!?%CtIQ=#pi%iI@H85QG5FE-h-ou2bTm*CWp3z zuXM3+m8Bs5T#mOMhg|`%P*8o&nmGW=!zRc%n*iqwvw&YokopGk%kV+FVBiK-9<9Fb z!=_aly*O30yvC?OfP7LUas-=}DjUB503ojZq~_X!Pg}~C8MQ!Yna-CCe?dl%TRJ$E z_G$^3K-*gHYQ-rEMA7&>>fZ&zAo{A>XWOFw&Bre;Hb?z8_n8Ak@VeJW{ckA0Wz_#B zDxIVLTL_9XAn#ad-slv;fHmZ-wnY7ZFnOf`xNZ(7hj^vM*UQ!Xa&GYe-o+|d$2ex| zwl3%oaFnSudc9?@@^L3e8MSPGN0|mHLmXvF|w9g%ixXRHy=J7Qt&>6RDUwwO@Ndc`a z1-|{}Z3!Zy+;m&y5?RRrcu5|8V@M9lmCN?7Q`*;00V0PB*tk{Lyw&*T9c{AIZWeO} zIG1QEbRc~dUS3U8ZFxSwp>Q$$hmh*>hNoI6M4A>)VW(s-udlA=K(zao_ENPy-)b2U z@Ypvv5M50`H%j9WGs)`WHD8ADVonXge8;O$w zy)q3} zq}*(oZdILy{UK#@I&xZF%W-Mc20PuAsO=9a5CH{1gax=~^!n(*bGluK3$$`&R-JiEBd&b2(VJH-h+60-yT9=u@p}VX zdqyvg__W?f%byepjOtOu87& zXVY74I)Rts;#PyNtwuUI*maT20k@Eko*h31CU(O97)>V^sg{JRkUqQ&SIfKF4J?KH zt0(gbKu;HU#V>-AnOS9>3I-PNAI zPjxab>jaWfVhlwHZtXtYNT9R-a5I&`4#dr5RhQu*9>mSmJG&4!lj-Y2+)Pbe0;B?> z55`6_VNMb2F82Z6=0?#>D<{zpb)%W+5I^E(id`Lvo2if&V}DQLcAC9iiQ7r`^CfPl z*Wa1AnPz?w?FHJ=OjA1lbay9irboKbv+yBZmWdghE{+gKFGyQJnK)C*s)4jDrEXol@wH!4im+!!BEBYCoLp; zQw_8*NX^rqxTMez4y1V*prwOxL7FM|@honpv>VsrX4-{6pm6;fFh6|q)m6pRpZzDC z6<6sMuEG6@7Bp1KCCA|Y#7ks$1S`@!aYG!8n<)5LLf}k2a~ya zaTG8mrW26IQ@-;{|6&CQLwO`m91_`D^)zloC@H*%3(-<@HC9U^%^JL$#1nqOD^OB) zm`}=$EgrE2h= zREW7FliF$NH1Wx6z!M9qWs)h;Y_~aA&==CQSreM8MqTD(~A-B;gQ7XBYDRO7VwL=&tN&~c)DHC?B z-*5?OlE#Bgo#lzx%ajynnGSoYdeZzIHc@Pka8h0`icH+vNYPB8vz4NS%wRJ`3*BAW zDO$*PHdM6G>1(NIA-4llMGNJAwu%;F1C13eREJnAT1a*^SG15BX0KR7w70=x4b6TQ zi!}uMn=D$04zpRb5S1!~?na9if`#q^2TIl6u>R`64*KI3nkpGkRV)qzh$>VHnp@i~ zT3V_ebXfnlHe9q2BxOC^p8HxZTBr^+U9^yGvMhAAU9`~Nk@2F1`Y`K7E79TRix$#- z>=!Mhc4NS3Azr8%yI3$i)WvmpZ~PyhCRLbUFoKY=Ta2Zt5mW#@bRFOc`s-uC-+}m&67( z)R@tTxo){YDUq-o(wxB_%F_tpr~LfqRKJ3`UKlS5>=eaTQHYu?EE=3v$)G_Yr8}}{ z03fCYx&9+tG^q6@lZFCP17Bkr@!jK|G%p(^W>;t_8jvk;0+F~UYp9GVMioSumqqlM2*WE0C5q znt`+>neC&BTCq13uat`f^Fpq*~5xgczz$;R2;`7P|etp>J>K%Yi@; ze;lWij_E9=2xV>rwQYco7$KbZ@lU!qjl@~A27p>k|0v(!4{|`DrQw)lI9}3oz6q-6K~jFGN*A7GXlb5k9NxYX#bZJRbS)3BeiNI638k$yaV--teZ_3X>f zKQO-h{IUN0@>4VX>{II#Ggw8ReR`cdcy1g$ICG949Niv$@-DfTFm#l2Y;5S}d+%u@ z!@6s@+RyPH%h2$E+nl0Q`})rNh(kdrf1G}O2k;5vT0$cTh}}d`nxT%lQ;ssu3?BzGjvl!U}SIIs1AxBHEnr z0iyk{r-_DGn)v+f@mp^ca^D?V$b8m(p+Q~5ypuM10V{^n)6!E~EbzOdxxdpPnSD;I zXL({t^?W0knVP}GMw9Q-g?-EucCTZ3Yc0?B_gNARTyI_#ALXZy^@?bIaG^5&od}fD zLyjqo%pf-;Mgi+@N8U%A+)$?@My0D?04vnp#fTN#jc1W)LHBcp0A#rrudX2uZts#T z0pI?o>F{&mcF7#2tAxJBojh3fi@CRiws#Vc?WW6^RWZ_>J=gzad-(= zB#HFG(KtVvY;taB+IBfw7XvnZ3uh0Y!7L#UPZzCQ~{e?Ky|SkO8}jrlsGov7=>iq-dz3Q4P~t znSekgfKBG9VU^kP` z&QZ4Kxq)G!8R}N{unmz8F1bgW5$Re-Pk;f7GgrAA+fVhDh;$oTaR6x$pJOJNZf*S* z$aQm#1chc!a+E}*W52nQh$fx1n>6Y3_<|HL;=;6=tVsKE=fON((h&>x1u)@DB>fc9 z3&%fN3fep?kgFziV%nceq?aSxgz}RNhNhDqMJc^Mmna;locaFgolBnbOW9I;3ta3H zyzZKVfvzK6@j9bi3*;GBxe6sJ9VV0qELsw`9S#GP`Utl04MbKLo@;usk@==+MQM^m zQRKK;;AV!M8owiOW{pCW8wr@qlu@Y|^@;|nw}`G%7m#3O@&l>MQ%zxg$TcM!T#mQg zTM83RVS4D@W*kUXVDaVlfa^G+0SJU$g~KStQH^QJ4ztOt5!(Srl2!Qmt^S;^sDRXdd2%ND*uGGIFdHR#dP@hY!{02DsFKtTd?)`!57x!lh`=o zYAq4aBLq2}xJYL!p0e>QUTuuxq3=OruTa|`Tp7sVo~!#9?l!A?bNdb%q^U9`Oe;`JE@3(t%Fw7a-Bm}N`(gp zsFbMfDlDZ$v~w^@sdV2EloAo4xsbZxJ{VagdYll}OCBn+&H1!MA}`qw5vxRNNN7ok zP}hKxQeoVw2f$v{Nc9dLsZr_|GEyVcKTxDZD!-8Qg0w1;l5UvYgF;GVNN3v{z^X)P zSO7?g)UdFRCQ{5Q3!dfn(XFnkB{HI1-w=-yE#j3bJ$bM0EJ|cS^+L`yz2Z%0ib7sC z5tb1cooUK~{eY)Rqlb14#+xb;WV$KhqHqzP!3^o6N=qKb3-tN>B0ME11gl-z)c|(4c~4EoM5El%pPKk+7;va?wMF?W0s0cJ-M?n$Pok^U|mN3`7xr6%!I)#*L z@p(Ej56JOQs6XzpXWGa7TaCXffS>qlQDp5^O4PO-mupc#S5$l`z$C#;%=*4td?=yG zVa|mc;GuNGi5=JXB44*0%MHxTK)yj+4{c=mGjz{1Q_FU2GN)8kyJ{_XP0FA=!Dh)U zeS3Tn+<;VI7}*u?Zv-kk+;+KM z!gGt9TDHG8Rs)qG*3S~TLEc#4MtR%>`-s561A?X<5J=7-dm;O^5#AaAF4#M zRrz$R0BM0m;jfvVh6yx9!kGc$M^!BsPRfeJs%e(Z;|FIJfZkpg0#vjH4^*vksg1=a z8@0=7xxHXnXH8K@YA;x}O^H()wZXQi61BZx;a*Y@EZc9V!?oPv7`gUr)^4#Uu?1!M zR+rM!Y>OYA)!vOn2CKgtsqRV*-blQ&I=qoeU$uB6u^p(#8|n5_lQ)tYs4j1$IYe#V zNU*E=yphN-HF_(_-s<#Liv85;t>pTv*BeO=Q?oacl(+ou>h?x*gVgSg6o;wb8%YjR z!>=RRLml5pj+E2`ke3>14pq-L5^d6^cUIFkQr?lezLEAYwS5c8;p+QF!hO{Ejf8fi z&Tk~$Pp#ibYJhsbk={Txe;aga;=%5 zsT{616>|Z3XR2Qw;M$6>L_!G9wh{baZ0Qm%$#864f%vIBmM4lkVb_2tt2(RB6(*f^$35tpLK$>?D=*H)6_jpX|GLmabAO*0%0J3ll zjuPyQ$JE#=akR*rB@Z!!q6<}`g|k1?t1=XXomA2o3Q?*7E?KhwhfZ05Aq2GjGj?9OJ*{OU!ty82;y#lC8TqdtjA1# zps)_aV53Ei!epyBEk+5aWqJOv36sSNe8V<%k3uFnFbgfKucGp4&O+}xca|H} zRI+MR=k4JLgx_% zjp3TU<2#nEQywOSk#g{z$r4F=V}z5*Cp<=nR25^2>RFC2!zBXa(Hb7)b4T~|%r+7P zo`r6Z_>SqizGY{rp18Ul7_n49=N@YS0;JT9n1g*;}R7(fi`M;OX*rahZnUM+zka`#ROm?DZ$%A70> zkeVn>EkCpp&yP~WLh7Q_j0=K2W4zKnOC!=O zYVi~bH|+(MNivVMx8L$jhfo8s8rk@EaFMRhsC0ZAZ#@#@Rs5=5S=`)Im zZsfGQ&y7qR-l_`d@&D76VT>vBhAEp znLw|B7LCF{H%NQ4SYG!RDWEeN*Ov#!5g)><=$Nh_h1sNGZRIbzb(Sxyyl}6M%2w8v zlx4c6>3Ae|#ggI`jgM|e*<`U?jc(G2Z06gotG2@B#l@t!L~hJZ1rIah)MPbZ+@dZn z*H5`l9}+E>^Q9ONPJ>-)7m^GOSD)3|umbF21w6q<{WSf<>vXwlTn2XF27zV4$xLqh zxWEHaD#XU$w)q!dpq@T!q97ov=(RXx+v|%1$Ys8+J3t5#i{sH^KFfe27G2Y}JAMow ziTjH%TWz;GT1%IgM=pElItS5%+OIDog0q4cr(=(VS);9V3t`t*t-Pb50y>d8Kos#T zJ%EfVxo))}io~yv9$Z)`yWYsVw(>D;VGPBs+zmzNvZ4Hzh$5S)bVd|uB`7b0_pdLn0MItkvc>#TGY+f+M_bL=A1>%I&c>9ta~MsdT+QWKJaRv|4D`njF3jVT zi`Pf5kNP^@O=e>=FbsWw&t1W`KXu-ReE6yJVB<0hudbHkq9DHSM2S08!QQ@WE zjE8ycHBoML-g|#eTT7GAonTwY&ZhKt)@-sjq$UyS7gyt|t_fve-UZ~_4V%85d1vIUy;_ct4pd(+=<3! z5(c^z7-{C|NrZc;p=Y{brB>*BSrGcMljuh1nP1=e zF-FbZ>yNWEbS*c-#X550&;ux2V#cN)d5IAQP7+vd;<&M!*DngF^+zc|&uQqSMh7j8 zhv43o;CAd%fX9;=P6S~>fKNCNq>G*{cHG4Dbtl!mI8FjPHKR~RqTVnLOk2;`b=-~s z8ZbUMF5yIzLVNur&Hufs($zg}v~)q=u=L;Qt1GHy8<9d4BNK1)-L zd^k1QnF%m-?UWZwjAoq$GQDJ5*TKO7`-4VTywOM>O0z0!8}nra$(}Dl5N2f_&IQWrvNBHJCr-LoR8YG8%uti>9;qc0@D#E}Hy% zh;F!mko9u{=o;J!u2&P zbebJ#U*IJGvhiv;*T5)e7%VIU4zLdx-xl8#|__dP_A#~*Zima9+=EnhBsI_ zOiE!&Qvi}L@j6^VioFE7XbQy8%Mj>#;P1(*RskDbL7n|ANps1}W?Q@e2uOW^Ed|2z ztcl3-53fUrbs9#MUiEPw(pX<{IxUeEk3vnd;`9~^iCwn=G0i(cO^FDHP?Jjt161q$ zBBfhnKDP8DZ{q~gd`0l7usko*q*j(a7Dd_Lc}c2!xtd>T$|}L3h15bcOOuttIS4t$ zNeM+$Z3*#1+<84+vBiXH`R6$&)!HyQo8_3Xm*I=~Ldx~6+m*M9#K9#IgJ&=ANr|BL zwt(0sfxw52H5$?a-(O!rBO#YqE+7b>yS(yC?VX_QJ8iE@aQE%yQi(Q-T?}qPZ8t5& zL7e6T|K<)WqK(UR#ij|H%L4LOyd(inD^6Iq*_3D3fErGdxN}sQc@g+<;($pv*N~su4mnolDut z0m${Q8m5nFM`*IYdL}=-HwFGQj(s@W6lWCWUecr8j8)RuNavAuvf)~l@Di2BklKi=xX$dqbf5RI8)i-o87TbhKx`6dseZhV7+1H$v z_y_qkO3DdSWlD@&I!a*UU4Q3hH|ufh@RGI?z{}!3$nWtbpNO4N?+p#Pq3zsh{Q`BvszM(Bq4H+1x&qlZBj$ARMosbxik z;#P%-EDy>d7wx3WAFCG!y6TVUu0YyJZkpcaOKv#s&^l7dkgi)QKFh5`-K6)lfUW8U zmRZ(&e&T-m`QvH);>bRF@d&}jM`T=CXC*LOT_a=#12mtthIi4Oqv4%&p5@B=t2-O% z;28I2%#sV9((HVP#xZ5(dX}J1msM#oNXc1g-0t+7Rl-A6n-zLpwVIXU-4&V@0=v;= zR*1H$F`p9yH|sH}C(E4kSncJ zKie3GTrP_~>_yE)NJyslY2@f!OywdA;-ZIS;B@w)<}93bNsw1wv*W#}fif?JiM`8a zTQcpJd@k-BA#F%ZCuJz2Rw3*Y?tzOd%K}=fyId^=l{pESkDjshPY|5j2Pao1PZd^M z2Pn7E=p3ZnN@#GPax3Ls1uM5!&^chal~UiJ<;=;k7te2o0ZepAS7G!>X z97Has@@6d0e=`1f5M4>+&6xj12TO|e9YnNiAam;kL8CAL6Lc-v-T}>PsgkE~j_}Ar zk_QbW^}l~$b8AcU8*48N(N?lj#Ybufx)^X!&_M%GkO56KK6wyTl@PU+-!Bs8eCDq0E~h2d%zIjAPnLoY}yLlRIFVwi4S-Ky)klB9IaH#pM!CvxBCKlTeo$ zQ>zZ5$tb8Kb7kpTt#lx`(DFj%^kE;O&x`7OC55SLWV z7CO@Wj7;;yM9$&hP&eA~Q_U0Py|RKs$D?n!BTZY*%uV>IZH*-j0*EgW{KOr9@%uge zBLb}tHE=pJRi}@8w*7|Z*S%O=XMQe)yYHpViL0LMy!;519yIl&M+ zEF*7~NAg4hhyIVCgnq`dIS^?DTU7~lUd&&>Lks4d;#nbDl!rHyi;4Qtni%Qb0jp9- zkpx!d1JZ(GiVx*buyJV!Kn55g1yqvT2-EY6L{;Tw02EVvCk+ka2e&0eHeyf=JG89~ zaHXDS>uHpkS(54zV)=Y8@%7XIs3}U*ZDnsuz(C|mx(YK?GK1_DeB=2I+}FN)Go~9h z-AB~}@P^&8ar8>%K@SSLy@IbQwfDA!z1fmNta34xi>$pZVNGtm@|Fn){wPlwMaROu zsA(`j_YpOFTLM4r-6cr<4V&Nw&Gg=ukgdjhTSA&bQ@yt(47GLOE<4`a5)fsww7)80m?~G`EW}x=+SU2h2z{YhKQ`I6A~VLW6);~0ylaL=2^69nfn47Bb4}Vvm<#lND1)8?ax8~9#c(lD&JLibY2Z7C zVYmRANpvp+bc$`-aT2G7=O$U;1QBAx?9@X0bI?=6)FU(XVgQ@QM&L%4XC!9en<>Cm z!oam`FSdffZw5W>P+<-9w3tANb_z(=Fa-FT;CjRq) zRcpEiA+}4@VF-hpiDgr0VwD50ly`l2P%Yn!3uSX_TxglLp}W3|j)rS!&0+Zl^(%gpL;iCn|7E2cfC9Wq2_FqfjQ7|2gPzhYD-_mk$jnOAgG^6rwM+ z{S_`Lh$2j02;(RSK@z#ME z^A?LGkh9{}!>}V(G`9f&H+0|7Or{F% zr|duja}rjp>mdP#V9rX7=b2$+&!=70 zPf{DZul3#%_zz21G~<+_8q51BF*AT}lFRg9^@`jUd+eu`CN?jWoUgYYj9u}y0`=T_ z#DySpZByN1AH`|%DLj{^)9~XEAbAap-S9~t&Tb&ni?wARYOHPA9*$jRfCIc>?P`_d z>H~THn#|GfEw+0u(<&V)P>D+@My7Lr>+@?L1d>%tfv5pFziGJNMfQV0nWmf zZfAagY%v)+mY-5acBj&3g~TV0>nufRn9MQSB}H!l;9zH z@OQP5YbH16@~sD@JC`HZRsAAsDi_%gfO*q+k;TzVcW`nm4$|;fpS(<0X?)IyrnGUF zUiRVa5`kVkEn8gUX~Xt?)Adc9LGpH7>`>DX2!{^UbOm+jK$?6gfwUVH&xlY1AYlL$(E(=+dFW<+P}0YuJhI6*1Cm?6wA?=unAJX7q)o=ui_0gKBN`n|+lM9;!UWJOVTth9;aDVWVKAQC50nJaXoK$POlbp{M`wD=b?_eBQ^R-_fFHTj zC?yTb)xK=xLZ(TEIs|FANgaYbHB6Jt)FH5VlMzMOYLHYKf9Jqa`p3GiN;OdAGs(Ln+-}W)clqsy!(zp5;!jF(O zx@M8F43`|+tRkPPQrq|$>X%WNyM;0X{!@Z(Ee+ks0^;3sHdVx+zwyeG>ZBx%{5 z2I-)%RmGH=hccAGTZ%lmSxz2oW@mW4MB>3EnVC_q9ALS>Z6Oh4&5a90-mu48kIRm% z?-qF3SBd`Sb5!t5i2Bm@uO^a zjUO$;58%V;7cOn@PhOvsAJ6#H51ybyTZqz9iA~%`mzz%eA`<43XcO#bAxa~)6T^bj zcMPvlGfuFngh>`>p%MGOuItETWR%#?G<@5Q{S;j01a=1hG$+I!6x%_Vg+3g~;fahy z!yam>vtNe_YwTBwIXtB-TVg#iY{Q96 z$MPT);lrO%`fqrE<20KfJ-Fe8mTQoh&$o8dj4}&naUVs!7+X0~rr}#X(gR?NIw68X z3?C6JC{vd$9V)EJmfCos1}R`X_|rQ<=EQ~`WvQXtQL4v!kj5bbO(G<8gG9vPJZ#(M z7wILk>n7Uu3=1pKUWSVaMRoSv=4&mjFOgjOY&{~qq)!7^Z*$%@JjX!rgR<#AnNQ#f zI=P~AVU?TJcYU~6E#HfKWpiuXYwEU1Q8&2j3&mPq*Z7~!r}Jls(WN=wf?JykZs1M} zM~opmzYo{@2+8fuAdDT`@%+@q#W=xD(?{4zYQ=~piENj`Q*!P!49AM2C=3y*K)jTq5eo(XnOo5MFdR9NHAe0&tHj7&GsDPS!%GQ=Sw*2MI^G_$EUiJy6y zf%A8q#cf=fA&v6eJcH0Xhj5;|nrbI7M_i_>#qGy)Nrgbgp_2s>uELQKn+TyY6P&aY zri{!P6I!X%vHb|)B8ipZP!Z!y4=C=yMR+zAdTO~@j8iiDUEel4R9IuoVu(Om?w1jk zxgKYB=B0=aNkZR6K$wY8&)AN^orwEJ;58c9#+gWPDt3adyjL_wo$Z|cw(jY!*pJRB zIr~kgPkGkhhmBwcfo~vcMo}D-dHXA5fBgnTs=Fe+!{a{er;_c*eWIl`?lW-l3Jl#V zlu^rz+w=MId@_D8S(2LG{s@iUg7X^6mAQ^kH5keU&+rVY+*K6%VFyD+$Ot88c(j zf~=2ssP|PM*06ek$&pn|;jkl1prkcr52z$6zY15eO!y#Cc($a#ic;Sxn@Xh-jUW^a z%@IyWm=zEz%@H{i5`;-UgVT9@q2QscCM&{1x$_lG<~PXkN4E=&r6JE(6S5PCI|p6a zXr|>Brmk|DJ1b`|HQwjQ{p2#xk6vHcM<<`$V!9~CXB|`ME%vv`Yz*^&p$`a=p%(wt zc^?e_Q|AGiv3}KrS6556PVi-?AemA%{o`bs$P5XUDbpJiEmI~%rhgbckT-c~LV*h1 zp)oUMa$Un_%B8zU&Xmhbe|r{u7T=O9P9^+hJ^OQoNttGa07#0R@clXM?xe~%MSM5x zbR2RB0zR6<0DXApS(<8J-REdg-@H9;kSbKu7&1lf?C&s3)>ro#7SVD;8HQB!jt1`p z?ehO;@6CH8NwPb!ui~h|V7i+f8Gav$ot>$!%&w_nWma`n*7S{ppP5k^84--5vNCH% zSnMvr)p7-`1c`tIN(2^=v{*nCwZwv4l9Il{@H?=Fqra$+px-ld^V>cAh^ppH$B^Bf z5#jdC+|1syXYcqupt?u_3W`pqtAnp*U(H7JzprLII3SR`Tj|SxGP%BxR!jefUnK!4 zu*U=kB8ZN0Ap(OCg!1a*t9!WKPmxQ2r@_fcasBGv_@7E2d_W^+hxrE|eEnX99KH!B zjL`cuit`8VOuC(Kq|0!+kdU^xkk*%z6*=x^(rUgz#yqQiiWm+Fy}b&5gdV>9|Ni8^ z{Uhlq3#gJ-3!pXO1rMe7)9xyUy?{-LKl=U$ADm-Z5Jy8Pnl-hD6n#qxBV9gJS(zg) z)oaM`M`FY(7lnK7sj{k!Wc)uXgp^QWkFfAqL{V|qs*JQ}U4gyXb&-DzbF*pM8u@<$ zsQ!-Pn}8NjJm&ln*%u<3M|?)y&X-@)4rlrSUY4U{0i?e81J9;mPxFX4=HsRF1e%U& z>9CKJvXfB;ULXqQ4&yShES`$RuEx=)Vfekus>b$kdJHorM1qdkP|Ic>ee z@2fIxDv*w?4^1G5V_6y8V680!&5c+k5<;p{Z zHH!uwFjB+At1J^^R0Wu_oluTzbLB}7qD)sPqMD5b72owFoT^Doq{U+<6$zrXRUmrB z42$OD4m`vCLeQh)YETub7LVvjG_THVSya`MF0cWJwN%@&RISKZ$G1dWoQmn&{9%em9w;Ecf~AiyBnn}rB|zvJ;{{90uNScX7nDy&j@3&Vdxb1kv;g1 zZ=OtlI`tnqckXA;Uiq^t+=6`tH{rXJ`#+>>ReVY%oULFh8bZ=+FFX)j zUbvNWwLF=kz3`|7A}-F<;1W*hr0<1C%R@28_&I&_UNV~!Zb7aT!Rqs&w3q{#5hCP6 zI9BHi7>(yMy1INwxM464z6z!31cAlNTWLL)!Wp?-rQh33{3~`@MBd3Qu70n=>3l)j zoHUQ5xEl#Kw-vh|QoYa*rQe;efouICYc^kB!V2}%pPc}RVRo?r;=(EhVZaZd5lw&q zJWVL!t}ESt`sjd!9m8OVRp%DBf#jWY^U@k^p`v+bScNJYgYgrpi0%p~p^A2AM1(3L zeW4GkXvMm|INtkU98{6z^sv#AYi^snNEM}oKtI%iDw0Fs399II#UZGo0W0_bz=1l7 zy^#g#2=;>zsH4^&E1-&Ea>MKe3Q$Eck*e6pbSvOV`h9nDN&)1ux%hnvW@*p})2#cx z6f-1Jf~^zxtEMokyRg@8ouOYvE%q1pO~tPwNsLz{+r@rTMN_oT+GM!jD*mPK`oz+@ zioQs9?@L;=@0TuLGYfOpaQoU8@ zP-fZS9B#bQccN*Bx>n8@&pJKm5qV3-c*QukrH0oxfs1BVbn9m#1L_+#CVN*j14~w9 zbq8@s$V&$POlBua?^6*3LqNOf(I3}6LNd^Y_lhao>`S3Cz`a5DHR=sH+MJC=23tOB zJCn+t%8g7e_s!&Ll50uVJn;p;fyJXj;4isJ;GJ1=mgBWoVw?~dv*WJtvULAUzsO`n zi~MtyBJhfd+tZ81bfg_nw0vwpdwBXndW?KMTtgp*Nbo3X*^4{$SN2Hb2=$voJ}$spSGHxm{p z3~@0eqy~8y5-KE5b`u4Xk{s$^NGNr+5GD<~dl!sxq1aaknX%h4WL zpF%ctFe7kEPKDP`j*hh_XU8}2uD5V1B;!j?C5&aOPeHWWi-v1f8+?_9;3NVCbHo3p zc!b77g`3vJoW{asFB(J)P^HTznXT`rXlQr9TI?PtZWAT-d3UqNw*4Znh1 zR}+2(iD4G}8iKtI_%-zU+3#zJ^*7&F5QI|9!pp|JtoIcJ#Z8=yaG4u?FY$;39%20l zwXEH}S>31;x3DOF}`l5`-->CP)O;uw%pef>;bJ?L5vL6sJ7eJZeKxh zsM)@PWR+E&$yFBf3$J|7wT@+T6?tKF?@3uS?`N~Go`S(9`wFssEcO*-c4M%wAe`FW zy4dS02=S%P8p2zf>no@YwANQp+>x=qg7Vw2)mL;g#8h8FZlI;Uf?~6w9+<59NU_dj z1$hTG1J$! zYqZjrTj2=nWTc0wG(Dk(2^%q?!swg%N~i_Z2KtOK9tkQhLm!|C8C!fRC^BEx80ceC zISW08v?KdGDE)?-=P~k}aXzz5bqK61t&%MB=Lmhf!ioUeFq}s8-%DR(K> zQoaZI4d{YjK?{7;BDIwWFtJ}jp@N>kQU~yD9N1r^mw|O5KZh8x%9-(%aCkK*>93Z&S{vG%DkCf&5*iK=U5(TE)=V^m z6}ZK#`8rm$4TRxsm13yH}N(vq|%?ZchSkYEf?{kiYX&adYH zW&qpAx=JEj0dj|$*T4cr;x63hl%Wae*5s4VQk#Qwmb{GgQ<7r~=Jpp7sX23(iV>9Y zx{Nj`e1M5I00NmoCV778F5TI!OZnCWxe{K{XRIZ{9CBDewGZ|IE~zEfl=)ZdkQZ-N zLNNh`5DF~YW?I3vy5sQ!cd=R{gl6=VtF6c!Kf4S^AE7GuG#t&N(P=ojxb)^r7@dQb zKw!J+iuQ(kJDt0TH+h3?QUKG|vAen<6y?CQeaBEy0on?E+mQWGHa*XGT`RCr=vy;& z*YYjYxK^ZY_Kg}-) z4&q)gU(dqz=-MUJ@_8KwQvNBdX&<4ICnCD)B~iqClq3q^)eIA0@u@`Ny^h`00`Cc6 zq;RyJ&vDVB>Jlxi<@L?;oL`TUgv}28Ksx+7!X(vp&Cn}W$fq_5?SO?;0WQgOj8dX# z4P4UaC{%rNgSO4i-{t{`{+nTwTF^LX2cOi2QfC;YdZO{IHJ)Svr^FXiTr#%eDebsJuT<)vc4Yxyi9b_hQCfDv2Kn@0jRAl;F~0z z3|YCUMEYt8KqUP0<+Z!K3YT9WO8?}aO7DFXLQyz;Fh?#f1lMgW%2w~wli&NERQf?s zfqsr)pXqdd1I|c#N2x5-MZqB4b*^ve2Ifel8-EbfTR%k^pV|6I4Da>>q6>AOxs^i+ z>Bu1!T@N-sf{YL<1vf(xihcJP$Yu?oup5MX*e|>N?aW7``)q3Ku zGJij37+~*sD9=I;J+{g$(mNi)S@;@TWah($GP_tEd>VT1Y5?iZ$?VW{_n%-pP2c@k zPLIzX;P!BEf3Y}t7DnIR06qdd88pPB(A!-61l#rC3Z=S5FwK1w^ODDe~l)7tiZ-wRDM z^ew;*YQV_XtN;ciC3Hp0kFfLoOKM4xe`5kvL%B?r>O_ywKkbiAeyY-@p?1a7seFi0 zw_mbLT=hvA1)8|tRBan%jsvN%e7IM5>*gp%m(+dtREVcag$Y$&2J6(+3`_Y z6Dk<|aRwFEG*u-azl!WBsPTtFzPe_bK!V1*h};(unWVuGIRWWBP;4+3|3$X4d3(mUBjEp!J#2*rlsN)!M9mZLAG?_(+ZV`pEK{X8MvV1)NjQ$;z)k9C zx`B##)$a$CYxT+5)!pgQ3kulT#rsiQ6KuP&q5T$M^4u1WKVlsD&EkB8QoPf{^t}s> zVgtHV(Ll_FWdtZ9w{0$Vk2f#u;E7#9IM_38Y7rcP(G}vhn&lB=H?SR zPBJ0i#V&fFNEsrY#_ICu8TxJ*{fwKLO;Y>{ zqnIcHj%0jd%YYd6dp#PiE?sKae#|7$DCC+b?Xbk}(gDb<{8zBPDH;_RtmzeN_er$BdY`^#*7dY#;+Q z3`S#@8U`mgT*F{=x@#D$Ssx99HQbek5s#uq!+4U>x3GP-g3V;&u`>EZ8EoeC>`FO( z`H6ONcai~{sf^mnLfO|I4H(;2@R_}ss7A5Ru{o9M5n^U9CYCFqjbx!;dtOAo+hU^4 z0au~(VKZjpB%mjpA)J##$lrhd^Z-^q#H1iNgd)g3lvW!bVI?c++HNd$BduJOaq zCaVqL{GOvw?F5kZNhkz|o+o_|@%BKqpCMRbdikQ|w)sQ7_f)oMMG#~xjbnwB@HnlPw3h@+o#5uxJ03`7y_mK=5>>fL8@STBf z>Id5w@1~w&d^ZpWdmq@Fdg7caW-+nY4V%e?Og|+1`hgC?!l|d)6%wbO614IG*!InI zdjsS&lkJC-(@e8JTuwdRyhQlioF z%ZUfAY#7}Pp_FWEM4g6d$lRXTM6^c4uct|;@c?|CdcwrIMdHHLGi-VVm8`*tiSsUK zJM{yPPll>qXu}LQO9?9duy^VQjuA6Y-W$r`{so+HZ^+(6hdE2r9=NGF4G@b#p@*&E zZUA}e=OTsMh%puhzCGU**&Rm#-~)*=5?Pul$j-3YP3dH*=YV#Gb&w;qBYge(#T)|N zQ%`juf=@kRxFe?XTV~THDGd)yrV_DY6XL#V6XL#X9Lfw$pZhGzC_O;>F=XKVG$Zb} z0rIIG?KV80Z4I};`fO|7i0)I{7}Ht-@&kj`0k`kQ82q+E4)0WX5LiBn4i{As;D>!F zlowomAAFB`$sq7o0{mpYOhrx!;V1Ldf@AQ<->{pa7?y>C0XxF@p(NBI1i!m*edKkk zSrGpF?7IYUpZ}Hu?(?7HCXM&%1ad#$OU5jj1>Jx2Ljq3W*W^Qb?HsHR1}_!|2m!QK zT_E@Qrr83xuUHClExb^cebl}V>`-+z%eQSk1n7RKhxiF07_Npbu=js#Q-^7W64Tw@ z|Iy^#*&8A2r)!i^Bo>4p&JVmAx%Q zI%E3R>iOfn|AWD)jQ9SJ$;B)T;in>HlT2E|b1}@0A*j3=^S_wq%e@$A*V+3&#t1WG zbGgK#4O=3zBk%nm!jFQTpY>V{o7yZT5YD(QhSALsO3Cj1AG-=`t@2Fl{T~b-kc<=v6;ooboHp1`nYF1#(QXqPD zoZjC5kp%o@oCm^{@*VPj^eb#oyDu|oKjfn!LrMj(eVa|nC~+W55Ml>N1*L+KZ<}d> zpF;^%p$hGkFbi8@xk4CsKHsTz@qjk-+tAPO_hGRGNe^il0A7hEtwSAz)~`Y|L0$xw z4SxqgseOu7ZCQi|PfpLCJ^JXy*^_6`h`!D02z)yCh@&F!VQaKq*1agEZI3wmkvCs| z-#B9B1$R?pA-^%x8Qzi4vb=Qtyc185;{hsxR zqv`pE3Jj&AsBcvU%Fxb~WuT9Rx(sTcx(p03fTVsdGc*r|j%DfwZ%&&ezH5-+e&r&h zxVXgZ%T+Bjg-9H|hnM1myQd(r79jqXWe`?>TpZ&m3Je^-!og1+`ACZp@1kqA;wY## zkh}|E5yB}#T?oq+PZ#S&1cl$by>h%q3p9GYdOY$Hl)K{qs$NGaj2HXB+Xj# zHz@0IJz6b7REL@h7!SbWO2OQxwZ*ROTFs$)pD;BO+TXbK91$b(O!N-xSen)&w)3Q? zf(^yAMoy>)jw>5xXxO2mW0$BN&^L@gQG8ccbu)C#Kn;F;>%y^Cu6}V6B9SeR@ccbZ zRybzwim#|d3u4-dYbX+VtAFv?TYT@Y+#1Y9FAw5?c6sv#b zUJ)l0C1>`xK2kH=zMsU5hg%Yvtey@e1P;qsXeND)H;dKP1T`pDF5*SkRGJwahqr4X zJ+~3bi%~8XIaCDbx@SA8O87?QGqyvArNiKaZyxDWzI()3p!k7hq9l{8nnC17E}h?22xwo!ivW11 zII@NlTn<|vu}4(RER;NVc6CnwI+!eOXQVKQ$rWYHhOcdMs`CL%!qt;@15YVxy4NXqY(RqOcZaNN2}F_gdL^9 zRO$t)ZJ4s7XUb)r-v8`j#h!`3?z2(iroDED7+-mJ02o)6kt>kwj%V)er$BrDYoos1K6I_Ra_sd&F$OyavWsmci7Ud&hH zx?w{axL(*UGp>e4I;t4O4%Tb;I;40aIx^ZOU~Z=_sDUuI{0w;U%%C|f5N(b^-8w!{ zAWMp+%cf!)3amYOSiR?;o!$kXzCb0a`|8Qr=L(<$e~30|IV~{b1T`EHQvKyOfBjd# z{?kAGTKd%={nW}KzpjE5P9;}O)Lf4!jV7pd#(@Z1fqse&ZS62w8kMJiB# zx%pCsp~*5epakbRD?t*yJw5XE)4R{_PG6q1MB1#AM!f6s_m7S5-#`Ao{own@=J##; z`;LrCOf#~s#g}0&F~pYwH&YI6SJ{f2d5@72##t1twNwZ^wIuM)9)3Le;?ozO9ZUWbLAwR{Dbf?;roOU;Ur|JoCMH#|UL( zWgQQ0!%6*``$kC~*A+JuKrdu@7Fu<>GU$WEs-`H0u4+h|%$^5Ate(6+IeP&t=Mx%I zlUS|Cauyv75UaUCHw)L?qn$)-+Oof(EzuYvZZpIN3Ed2x-HF~T(V+r3L#wM8&NS^V zj5CdQBa$-&Yu$4Vf?4n@A+ql|c1e|}YZ8yRQk0qQgwr9Wl5D;=ACk zJckIG!$C*IA;CSTPfm~N-1gU#SK;||?q8v>wF`f&7_B!CZt>i&{>7jF{a^nNfA^RF z?C<{aKYa81fBvgK|M$3~ee=Km=WqV^fBWk{_z&Ow>wnL0b_WL_25$?J`mV#^9L3zv zxoz$o5RRNA)XR7VNa<+YNsTvuaRC<7IksRZhda|CJ*2G$kh7l%imLrRW~YcLkFtc> z56x1e)u>gnd9vHK7oxU#2A&X5}h^b zu6?m)yV1Mi5p=%_7X@^oc2Ar7K3k=4EMvI{g&hp`F_^-B^)LVA*MIi!S_o7~)Zs2v zGwWSv0lNvRBb*x_8#bY4MjR z+1ufNLN1ujNk-gjE6u>;Z}n6^IX?O5n9@GtbNv*h+rUcFDh#hzK%ker zP(o-9Uid=7FDvOfTwl%u97H`%@>~$KYN)EN7@5f7Wd1q}HrlZ1^rLx`Xswm3Vnpoa ziowt(iQCwJ|Eat7tD~V&rcl$=OxVYA5=9$2hKm|T@w@h zWnwn*ug6hvjp4V@B9f=`>Oj z1xZ`?S`jhO@{%Z~Y0F>}=qqsZLvX}BjUPRK+HP604e~2fiijg-;=ZmN19E0zU)P}0g`w-aw(2XWE$`Zn zjo5Kj^8-pm;L?*DlX-Y_hYm{-alia;{`L?5_V<7JfB*77{_@YHU;g*M{Oe!-I0X` zpkSJdaxwQ~A6Co}=*Nxmh)dk48mK;Js15>0V{S}48$WpRF)owtiUQ7BNXyEWdH&=P zsIjwk{Pe+5$m>+X8hSEcu2(;sAaNotJXnr(ep~U&7BS*iWkb$N-iPy>^`(1_ zn80<#s^@?0v+Q{az1Cd}y0q>HZwDl+p)9W+sYWv9#J6bs#0vHMtLE&$t=m|A{VwCf8B>?U6$>jthSY zP3>;HM$G@hZqzKGx!K^tp4&&D7Q&5FciEVm6|h3hHm{5)JsY>25~4N6O@1GNT7RF8 zqu2+8O2rbQd8y)uI$0#CO@AX~ru7iJBO^1&)W|68&br9S4K*k-DqU@etWkHfA#1i9 zOJO{M?ryhz1nRw$qilTbJ_2%AU^g%*5LuYrQ zH%oM=0M5|rDuy#ny9?t?&O^&!@)#hk3pEzI(THroua2rC<6fR!CX zu>)06LJKBLd;n;ZsXMM=L`Dd^tm8Tc{AgrPN(`_TUer(=Epn7Vv(!kD%>bxPp=qg_ z1-vE)Zrspe<=M&x*bW_*46w<%3BxPwy)YkpeyGDH>_w3w`|$ilhU**nuWm=S<$IxJ zv^2cJJuthH5H7(tTvzy|{K_Tf)z)vkEAuL4^z8v6uuBtXNh7KQJoJ(0gfwd{*s~p} zJlFn)07O_;x^bS?q3xN#V}qXsjwm6cJ)}Tf!3YJH&idM2aNfxo=*v&^k=kV{y~MY8 zfs*)EZCNu+7E%@a*a|(O3Qh4%TWpv@qY{z)Rw;Sd%+3)Jc@LZIDVm|+RB~O@H{D2y z0xh&{paXfT8mggf$*OGnIRP(Qt{*s#h3pW7v|4(Iu!+ET6vwqZS9eX@_rt*Uh-1nE zzC(v40lxws)3tj?dA&l!n~@g*7Y-#qqrh-Y4{!?(T;PB&0 zEu+ODJQvP?1Fyk1W>=xUW%&{*-}<$8CFL`*54Fr{=?bF3vgmGny+)o~9eRDilz=OkX3oszlY&Jq>tV4iq%Yvk=YTLR0e$H8edTktClhN-$Ugj? zve8K$IxKPG0~W%b;X_-sJx4aw$d(lcYL%)OT42Es?*cL`)Lc^u923}LEmbZ5a=r`? zr8rqndUkyO=;XM!tGjYN6V_}!54&Q`4A4?7Ynmj+G%W+X7`ZF=N`*A$f+}}{W`FC$ znA!Hd_)-kF#Fwh$s1_m|)5w&hud$+%r@sY1=9_HcL$hPd$;IV}m-SAfPV7MT0&tHh z17_BJbhIWL(C!B~-4q37FNC|NOX+X2pBTx1b?V(t{rKnb< zf(smzj;=B%cIdFgiOJl6vN#kC1*f6zdgv2HvNcchZCAq}0CVOUn&B(H?*Ij`?Y(C; zodn_Xd=}mu5V$Zp>Je^|jFXl<;l0*xz9ZhV+t?WZj7LzRxTgyp7U7%-wV7PZ`Mc+M zFZ){`-pjV{#d~77CEg>@Q&~fNZgM6jeT}K?3Y7BE<$SZG=Sl4(PKPFhwU`(-b zTBBIX5eyG%7-@m7dRP}%ix7MZ1A`Iho*v1zW@&(KA?+>UMbGiH$n`YY({#^){Xv&Q z(+7#j1a`1(DKfMLjYWr+d9g!>C0}4T27l2Q*we&pR8-o9I zgYsRBQ1Kx?0KBCe2r6~$(1|pJl6rLi^Bq9T|Cnv61OJlJKM=sVaxW;G;aPY+e-%ob z8Qi^r1R&rIgD}J^2vH`?-d&e5VY=3D-izsSDNQhXAx@Z($Hd7db{1Z!8_%$ercCR8 zJQI%xTvPT5IGH%^hVXr$jXAoO4c`ykSCe4myYPL_!k`L`y8J}9m*>9!GL>GFAYPy( zIw-0eDIHFFr@dO@jmB}pQY*=kYmpZmJbE9fk@5ktF+K_`ag;#D7i4RK+83LO>6QCr zMius-Z6hKZ*l=S1vGMiWe4=TuNw*X}lIopDB5J#d95MGQSFgm|kXR#x(-G?XfJD(N zRrtBjo-2^(_3mQar40wI$hMI_g2Og8qPUBzm+m#7J?K9V;1N;{4Qr$W+Z)I|p*M2jHX1pRts{p?bHm6-@0qRoj|w^8$+%YPZ}ym90)R|; zV0DGtg{PCaEAE)gPknYvrg^`e5|6dCQ#2WxEV5%WSBv;1#@FuhRl6M`M#r1vcLoU` zmWXU3j-F8at@K(C{YD(V;vRvoxH!YVS7XW^LEWK{#t~DCSwN>iY2KIH>)i z1c4Li7Ce|bR09PTHZOON2o3mh;k4Ct(Qv}_x9cU*;_ zyl9GV`pEb*d>W=2n86O}ix?JL zuS9)m{i12v7&wjH2oV0EV|fPhDxn`Eg;9s!z;*#33RrsA)!=h`S93#`VF|hL;d16q zCCt>-E+?q<+olsFyDILjs^=-NLy+W?4NM2>KEYWW>Q)46lCPKn+4$ed=HYf&35aGW zfpT%4DHK~2Tzo*M3hm5L@HeehpR3t1ociP2UczA`2rZo zt4nDO1#LBDcyN+;E1iW)KmohnbpHA$N4uQ1)^m_fn-xZ;?4g{G;lq5X%APCB*h31e znF_8(D3PYYV-}Ek`JGJLYB8OxrR#aHVfW6R?Wor8nNE!?>z?8o9>PLGloe5NLBu5~ z((NF0kfIkkj)U4``a6?Hw4<((pGBA!bh5a!K!WIwP$7($`rGAJYW?!*d^xUZ1|edB zJRc{VqPU9etAUAPEVinmFdGh4nGDVEYAg8!cOiw#<$Ni*D+x)+n7LifQR^2@=g9CQ zOM?tobQc;%=xQOt2b2(}rRIgUB;(SjNdQWd}apS>MS{+AIio4FYL?v4ov$ms_XxtERIPn5t`q zPy{?#QFR}oDW(Ijx9!>BI2VpPD3h>8zO&hRG=rgJEv=zW@{)t=$#ux!n0BZ&wSMVz zo_sBed|8Is6QMhZ>wz~=jby|>Vt!C<(K7Y7xJcW+jnH5K>O>yGJ#fDZ0Yn4+z>VJ75l3oMJYTS2vgu-M7zUJ< zzDqgP`pwhH!r=zk2|z+(loVQL!I~9BDlRJcx2NbRZWkhIfQ&%zWQ);c1@jr|?n&Ne zz3%JQueJ%ae%W+>Tm&&ix{koYfDU|Ja{|XhJzYd_E1D?-D+5R#YWU9N_}fzfTEA&J zIUTH5?_~45g3G`>h$E3YJE60d!o-Z!`W1V5!DuQOtf8nKZp$?K*v8+0G6L(1sR7V6 zwbo8>)1R#`!)Ozin1Kk+1%#9y=wrDp5$R>W6{9cNZvhdd!3IsJ!?C6R^@y3_=dU1o2x%D{Qr|pp*G<6o$mZ4=horU_fqG$ZPZmSNL}|t53|@{zQcDy2gD1`pqLPkm zP(8fbQD*21-w+1QkHK9HoKpkYW|)f>V+0L`Nn%+#{BNvA=R62G;wYu)Cspz8eEG@I z#ofu-akeTR)f*O7@jgEJnS{d4iv?LpuIH<@G?HfXwFE3s{56k&1{zAFd`s`S)74yZ zH^F57J_f)%nVAwzC03&m3eEw4WCkc8|38sWs6H1;HGy6eXKJNJ24nD0S^$ zN!Pd1)8~rx-qZV!CBu-__a$ckLyW?uT2637;{O ztWQJ|U&2J>UWF3MFmei@4R1*LgCc+M0e$y_6}bQwRJeS4ix&ir<7$E&u30)ABR&~O zaGK!}wlK5`G$|YALpTesuCQ7f>*Ep=zP?A84EHb+E?4UNrYh*_Y+ zl!HjJ?}JG|lScE)j@iq}G7vu$h+(3z-e{2hen#)jzPrDY9!V?rHh$O27yRG@w%XTj zfI(oOY|M1Tr!R&`rSK3-CJLAZOO#+bxR}o`rXeeQ%)X#w3!&_*u`+sTd_H=7ZhO{? zpBT~aK3)2oi{N%NUH{*-Kh&q6Q|FAgPzu(;z#Y?jS*%}f)FD`@hPjmxHUG8HK6T ze<;DVF^h?a?Va#LXKG9$bkL(3Z!q9?;*V6+BC;aDgxs zm;*bV6NfU^)p4PM?A+9ROzDJCE@&ukyUy@WMp8z90i!#<88%r6C>9zldH z0|*LwEwHn{oMY***P{)XfTD6SMbGiFlhu`U3@aZB(MzWO@FVGkB8`(@UQA*CtN32D zc)FZR${8AIX!JOI4fzQiZtJy#cmblNNk21X>Akem=ST13$<2(yr2-5dPpF2;9{o_d zh9Fvzm=!PLhq+h2j>QPg?PC|_Z7)QJ+7Vm;w6oy-=C4iOZ}2h9N&JXN=ZW?hHXJQ7 zlW1&VX_v!^;7tMKpX(1(%9~z;S0)gB5`^*!XVNOq^Q81c;DO;b*NY+rQb}SmZt`Ml zoOUnR_J4#SBA!=zI`QW?0r9m2J$?fH0o_5MVtXJA1pkKQ#+?;V(CCQ?AmV+LuK^d) zi^eQT!d@+gZ zg@t3gAELbM99{-z8GDg=#2EoMB%+2>C&ewSPBy4kj58I^cz=p?eUO1p3($Ec^WedLG2qhI(WRm1sW)(tT1{@GX{{vjqE--6>}oy@+sAKjgE)gdJNQEEz?9 zlHx>15%{04J#zMN$VZsLw@`aZqk@Le{RzdDU8@yT57M)t(8-k?4|X#{vH0$6^QLQV z?JXDKZfrzVVYWbG#;9TwTy40dgMd^;$wUmFU4~C5uhFt-cT0Zg_M-fHn>6nAn(-h@ zW;SFOAW#yH$;8aY`x$=%RO9tepW`iBMA8=85=&&`Y!-BUL_9vO|X@<94!aB2H5CeJ!+PfYf*)94!bb40J$l`v|!Vkc}CbR%9!H z$^S7xcd8Kq9?Ws)XTCRY1HPR}*Q<*&b}Z2Gg%6LRe&Zf8J0mz4rYF4)r>|w)ON8>t zt8_B8Grx9;v92fDK!I93m*dtm*xhyx5mRA1*RYT+;^X&`&SP$4&UwjL7DZaUj>j#h z9u<5RITt(+gEQ!P9O-_DO7#@i9E3P9CktNli5m|{6bww*s9x?iNwb!TJTYC)gtZ?{ zaG^eN*^Nd@}uXskeV&) z4sD^aO`dm#@InofB<|fuEf@sI>c}F}QH8+uk%R7gF5<0h#W8@`g5+2qFcN5yNOQvl zUKes`bz5?j(Xu2(NC0;P2oa6=w%cZRU12UPTyB=W_VzAXaBk^mt zo{wG0<_x;T16%{v;c->b8%4H}TV`k2wSZj3Cne|DEI-kQdCOFK@vwM-N*>1D)=7D| z(Bn88GGLj7okaRj_3ARwh+L6k0G#Bt(e2;8^q7XP9y2}XqZ!3$bQrs&U z&v>m`ZkdLmYAW(>lH9jT$osjb(_v9m&0&8{e(SSmvh92A7BSq4-J$~@06Kai@sqyB zi_7`ss^!KgwaV{-l9p}{LPc;D1jL5GR)Ju5UEeb7C;|`{GHD_UNlcDmpbBlMk-nWs zb=mM;q(G_2+XfaQRAd=(M}&T8TPT92L8yA39~ zxYJoMhhWBFzMh5a(Y1?f=5qceY|UTusmKfT+*5d<4{ug? z)r(8Tdz83TF&x9xu}c#!<-LyG)dKJ711xH^p2OtL!v5RHarWj_&GUTAWq05%eat1@ zlSi6j0XsxdMiBt7MnE>~DQ`ZMJ={ z*NsP8+NvsT4^>SAtDa(CK1DUWvG@aT(_)8;r_*Nnoe2Zu6?w0@<&Q2dssXtN2Fb*$ z9N#>d{&ea;bne{Gp1tyCS9d2bKfgVB`9eE6d%*&0VEcu8T6Bh?kx7;WJ6Y{*g095)gL1gJx1%gW_dUGP?_v$>eAFwk03b zdNnjGCZ#9BI?g#^a7?TlydZE6GW)K>b9T3lxf3Fz<$lg`c+RwR@4oc(Cr^~inM&y5L4o~A2wsLDQ z8rotUSK)1664dm~82?6u;x9nTpHJZ-oWo5H4`9z>xoR1o&%&L78=xa?)4=BPsEtDe=|lf3ylZgoD<=mVh~D$h21o4^Y7_&A#qB#f(R}~S@tfa4{1lUc=moK5Vb7t)t;cT= z`V#));Naj5Vfv6PgAunsEAqymg3J9S!nk^l?u}>;b>rGy|Kbf?ei02Wz{Q9XrTeaY z(jK(WJ|F$RyzG!a{d(-2#=@2ExdH)F1J1|bsexq97mfEfxH zUZ3D~)Ui@WvVJBThl+lvs1$g_%vouCJ06i?9ivAy`%ty%5fZ7~)`7nc$7B5aa^tbU zh_b>?7kso?0r)Fv^W(I|VQmXU(a(zPo3=xFrPz#=+;K!tuV#e_ZES_HT_X6H+=eij zP^<^uXaVca0@j__I&msi#2w*vAWLDrL>SsV`Yx3enJ;f9SCi~R9OGPMKd`$|ruXX!fr0SZh%*tm zR7?{lV1c73nDh&Z4vvSIp+sTFfIuLF5bjNwC`9{UMq-Q7$)hvrar^}4W)ZxObH5&) z;h{#eSWI{|jtOSWT)uhsaQgC#PmQ}T&W`UWzJlNVXsR=#%uPM}0OV*FF{Wv31qHri zAlZUuFlXjIZ)KojRGxy6Jb>)LA}EZsnG0?=+a)v8W?DBH%xdjrVm#HBT8iu17L#YP zGHe-0=A+50$t--bpzBJ}Qk(s)+uQQUylnek?;DS{!cuDjU={zD?9QaC@ydn5KSC}^ zIP=`i^@uDh+cqdSL~NmvH{zDuf==h)y=<_D2j?=tU|czr0hf*~hk`|@&=Z8F;UYLs zMM(l3RS9w>L_#3RA=FPnMkYZ!qgW0CD&SMFRnvlJ!S{j?cwq{8bxB#whwgRgu;dne zPE#yB6H^TO!Z`@81mIF=`9LNCv>U4UI65l&s3;==xH4T0>?m-;K>IOUrDT!lSRvj| z!JEk|2%pgAH4=Ij2xBH$u)0K+0YlY-Uct9(SNCA^5{nzaxb@`h%2}8JQ*Vm=umJsH zS{Xmf^%80pK*soNC1YrxuY_;jPRy9Kg z-Xkh6!FeuwiUB-+jq=V-#ED=rlF$&v0xCR8sL6m?k>$V+0Z(iBwylSeXNG!+pU|SF zVrPdAOJ_j!(u#8czIC7nfyn_1hX@e_kRuw=0YbD!s7wlwbwhl#{BE&-xD18JftvXf zMw5#TBnUnp{1h-yhx`qI z#d3fUgz4haJx~r%uuoGC4D!_!eo$lsKTGeCHDhyi&DBU8t^x&C$H($Qr zIF!fp3*&MsO`bg#J!jy<7?utGJiiuo}G_MVQe7_Z@b%Rh==hkT(K@!nT2_W z-Jby(?BICj&jZZ<>fqDRdl#Ko?#3g*NVg~0JkxhOj??2aBx-~Q_ZN$UXJPd1bpFwD zegn_ZQRrAFM**#7$=o?*? z_mU(Qfn$l@-ugi6rMLekhHt4Eqd>#W!T_X?rDiS`7r>N)g{A6Zk@=~QPMB%lOA(BR zTG9hm9km%O6p>AA0-~oeVmX5OazuQE(C(sX z7yueIOoXHfyBCsSC*HMtd5u&WhrsKL_l42}efCC)NWUEtkG`};M5tZ5Me-fOB)r5e zZaSH>@7ryYW)c-!g&S!z8-?9w3Fq<_J+`}$zTK=bwM_+L)dVJ{PF63mM}Bw7Wcu&A zQ!*PDH%R{1KD#4Nq1VM|yh-xfYa;MZB12tRxz=&+y zQkBrsQMJTXfL)Dxc&=wVCO%mPSyjt+#SR^o?v$Cy0&Q`ZgdB1L1=lwe3=aVBFFQax z_HAUog(!w<;oq_yqC8_=8Ag8WNdpTJXU0~!9TFX+^#t_NLCRJjhSlF9(ZDes2Wc58 zyYj0pV&c}qFjHjN^a(6SAC654h%S0@Eu;(^dzovI4~_(WonohXI5Yrh=F1r{aRH}- zbplky=xW|F5vZnZo* z1XFFWL0d@UT#Nj=mL)Gb8e+{uVGWdvMWr9)y+)=HxJGCMi1bGtGz&?(Is}<+*%oE& zC6X7Y+bVwd6d#q;P)^PCQCh)>6r~{qnn#x@}Y>mb!>SkQrtJ@WjmoRkQf3=NT^ZTQ8=|wC}}u zVz?#F)8Ivv;fuwK#9|iKO8y?>>3nj-BG}uoU$NCT798YK)g6?OK>2nZC?=>}>7j?WSgjC13Q8?18cByvg zu*87Lgl4!8IQ%kvzdDTi=oFQWoCrnW0o33^OaO!)<9Afowptp|^O=@VsFXpOmdS|Y zEs(Hc>uJ~#E9#j$?L&m*Z?3BkK2?U+t7Yyh2p@sbZ$3fDOZmEz`>_u@<_PrSM=TK= zafu%(Q4PTQR4qE@$F#FC0@#+bQMg*L9O4#SS<|+_n-n<>eAPGiC>lv*nf(MoRhT=0 z>l}YvZBX|LmstVN>T{%%dsNJU;f5o606LUrtALRPq`o5~0TG3$P?`Y@=h#r^0YZcl z9;jPwShTv$nK0EaFs3l7F&om3Hky&iu5U=`74QbB)Gt5}RP46$6MeQ^nM%KX7XwU` z_8qsM7;W(xRKup)M|9S;*oK9{=b;`FQu$rUm2s|Ek5I83fGB=lmD#tYbu--hZDCgi zl8e=h(*1bjqn_u46uIK1EAvyIJ&D5ImHl4&AxL`UN}9FnY5cZ)?X zHp(w&Ne8C@FRp{*51}f?9(8=fmmmMG^{A^}2)hMr1-=uZh?@oY9K%E)lB}wMf^RL) zH%vDdRRw$+l^D3KG8SSst_8WeYgY9X~7Iy>sS z!p4H)u>fI<9MzNo$m2kb2ACNdmsEhq8{iGz2dE8S@_=u?u3nhJ5+=uf z>sKceMtlMQI>K~N9gglgI$p^JSdeLYP{E=gv@`>^C443g?H$h6eT1GN{2U<$9ATG1 z@B%syFt$6Mv9_0Vrf!Fct18w4ou`P=n$wSD(=x(t{K1H#X;p*@=l>NpahA+V?d8{BVMQ2(JuX>^x+ z#~bV#QZwFVz#WAMW5FbVFuh%1pM5oZ7G47+RRZQU0v>~K$5YvQUec*FRiKH%21~Gv zhKsu12=Fm2gn9-tW)PT-D3tAjo8SFZ0wZ|tb4=$2*cLu?;PsMTylZ}KJq78kIqeUi zcf0{zDL+{W?5)UV*zuNYJrlc9)^+T}ZE6`J$Wc1k%qV7bq*Dgn2xf6E?Q=Go!q0sa zv;v7oNb&gZS<6W-XMp>ZV&%HVPu>Vm5{G7I9$+ zVLpdd3~E3ikMuxsM(|X5BiFRlkrUYz+^)H>jAGz%uq2&-Aqp2-mI}vIsQC_RJ$g=n zz{yY#TtE&&FG68Nv`EaWFkL#P2NW&XaRS-&4HO#n0~^{N3LgU~H$VeNVfSWQrF_7A zhYm}uEaqMMi0vw&*^x0-M)_P+%rk8n&~i5PR3{4Y4q9NLf;@l{^-yn%kVwbyb1|I~ zN|?mgi>?}8<+>+&Uh8?-6(hItYFN6Wpze1T(~d3R$dl{Xc(RUv?90RnfnF>uMqFZH zO_3ewb!zH~=6jJw8!tjU@D?mw-E<2JE11SEEL@CZ)^JgQVG=5{2er!zEY(ItGd#vx z2>modo(mWni7r{zgf&ukLWBnc&JLxuaoh40lyh|rTzqi-2@t#+nZ8CBr!s4H=&+JC zS(=+*N?Qdwm~5yKainees$zf{UDA$I4W(|v~47($*^?L<-N?Y9Xc#=ET1JQyMF}l zT4rQW)&tJ{AV3zJ7a?f^6=(sQtlL2tf`tK}Y3nU{mm7I;JGtHVlA> zdC8uh5%Md2C}uiX5zczeM4*A}BHt3nl^;g3s++JzTGep_9Xc%WVzPFE1N{(MJdR1Y za$s^r{~F>KG)K1rO~IiL)Nf$b%5H7276gfOy1Ax84bL~%2aBFD0>wp3IIZ=|?ugS2 zGKg%wh8h}`A<3kfuK>S@*R#* zb`OzSqi3iDI}Jz2D8=QIh;4CFwjs2QPk}PtjZd@r+72A>ieX@K!HG+&iZAp!$hj9bC|%!xER~ zXA3i&a4Wn$INv=5!$o+36QIgUq{;>ow^hU*A$uET2RzxVi|>h8Z7gxTr!E?SUa^~% zOqjRz9PEgB%{Et0Ts&=q&|5_qv_FM4*L$_BiYmzd)`w%W?Rzn6JlYbkLP1BknVHGT zX4&`1ZC;O2TMOmJ2sp7Fb5^$8#*K-m52mYvrw`w3_4Ii%oNSf?R)kWjAuf&8G;v`= z0q8TJ6c9b9!QV%sG~q`LL8Z1H_z_|cR0JP@m1RR$Py~s}ZkRA6d6oyu6WWL^P5}_y zcV%lDj7R`%S3J*jB1^YWb|dnQ0ASuBPFq-~RNpr#mA%A|4^TG`Mn;tXOE!w&NQ5~9 z9o_@1JI0Rc9#EhIJpw@&;105H0p=a?5x(`~WRlD7zNsQ3yEIN{r4W}D0@f)D6=M-o z+kr!qo-!LDVae9hklMsMEY-W7ImGO;sNG%9QtMalCAe~VX}ENu-d8G(lGVfFcat~_ zu_oKRpTJ?`fxMv&K$z0^6d-M%B zv1XNN-|Kb7a7zM~#m?a5PtnDbzQ#a?!eC)=o?VPKv&kz~C~`HL1^5TC0AVmfF>@gE zju1b^Gss5(E*lXP+DIAAZhcu90q*8v6st?dR zOU1^2fQvx?vNcpel2!aWP=GVwqP`HaFd!l6QPU|fVc;}S90?_nEFZuK zHfl2gBLU?=;HO4_wG}yGo$hrXc%eWoj4O&#wQvM@Y!+1B`Z0w7qN^Ta>}_t!lY>Uz zJA?s-kSEWVeAWqGZb-jl24gwaFnl^rkg5h%50Nx5!e(&gj$c2Sex!I0UqAoivyYW8 zK0B39&py#kUtVY@FR$o^)f`e<`_`;?);U#NuE!wUM&N*&V;I1(^aW^QMGeZWWLSHe z3My?|7>>J`2y8>>uj3fxtZqAq0+%$gnWZEDEP*B_%Q~Htq)CtsMeHw_X?cq(z6fiH z>+>QPim=yEkasc#o(VJwl-#7?ARM&};R)B$Z1IWfS4&ML!z3*$LUxeNt&tNfv#O%> z#IgM3=t4WaJ9&-Ao7ktm^n~c(NBwJ0Bm-{VOUYxMs!s4${Yy^d+C#DEU2h^LG^p4_ zOaprf1zH0Pg$j=_yxql|U{|x?&|9!qxt=Bn4lOeg)9G4cB5uYw3d0Xsv502w%Z-~i z7+PH-8HFDLj4bFoZtNtBL0KbQjQNhU+ zqV1z@JFlPqNCFH$93!kgIAC0Pne$-I()%Jw7gl@`dfnN6BV`LY;O;o~V`R?}9u{1QE}o zOpEV^(dRh5V~tHuJbpUzz^(%)Mo<~U?HD13K!#I92^9lHU6JCVD7bid$ml}3ZrvgC z6qyV8_2v!7vZm9;`?di)C<;mF#{MY{>wqqQ2 zQgO4()`E-mgo>xO7KGzX(bHZhUjn|I-B9*Ad84?@>GIe)U~Ci`yW<{+4r22=ClK1) zBCCuzd8A@tF%Tfc;c`sK_-p(VE~U$Gy1;)@3lO30ckl((ixOUzpoL+lhD7I@Z*_DA z7k;ZFoGteTO*H$F?y#+^ztz$2Tmr6+P~SRmb@XB#SzKEC6oacH&1qux#1*TR(p^U_ zA=0lbTpd}SUreRR_+Mr-3rOoQO%G^ ziMFmLw}ontl5%wvV}nbwoxokO(P)rdA|@@8?qa@Z8g9`n!W{uI^&xB!OMNlUyy>NV znYsG052-a*PnDIc8&q(vj&`4_b9JS4wWksB?sNRFkf535OJ>tD`xvI$a%EU?GYkcXSXH?EdmdHb#nerpSjd z>nk$VmMhx*3(qJOCF;2Q07iZJ(69~_V@rv;nz4%Nadma-nwxDYR@dBk)l{*rrYWW> zEnCMSe|gA^DkIjB5^YmOA}vSv&MMT!UJ6#*j>AL6-|)L&I-<8wqK?l7>xh+u>sl)g zQB_NdNxMgtNtp@U^};EP>f-)9AvMVRolqfm-Hrb{ zB{|dso>1y)Z%Z0>_kt%)g-LrIsC7<5^A@O88YkczZeeCg~ zF?!p}j!e;~z3gDO;4Rv7VU`A4>cwsZ1l$F8OE2c#hVa`VJKCLuZ^?Ea>s&1?@5ypi zNS@Z_`&uHM4fyqx2AlBfNoTG0LyY+KJ#;qX*OTgN$giik15HPZtlvzwpJBh5W`EOuJzc2aEViqkalf8!fAfAl&GdE;buVj} zZ&r%AccY$cmJ%t$-Aw%TbTfofvaOB$Tj};N^VicXTH`w!`s)b~HTBn1t}?`THul$( z-;ue$z608JQLCja_T_c8j{Q`?Q%zn*?S!+$-!0jB?Y zq63Zp^@Mk1{;%)gZ8!kxdmG{csHZy62~bbC(G8$zBN>>E#+eE?fOTlF(EhR;Kv71j zM$gFRp~_qZ47I&Ewx47-zy07Z#PZ_bmm81L;>We4-R20`)^Lj}U|aJ>XFzRZNX)M8 z0Kifd-2sGD;m$5Lu-L=g{TvZtRQ-vJ_?+8CG#E4MFXu0j@qu)P^>TxR1o|$OF_|x^ z)Z?ls36#8!-~8^P+`kdL8jxl;sal!feGDWcU04S3T9iSw3sB} zWOy&}oHlf_t3Jfcqz>hHx)?a@j`oHK4xyzG7nI>IASks@Kp}q^PhUUB-Fxm&SkNxm z?4q%H%8rfA zSY%iCPYzAT+iV?7pX=l%i<|ZLlH~~uagqs2gM4Iy2;F&i<04Ba4)u@;LS2pAqFr|z zw`jQ=_n4qo>m7SRSzy&(F(LktkX_0fWPbNFw*1@&hWGUxdF|lad;%kD4P?IwMzWTRd+(`ptYAjkwaBuM!6EA6s{H0)}d{VOo*OZ<$hsDh;=ZE-*%X zZ;fmqiUX#F!h>Q+Bi{%u6D6Wdlz9!Q?xd%?08RxWhUHm)gp%Ar*$AN06PMKg(M7yfG!t?SiMn%;yrFX z8Ql?y^e>>+7opEATKVllKSpaz!HBZ>k42%M{jHDC&$jO+^yAT%g#J6mmgHhxK>20l zI$U3vb$-<^UHwTV;c0Ok#_0JaLDevYL~{M*e6?aw7?1Ctf(ElnEya03XC__UI%zD} z7Qd;ueHLL)Z#$HLtck*&RIOVmEdJ%jMOk*VE$!UomtOleY29nrih-84t)e=RqbNy{ z96s?Ij9095!F+SaV2qX&Hri+$s%W?ESV5;aa7@$xbKuU3jpu&s? zP&pTosiv-mb`V)!s1X2T0+1I1gBsw0rlW*`Y`K>2qp+Nh1BP&paR8wTA^_n-l3eA} zq(g_L(sOQ2__LN3Wz)y=+?GJqk+Fd) z5)YQ$4hr5FdImI*ca4eeHlOUWnY8USok~0wOlO7K(FV|3H#J4eRjXakHxX`|?lf|j zlhveR|CFET_Tv27S*Fr!3d9SPb`-yT>NXCgI99jN<2YI}FLeNX)u~G_+TtFug+_kw zl`jwp@HJUQQ1)Ol^Ve~STV`{iJ1Ufz+7h>biMA94MHXy=iB^1B^-RSupl72%Y~(tM z3&>L=2YhX#?iir!eJ!vF?_Kqwx#?aAH0y}q=utvN^F6@YHoy###cBtPmN3E;#G1s`e2Qt@uH*Uxr$v(cw7_;^W;P%qx z1{H%p{A%{q>?c5+{sC~MrCE3*A-;5Z%PLvl&NoZa0GIPu?({%9T)TmLNY9_3vKGp$ zLq8<(4Kp)SBP0M+yS^VT*3xACp)_Ag40jeE=oi#h2k(det$&!vyy!wV$-zn@DF zc#LfP`M2mlKc{!aD~tb0xliKT--`cA>|L2b3c~Ij+vn%MMGIMY751(%XS1KMqnBYQ zJ)JLS(nEJT4Z$2MX(aswDAUiw*V5C8zXsU!>Z|2fGvX4&YkE`Eu0U4(H9SIK;)7}U zdh+`9YZi&~BX@f3O7t-O16Bj=1<@8!h!TQ+BY(MBO#o|$OW-P$Jd}0-%f99hu6z)c zAi|c?44&T^;H{&W2BUU8_YiczpM^V0T3iy8b=uJiWv}QJP+kQHdMm!VWIYfw@pAy& zuOUxv!j&$*`z`q|TU~ZTk6-BLl4DVQI~R^f*Yi+&Q>I##D59dNfuq=#@f-W*>|J3Y z&aA6qq9hB7hpEbM>|0e2{O8bN+XU1U1GKAxZZi1nJQO01-Xq-i%ojQAb^g6b?-S37 z&n58mZx2Lg^sIgo)c)O)u+QL-2<1OA$`FJq^b~i

$`U7sJ$#9$Rq{(BQZlkANn{Yl3XU5qhrP-%~nUOgLePHIoc zlscNj;Zmw8Gs7Rj0J=;6lJbQ6>OJG#z@$`T~0yC0}`<$5tB?iEkH zM&dc$sVRE201}RqUVzZoQ%Q)hi&F)afn*ym3!{toLCW^oZ6KgTj&GhE9V2J!;tr4ZgAx%P3`p22kG#_^#LyFeb+bK$yFd!v z_0Q$1CNw0IqeyX(&#Op`0#0{R&!9wkXuemGU{}w0v3+;HSdoHo91L@i6{+^|lnJbn z4x(Y7P~9Tlv$!_l;xdGGnO73T4J*;5OBar2iNmi+-Mi|YYTczPq5Gznko2;)yVnxu zVR~!hry+!KD{EN0H%hK1t>M$ldD(@Y4$EgQ&%iE!&r_^BbiF^kP$nMt$E%BLTEyx6}o=@PPxBK zWQxEfHxXKyF4^FP8INxz`^&^V+ywymeb>f)RxLXBmx(z28z$yX7whUmHQ3lY$TBZ( z_gd+O?DZY0i7bg7Z$N=|yHjxohwZhR4Jgo4WFF0zE``y&$$g|8SC(eJyO-*mwchR} z`ew1WqaI&2gaXhf?5|x%ya&vBlA^x5nNLXe%X)A30zW3oGjyB(1S^IEnRDpIK z3`7}d*U64h2ikS^Ho`R9^*jWXpj{6GQ3~31(iqmM=5c?OO4NeFGtO|-f>t9JVV89% z23?43K{e|VN>m0 zP8m0OrMqvucR8_Ct!lq(9MyuIl=z2sXLL(Q?p;ph7|^}TDULmkFHkl6lX=Zh6)pA5 z2?x>c_Nkya-n*QdM8)3aR4}8|Y}vibNn{3h2~^*^oN@uXU8ZjDa+*fXr^w#r#9;oq zY^uG>sRGZo%LMLSPPkR+fbfi~34(E^7E}jb} ztHsp4Jum%mv5avKSUMJ-Y)l>I872wUCdh<1r;l31fp{_Qw;1J*XycNs62sS2RaYIn zLz45wI~uQ|i_s!nkNoLmHla$ujbr5EuevFET)3z`?_##z#07=@$V4y(XoNUNwzE7ptpV8fsxDBtP`o2}$E#J3)-Hv=dZIH*`bO zsLZl^jrtn*eiwisv*-SD6Gh{bv!~1X>)Yek>m}R%qx*{qUaZBY*h(e8KPX!!MDN-B zMN4t=>3_BPi`vQARVIJ2X4KjAMLwH#@3%E+FX`Xc|H;UrPj_HVdcZNF}Kx4v-cyFMi27@zXZHuz^hH+O|!!2Imqs5#Ln? zVN)NSow!ZJ`eq9@(TuNrf`$6z2sV-Dbm>@GttJ;U_`{m{nyYI~6ca-IoU=`&hhzaZ z(e0Z1*F8_sKV96c~KOnG>2T@(F2?#(88yUC+#>LE4t$NOaP4&)moyDwVj%ry;k zV5VFX=^f?AHFfbeT$D}y4atRTqB}4Hu8DLPC!|`L_a=`Nb)>3iih8K)DC%30_a={I zbEN95=&yY!+w=&;aV!+^SH4HD|G10z;(e0}zHcZ%8HUD-#dM?{$e5Mb^7!!dh4e6-5i+Lqlv!`3$Gq&X z^ol>YS_H2-n%TprkK@LT7xTE&)i~2x1`*9S&mK-+e(|Ys_XSxHVUy&rJ*C3J82`3B zJ9q)|MrZQS?7#@^fNX4pehNePag{s5HWbUDO(ks5kLTCku8O27uGk-7{!t zs(YrVhl9DP;1S_bm0ekxHJMpmUDY;bBqef5ks@hJE~({0B6mfuam_@CyCza1DQSP{ zNrWB{zw`?G9ry4^k4r|zB?kbBA^~(&W%}{!Iez?Hz9SJi>8&+6<)}3@N%(UNhJMCj zX527LD>B2-^P@EJZ4RnVlE!Z81YXQj7O=>KiTkxX5yv4TOM8blnG$>F@Z(Q=oGOuL zqKxZ-=?12cx&g(rf`N5A3}lF$$Q?r4eg{Dg1qb2t*QDkDj_G)z;k$ll5UhK4?i(C& zmSMP_<=C6)JYm!M5wi$lzI^hvkGjoO+PSsny{4UT2>3)xwr@ zzP>k`N;hPS!@sR@@%+p4EWK=4EBvZFXg@tJxX{qtv0J5|V+LVh1)4J!>IEV{#f>m!{-jaNTKX}tk^u^%Vc?px9oC)WU1)| zUyaWbOrpgB+1k2zLMjr{MU96{gQ-YJoZX6q%nw&4B%L@g!zkvK6&uXpY3!vuwT#Gh z<0LR3CPTPVZ7anrav|xONy1_;puh-|+lFN%o|i(hnwD!MZsOQcU|Fe)HX9-N@{Ytw z?$9B-T%St+e%%s-I!ApL%J+2AgoWJY28NG;M}eJkGqOF42bSkB)3lhEvc!K~2#td| zWc|hLI=c+XF;8m7IbW?1)dg}(ej-$!HAg81v5li=E14Xq?w}4Xh;2KotRR!tEAn}t zi>5}52UxmY>Wgjq1_e}Xg!qSx)g}8DJ73J%9H5+_QI_S^Z}j2bDwSTGt0qw4T-&m3 zc-KQJjw0Rbr5-1bFZlfJcgBz3cyBCBf{Pg@+k%H%(AmY!P_%|{vu8x96&Qxi9L_8! zvZ46+vFrG0U^!mwn~CoQPH1C3IXAO3PNFc5tT^$Kz>Jc_HZ4132ti2vg!#7VS$68v zp{a6nhYl;;ES3vY6&D)@N7XPZ^*k#vf;4d>#|W&@jzZt`)5P;llNly+U%zJX41sMA z;OZ|h?ien^^NZ0cUIHw0luloKG9S}Fqt$GhaN$Ng;iKsCMExDwD}F~z(HZ>}W9h-) zyLUb3^wz7jCr&r%CAW*yJv$5yLwl$s7t3ol_vw*S=5Xz!KCG=Z@5R&EP%A9$ShjB& zp_6lTG+lsm6E;ylj59%wIkjM9)vDTj2md-4LKpsxF3&IE#^)>k8AhhAWY4#vFo}cE z2yF0xpW2Dbc@(q2upJ|I-7t-~*q@wMU$cX2hBAk}_;l;0=Iq&e9eS~6;l*d-ZnZ5J(NyZmr-p~gbz?2@=+j#F z;w&{DuvS%JFzLS7B}PKWhaAx!edp8V*&;$5MW4xZ9lN;1iiP3_~qc@91GJzp42zpAxqqjvV>|CVmO%)ae3(AjG3;RrZ$TrGfkby zh#&+khzUfRn%r_7kD_C9Argly^(_{2H}Xv<2%tYOh?_7rd0_Aa#*)Z(ph=@mRfu%x zup&f`=%|d|$j^$BBeu^I*A8O?#v0QO-H=5|7#IVO+?y^pPL6{Vrs#V?MUrlP_hkm zx$KJ!8oFuh1eS03zL`dLYVtTROotnB>?C-iaD#3SK{Tk-^9D*Os-0SU-i%WaI40H{Ef=s$jxH8g9JLZhh_FY> z#ry^DsNTJu+ zkwdPW94qvFC&Y^&KRI{f^(FNE@x%Fi0RT7b&7}G#WxSg%+8w7Vg=V6~GgdLXdQf!x z%YIlY;f;zc&UhR}uI;4Ujv2E#r&{`C>h~55wt#SW4XiZWtv7v!Pwu5&VQs7~vVp zJqK1`AJ3#o%R1Rw};* zi=TFzyL<{3DfF6kHs-2;@{y2bhFW5t*4YHd8k4%1jxSqgVQp)?OW@!k+D+hOS6ucU zG#TSI_k8$xVs08K+&VA`!4kt@ATl_Z)(<>x7M$TB6uQ)~y~J~P;NbBG9W%94B-f?f zGt(e)tsqHaQcK;pUj`0PFGZT8=tR6ayBD3 z@fb{FaPmbFl1f$1wlw$tJKMrq zLTLJ7pqY8DmX|X+HD#VwfA7Q1s%#0q^ttf0`krg1b`Vie3vO6&GW;Z1`dmkV zCkF-|9{D^@?Z{_t%0k}@g8)}Ecky6^UD!#o~rVLS3=U$b$Qc!My~RahSrZ#FE!P`>gsbgpn$H{D^R$4z5;xdvZ2vJ+FPSk!Gj) zfUV>D@G!?UEfdb^%@r9fu3@dB{VcQ6=950mv}xUoozy@p{AAfK?D>wj;ivm3)d+vU z_2kWW-a9^8JV!Q3Qt*-MsRAwhgOi51QHNh46dpugzYTx zVN^>Iwdq1`(Mt;9f{tzQdiAD5hZSjgPt>~7#ibQs2yolM0vHB`A)XnsnW&q~M}- zE!)yr^Ayoo3)`WXq_TL8wa z*mr|8HSse{BXEZM&{}xlav_)Hd0ZjxR)v&x=&-_z`GRWfNTGeq@L-_Fdm=TVyTB5k zc##EdiepP$Od+;yyCpk*1)MuFJtKrR2P-LpS`LO7Ir0%_o0+p>>t)y%D{3b0t*mGx zh|mwUIMDU!^x5j{w1y8ipY-9vP3vAfn2oc-f+k|dO}J9?oALhRqi2`N37;g3bMeDi znve;cpam;#Z@!BsJ3c4Mfu24rho*-xs=$Q74iWH)75gbHiiu^!sRz4&2}iGp(azr! zh^F)`FAZbdrzsV$5AlG2UC+SrkKlJQm>ZdhHpA4bT-l++3RfQ8`}XJ;konFp$x5$Y z6|NJ3FMS^d88MU>M{EZ3RdPK#Wl5pUXgY_T1%Jf%V`Q=5!{yoK#cQ9;aUNGA{O25Z z@#vJ#E`W8@(@?PW%;c=!daZl0e$jww`!<3JH}4iTI&4%oz7(otw^f6N z-NsaD1xPb7!CcBzc{RPEFsZVZko~#a6s2)8Yuamm+3+fI2{uVYW(MSk$W->XKYVg` z{Kjk%pN-#U>ou~pCU0La+4vp~Am-CTHZ@Y%C7wDe@F{TICaWuUfuSiArSC-~m`Joh z-$g_!vUOm1bb=T@W?Y*o0#kjb5VDd40c;*NF4maYkWLOvAO>R&JkeH^AZ8BQhv67> zQ&lAtg45b|Sdma4OmEmS8GX386!}j|M2XN_Xg6k*BJiA>h#>NzMYu_tM6TyM(DUg! zVcT5dF`LDgGqxVl(u|hyIm)Bh)e_RQmATYtJ^$fS1F;?}omzmM!KWU;u=bG+E*5SUP7 zeAhx;pG6@uxtbFgxBz^^K&oJ5+o^-Pijf1eK^&w3bC`>K7tk>4^I1A{SP>#>c`z6y zKq6$M#dhi@4B0D?7=fQ4&j_Xfn-X(;s2Z^Wm94doBSU8gngG-|^#hPgk=6^)ONvx) zb@7JJjdQcv6aLvHG`89#Tn91-84ud+4s1me4^x|T*76mvf7XX3_4fUEG8=A{Ck@v$ zEK7?$Qc%n*bII12~LW#=;&miS5ioEKn^opg!Oa{cj4ik zSKt55SHJ(yfAqio&a3bL;TM1Or+@eF|Ih#NpMUfGdiB}tNB`{4Uj5py{_t;q_ltl1 zM`%yC9i1ViH|R`8XJEtP`Vml2pYIxvpFXf3Jv$-aW)n|ZTT|mz2Lqr!^)WY}J^h}qLe4spB2^R=M4(`|?GjDU6rl$@5wOY=kZpznfo>MLPlZR} z**hd4mECyG;AWwZB*$zG8DJq7VQk<(K&|l(9plgf<}>Kb7Ar2lBEvcbuvFy_$MQjU zEYgbQ7Zq0Gox|eqWGw!ac1LImpe+&jiAPEwNc>9i#~F(Va#Z}BgCr@+$&#g*LMGI* zr)BfTi;eDZ9RS4NR!WvQTDab?#H4p0l-_+2=}Kq&o);|_b)>^&slV;7ul#-ziBL+su zIS>Wk#bZXM?PtHpy!j5~Nle^cnT0~o7loo-WjUJPwAh>5D^rD5gC(;{!1?){++LaB zt<_|+AbqY(5-$q+$2Q;+G=Tn7dcs^io_%{3zZKrF?>u=P&(Cg-?tgfF^z5#4^fcCR z^`WYdS7UngjrCWbj;p^J>y|I?gx1d~fIV(i?i#MRl^=LguPa$9d<`vRHIil}I55es^mFiZ0we8QJdVUQ*$Ia~7a`jQB|!e# zD1XhAI-~LLAU7D0e+T`2Ve;?jMm}qxcrF%at#scV^!g(6?;xA0?CM$D2b_OL50W&_ zuX-x(V>NPG{UG{x40#Aj{|?e!f%)T z{DfqYFn{i2Vv-Oh1)vxrtbqFWFdIecqV^!5f5iXZi5OyDC{`fztH1!Ff@B&zE8IYStmz`~3JB+JfV`^|*(NqXjDVWv zMGu*oz1dOTK%-9{eu#!M23VV=+p)UCg_AnTqj>azk&H@!mugWPItTLLvCub z)BB42#_JZHGhh6#fAPh? z{QeLA_IF?X&F_xKum1dBz53-pd-d0Uh4{!X{>|_F;BWr$NB{S~`_V7{i&ww(tFQk0 zKm73b{_@p-`F~^!>?J8vxf0r_qjiXO$>{DlXdMW4_SfhqZmU?G40hYJ>tojXzeX(w-vhjCKgM$diFPmvS$aJ-o=>U#V>$!`(~mdg|k4YDalL&Zc&K_47Hkqdma&)UJbp9;kMm?8y<;uCp)0AJwks znaCjN=ay>M!$9v;yG~j-smy@tPP@UOE9y>fbyC5RWga?ylaoq*MfkDkzR8_TMJH9O zk?-Azbzw2NtDXDfboddXNYG}{O#1`nlx7Y#<%gq*$cohD`H^L;f0EuSj7J+K z@}W0tFMdf-cldI)KF%t-9-=q_QhvyLbu3VbXcj9zOX=TJnFq8bwz`YTnpQ4B>VnovEjN>~#EzNM;T!)aQb7+oLJ@PT(aoE5FBxryWh(0X;4UbPh zygaKb4WNJ42a`i@-{f%5lHSNilD(+}dc);J4Y!KP0d#JF#`p*r$y|dp1<~K+!zZFv zdJCgSsSRxdyPhqmfc;Am$a73l1s+fcv1$lTP2xJvp&Bs7-&>^XE1-d3TQZO> zRER>|D91x_ri4llg}~cFf@&1niD3YgJ4GR9U|beJww%O4;YpMjLAfW+P%j#gX`bl- zjLS=WKzyPwB}Yjrf>_AUU=GgNp~DJ3j=p&cAP1eAp@+&@K>G&@x`DdRDXM?Qfctek zl%Td9+e1k$t0f5FFBq>8*t1$o#Y>%cPT4Rft>@bd4yORcCyu7Trc|7ipC(MH8@G`6 zZlX8u&ny^GJ%pA9$JbO63z$d9iqyb+srL3ML++8>r~-}Z1OC##DE#qYH^ zCZ#sT-KOm+-aiBDlLOV+V~!Q^khuVzk5P>@G~)=E>kK7aICHJY^^?fP*mHC?1Bi(L zt2Ip&z_3vI%48e`X+Xe5n4S^(Aq(9EwItA{di!+fuyXt4`<7olZp1Odm;>bxB}h}( zKv*DvaaoLF4!Dw1K)0hXv)l6OSwjaq8(l9hG4dYwPjTn+`=|Acd)+@(I5wAH@p7GS z2OJwfuu+~=6YXcqDF6}|tHpDZSQg7rknW|A`*2^0L_Z$P#$Dw>2bG9?AdGHgJaqBv z$qkFxG3+Mmg;<$ZoVcoMS>(s5gj*Usx>uk38B_VqBCMzEw#)MB<7<4(rBO5L$Dbj?Ge91D)!|Pm*VU- zsz5nIVdl~5xxkqcHzghj>f$OLauJA}^P0YEc_6ZNbpPzd)Hd-%11_3kis#>O zKx7ZR*?eM3bLPb#Q50oh?5rkZQHUR~lMvOX)>8E+vCno8W@o zq=kvNOnV?{Wd__>Yd03~-lX%}Xk&WbSY~@u&5f{b8WKn{iqkScwTG#N!jK+-myOu* zQDVuonVGt=OLg|j=w~`7Ax$T%TPa;1`L7ZLtwS%jS7Zidwln*kR%$iTcj5MmB-42_ zQ`D@Q9*;#k#4+EWVkF zdgHJ>mZsqj%U)@sJS=CW1!a-{f>qA^bVHXoBagG z5dvSu91iUuyFJu+^?p>o$j~knoql;IO-BWz22d2Ayrf9F&kqg`UXs0tRC^IFH+c0W z6_8^x+IZ+n>?gCNX+`?wlQdD32Sh&?!dyCZDFhLn>L$-)DCrF)oqi#;V`vuzVtc|Z zYubd_fb5Vax&w1Unn>@=1hK}p@znGW4HtF5cEOeT8KhYQT$z99h=dZ7>@t`IKNT}U z8pgXT|6_O49a$f{2{h(5M^HIQVi%uO=*iz_N}K!ZxhwO?+9gbG5SM= z3HL%BSeWqj?C?LJC?tY?co@5h%`Iji*wbe&OZ*@~sTV7P^|fMxWCy4od~t_}p*s=Iklwo|r>VP17LhL}?#*l}*C z$O6pXC#Hhds)wwC;?&R>go>Mi1- zwGF?neP`o+Es?=i`&z2|GS}A|K zM^a03h!MV)U{~vVEfKQP^*6h3CE45FzLjD>L;F^8{VnXZB!`*SYf1LEsn?R*ymz52 z=mzlKOrjG3P0jS(o1{i#L$NjFQ~kWPmw=dgYlNp-a%GD)nN_mC^`15HV3{uc-qupS zb)bVyRX7E}<`>}u5lI~~tt|c|V;$2H`psBl-=ALZa zwY0ws<92OFL#*1h1P7Y4YiTyxvCUv?_+u-4N>D}ip;3!ygwhVT+_n$xrm`D` zb!dhe=n)CrEq3g>f$lP3H?-Mdxo&9LXtJ(rhl^>8ts42Yb+&3`k~PB-)!3@PTsR_R zWqk>7L=tv!&} zQe!|@Jpl$0RzxPP(=-|oc^*A|^6-uK|6u^~fcG^(9>)Tbj|Rx&0J8);TSVk>oX(Iu zxP)rbvjd3dJUx3WB#-M_o{3>8Z`B1xb2YUc53S2d+4^UFvOe|pP42A*NFF)dN;{svec0r>{`i@+9) z(F`rP1C1z*;=l==B*Cwdfzm^M5}J{3a?A6W?@?TF4vOG}am*|~bz;xA?I7|T7N==q zm`FT#8Hgp!;@qa1MY+hxA$dAH^TqP+jK2Uj%yRKuE(~5N(70yu3 zyO5S%U_>mkB0zj`pPON9`$hstmK4xNp^2-9bNgZP?SCb6c;)zBpGyu6hTUI1ip$i>^AGy)Y2LUWduF4oV^6~}aTM~qQ+7m)egW)20f~rQ7YrFj$oUDT z-{L0SL8F;TJp+Ro!lZT*#fcXMkV%Z0zJscMjt3Y$4j7@(iNSk*?AReGIXRQ!%twA~ zCT?tmk>#4Pg%(bPdpJUdGpYgF;8iyywW@lvcIdFer1`!o*7Q>rdO>2w+zV_BJ@o9v zwj(kLQHXi}W@_K|zWW?4nq9T@~h|?}AeWk;d z+Ptedo3>t!J+Y}zI3(Ex`_^JMyF9OD)DWRpjtk3#x?xXF7712Ku0?@SH=p$3)J^MN zteTCp!l@q4uo2)*k?FXnnCg^I&H)F>m!}KFSYakDc(bNmi60^2@luA~c!8gev+f?Q z`T1)6@X0a#Knp%y69DQR@%Pc@@2ku6bGFQ}O>^ub4rEe5I)k%Mnb3ZN$an3;H%u?G z96RLlo=qpk@$T!WwYd>|3y7HjtK6KlZ?QA$ zdV#5w-&FYrea>0lxYsdLqpX}W8}}KYKIulwwqABLk^kI(1M_Hc%*u^QXRHJ<=Nag( zo6JWPSpJr>>>y2SCos7e(b+K^hv9)_0y2&R!<0eAiG9xLQqCoQn&Q3X#4esO%yd$N zUSq(l2uxDxVyJWhAm@;Hjy6?^-=V{b#LxFlNqoj4kENlatPGhg7s!t;8<%5b>p5%Vm1&`R<9)0u9Nr0W=gK$55nQ&4K}E+-d>rcmaf1 zX1BtJeORtQpcmVz5m(s`k7&zvHAQUG+2p%51K~y&-wlKAHvF?Rqp@o*g&=Ne*?TW8g8XL-Nc&=(Fp2<6b+i zMp?h(C_lY<8Ox3)@i{x=$9ValUl2@pD{))jw7BnOTu+Z6!n+CG;%hjHY{K;fDkn2t zkDIVx`4GUK=|hZ091qGUjG>I{V%PN}D*z^t6Ppfa9tmmN@eP=ZT;?Px>|SBWp?KGd z-3}dA#4f#qK~xFdGGMZJVCvz#^^$( z;O_mS2M6b*+4PXNwcD0U-PY6Hlhh40srwFKC7l(50vI zZ$0BP=zpY(mZfjy3w?O8LZlZ@W`nP=q~+mt<@oM~C5!z{*mQAzz2dlImMs~xi9nG( zb5$8m+?7z36?`OJaO5582=m#{b>8qNqsBHVMb4W=Na&bO-ZXcKj#%R5eKM^CBQ;`t^=ujgQj#{~{zvW` z82LYP@9#W$?BZfI*)+uW^Sp!RkT;pCv}u`l**|ex)$}8F=TwCMulllRMws`Q@Km0e4vp4WnY;Jox$q zgZcX8g2o<^sQ&B{Bc|U@t#1msYkqx#AMuCF8U62U`c3kW2>A?BWJMW$b=w5S;IAn* zbbYYdX;Fh_=Qtr*C*&-j^ZB5go?63BSKY3MhTAO4B<$)GiHmc zFLz9q9FtWZlepBLt;W~vd?vRRHD_@5AvtuBG}J**eJTiU`_X6zp>$rM}2U z-{2AFuEX;6$QtPD@zZ!E?PqmN2PhFKfUncQicR2k@Wiljh&>k43&=MZb5hGBu`Q2u z)<9pKpUTS->coCl2+<~qhvS0C6L``+D>4!mnhdtT6pr=~OdrNpV)^+BWexNd0u;dL zoIP7CN6(Q{j@R&Lk&fiM7}{E{`Rr%F2w`Ks#go)Q+>RN}BbZc(DB_OqFjVm~n4iFM8ue=2-pqE&vWEfd7{Cl=< zG8aZK4iAzAA#b1pqL(m~*5afiN*>J`=u37NVTyPc&-e(oh`k>5!Z_oo>-)LG+5_M)~-%2KxBqp=)i|GBmrE@#UUA(l>DW-16yrkMj{BhmXisIhxK#!{v)W zyOUNspxt%QhbS-$2KEspHqbcL5mav&?WGbeM-w~+>HqKN#=p_k6cbr;xJjRL1O{EB z-q1WnG41sVA0cRHeL7u@-gz=&tI=#RKcRn7t!$Jm=0CR{u^FBrqv@Ldw4{R72cr-1 zA6kBNvrJ;ic8t z^=QAar4((m!pCeqI%U{qC}wkPMZ!stPuGP`XXx)xD&GsGq2=<(_fspiD1u%gny5PI>URoG{FGAf zgm)TvVKNC1?}73M5=lmUTV^PWutsutQr;6{hmf{XbbP(uV=|>-2T|avE;Ogk< z1316Vt}vJuA#Y8-K-oQZihOW5K2s6ckpDu2(H zz@Y!b7n7b#@RrDGRXsujNw5ewJbBi=I$X&TH(kEM(oEF~b+~EQWlE=OsE7_sq?jfr5% z$RAX+4}1^Vc7ALl_!B<`oS}$3_NZK{thhXflBvj%J}DmD$xffmSo({^IY`0cdm$wS zYlr!jBLj-_!{A6l<^evsd{AJeM<^ot0I>lN`^E)aPE-s||2m?TVRwl}!7Mw41Qa{# z9}Q4T2O3`Qibf@ZgJJ+mwCJ_9ANPNm@KDcxiC$Nyf2nzQe}9R72QbZr-&YJ=Nh*OQCLh;k42~OW)jyiCS!aD{ktrJd0~| zD{k`0^BoESU2UsLY4tLQHfh?ydFvc#RHAn)ZeZ)cSfO_6!fx#gZYR8LGYh>*rVu@q8XSfzD{IO#|)=>e@szdw!@p zyie7&Ci0RlRx>wW3|-Nj(8~#lJK8A))H;;3qVsYhe-fvFoeVz3U2$KV78Gx;0r0Q8 zDECHz-9;GDi#@8Y?V{Qr6Sj$R{%G!1b*+hVe}vd3s`OBi_1nM;xG>GigR8DJ(HAZPQqnq9U2CGZAJo~V9{PdLHc^xZ zL_dGRDm?U12qHSw+@d}Bylp7y^b1(BLq}gAwx_CVO`9OyFPILztEAJY0RN%$P;_2S zrlMFO?76eWb!!ytrXg#jNQ#r+7_Khm*E7b3hyOe^twYO)Yp=2DntSLtu;IQ*TvY?&WLTwyoNfGfyiL5D+E_OAUi6;nXwyk6DTQO5}8(NCt(2m zktnqhBkII4@E8HE2CykC*R8WfWP{&2TQ;Js-bi`tY?(j=OtVB{kxx>)P|8p)V~)2#nAjPm@}9zje0UI$KJ@y5PgOb+&9E zX(qSMmMnZM_mPwylqCgYw=XXzbn9$6Wn?-b^8h(XhAu4VOm3YmqAsqCbe!BeTQ-gx z95l^CGW4uzq&9?aoh=hYjuJ~N=f%)vR&;c;u`qw%I$OZ!x6T&4i3+OQt+QnX{B9&v ztzr2tgw_}QBSYD;K8RdY;cq=dzuz2FrWvY*{H+ z($9*srC%w-rf0uOts-v_g`w7zuxoc91r#bFk%Ev=R%$49el=!MA(E<6i}p%bM9hfC zF2-F-D%(d#YJD5}*Ud6cWgTA8GKFMrvB@m@sSp?d! zh$?bOV0MYVp#LTR$}x?W@MkaQXY<7sl~Kr2c_a9GU*6dY=zN~B*16_ad?vyry$Vw*Av+=~qr zPf?)+_vZ8lmj`V=Do;)4@w&0%X|Z60VTGX+1wb`GaX}P@h&aF=LX?2Q|Dmd)oJAQs^#rapsjIlRfzSZ^_uLZszf018+O%l@f||raQqDi%gr1|MqP!r!iRl0 zw?Lp5*Qya$+14~dBM2<8NERx$=`7oXY*sDUwZ7>NHZ>tJhOjBhx=;Res#^vM0i*hs;qlPrCa~d96*Y`f)LAiI&g;u* zb?C6druW1%L1WQCz&yBCiZX0r;K!Cpb>0WYPE(;7W%8H==qk z$7i-#Bw_U91qEI>23E!~hz0-HHil8D9y?nKnKJLSwB@(?DRE@jJ zpcaZuV@eP<8H4KGP4r)|JS~`1Z&7T%gHbKmf4VWMUiHrAX2RVdGy$XxSYjtc={l5R z3K$PDK@{?}BP&5QQ%oYiO;KUaj11QRENz6^s7B}-D2ST+iD@Pg3aKaHZvz#H(MBFs z!c=;h6>aR$VU zz^Y7J_cLeI)+@0uMs-^-s)wSJ01bukS5NpWW1uC1XeF$^vlaZl%Ca6*{x}}iz89Cvl~YiHCzB1qk1-& z(B_sGM6Ls5vmlIcnVKo{sW^DReLrG4PtrkmQL)&Eh8spG$O9c07-^OhnD#gWw&A z!1oUTs%?X10ZZuPsTW5M@XBoiRbf+KObB$3a=@km3ZUY7DIhPAoh+<(5|Qst>fkl!ptPuI*e*la05|p$=)GYG z(0dz2k|P$lo=e(6uJJ}FC>o)hCwL+Wz^PFREt%t*1=gR*$eM%~t>sb0%BsfeTBu*j zQxD~!W5bO@FST93?AvK*hdy_c1b;GM_d(+di{3>F-Ryky#*&|&6LodNQkjD|37t4H zpth$DKnWcbMX+EyLiK0V(ul$Ub*P=!BeXm~)57(dEesHHuri#mnF$R11OX(U%;8HI zo$&SJIsfX{4i?J?u-<<4;NWWjEQgZ9dX^~Nvhg_ww_c*pUsLah4%_%+T2=ny0yQ^B zM?hJfzLT#kAcrJ>sDs-<5bj#G)@#s9@Cl47a^{iGE&XsCBg#|sS~Ww1>GzRd*nJrR%d;5ppg)Kv^* z4>dPvB|r|Q8p`U;a}St>i}l?#f8%mKr;^#_hfn1T-KH-cb`>JM7C?=@BD-x-4cymF z6oqL`D*d<6vx;rXB#MGu2xjF<&MSnASJf2DPwOg6lIgj%!Z=aH^&%L0A^k++`BIe{ zr$r>Wc5xXY{a3M7Iqs?oOkF)ER+|gm^-$&1b~G0F_CGOU=cqXy`3HSYMc%mIX~;%d zcN)wPb+$JTV%gDTwYp$)J{x~Vvc1I#s5UF^dZj`*y}^e(hfy5|cUt13QWV@G3_2;5 z_hu-NgzFgQWDW~0HxepWn_t*&ya>wm!GuT_Kgflb+9TaSFQ=iOQ)eE~r zhn1@(-#v9xqdt*=dM7?3ACt?F=gm2p*+S^jw&PGKAXE`|ogb@lse>L3GLaY;aPApD*^p2Hb3I0Xj&G``3HSiFK^t7^|C=$IM0HV z07gB%1u|3A{r4V>kKTKKa-Z{yCyVHEMORV_)~jh(f@z=_dH(vp5?+|T5!fCzGu+; z2%d5i;>t#KML6C$ta+9J10UQ1Fek#Nj;*bVP}G`g+hIk7s$~LUB}9F^$hZkRB0LRt z04t{fiOyk|z#GbpfR&M=5M;=`ZH5U|=S@Vh%d^3zvg&7l8q zwYuc1TH)zBzGWLG#E+7m_Yo7hy#6PP`8A9*&ue(I@`XO!Ss~JkKh@|f{0T=>U<9TO zW4jWog=tORnoV(^jNf8Q6wAOQTX1M`$R!Fz9?eCqta1YSdEoEBj#Qaghh8rmZMpm| zDxzFSUq$2ivHuKpXj>&+HWAv4Z&HTDB0O=1Yz39RF-h1D9bd!AWzWwMXHjbX2+&sE}^bNF;P_cIo9h~F!bWPE> zcf?zjDmJ|}N6j)6e@dy~3*ohk%SMZ@Ee0-@oocW#C=500YmXWSftJd}tRt>koupOJ_)gZHeHZx(g**qyg@y?n0Tc1`SFM zxz0f7C3;=4IZDli;KMN52#4C!ARE4%41)ryjH){nkQAn}{FDl>&o37$Di3{Lh0`iT z0TrsRe$T2`)Yi~3$txjV-27V%WTw?Mo-{@~Gr zCnS90_4GMErm3O)7F#XmYPiuNLFlkF9bNDx;5p8LTljp+j-|)=m|a}R&pXEl*S~Pc zxwgxr<9jZ=a%4_ZdK60TUGN1Qb!c6Fi0Ys9(Vq17O;UQRkXFO3Q=AYE6Sz1Dnc|f9 zHMuxlOwTB=poI=oX;oB^Dvubt;kwy@^gtyeNm2b8wbtN4Md*>A0wvGH6UN4yATsez zv6;m@yWm-k-GC>km>oFeb_wBu<_-%IZrf%GuSsk=X_5kF5A&@)VLEhJdBWsN1Ip?R z6T;}j49`vR{6fWdghYm6n0S%J;03ZA)5UON+qPR8g1&<2!;$GBNXu|N3+v(@NcXEe zi(Q{L`G~V4kUwf#FT=hbHMASMZT3D4c#dh|ajuw=U9HAIIi@-fi{%(1V=QIG#|Xau zR4&TJj9o+AoZwsmk8;cR@zp;3x{aLbz8?=~v#jA^#L>H`&Ykmc!k+`>bR5kt`FO?I z1lQ_VTE@rx{9=7Qj#u%RF3T~y7_SzW>(en=Wm@ogFUmz((908$1w|Eo0S{;{qbHch zO85{)*=0s`PVc?>2s7G)lK^)_!TIIF{D_EPEhw(ECY{fW@PAc_^g1MJbT}kc`>IWw zyz6H3oB)n*Uvq%H#iHdDi8=3ZK)6;fx6;Rb_@zXm*UZ(ptL%Y905dc^dW6Bl4Q|)F zo7|l)-909!6rg9C2S^8lhv8f)J6mgXjg6O$-Ak4h#ek2Yj2|ZgD0LU)S4A4TX-czT5e& z)_R_My47sW%^_a*{6U>38tNs2sclWgOxW{j@;0BI!yjGe?&yiJ}{ zY1|WjamtZe&Sv9yIyRswGtWse-xgB49jQGWn>tP9OFlRhp0-;{4k(P&(=7kjmrJH> ziRBlo{#l>1qPOpLO0v;zJ0un^)9g0SyP7-&@X=GYqI;sniKuB;v;AE|R(=B8uX%pn zfo!V3Ox(coq1J7lNLSOFo9lC=qSeR?{j)y1uea~D`&KsG%J#!GY2c-!T_Aa16L!Pt zVvI4T@zr8IYk3Zu2ow)QRi%U3q>D=T7N4E5v$w973%YKw@L3otbKM}e3^PW+Y3wqF zgb&MNiNRtkaT6zq6UPs&nAEgfwKHLTianb{u{A;mhKwMf$W=tdq%LAh5Yy^Jc3{@K zWIJ?NQSCmMe)JK!3zS}G2Ql}#X+s{{MvAmC%JHzVMQ-3EE{CtyitN-%w&`{6#mni% zI?IQYhq0@Q*RX}Tme+d9`_l5-#T%;IaKo6Tn@X<8-{b3i^X@9mtazOxk{~6wJ?7g& zc()@}WZzy|;7>rFYeuiF^4#~36=VmR$;*lsaBkO}mi&W0l00wRON^^gR>U~MQB5#<>) zGODP>xf$L~@k~{(gpL`wS5wNR%&M|DrQHpe<09I`~N)m)aI8g-A3rjZ=c+gALuHB)-$~|zOUZbOLUs5=Q zx(mpF9^xX3BG|7HON7*YgL!d~Ad4t+{0JdCL4y2-ZFj+46j?lnYX~qav+GfWqP@tF zzq}xW-rJllsViuzU9X41o1R}Ht=DT`mq>^i@3Pqa!@oj)YF>mDb|=SK7Y#7CL1Y|n zz+uRMBLU8aO*sfs&qBVs?FFtaat7fJLNY=?#~|1I91EF7KKw-~@Av*dysE^ejKI4F*sT3(BAon+bA|pq?TF z+qGX`F`(1J9}{z`>{84`x}Vt>P@$WE`ar%1ub0MH)G?IFAm``StFb43cC_RI5v6xe z21(Vv*>Jxj*iw72CqOUbGgLLBBz(C%MZK`}d7lfv+()l_KO1@F+DFVNWe(++exb9; zGdTU>w4*qZ7B~5pw#Dmt6PPD5en>s)5}8-uhYA`)93|+9m=ocCYK}e<-<#A^1ex~X zc=aT-K@Ez;+fALgGb@TA!)5x&1H?edkT{qwhR29zA^*L3kfpkDi@fp>Gv{2THhivk1I5r!SE42(tp9^46mm z5&Dbs@#=yjh-IeG1P{)WQL+#?Tjj94)pUkz{YA`|Hxx`k!$Zsg#33oa+Tc`7-qFp` z(|2zkJ-tg2flcgZZ4LLx=nn|VD-F7NPfB0z6pp92?H`O+LuE)PUV+@8K)eE_{e|Hb z$qo&|D^Tkif>&rPgdC1-8^It0@Cwakv!UU41(JQ>Eq^@0caSjKg6~ZC&_?i`2tCMf z!tz4Br5r}_o#x;>QKwfbbEV+BdygMIee&>)_n$s~Lb7IS2p&mSMCE;ktOAs)ecAtd z7TDOUOi(uqmED3Kn4)Rv?%80-Y`JMAI5))m0ky`YFDTEfKNZoO)L0p%cn64yxFK*; z%-3`uT+&S`LLEmRfA^laIYz~sn?ySQYCcZ<%~FTSOE2gqVOjicF?LYZBhf zTAV(f?~YP7or&*2bGSftic!R42JRPq$)3+yyj;*g@aN=! zwxv1HQ@(7lw!==N&;>;y6`|2geAh<$B_L8UfnlwS zw_+wC1ZzVAMrGcSe5{i+8e@MJ2zhOpCtlxli<>1ZWU3!x7#f7*+n(~d@x zI)WHf2OCKp1#L*fOeDLA_p^}fqT1F#vV#t7ZkCz|qp=7Y*NhOw)Wpa4Pi~H$eMpyk zZW*yP%Sg1CO-BibL2`}ATBP@{4qnVwFYxt>W}!xTm$q9ZOl7#3hkTS^a<5)fG$xYF-VWdX${jMax#0=A2u`x>kc`o&U!=MvWL!) zx80Mzkkjj8ydpr`J+(x2nSjG(#h7=ZAK$$FZh)hU3dVm`>jbA%5(M}+7cAW;hd z*(J$TR1={GYO%-9KZV~eD_caD9!UQE!o^*|CDQ#lz)o#7s`|@fRB9LdZC(=^;z~-q@^dI6)EWs$ezz_th|j>Gh45i zr@o&`aoGk4p&ZvDi--*Px6m<{k9tmD-T%o}OJ~TttweCpfl08ptuP|6bva2pY#knOLL?j_@@>b%o-cxd^1gpbK;$};%; z?pTIZ@`Jn7llTfsVUs?1ygFt0Cel$1pu2lOZO6!wrsCPLX@@p|Hv-EwO_ZT&3Zx>_=uk^8}E|i<|k(iqHg=JKe}a zB2AK_cmPXd-#|%MK+4%6YV@F(6cRApAR;hqnXv=akbrZcSr)I^L#1wux3-4TDzi?v zeJYjI4x=Dmxm8fH9l4U(eAH@XOWro8bE}}r7}QcIV(sePUSCDH?b=1^etpSQBI0d& zW9o?Jx>5D&@$B2P_^t4Uedo#Zcz%ZXjCY-*`zJ4sZe*NB260xxJ5MQsJM(Z91y|9w z3x*Kbw`<^}Wmn(gYJMwn1TuauHf}}Er1sF?8VeD|-$sP~)EEo<`(Pj`3egubJ^?WS zXSw8P;fLNKi-_ECZBJ0ac+dFtaAHK{&V-4e^m2lC4UG|hIi@ZKFD{WL zLIuirTJ4825y~mAQLuPFWCf+1u6lD0UJFHN@-kcH8JnM6vXecGI;Vuaqs#n+Fx7@H z#)cH=QiR!Z8X<^%50rIcG-hd8i}o_;4Xq933yLQkzJrZy|3xvu~9C2Uv zx52cD0n7CFX6#XfbW4)FPO?u14?nw4>N?6I9*3WDMQHN!A0rOrl;j`!Lx3e8Jp7E# ztS}j)A({=O9%IQqk9q6od5NcA1rE3?J52pJzdXpI(z zTn>#e#-=s4{HG=|`;9}(ZVZiZ={s&n-=Sb!I5e8#9!StjhQ&|CO!B4&7WrV%!D^)v z;PLzG_%CWlkYDDoMO%cR&C9}KL!r?ZqI!Q`zE4}W$H-4n5$ytsk17w8g(!yt=6IuY z;1ax~RB-^VTv56|X$PA>DV+x<{d->_qHJ|6<$%gEpuZrq;2Gdw;5k|^FS-2IMgVDl zyqca(^)J!*&?+;g$p`JG^YbZ+i)Urdvj~4FfMEj6njjpOMKi756NTSrBUIBcsT>7@ z@aL$|00Sakrhh3*4KiCxHWv{Lh;t{N%n#^R+w4~u`=lV#0%_^ne5irB91j}RQ7g};TV%V z&7pttY*BZ>k?CS-z7;vU<6}s@xvlBh!V~*bBXYWMK*cM2>uZ5f(A^=!pMnKyx4ss| zC%3*9Hpd$g4uM-=%f^dy>uZr~p{xbN#ZOKNf=#nkG(NXmICnRsguuM@wcPqz^jNSw zoK`m$3v-un6(P`euo+Yu&uTkTE|S50C_=Zs7CyiAwGeJw!y zDOzkQ571j*OXjut+48jjq6R>pWGP+oSxWz&O1Fx_k}8F}wvabMKofcgTsdSDsUh0Z z1t`(HB_*MC)R5{vzD$3SWL3n-ekte55v@Tf0cQP9UjM$KnYh77E!q?5J+*(2;+K+xQ^qP z&5zF)z{G+yC}u7r!~*h40b=4e&qoRE1YuPIA(Ltn0a7qNMJO?XjZ&0pz@={nB<1#i z->ucc{eU8H9@Ig@p?b0BJBEhLh^ep>_IwF3R|bXCKI#Jpr#0^d1gFMY0fI9_i(qB^ z4L;+0*K-urSWjO}7n7Cxd5j9DYnoRJb6*ny+8%aI@suR~^KxgzvH#(i0NNq)4FG;@jD%u=t<9CI@=QbWj7;cLT%mF|G^*^gbPL zUVGSVGcZLNafJhNM3Id1Z$0C)b42XcoVdytx=mh6;|h^}3m^wyIeaJu8~P3^1Lq-M z#r`I2x;Vc^-P{#o@7o=|CIZF7C!Ym~f#mZ92~q2byo!$Hp+uFHCA+yEpR*T}lT-P( zvHZqZ7$Ep^j36}gK-SbtMF|-wI?@M&v5GLrrTR0iW}nktb6(n%SoM*PYXTy9gIf87 zMbUKqCTh*s)m$!q+UKAYDfBueYS5Kq0@QbuUUumrn?(j{y-n_;=1&4`w3TeCYgjxM z6)ag7Mfv(;$vUVt&to$Vn9EYe4L1cav}Y!^nfL)SY(RSfv%x47Ohs8z1HiHdz+?e5 z>!Cui69P`wj_f3$a>ZV3x@HuT;K&~>IhJgP4l7u)YIUB7L!tm>Q!7q*;)Jmgr>VjCS6Iqjb4A zr>Jc6z##N`c{Pr{`W4ss+9&f*=0s&R`gkXu4cepjFx=VdYxUh9e6svxJ|2DiL?&a5 zkQKsL{dzz)kWA?KT1NApczHk>>q(FDPE~2Vd*8bI=&c8DKYj~US#$c*8r73J&Kl)$ zP2`3k|H`%S|8eAbfo=Pqo#F(fvF&gu%iIBaPz026KTTcHJx%ew=?N<95LW&;x;~_$ zDVdrij@#(#D_K8JOTYLgHKYIDTTscLQ&KhR+d3iiKD^)laf#~I6Zy@4mqddum|qsH zd2nBsg@*axr0zRV_}vh%Wu@<@WY}I%(ckjZa`Qx-(v z65}Q7X_C$^;kG}2{`?%1Y4M({X;)O)q$YoII+nRBWTF1?>Eo`0S?ns}fSQK}ZU7m#-BshR?5=I1aG7O>o7(7lcawWh-)#9_t2Qg{ zZS|JNLJu7xo?k3FjO~Z&|KT0jA=@D*zCo*^#vlv^F-|;?lT@H2K@*|h~ zfZ+{|2nw%hL}36Rc>wl$P8bDL?xlLicj&Nk$LnhY;_8BrL&h2Me%uf+aGY5YLoEtF z4q`}jKQSE3aqZagqSvn(ur4S>o?f2ke6q8W~o(tC26W^C$EfjUwqJ{gO>sp?viPa0-<5yGLA&XyGuvYj-**mLHCebS-la2Un(3QiLI8X0El`AKL(OXrs7G2f%-f0g+i^6LBg!iVu8O^kts6bS76^BnVu1P281atQujbs zTS1pS-o*Kcvm=nRV(Vqt7b~_gQMq{5!#k-xGpWi(nF-b3`!Jwt+l%?+ z0Bcwe#wa@sa1CXw_v~^SU#Bl7;@^wY3rwN~>s4CqVm+)?H`WvRrwCa9@&eX34pYxD z$ljbrh8MfAEX80d!%AWOccA5I{S`{TZjs z5f+silf?0(*H7SRnpLmABa~cAHW!pV#CcPa@S99ac7MC~?tIO$iovWkxX}2j$ zKSz;5uX(FMS0o1X!@zWWhw2T_!2(uc}x$17LsFY>!JkN zhjXoF1GV?-R%0jTYT`WNai9*Q6c6LbAOMH5h%bEDXZH#OdTpK>ab@#t*yfEOur`~w z=`7>*Y*sCHuD)q;+bRzp4_yxt{64o+!%94pMW)BBBtZoc7y_Y3L7jpL$O!=*o!A5* zkZWC$?L}e89jKV7c^6uob7sa?5SWSQ*amlaf=7e^9guT^^F8-Kbm*`m`0oj`7lxvw zeP9JqXt-92A>+9fLoC>d&x{x)UVwZ}u9VP&9@SFiipeZ>I8sIJo;?HcE(@Lj@nbEX3}w#LKI+4lTJv69nGLnd zl;jX}eJbsoNmSL-1ee4Vv1#Mw0{`=zVbsVFnN6eT(`Cy7kSfW2Uf? z>^NbS33X;1Ev_f)*=oEx1t8BDm^v?7-qB42ibp5Ert|7}s&pRRITRO*+7O>zfe-Y}G^PIkQ zs;JkI^XTb`b98e?+ttJ^W|n+IeHB49a(3wts*w-4`M~5~>xA1QTlKGMSZF__XjevP zP!+?B#{QyR6+tbVlq~Xi;IaAiMp%4zqy)={QAURzhG;HswB}^ULNoDwwBr;%*`+_( z;N@f(?oKxNKD7<9s)Vop#UH==l|TLAum9Q?-}`s3e(g`b`29bB^{c<~>id6vNRCeP zVDxw2|F5sU|A(UpWd+Z0hDI_Vb@UvNZ2(^VhH>B>SoGBq{_oZQ^~+!Uo9}(`Z-4QN zzx<6?|MCBQ_5EM}yMOyD8R@_H?H~NjZ;5aJkN^CeKlo3-_v+98)vNFQ*%$x&fB53} z|Kf{3_$&PJi{Jj8AO6YTlsb}Mz^6a@-Y@>}_x|jQU;B?g{6D_`ci;b$|Ne`=Oubqd z;BWkC-q#o3`$dq;JlV2io%R=h@W+x~*4jQ8z512E`oZ7+{ulr3S6=<uvS>#z8F3(}A)3Qs%yWImMLiuawj(?x z;1CMq)Ql2>qEjf@D%nB(P7j_>i6O+*{1YwU)N~oiyc)|?j}pPdR5DX#Pw!w#nI6@; zhpg^VG3vWnUbO9j-daR{ld~g@j=KfR?jG_hTP#yH3A(Q#%my!zqBFtcHGtjKWI^aN zi@UJeaa4$hY1M@>(`G3i>C8yz<}cT7l7j3|=qY3Rf^>OrewSE*9eN-!t!LoK9zgk4 zw?JXf?BdAv5v+^+xn(bIRof#aAxRI86uy>e2vz|}A9teGTR-im{QHhU`$O3BHE)frr7?PpaSw0RuY zSfPq`!&krdt6%)(FO8nQ{oV-w{^)=HZPL|$@83f$|Kc})eYBcSNAer^bM{qAh#$TB zUr3|>;jjPotN;2-vYoi&C6j6v7AP~>PB0r4ykLj zg=E)?Mq9`rTz)_;qXweAs~9!V#OtL;{h|hf{VNx3A(}thdeto2LbN}E-WGynE|evY zz%^vO?NX;`3r(F2sCKMSw1ucfWka)dZK7tP(sPzaAPtZinJc?*J)$kcB+e{TR>q8h zgDu-bgltxpodL8n8LviJG`Y;zZA~s)79?{stomW$Z6zu*UWQa0+Co|w5J?YFC4%~E zH2bMCv}K%|@*Z943vD4LkAS}O!jw4RP>J?B!A&8c0aQ0cbkc?TKLe;2=%S4g z1ASR~YE61<}(A17+YUKmC<~C^bVB2HKS9g|`JC6e{rG_ud6~ zG=Iino&_vT>iMtIq8^(_j`V!fHv{HJerRw6JzKtMF@(sahC#u|NJ$_sd)cC{b%IaH ztZtd6>jQ74XzEig`-d>?y>CB$`jA3Qnq2nwR+qi%;OG0h?2DsrHcb@2n_I`4<*l?C zX-)fk@T)|InA&w}gM9fqA>v)+!M>b`s`R3&;KhOp#1*V%U01Bo7{oez_4OfkHNWd^ zg=-B1Xz$n0<`apY_R37D^Fx0Dfq-!6a6UlkteP1%%6ZwKT`u+JYe-zs0ypr zmi-1Yoz44Av&htgJbbQ@}CXF}6z z@5!Uk)WtBjLNn#zzJ(_GeH;u;^!DRrXzHP#tD%YF0DnUh*?~@nCenNIJT!IjWw;-j z`WxbdXrepN5z$0?r#HeG8`e|PM3TXwZPn!&7-Q2KTh3F{J#^heM|_8pu!~L&-5Vjk zLXus+qwrJF8__V{T`q~;O?UVub`xlHPBb*fC0Xa82ncnv;-Rn%z?CTbymDKJKPuG* zxvmv2g$z0SvYZqSd@1MC<#Mr<8zi`S zxKEmYiA0kxbh|4w8+Rqy-v{Qp3ry!cg+lKQFuzF6XobR4ZAP22sclikaiNP+IQ40N zGsyGf{4dh|Oy-XXWq++ubs)zx%^Vm^BRB0ogO)Ftuvh=1>j}v}z$|0YD%n?t=2*m)5s}*9tEgTx{ zNbTZb2;-b%)lqBUVQDBHyEgYj&nBecjFq|XB`))PpLG)Ck}$^lr*IPyk05}3mz@_)L#0dn8=>VV)MInI1#~mBD$LlMG0!{E5#k>m0cRxG6BdX$*K{Jiy z4A7NY}m;rZH&gbPWC*?n6_x!=M)(Q#NFlTj-%DZqs@WD)}hZ-;%(IZQ$qe*hxZe zw5=<_u2v&D$0KOIswPoa{I&9E8+JKo_tvYkFLt-FhP&8ZU5OhlyClOvqs;BqZ}egI zDwSTmt|n07b$O@z=BB<}smG#p2AFypg`8B_p?7*tY6pLNcnWm6)64vgqi;kJHzGi= z8XQF%P(21UVO-ALG(fm#WME2wrNxwT{&r2Uv={gRKuD6%4+x=|N2!hQP-cb>2eP+q zMy$SUOot9D{9Rgnj7hQgey{Q`?fO=`n)7q()z}w5YqcS_0-y%2>7%OGhMnJDoJZ5o z-dNPZpX#6WVPU;}FXqigTj5>L_JIIxK?%v!aoN-4{=4J%V%WzoVF);B$Emd~cQGc+ zB9bw&kV*~Alx_T_@?b7ACeYY%+j=~30MQ@W>c^no*!GP4Ve*`dwm z;{B8+av33RT`8&MtO#>#;6Ly~Xjn#wyCs_%1#$+a8<@TZmn)YGOWW-{P$=&tZ`Z+FJ4Qom4;0K>_K{^B+W>wpZl3?2y*KNP zBgxVQ|BAN?g;c6VhVS9d?yO3tNGX*iQX7@45-eZI5Q7n{SVWQP1TOl%%*$YA8Z-Sg zKx2TxeVLc}1M_EY4=(1hf5Lpn%+1|=4PQc8Rkv7`lE?_RV~g8z>^tXt#|Nl~WDC$s zad!hTkrf%f1qg<2)9Eqg+JIsrBxwNGt{Z8QW|}5ai1{iGswi|KL_(-ItZ7ZPKcSDwnCK{F>!wQiA#*5y2Qa*9i5&=OPm<{}P|^x5F1egE%pl5AigXwf8gaSsVbu3Npm=fWNMH4tGg9$hlSQ<(da@wva)$hi zszz5gNLM#APJM5QGrZO8s3}`D9g=;x-5g+Bc5VjTd%;?#7|K`FJmv9xp?npA{5fKj z-Jfb|xNWd#6DeGP+QXnB4*T=T<=mfCOpEl3K9eFX+-pjRR+grO2K-`dYfc6@^NL32 z^VRZ-DeEmZib9$E6eyX22)OTdis$pVsH$ywNXQH0O`zd+9mGh%=Np0LxG)QiBa7~$ z$V`M+ke=fXKqSx9{mAt!Bs4&x7v0s6FJ%l#dVpkN0GEI!5mHe;$2(M5I>*!ZCJu3E zPEmoXdAivx)Hgz7C4tc4wN;koy#5YAlx<5!^ zzATK(zm2c0+(7J&o*zv&1Z8nw8L6CH|ETDgN2|0g3rC$yAp@P`!51AnmTO=dzR?{0 zRMQrEOSlFjU$HsH)>H_Peq+D>{`fZh?u~JL8>q*(`!@)ZW>J^xOVIS++oM+mHD&+EO{+k! z^+ZVI4~WT5o7+6N>0_NDv3aTfL6f=iL*lO!L4!iC6B*=>xSgnLAy5hypq;jJz;z<0 zYpiurjBO66w#_=_xJXiv7Z^&Tp0*;0;AIt_ri(o}v)&MwFljZb=+p}@DV-nlrNq|E zH!hYOh(#=0wuv$&cS%-yEO(aD9AxranJ8Vx$TScr3zkadowX zk8P!Qp1h~<>PEPd1nVU+u%lV&%~1Lb5q)!P9QRx}pEzViOPn$@Cs6qgb}v1%byd|h zU>;do%{{{b8%C8kb`?@8vA!ohyDYtUPmjQa+5f?Vr%Tct7wNzxqk_?y5~U4g-|-aW ze1S9Y70TA*N4pOm5W_zG`4;nD!AYa|5zLw4JX+2^TPe#Zx+D?j-up=L zW;e=mzE~;qSfTT2IiIe{+Ybj-FkQp``A~VPU~Jcykuq6*wp5m@36lQsV=S7^uV^Yj z3L15eJ$9*FPR`C(O2ATutgjSm@Z$HPK@T1rB(22bQC1mx`&p<=Cl^uH_0$PTm*USfZOy2au)`EqSP1dN*j*)6XvPVzBR^1kq5lcS~i>gwu?B$R<*v=%6*TD4-0_i<@1n;;U#uFB5z9 z`-ykT9lTHBu*sJx_T^-qk^!RQ7L};QVxf-!#F{Qp07@6tte?mmwWM7ChW(t#+mXew zF9v9(Xc1E@MGNz1&f(4Ti|K7(d^>%qyDR^@Z`a{L0E+FG7EbnPTHd=*I$1uNWdZhSq`nW zQyP1s%3&H|^EBW}PbzAV4w*{Xo)(#j9I8jAlDcY=X~FKgWLk7P+GHxO54lFIN+B6m zi*$2UDg{TX8a0SSPx$iu(u3NxP;R2-Lu}4C;pl+Ik#?g{4zo$Xj=s5a4Yq3K8nHCW z{mc1sHO1FB%Wz127x`CSaDiXh#(#M=A-g#{Kw$$|;_ONGe4Lum^7Gx@^vL+~=H`Qo z^rNZ)_22@Yf9!~T$ciQ(oU;$H|06f~6n`(~mt3pC5wN_9SX=}o@Tq@$V+NqTHPLve%=aIGQmphMtTCrLOqm&)Wboa{)u zw}L}xixZ7dpe`18;Bf2~CoJ$b60ln~p#TEN=BE{HKZ|7ZrVXE%`5F&QW`a-4Hf{U0 zfPrWWkh2P`P)hPy>wW@vJQpr{uylyt_|Xh1&4jKKMSG3(RkyD4O;;-3tGA-9C7cl0 zwuY;slxSU4mDp=Gy$TMg6${Z!X^7GwB&i!bFB{n%7k69VWHyn&_YDV5ycRscf>4dT z*akN5MR4vS=iL;X_jCg$6vWw#<1tdQTks77E{;zF7hd78vqzR|g*HK>q$IIWuQWoV zLxm-9UW^O`3wYjBH6t)>Rrj>9qq>eA!wt<;L%4M44iXe0*?Jfok=qiUhr-L8y0KkO zJS=3oOrSQ*z^+KWXlwH7Q>eam|F;FzxAFcO>qu6t5p}0neqVbR`VF}*7Z+dpMW3aY z7Vfq1L@Ub+5Ai^*V@NKWyrL2R=in>!qj3-93$Ivc!@_f5L>#d2C;~wZEZvK205ndl z!|w~Qa0pLx2ayt?jl|WOMUYIo@DP-N2r3_u3$Zu$A`12iU=B0kO5$TpMjn73n5AkK zUi%753om_d>9X^D+lyTrZLnewkrQKgjIJ22PHxs#tXt;TF?7G>vP%>oocYluB8r!* zT^z#w)?MKxX6vqP_qVm~$ey{$iyEV(8^~;)t-Awkmy4S}%x5)qC}G1&CHo9tsrW(c24Sq>Da1JGIE~yW z)KvpH98FbqEI4z9T3nNmURPbqN34Yl0U^%e02>7S-oWgO%=Zyod5{JfzHfvBm)0sD zD10N;99v$({E)yra!SM!RXOT3U#K(t{uhRLl2V+VFH0fh>Li|3cG_ z!@40miWX;)LXq|YxmJENcKD5>FaTn7+2D$?1xz~=Uo;InN6rVXo^;e(58-yUNKGYs zNoy|x#0r~^?6?!a91~0@mq3z#^5?6c`Gm}EmeM2mw$Dx}Nf4Fv+ABfH&6;1aS0XeP z0mfvX;m!rv|6wE^Ekk0I2b%v5cjBE(*j9GVq8UO-S1<&%(r4NT%I};5oe^48C~WX1 zx$ZEvtF?rI@HG=| z5ns(`>!tF7F92olHd@U0_JF_a;d#2r6A~h>D}RXIPiBu7-Wgp~SwnP9wN$-ewG~Kr z0E_3oc69J`Q?mJbq^jW@5ns+cw5{3-O6rqBPqS-bVtBM;Xh-A zHlKktGVWG(qc&X{wZG|=E&JBot=PL23-xPscNY6nY6j`({0lgXe}Yx$Q_~qKF+aaS|Zu+jY5W)4w`bEV5B;?M+m> zXHgZc-LpFMCA<12PFn(O}r>zRqi8*hj7?@nck^S=0MQ*1b3|y+sqj!ho z2G#^psWpcD$!r80yfNTLE4BN#)>i=Kerp|Ue6>W&2n;d>^H3nwXA6_R;7-l8F{x-; zY5%)!gR~*Kai!Qn_uop1+dF-$#Sgs`S4!=wLstsveow9xvz=4AQgrRznUkzk1tU}+ z$9Yzc-p*sm>6;t~kFWrhM;uOv3piYxX5RFMT%x%ThZ4m>VEJ~ye7Qn6Qw8L5{@{TQ z2WmtBE+0IAa};-lk_{ibWXt#(ZdhVHyn`j-Cx?F262mvf30m?=NWUHSRG2*r@z2~*Jc z(L8Fi)h8I|=euty;9$eKNr?Io$1ckPJ(EEU0Rr6QO+?Mz3>eI@D=ph}Ak>@(>yc;+ ztQIB5E>L=+Nt-O(ur0cX;FSXLZ{E*maQ#M90E!pAOLAX!>n=YGasqnwS+uyqQUliv z9exg}r6#Lv^bNv#+nTb=#qw5|as+lq!mkyn%PEfvC{lDQvSX02g5zndsbiQg;TGk= zSt_tK&w!13?AW9rrPgb3dJ@AQlE+$b^a_0kPauHXK+HCz*naF7ro)*c$}V0VDlC~| ze|Y?e&kSL`wm|m+pR~~QV#A9-C5At7ugW*U{j~Ah9;l#wN^~#idB!VM_E_gtFLP zYf!Ybv<7udV#{`{%(Dba=EA!kUCu+WR#1Z*@jGrTE0oEvzSIUv@nwwXQ5dHz>|)fl zjyKYLZApFuiztXlr-u{Gcx-^Nyl`!(wwT=pw?`+3WVLF(E>+YyVpTTZQLBr!ypGls z<~Pp{m#>1H~UpEt~0MA+-A7*IlHhtLVWTW0yZeR zl3f&VgTZ;Rgi8N*hU>-7PU3NeJB@#%{Pd5LON2x&f-l~tvD|RQ33o*vF}98GXwLc0 z^8MM{d&+xnIysx+Y3yFB`Q_Vtqu=3fM7?3>>w^c`MMS~`ucHYQ^f|TS^pQ8CNEqcj znqDavQFO&`Q*;g?6lD!6au%98!M~{Oee`?O@Y8?%+rRv)2=xU6&fgnmeC!3ajCQl)T z0V6z=XT%};n7yBJU+{di>_ge&Tmrnqg%_haiN|81y*A@aRa!%OjtkWf!&u1HGgK%` z&Qp}yTPXFEBxb32(xBQ_OfPlEGV6cRR63J!iuREwijLw44z;EOU-u9$x8Pg?-Mt^_ z@U?|Mre()2NT6abWYN1wJHotxh^_{qPF06GC%DTW^xR{#Lq$c+fK`MSPFew&(LwiT z;Jz+v1;W$lsdaRFh`8D#@^Wg@h3h?yLVBs4a@#q}MH{-4uu!{2pd&T`ja+Am)>gKwTtAOx^=|OpgTsl6eP1R^V>M zlYJusOQ8NSAjDjEKL4Y=^+b;i8pZlPidW5yepbMRe1nG?n@|!r!Np z@E1q{hZ1z#Ig0`4Aud<^BNVqx8cAmwbn_DCnsC00T=51XHJ|qxAyy2vbK^WedAc_u zL5ak{#epK~R9}I-90a5{k?xI3i+&u@-bc;hWXkO{C-%m?vmVo6g;La% z>D=#88rRnmEBbK+J(^m9Pfkf@_W>eVR5B+D8hcMsR5BH{T10(@nKg-urh>%Hq3EW_7gcS7oL z<(kiW47;RqvraM&g6?t>Y#^NoG|xNW1^MMm^QtINT*>=2t$3N|8)zc4yU1h*6>ZAH z1mOMxbkJQWV+}*e(Z|1s9pIdH3si6g?vy^VSi#Xpke)}sfS=_fC5j-C3}x!kI$jO} zl9bxr+w@VCB=RzE^~*=3W6!maZZ>#)xfDLE`2EZ5;k~Md zfgsO{dqY+vxqBvBxsd<9ct+F}Kx57k!hYqQ5r3#~3`*_`yJu&kX!XtU*Nm%J@&?)ciYPw_W5-mvrr93%)qwL2qqBE5zEIxUvykP!M$}?VA zdC#9;UWFfUkAaZ=Coi5QLK<&k$WKMJFGq5%5(X52gm?Px$M3A$A5Y-*3Ohc(Ztd}L zkopA5ZQw`ZjU_KIA)qZKG=ZkcOs`N zV zk5Cy0JJ$39p$jb&*IPPfq-$~a4Js=PNivY!W1`E&sa@T0=t2*r(wVH*Ky|8f~bMObU|7pGOYua9`EStiRyq*V$Y~ds-*5{`i^d#=-QqxVCModU3f&@ zfK2C`D4^pyXu9(04cK&LnPn3=oiBj{q9ZzuWahbJI6;B&p+GtXmWz+X(Orj3CwTIw zf~L`eZQ;`B%U>rfjWNh$(%Fl;w}&sA0BO)-&)`V}AbuH5WBT`;!_UHuQQ$_Xyb`dD zlLEnjaMR_tLX2cP$xlz_@Sc=qTX{v{Hf=~wcHRhaz7Lhf)EVZ4j-D0V@O#P@W7Qyf zkYv&I>_9}*=|h$;VbJRp${oFCadYU|R#CjYTRvG&cvx>CSJ7G{f&m8Gti{bUD0{Ax$u=q0-)5T^FvMspBn`6K3L%(DTQb|G5{KGtg`lp6 zTTzZFiI|EUZ*B%uxIs>o6kzu-)2)!!$99_p`aY!$s5p;v%NIH9CNpx$OOl`>{Eyg& zknHul{ntm7@fBB8R0^FTq@1;Esng;vcu~pjPo@gDl6o&H{REfU^qK#z17Yj7V6HJ6 zMyh_6RPp8+#;+``q%&2&D1Nwfp(18FIakSBJHJ*dDI$$PGBio!g=#&d*+Rw$93rM| zx!yQ7#&(FTF0QG?UV!vaj_<)4$uL6O)*|xTBClDx4KVl!Ds!?3_tLC4{9c*<%A;jF zRB(4fX3m9$8*zRUO^;Q)l}<5qV&6;)^=ISf7X$ckF3G$=|0JI^$5^m}(AQ|x*avMi$cc*gc&Mr?CA_luXRmhZmorbtRRfxvWU6Lb4>%iLz8GT)# zDnum+j5zoDxItA&<>JuG)SanWBjJ~b3PEZ4e(q2e5{I}%Rfy~A7F8i)m}^vxz~1gr zHS+qoNYx1I?svb-D80&Lu_o)hDiD|8`3sr^0p>9+aBC7xhwy$<^rK*sd?9El;g-=w^moAF; zbE&FmD%v>Mt*SySGY8T-6cM|(2aK}QA*llGOS4TSFSctGb)?l~I z&SuHus@Vza^`qCXsSYVPxW5aQT(UkqczZrrkW}))g5wJMlK@6XPftYrFAY^1`isx; zd*j}lM*SuNrC_{V!0)XT@Qe23Jge}#82yc&RmD(W*#NNt6!&!9v~3m9y~wX_2f^6! zJlFMX%L2*1?uM2Xnyx>lTuwz$T&@LQGd}=J*IX4g>#A7aHySegSVsp(6m!^QI@W8w zEi5j7faSQ*=w>*f@Nf!kHSg{mQI^a0HzZd`8DdS&i5mo%=Ok?pHP4HclxNa=uxWX- z$!!~&jf!{B6)np(rMsCqS6mFeH$@#xqo*XN=8XiF`3h?2;-ER(0Xo5cN+@xeC#}WcNVf=Mc`vd)T5;H^rJH8Cn zH=neP8#x^FGQLlUl>qx8QYA5&(AKzr?Epyk7d8Z~!T&mm11$h`VuzXm>f}~|^_^`2 zb;7q~5U3MB%qmbXb+~DuPIe#rK%K1Z7zyg6_p=n#NgH4;s1rHRW>6<~ONN6w@t?wa zP*>Lw6GENLfp&yCv5m$Au#Bqijy^uo+&$eusCJcqJPXv;v=d$31BIwHt}rI#AJI0& za@VwVlSQGq*aovgbKyqYLQPQ|YC{YR6%3^KNGKxk>n__DGNRFrfLGTr!z0gTgO5SQnk%x05Tn<9m8Bigm z;E36*TP7L>mnd|XtqE<2!e&A7ZGz!9jb}q0L;Jx)W5lRrhHnghqLpr^1}XRkqQzZj zsB9speU!<6cR}EM>rCGj7QY+=jxc2@23&*nu@D5VZ6^p^qxhX92>j6^LipNYWuj-t zbzzm1;=d(hb6bnwF3%X@9!zdWoak5FZ zjVKsl2NN{7*jdfPIeOOu=xh>zbtA=u^H`{S`apbkn!E%K9-&emEmfkDE`YV1h=38< zEQAPV7^X@YX}0j7-VlfgC8|sjpixkGN)fO;ubdmU>3~prEF}RyoV=UtJOx4cY!1%r z^6V&n-)DXlW%QaMqUjYg1bNL3)j_8c_k&!0L{NXaq9i91uVsethVuFOLGO~0n%lZ# zfvnqh$s2@uhG37tLPPR_V0D^)!sinKWh08iTaMB&J06yI4*`3g9|M_43 z+rR$b|KET4pZ?$f=YRii|HJ>x=PDauv20qb{rXoc;#Nnkhvb)^x3h3Tc%x*igPD*T*I)ow+`01txb5>X`J_NKK{f zFnyynWFKEe3UsINhOvCC&Ld@gg&l}!KS24jo<_>`IpqB{7i{OXiT zZ-#%B=>32FPyYqAv%{NWsgtz`a+>ADo8fv*OOXXPYPRdxpaqg&w@Bb{_~H27g^53# zoVx0>18ZFV0H>~eo0}(E{@K)zqS<=DJusxA{XM$MLWcNX$kGP+bIF1*3%5iQl9MV~ zLwb30$-=t&UdUw`2!OfGZM$7xJTLWeG|ZJN-=18;2(&CYNZ-__eMqQ7u!N(<%?gU| z8Igb>@sM&g^@3>c?c(i>{v1KQN{B?5+uWWa$o3?BP7*p$#Q*lHD9ch8+w$EM#W>&q9sUB(AanD{5apDxem>uJb3=^;r_kTiWp>C&bUKADC~#ak*Q?RqkuvYnZ=ql%7&bAGBPy1r-X zjY+L)=~xO$ty0F8gf7lQb|-#IV;``v8{8has;v2@1s&To_1G{q!!=w@^ZXF%SnR0Y zII?udj?IWJQNme4NE5#UtorF^A};yUI$C0Up=G?EMAtYrieGSt5%x4U7w`vCD~OOB zF1#3xP9WMuzi(cb9LTFZT{&1~33V8~DX`^jO?qz{mkn*FQ6SkF(8g~*ZFyX3#S6tF zg9wkD;NYsRyN<7VF_gy0(Ty;Q9M>Y3@*-b$R zA6^c(lPRNet<1xF8-rZrvUi(GvJVn|KH>+eJU(}u3Q=-5YvmQAHdqhIy@R_=r6+Wa z)t!%XNpKeBtJg15K;p@K8UiPI3Z!B|XN>Ya844aLuTQ>GAfO{9Rqn;*H>TF{FLg4o z7#B$2@Q~6dZn3OdKY)Jp0b1XC+8x!8+yxDR<%t!yq7?>+^A znm45l6Cjn+kI1UFnL`3$YK3-GTCu}IVm68Gkx#Hz zWC9qcGnIU0wgDp3!Yaz9-v>jmLWqp*vfaB2MON)_BD1j8w3mcMHy5TZ)U3dAGQkn%^t;Pz5<4obnBeab9K7DJZr5=#;wGl{&n^ z@<8Z$MeqS8tB6i%lmgE+2w`2SkWv|)QY$Yx*qKCex^GQrW)4Ps3&!%nmB{9JW-u?+ zv85`+uw=&vYN8K2WF)K|f4LVV52D50V{r3@p!UY|PZ6KOw*omyA^(J_Pvm@)CMgW2 zkw?kM5}%W*6ov5bEzKh=bma9LJ1$u6gh#<* zjZ49qkFrJAHvv7#Ie{f>cF$dUf}4e>3F`YjU6-cbuF;Rn(8}&rl~er ze_e|LOwy=>C>;A%Xgi^5n3k_wDCuj)*fp#;R833Oop7vsD&?(AH<2{zphJbFsDoED zVU#DkU(L@#Z#I9wyqKU45qqFUQ4q(L7r`;sjDoR&Rz}7cAqh0|G}Y5gL{&K2m&=Qr zgbSDvdSZmL0EBq*K|yxOOU0XVS7DxE?Bz;i2tuWjRt0 z!*lP#3wJb)f@q3+PVUQY9p}cRoPb_^7A-FAJcxut`p2=f^JJBc0_X+{ZwlQCy=t-H zR2SW}&tMqSSSGOm8lsyxrcC3Ugg5DMZ5#VzC-O{m25S_7P6mZ;p=S{Syi^N+n`1gj z(v2o|9K(%m&Bya&P1kgaj?zunb=0vMfpgVVLoIYE8lb$;_o zAV1w?!qC?}O^stM9=pEjd8!+j@Qra}&9rn2>b4tMZu}*i6T5JCjjpCQlD#$`@5Ey{ z70MWViCVt?B8%o8(bkU1VntRe?r#rpZOTT8T;l` zY)kYVKJK$3WwE^$q-berLF(|%RFQWNr*EPPM3d=qHM)*2n1a`08OjAVEk0-*$>Jl8 zt`J*@k2VGuns#K4;ky;MQREx0IS#bgN1$E=?`6j^T}=%`PxtBVrK^uts)wY4Mr^qu z$gaI8G_5eyqd1BU&349~X@`+VE4IA))bSV#G&IJ6X+{oW6n)!{?b!3i0eo1UI95G1 z7_+5YT7BQl&u7Z3UF9`=-lxo|TC6_L($LOvFvdBr`q)Oi$Wu*tr;WAP^lZF=YpiW$S^-#?o=HB|DgiR;@PfjLUEK^dK0aOHG31D<@owIa(&hCaA^n-Fo9Da z8w(F}5@(_22AX9Xnmbkzt*-~JtyzW{Aa+B=xoJe27mP_C{tKDh z^Vt+}u(9-%*mRXCZMC0jBEPu`F=LfSm{(`fv-uf? zux{yKZ{6K&gj^SR2}oh$5b-+}s8>SA^MTw{gZeCWiS}9m!9)AX|4= z8X?m+!eDHI(aBX+%g{m3>%0FUf#NkTS8-*(y$4Qb?hpoqMaZ_08F05>u>sa=lIA*uvL+VA+C* zUdSwObs3j+K!K)Xou#;}T-iweMPTximehfA**Za+a9r4EyBJZpx`mgJ*igU)hphwF zS=X^B!<-IH$PCA!6?tIx!|e#vafZ)8)fB}ILn8!EYWuEjSjbiv8J1yL-q;-ns_ARk zi68_xH)<)PxE(4it;uhonlF_nG>yPkmfac5vFXFk>BElVKu^eaqnie4o<=AKD6*5s;FtX|qEC--q)I2i?Bisj2xU^ieF~Yav zevcw_dk72_TxMfC3c}a|*^RB5A+UHDW+UI$arv*KbA(S6czzVjL3qfl14|heenpl_x>B?+90GZm+;U)b#W5yj$ma7}^(Lw(w$1f#3Iy|y*p-qNN9 zmRJ*Hmn!@yl1(kEYV<4$pAyaB3%qPZv|@Bx>}n0=^V?d+c*&TfLx@jZYX{XcN_=bC z&4mRoPQbN$(SX|363~NlRs}j4z8~gS5$G72kZ}jIUZ*Grnk2Ekl5ILow+0=2~ttP7} z@oXLehX8*aEOv?qzc@}%cQLsF+uLksiOnilk=rW~>rosavm;1MQdw)0Hi;!JH%KsL zf+h2I|K@1_i~dZR$%=gcg^BtGZwhVS1nTNU3zLmXfBuG&j3JaTlCVL9Fp?Y!+gL>5 z$I<+H7A=1H2#TYt`7ao$9QQ)=>Y>@R9LYk5lEFx_y0SJ%McMv`uC&XIY{8y=ieP4zQU`bgYkU?Xd}1)9iz9L zgH@Xc*Ca%t-<`wX7<@W_W$CJU>EV_MyAiW2fx*+`w*2V?1ft-(yryUHC4WxgJLj(Q zl(BtIX1q4oS!Y4Sh&DMz=IpbT>@UFTP?%jSgw+ia)B1OnlXKKcC@}X?PB=CJ5u=-P zIEKJ0VG6S@{GzX}usOrLwqUHBCvzo)7Xy_>Hz#=HDg8FP;LRn0N=JJtKYz3z-aNmU-Ui0E)0eut^1u6b9UcVQ z(d|phO>QJ7>)jdM{4z>Ac6zpB@cGYJtG#5P91cWUJEv3&9f$0^?I`T-j2?{&k%6U` z_Sb(#7mv=WV{y%_(P95{F**JA!O9%37c?_vcUkTpgrfxi`4OE^A#L-3Dd_AwIeGG2 zIeB~n&}Rx}>ts_`a1s%vb&JiN?yiF~;uvI0OD!MGi8X|icLp)Ye&b08Qv1i>o;!L5 zA54)ah|mLZCqy({uap_GpEQl&(_qL_5~zg_RPF_AQq{$+{U;jgpP`(Betf~rCd^AaV}dOz z0rEPacayCY`KEqkzr1wSquUD;X-jU74uVZL^*S2Y$qcUrp$G#=T&cyswZ1|q$#1QL zjk5w8C8&r|1W%^td7EQ5S55!xdX<ZupPA3ezffWtF6ykAF=^3x+8!~gUBk-U{q6|?~gv&rY| z3icECUR%~ZOfhQ9&$%l*1uul)c}2_<^GDjD|Gk~@Xf~vdxKV!k$I0cHvRnjTyv5ec zxzll@40i=j4_kLTnsdIhe1G=#9uiedCucJ}jkSxr?Av>z-zg6sP*Yi8*n?DtV{@}qWUPQB6rZFg@jat?M(MY%hYCsQ0 zAj2NXXRv7PdID5rxx|}5+*N{wh~GoUvou!F#qYf*9+wqYCgX~e54Fz?H zoBvZM9Ui>bL3~l&62YUSY9TeAP7d@1Ef`Rad-J3IcwoxYQGmC#n|s-3kNB38Y7&vH^;hXnV67E}rV7Y_UT9l`OgV5ao)?8KhKk z5!+Ly5_vQ~tU#%@s`voP2W+UQFHOTEq zvWy;HKc9Xx4W78S-uJKG2eS*L?%Ow!t>X6hB{NDU#|di-wo#e!p0`hYvytRpJb1SO ztbK{wo{wU>XV4hWr&DHbDeiPv6XDj0lPICamy6$R0QDpEx48kdIIyxX_GlR_COmR? z@7@W}PP$s`Bv%VCKlr$S+^5`jpbH{H*HN@WNXO^93d;c~a`Az88r~73coI>9Jmw}F z;P2@pTtRk~$GCsUUilAUM1#SOqQhT66I5RD404IhkVUca89vdR*(jRr(!aa!V9Zod zl!3RhIF_!D0k#Mz5jQIKz$A`7uvN#!vA1w7M7tK}Fh>;0_QXGF-dOpKLKeqMp?G>*>?$EG*pJ;_ zZp;uuds$9b4tu#QK#Bph^+id&nd*yzaA(PgTO>eYY7~DJUE9P<$@781XkEpyLb8+;;_LkWvy!sB z9JhMc*5wLsiI`n}4MoRkL8IQaoub^w(Ig}lL!wRZDoQE}K?T@dGs#I%*G@pUuG@RM z^CO;VfZa89PiJ)M1;%yBse&G1m^$rrT<^tCdB$~V$msToI+x4y?BOr*S;Bg~SAKK@ zuX?#aBbB=JIGQ1`rwdJ=Js|GLEc7vnZ*nvZz(;ljVq0G$;$)A=RN=BIIK>Mei-Q;7 z=r@R#c+IXyRI|5C8ObH4^u_!ge8XW#$Ue)Ky7b}o1kA3|??k?YQc0?7x{EADLv+i4 ztH736)@_60=U^Y2ErH>Gq?}#o84gNxDS>&8o}MVrk|!`;SK)_Kf@|*Kb3D{|GfD(6 zM~OfQWC~#an7;e*JL~qxlfzpIb!43cO)KkOj^Uj(QoN7!1vT-!7xTa}lsz;1SK`suxl=Y_J{2_@F((yV%JW*FWa^lX+ z@Z8{rPPBrZzWvlF6ojb6YwZo@4}Pn%@XMIBOhhW}CneDO<_I3ZM+YzUZ`R{Ii)QKb(qpHuSvl~j8y+tfa@L7$el)4#3N-r`ic1E>W+ z&GpJgEsSHA`Av>%l--JT#;2t!M}zTcS=hGlX<24xd|EEt7oV18BnXT+Yy05SvbcWu zv@BsDJ}rwHf=|nGy5iGvSzJm7;L}A(z47UypnmvtQA&S&T9z~npOz(wYcd0IQHy9$!aLR3e5TJD%sG!w)y=B{m$bpzJD*7&sC9s+CuYxl*cWl^+1 zisA$w+_iI}oQ(Xj4UU25K)kyOOm@dAxn1ySxxb=ZKYThbX?RXjSzaG}S}wmGd|H;6 zfmU7cX<5Pmd|DPW5TBMsZ3&;2MSco=T9!WqpO)ne#HVFZjrcTW1l1{s9r(0mA)KZj zpGHPdea{r&b3HztK7#Ek*+lSD9-o%lw+WvvKe_>*E*EITr=`cS$#=o0ZEXx^*z5=t z_%Fa;frUyRi37I@mrl@Rf~w)-zja`Gd#E%d{Y7EYXipB1mRpH`bpVy%dOt z28a`Qn54|X9U=?9{e2{-W7HtHzg*GhOq)ptqC>jS;%mtVI6$6IzWX#&lx^?pKRhic zM;@4}Lf(BM0z}RV%Be-tN7AgI>)FK&5h~aa*>~Y7N4&g5m*8fogIFvT9p4#d)qPPze6{oxN-KLT%ddO1fdI+lH+lu&WDo03r;uD^_H z2gfET{K5E05T|0^kZb&pv7V+YJ|{h@@_~h?e|O%;%5YYJWWQPtp`S{Naq8K-9P2{A$caS z-|oF|<@jU)jR6puBU5)Ot2z+p>_hPD=5J7?C-4{vWsnktGBTvZ!)gf5V9#(> zq;jy-cpL{RvNpzJ1Njtv%|mtvBrAX?2g;7>mz`evnv--rvMP@aQfJ<3YW7(|s@Xp$^8)rQ*Xb(LL|<)zlVX5)CVMWoe@ zbT-;_k)i`1dCJC6p>hGAC90vL+cWUmyflcL03$8fcOVHTVZw>Kk1ghK>Rl0GA{4QN z#hFfB=_>aE8_~@pN;tv1WgKk`ZuordscRhAbOQD0-4S`~G_8~d*ElYJfM;CR-sXYM zo=aWbnkORH+>>JcuWoq(LoRJX(xB^_5VF0CS}Jkq6-@~0dN~v2*pkFdY=12iCAV`S z6Vht0VsGmG<@nBcZ||p{IjltbJpq{L4pF~?-$PuxgpFUIH{y5Pw5V`uA`#!G``R9e z&dOX1K3~7YRhi}l^nLm&yNpjXQ-vHrOghkwtrfKl7#l47Fuf6 zez{CG%;pWCs$^2InPaW4U`w90+TxsR4X1ZPhvXsS_hcEY8KEtx3V)-y`ooO9{47FF zNyPI8YalF0h6>7Bwv(?W$S(<=LvMPCyBw%&|FoU}f?+I3M4(HVmXR-s1=UiLL?Xx| z-dj-eE^ol|%YGrj9w{Qq{l)ps>ikkUV?n?0I#Qw!9@1S#pTAvz!3clA%e$DM*m6F7 z5AmG92z*MH-Ua>YC1(qoj?AqSR1BhDZ^5I0;TDe!=E#D1qg+SR>EER?Kf44oJ2Jek zLEFR_kzk z9@fOfTkvpare`7Oc#(7$<9rqY;qbsCNm0!-Qm6`Nm! z8L~k#eDnlWupG>25se6M{zD>LMt}B}v>^8sEQ2i*1{bGQg87T(p0Wg!HqdWjR5JsU zJXTlp>A6WiA}QF^1Rrog!`Q$Fe9cHL=zx|rmn!|8>JaL9wG#6Z42_4^_(L7*r^JW~ z252!=ZEt>SRV6xUHYEZ5b(}g;L$sZ;%t3ljS={zCpbFVTb)mAzu3Ax9LU;YBEMq&G zQdw>vovEnINFj0La?qO4u1R-Ej^;1F@q&w2QAo^b6A#Sv-q`}=h3vEt=P^53KrxI1 zA@)GuH(BBYoUYF2>$7tOXEKuSg1`^w9uf8@hXI|JZ$Za%dwTVd5^V89$@=z@7^MgjKLdLxP&A6H81CIzzb* zflR|5KmM;5)NfSHzd(wu$h+hxad3s_L#Qgj3Y{YT;fCz(EExc)1>XQ0VU=KjCvyau z+)$5jJVP@8gW>{Ai0FHaF+!sPqDCZMMLyo7DbYcW!2%SnOfjg--z$o8|219*hTtjG zB#amif0mjrQM;%klsDn`pW`Ula9k7U(vbq11ryMLMTZi=LU(L9q~4zqHRiqaJV)K# z&@0**Mso3{Q>@nPkTeLG6(t^{Cf-9>oU4wJvd@&V`#k}#(fabR%FHr$k#}t@^=TRT z;f+7PMzRO=stBp)zwOp%I{TNSyo6rePTE|C>U3LkfN>M>!p$vGWh2q6UFe_aS&Ms1 zZE2cFnSmvVA_ZzqKb=_~`+B%rog<*4h!h+<(!tW{e=jZG>0TCD*`Q;|#( zaB8-OXg9f@Pvaf#T!Ri3=Un-TKJ%_DrPtgO9jKaoWb0F5NKIxyp~g{kb&hm<*l~A) z$xb}B12wiO6>f`}*iKYoT9%AI zQ6f?nY2hQ=H1WIc1wOvf9aWHg(W*sVdx-VSc4oBNp9_NsOqk*k3&QCROHl*v2z9*QrT+`QfvarHNISW z;9tcl8$`rol}{K;CLo-T;bpYD`atpAn7v&MKZPb%Pn6Ue)Os+swXSnH59-pynwn-9 zrep=;Z*j+0lR?Rue{x^;SoZWYseDdAR%hHkh98?myq%~_i2g~-wxYigthNYJbqW0%q)drn9x7t-~KG|#cBhqmVV zn(gUfXlW+aux_fZ85(9}x~?6BM)msaP+@6(K4LB@^0L$&-&J8*M)gRs7wDR0gkw() zJkxg~!?U%}wXy748fk-bu!`>~30;Ts>Tv(y=y3OvI^ScdR=&@4X|^7RZ7og0KQ{SH z*cwuEs}9a3p|*zS5ssmEV_2z7O3+<8a0}n}S)j!_daY5>^zs^orl%qEc&6#)>Knb7 zUm&v>A@MENXm!y|Ycx&a+{=@~G_n1JV--1&F}qcyCUKCS+R>vBIhmot`}SDl4B_bt z)#4CY&Go>H$4H#4TAHP+NaL&q5!6J>qvX~m(w~zX4WFfCU4TFIxrZZr+`hun3eAlV zq>J;@HKCw}V;rJbjfNh2zV8I8<$9j&26`ApsuR1O8P{cTo<-Lw+a$wr38bB!@d?@a z43+1sc>n3bY~B5BElkOoiFr^gD=%LnL8(}nS)xTg2)Q#e_hp|YnG?`!Jti4XNdqEa zO5BV8B61LmBti`5ZfTgxMx;L19^M24;qFop6MV3NPJvqx+6?Q6qmmfi=KE_KSr9_l z$6X5IWKlC92!qmi_Hi^O8{Q6Y0*`jGT4a^Ko;H0=qZ-|qHn zH$q5-`8xlbNI^_K^W1?i&5?MQf|vyn0NPK}7Xz79?otrfq#&kSM@JJy1@tfZ?>=G^ zvQqoB9LE^z(!KC(2PypG$_NYTt3IlyRJ@nsnKZR@57bRVcMW5lfv%#a5ww+XzSz0` za6Jj(hO^vs9&**CzIgsV$b(BM*amW?u!6G|{fScQuu zS{X|46`WyU?z3H*O+|evcO;1-1--|;}x1#_N4W<)C zI^r+@@xiiyXa-#+bSDK6bX&DGHS{CkCcuO|6~P)2@V?0N)YwD_grVB5X9Ory1`s+_ zSOO4|5krazxG5{Ily6ak01-UEI4~UmaCa>eodPPN>Yf$(uo6W90EJLqFx` zi0}Jt1Z`T-*l+lP#t#BoK21O2CkFmrjtHg)TdxSROHg|kXIT^&uI7eDXseO$smL1@ zlU2pAHP;QsM&MZ?y|#2ocPNuB>7TcvWLT1t!62?joMgXJ)i7~@qk9NC74s0eIN!t9 z6mFczgorK`518Wjedc0OMz7f@nqHcX8YZKPtdp>LC9^SC-{?xex@tH1D$3>O+Q9gr zvV0Nr;?PTEE1)&JRTc&j?Sq8M#j~~y3KMD+Op~9`D>RkgN832UHcI4TAg>v|YLbD% zgw!A}xeo4alWZ9h)$SYn_4miO;dgH+8~M%gyQACVgQtvQcYTSx9ryMeOgs@Kbcnp9 zi#;XAakqkh*89m4aopseb&H)4^$;2$yWPH+Uq=fh=AF}sutwO(3dw@pq$Y@%p@7(Z zZ;x&_#ta#?o=S*>CHVuqZF5a-9`xL!osg=mWPhZpBx49tB?%kkN-N3Po)4`obg1*J zB&#b@B^B+CR7r*Tk{*gwNdo&g$o?8ZMH<}wia-^2#6?t*x@W0-Mr%i0DYNvDsG`JY z_l5rA1$Y0%jurj`xs?9#A6~%y1|b`Yt~{F0;>p>1!7^{sm;b;DymFQRgEx;(o<2X$r0u^sdA@&ez`o8tefISDaR1edr^ip89Ueb9`T7gP zlH?tJfAVVo@c01j-ak4#KKa6uzuo`p_48+MP7dj*HwTBWGO0)V=9lyPlCh;(;{9Ie;H9ok30kA2;y~KkUuW-r$*v+WgaW&ZYt*R0}=w#^$ZXooSSh} z0i&UZK&pb@(f9OGylFTmGY4qTM~KdvJh4$6{?$0xkfsPC;IzG@s`n9YesfC|Kl5(z znKDuyuMv8WC(#CU%?G}zL>yuSGljDs>{oVibemhC@K2(mVB}AYi{zT=4N02 zF{@=YpHCIKSW=bCfSmf+7?vl8!oujh6(6FL=ieQ^IyiiGvX8MNk7f#4HN_irSYU%(d|&gIAwxt>KI;9`v$ zm56i#WgakJ_YiK_2x=0NsO8Kbo9@aaN+ha>Zb8vsGdOH7*Yvip=6DMja$#nWDA3Bf zjc8b-IwBrAS-|6-xz0bG#q&M-_%Su{?LE?*cdy`G{}5jFvq*8AhnQ1}^u(jRw{PE& zJMr7MxmLV=doT~yOx1h)mc;PCcf#oX>B|)!hKs@5x2Mdf{*=1}oyrfseR~u9?5^ZnM3rg4rZ=co$* zk-cFy2VD?0q4nyDEe=`(H_C)s!oK(XIU@gPOsQReeEs$FS0_rc3EscNgmc(F@VW9V znw_oA_bhjJZ1X*4Pji%~Gl<YVvH3H-eSITv<>(`hy5ewt8uIyN|#UigrYT zVF*?(FO|>JfkMp2?1B~~$$Ek)74m~w@;HY~pMa{qA;5tHci3B7`ak5>4!f|5%b2(@ zr6Gyr1lp{1*9&vT)nSPwlkGD@Z)4&TV;QDvIVIu+WVfFpP06>@m%6+1zx#F_9t7Ia z?Mv(Uw104m+pRp%9r2HB`Pno&poR8 zev@ZJXh`9g1|xD~#wi#Z=D~#BJK%Hi{JZ1BS6D8|t>x>pfS!bNHykBcoZ~`Xgvx`yo8!X53)#n5(2ls07@ke4d}+~13G=7AJX3} z0k{X%5w=27=ZIh!g1(#JbRoqXKq<}~7D|UBjC3Hx*Iz|3RCt8K&*!tINGu*ts!9%(VpLo*RH63K350&g>QvNYV$t`6j z{GD>Wn6IKe5+welr=4;#zr@J>jtB>?Dfu3b>}wp9;shmajcdb5IZj_O&6sK37~3QX z`E))zqrstPKNnT7xJN$t6H>F0SP!%YTrFVzgFsZejG{}%agg;N-Qy47yvCutbNT?ee+r1A5{FtvO&MGz@sAVn`@QfjF`|M74C%l{~v zEQCv)o`BT=k&tpzQOOdQVWu8J}I{@YvZUGn#?}o+=gr2gTpivMUiKbI0VO51%Md7Gy zFrYqRz}Oo=5e#HHR$_Rt4iM^@bq3E=&V4RJR0Tc<5I4|o6!gjJlclg1K-IBtskJml zB$s_dH!QjVpg8Oh^WEFYmGX~5$!xsYjHvu_gh(Y7gyADm`gbHMTL*mwI&fGPfGo*i zVxNf?QU(P$8Z2qNsA9}Ub~(lzW0A0)GPy+HAsgl;u9Cn?Fxj!F*VENRnfr`_obMY~ zxIp6t67BbbG*XNde7Etqr_fF8Y=PvQP?JG(tzeE_L<^Xe`9!AKL1URV##4?S^HF_> z0jBA}mlsWbwrttX#Gjbp?oJm;+yF3M6=OzHCmy;;uPU7r$?lglm$ra&n)wQ-)uBj7 z=wd=qihYeuRURmeD>dj(ScEbQ%ATMApWj$>q5;_^L<^7Kg=vv4qU9ARQ2A)a^a(>B zfF)4LTHRcTrL}?mhHrS(nb)X#J*lgKc!-t?nN!|sG zFRA48!oVsxU9)$FU(!b?xSZA@*&FFqh!J1|3a~^p@W1}2|CN6H0b$p)SozUPgNk)V zqZ)X0J;Hc^>jmG_DTKa9;VzYW6Sf%f3P2Y{mrxQkG}uG`o`SffBpS8 z-yi<)?DhBN{AWcwtNkJZQx^}H7X-az!<7tQr8JkfNAG^PIePcTK)OpQ z&1Jcvq-Kc-aB1`^x`Z?MJ+{h}BMd~qc^jQn93wzRIx&{{#)|tVlHS5lcy#h+)BRK5 z{IcGELBYGjr%dzhGvC8bcTcHk|C?u72sXmr_fA>bpj)RbXnS|goYbK=PFYyj`=(sB z`)yM$y`8(JEV0i`v-KRW*aUL?+V@_AAq6Bfgh;ZxhR{rDYukleaD@Qc&N@&G%YCib zydbPqfKP)MtVRgI=0T|_+u(XlvIeKKY!be$^p;I^bWV5KB&=`x%O;tL>LpfEpLCc_ z;<;SRhLrJg=#)qWePr1>et~R}_Hw9bA?M?W|3tDW0p(D+UDIhc4JaZxFN|-)Um*8-%o1t|ds|Y&&Rh(3Do&@v&i z)RaMcu;@&ZEI)@W4SkV0VIP0L1fUl^gmb_{Oh;HMCg7OHJ(Qn3@D~`|CGJv)?f?cP zsUj`u(0&LxA4e0mY@{5eLq$uXXcsR8)%G9_wJ9Yk3$P1CY_8_+XzGq;6Op=M?wO28 z9ouozcKno2ciJ$|2~dIjB|^M7Qib0oBiP>Nq8rkoZWhp(9<`x3nw_Ofr$`y^SSh=cc*_sWL zWfCGO)i!#!1~CK1q=j*>Tx`SYq)@gYt5Zde!a((61bKpGIY!n=Ol!>XSPN_;L=1A^ z`i7~I2Wz@I16|buMB@86%dn^;M>oC51DU0ToPrVZCWeNgAp;@G(2bepVND78I#gI% zozmz)wpg8h1Xf-zGE^f7RNsyCh$sbBJ=Vk60kfv##o+mLy_TyJej;#jo}a-z$fJM@ z+*G({&%7sNpVVqT71EX2dMviIGVL~@^dLe75wamM+=dii5-#WK+o}wQ`EUEI%)EqN zD^oPOv@*f#s*geU0ltr9WlFV;lJp2Wv>&%yptYqpty3K8L)NJl7^dT4Qd^!+j2EHd z`qVYk1x=>wMUIKdKUQ<=)KbAB>tLB0t_@~f$Myovw=EM?m4Qk;w}t^S3NT$)tNYXk5uPsPBV%zfrPje6l3|0;oOxcX`HY8qc%LS!&+f$TW8Ht9Tyfwkyy`!c+ zuf$2&<2;pGotqfxa&0{%+gh&Vo3QyBq`NBiKGGV627EJFdDAr?g&ehJ`bD2*nilT0 zLPaY}D^$3qWGj?cGy=A8zV>(E6$k6_`TQFFX>o$q70$0ub_3$K7wPuHtn}S-Mc>;; z#t|QWZdc^k2nRz%{!M1&XO;<5_ShqP=)kACDlvY8ROgybU-7(kuOjkQd&EfrDt)a? z(*o%RrAro*=MpYS(~7wxKJPPiMA=?5M>MfCbKq1(JWk2J{-+f@S4Zscb~8mTke?kD zG!zN+-!k4v5zytS_FNS zoVT8;&!=B${*w={fBgQj_T%@*>YK}Nb?>`xjV%1!mR$=&f3Ed9zC%6z#CeD)l91Q#^G_fJpBTl4f3&eU+BT}Fk+ z5WGr{-xtN+%_p<_Lfk{dI_~biz4tj4Ufv{<;pvOW*ZbbsdhJW> z2Hu~{(usMNHcEgzTvo`=9_`-8#X+) zahQTw8#yaXIyq8dJdfs`q9bZEt=7^=IcH5L|Lje^oT;6a;I7gjjbph8FL{Xg803n5R!Iuc=Q#ENjpVoI2`cc;7pm>=-+dWYYT5e z?`k5TQtW_iN-z1goBUmSGD91n0jZG5by60>U2JyKppbe&4%1RP;eL%}BSS_Oc6!ke zz_HqZ$spbAi(l~HDO>{w&#R|TzCOXoCgq^@rRB1Za?e(@e8?+h>I|ZPE!T8WyR6O} zmeR%_pHQgr8|(Psf)0`%a}=eT(A;#MzZG$$AAUG~_r^TlXEEeWM|wRqmd3;nIM8zqZk`RfM>`$uS;_wAdr8KSLtYX# z=%knAZ11?2g-RZ2WYNIk-R;bmWOY6GrJ~(Wf2r_xQ~*if06pM@LeE~j0*=5}G>;if z0_+e3D{ed@&Xk;Lz{?RQD<6sio<&R-u0sf?qqs@jdAQ>};&Q!dqK>iHNEXVPq#DQb z*e@tXF^Q8VH~lp6>C+jgvk@zadKT*$13GZ!i#|lbdnhLGBtTR*V;)9oR$`xlO$T9q zS#?DGf#6Gg93cfQ3$MezM17;M+9ht9xyJ#n@MkF)k45jMwXNnPi^Be<6uk&h09}CL zA*vUld-#}w#21v$9U-7e)9@n#c9|Nwiz!;vp5P^;@95(bT|(n5HQ z>%M^}1-G+#r>)4{{IGZuboC9PB4o>1MW@JyNp43m0>-0Xato2i!?4vU6CI{bmtrM{ z3oizV5tEQwVY+IK{2oJEqA*pUfeD;QTTWZ|ouWmu+o|}ht3*j( zmYazs!6F;FiWB8V9Z)vzHz^tq=Ol7vTY8~6g@%6^Q`>YI} zz5@VQoaNnC!R>88bz1@T*&G@U`b)C@rnidbn~yX~Vx{M!>-Pc>uuYH(dS9U(Vh1Vc zS0G^vAHotET!6<5_Js-H-ZOCSAa&Gr0uO+3Z9$YuGlmGjxs)+bbB3iC>`G5tPPZ`p zing*~gXSZfZT9k!%@tD~rqDj%zF7HaaFl&X;-i1vw` zFUjP>FrNgnv0<;NnGtE}elhZ;W(^69FA3`!4PO!fTho9L_)2lT|QCV ze}sEUTzZM?71mx7*FToMB#IPt9tw|{j}5j{0DDQAECBMPQ1f29t5iOd);d(Z)H>M% zfc3U@e0oU~M@_SthINr3sr_~hT31DxT>yy61`@_1BO2WNmx%54LXv$~v`iLGuf8p) zQ_)&pxL=@og}C9-S4JjocLEUGw~g$nKg_jp5wIGU#d+!wr9s)fIZe zE(g1~Fw(Kb;uH}?=`w!_K|F&jB$O%u0nUv<-S^UK&R>0C_eY{71Ii3@BZeixjgFq4 zz#$}v;CD-7brpW#KBf2^zc;$|5Rop5!M~3Slu)a{K6x^I_v3fg?T_T}35OwmQR@>= z4kPB`9=SJ>hcTgLY%!xB>?QA|p{3l>EB%#&=ArJ6BhyA?sSnrb$n{js_B}VW0@zob z0HKCQ z%{5s|8(d;|T?5ReqUFt)fq1Huv6L0+50}fuhalx#&LEJSi`X7Mp2!;tjdL+wp)Ovk zJ0Q->iEI2YCs)yi8XM_z$@PbJnv$)Q=i(G_xQOGBHkA?-t{&gMG?EyG1{j<-jQx#@ zHzMHT!Mk24x4G_HoKsw*!?gRgVeP~V zqfrs!NMwGSX$@&h#c-~6qmPx#4hFJiVcWv6WtpAfYq@Y=s(BVr3AhNn)DP!)4C{*es2rg%AFJCWH7EX zzAOve60|If6p(a3R5>qcIG`-c>w_iB<+lSP%M$w`$g+e1;IS-bAZ{#++7e_ei~JO5 zu`GWGP%O(Ch!M-88sTBp*};E+epPi(v-eE33LZ|WP^>+}*)z4x@GwJ}X{W1!ho$yy zLWawaZUBYL1sd^S>2YlGEumnbzS+?y_&s%92f|lGgZZc8xCQK32?!%OcZAx({fPh@ zmUB#yw$W$V;@-<1yq;W4hj)NGDN&C>YpDIX1$YIid;X`M)4vL>&RYAh?plNbvsSyD1l=m z#3zA0=n5YTv2vo7_rtPZW(bQ}T?k|%S9aiRoQyop!9f_X^gf!9hd>ZfI%mP0YL}4q; zv0Rm(=+=9V(v_w38;GO>CHA6(_e#b2lmOa=8b{I9IkMv}yy;Fb*@?$?pvHEL{A)!Yiu1K1{mN_1e4NWWN zsjK1!Fph77Tae5U&2KZT*lILbOGea?X3Bsr!dfy3bQ0N_V4$7!0MnRqL;Fx@&g?7e9qVkd=tWHanWoO8&sinc!KR?>9UstBt)DltV0Kf z*GKQpZt-~2s#NRuC$TL1X8ywfa1(^DHuGf+{vAN4oP7TTQ%8e*y`N*rXYEea#$ zeLLJlCCNh#xJ7|oO*+N$-Hp0M3EMI67Nz!ycS_id4mxZN#c=%eE=!kPMC3Q#cco|g zgySc-tR%2rgy*KHeN&+Q&!iHI2>eeT_*;B8l}ds*RRsizy(X`~|XwSWj! z57uAK;Z2*efE46=YLkanmOA`kUkX;PJfBGSr3+=pi| zPp5N)hPLwdDvbEuWrDbTd(od2NAm76A((Zx0`FjA=lsdI!cV4`)TFX4OpC3dmKny2 zZ@qH6?CdPoPU>JcvUb&M%fYN&ZJk}u+KKJ!l-5pqa@i0HK%W@vb`|j&FhSFs?e^|6 zsmOlO*zG#NFEJ7P&iGHn(%jbVtX&OV-QwCwC4Zp)4s-46=dX< zdb^tXI5f7Cyd77^c6DWbQi&hU79nXqxiY^JZob}P1p^%?+l|ncTq@gD_9>h#+tob8 z4YOSh106KmRnq9XnT6ytGnLlHl*PjK>mvKPwTmTtZ*bjg)$&bFon3@%aQEyYs?ia& zl^|#onTsgD?sI;CN{`S@#P_$=TUZ9c>Xoh;g{S;N?T`^@xOnlko zg;@;HFT9aWq57T?N61!XB5{=!dSIvvLesN7WOEO!v8_i=96FX=6{=sT2ru~#;=O}- zGk?I*oyqCWUSomcADCq$!XMXpzcgg&6n>ki}TLp1UBS*x>_(xai-`ylhYofmL|7-oPkhG8D`dM zmEM`0IMX%)##7pnt(lzq5r4FLZz5if=q(8Nq1cCW9yLWQ<9()r2q%X`=8jMyvS7C9 zvV$e=Ga5Bm_|SZs8nXB|R8rY%=|@I#4|%@vCt92a-t6>p4)z9=&S%tR6c%0>PIz<% z5n6=NG)jJhl;GT(p&O_1WJ<(LT4y2_7TCIDIhHXt9IPXj_krFjOg58QfE?@M6TXWRfHb1OS!6K4WI;=K6zx5v zUpGC|47J#E?I?=>|MuRkN0Mtx4}15o2sANsNV>B!?w7L995%a)&E~MGo88rHlIIY` zxa_FPuB^;Fd8z8E#sMrqvH;n#B>@@;f+5Q@4>D|6vLQjhzz=@#PqD}uz3C_TTYJZj z*pU&L8JFyy(K$R9vNALFihWyaue~nc@?91uRuEdIrJIT6>!BWcdT64Bs3DK-nizKE zqB6V5LOl&*C-!}Y2h$YA1)Ly`EDyB??9@ja+P++n{QB*^th8_Q7YZODk`3z<3d#)Q zz&UjVm-Y48UbugLYm>J(@%S)OK$)PK@ zSOAg?YL*b27LzNH%o^m&tS_b%e#6G|{=4sK{Z|q63Hja~ zI05ynNWdmLS@IXoUsMuRV>uR{#8!QyUdzl&$7K8xhg);#NlrkVO?;D?rDu!Kck zWW|Q=grQ?vNgSDJ6ep%fP)Rw@rbgg1C&Zn{@ne?wu@N)J1;_Yq9NLcKdnrPZta_ep z@xltvu1^v=C0REKBG-!Ih=FILz;G-(jLk68O^>RWB(@d0L7ax{lXK$rDz6^SsGjFJ zI~2Q;3qHvsy_PTM(#8Yd7nhQp-NmIY>b#T>%!e1@9Ow3nB^@#ACuZr#E}U5+(1|By zk1ITBx{m2s$gs|NvUu6>;ft>ak05zRY%;(hGI%(>9wh@K7(AJz?2>dB{D1*BSnAeP zckr)`L%tpVa`?vl)D6ruWx5pvVQ9OKpCmX^&Dir2-A_=wC&Dr6yWj_muHayk1s={~ zD{^r{+j?X(X4!#nS`ixhPUM-0CA0#xsh+wmURdGaV)8&*@@{BZx(l5l^q6M_ZffaX zsN)Dm2W&e{A!(h^2vWDrtq!W*n2P(}`R3w%G>CdA;!z?Tgn5w=LuK zhX6rbvRd^Rlj{K$4oaRplRsyuTI`XeSZDR(mo9u>wC=>@vZGZd*Bz95H+V@Yaqwnu z8orvo8a$g%2ai`H1d3ol4On?Y+cLunrT0a+eD&lR$l~K!Hq#<&65k0#)e6EYCY9wC zz@Z~N&|XdF<3yXL+ACnt&ck%6K}DQS0PO~d0Q?UR@KMnD^oxad&c~wRQa06=7fd_H zkPq-aZdRPjZjdrcisv2_I}#GRw~+&OMP0aJ7mZhOcwL7cng7sb59N(JZK14_)g9y* zx)&HGP%tyqO}uBw7BdQQAHbT>X!BH?)$N;W>p(xCtE;ka5TbxD8g81?+ZlTi&quSR z7LRd!Ej8rX^WAVHI;@?91c0hNc=m*L3Y+5^MK_Fhwn-ci&o;?30FOKucwNsqTw$%) zv2Dk44MV{ly&52l2xQiUj{LsMc9Cs6?H1X^%65_Uw1luJgJw67FlvMH_Q(-Jvl|#@ zLzrafj>_RXT^*2BsJ@4ds$#`hPsg7c(c?ESzWe4gORAk!9gMYQ6kd+c8k>(+cZ#q)26 z{i^ZFK5VGQ_ma+9($|;lEKIIo{Swwu@U{SHEG(_40zj;GFO9s^HY}zmv28|{A0$R( z$4J(3J#cswm@I+5Zqw0=cp6+zmav_M^-e{e>n1I|q?zM9;ON5JnM9F7!j(e6-XD;U zAOl+zl4syZk%PX_ufWshSd7~jLHJtM-?12SMD`63-p5DBpK@b(;fUJpD_VaAf5X;c zaIL5qM^o3p`iru${7zW1%k9x|e@`OBkbMpG7ee&R!1kSci;n-5HmXq&sK9)MXeK(XI zZFN!>ExR9=6&iicOodplgHxfiztdAC+V==mXtg~@m8R_vQ>F2KPE>_p5A5U9i_t=R z_8h3_f}??njteo8g=4r|v@sYvCdS6^V^}{D4fqku1>Lj-=i>s6XJ>3azSXY62@Jh> zaxq=aV+LE%Bpi?KaEroCJe(xj>lM(}&w<;IashZAWW&hJb9 zu*HS^Mn7LoCUk?JE)Lim7GG<^*rv^Hmlx9sF7wf9G=^EZ^g5z3pRVvVTigeEj1d|t zjcvMM+5(r3(&L(ZR>OF%rnvOwZ(B}@7R|{Rh*h}sE2=$CmFM*!X*q<<$1p5l|j80o2o;7PPz_W(?5#D(( z+TMr0Cv(Po19DfjMiKf%TB0<^gV)!hUAkXrI88!FuMq786A*{*rTCh3!cuni+d5f#PZf0&=q191S;-IY&bisv@`n1y*Xzd@6Ihi-Y& zzfrtD6Zk)C_4CEBn3e9rze1zW0iY1;bqFYQ_ID7dMEf2F3az#Wg3`48p`bM0&%vM& z?4s4v2&AFgGU3v5ZHFB9ss-fc>G+Fr{5ZG^zj=NgPc8w9{shH}zJ+!ATe^2=?i()q z@li#jPvfM}xl}XA1*gc$Nx6HP*{-8z0 z_M1<^wRw%jveW%Ao=z`E>`;54k%SlkA8WZn4Xpdx1x0)zx>|#6kZ#L>=?9QvW*(Sp zH*+$@3yT0U5Yy2)HG_*)%PZLm#B+gN*1!&2(^pZhwnJMS+(1Rgz9Qi9CYs&)%lpGe zR4A&@5Pgs$Dui2uLR2Vpg&eOC%5-dbh!#q__@>iJh^AOeY1!zupn2qL(jVVx#@CL2d5g0it{(cn_E4e)hk1~a)^M_j@K zbnGoW=oo4@IO|F`(ZAlv)fJ*Vk&DjytZ;p&f$j$!pwhQ)(9;z%VtLgq!_9b|M#@{N zqzdroPV|cAD$x?ib0@kb3U7b4K&})h%S&Rm$&!?-(|V%hZ~;Xf!@5K)mEV9^)~2LfyvC%>@gB{ybBf@nLUhhpO9PWI4lTt!;Qiqaboya{TNx5EU=Jd zNn>3znoE-zkAksHJK*8=${>$!pI!#H-Z^L^!f;Kr(ZdUKkX3`Bi_}+ zT`GIN-DV)4YUM2Djk=r5)#iOH<$_KxBe@_!0%1R;z%zP^irdNFCCIcjb%|E(4dSAm zyvFy78I^t5;3IviSpK+FuEvh4=5QHtuJYTuDO^9f`^q{IkqKMO;G$#vpLp?33%Gpn zXTIksHNvDT<}eo(m`Cw9n0UKFR&D+>-_L5w9E%D5!{qx0=hWYrSv%A8wkkqg?us7f z{cLQ~77H)=tDQAlZQHx_rb=vIHf)tSLu= z>9jRat8H-|>|vW;r_|Xjy-ui`MS7h|_Y#sSrG9p3m6E)nl9H+1YTL;vUfHCx^;zvs zKf|+1sh`cchEj(zjVcwgwf3+ytE7lQ*2zgz?shGza>C@1ZK^S@wS8Ib+@4I!DoJUQ z?q*dkQ|fO}R_S%IC9CcCV@6gfcC#R>6nYqsRWd#8#ww{jnT%DE@4{NF((hv^R_XM# z5v!!Onum3Nfd9ettLujbmGG-G4;up=|1(bw=g{&GZDY52m|K}4t_ovs**vWDZ3kfU;>+|n1W5yM55ceHCTKrkK0WK;dfiP&vua)xv$!NJ`z3t zR@sF4=*ndSsgH6Y?!j9@3$x8MT;$I#*cg%26|B`-U{q!6s2QoSR@05NhDzb^P;Yxh zGBFvtxfrf#yR!$`0nGC}K}RYEJxS$?0`+Yz{=W<9wY&nJ15lydov<8rq1I$m!66U( zEUVPKXda{*-ld;V_UZGMmP*0a*-DW=pt2MQ=ib6c7yKtfd^<) z1y1n_agCRw@B*zXFe=4Q?M5nWmI~!gqs_Wn!BVkwB;}ag9hn)e<(q~V(;3Fm;0{-6 zfeo#onc}*OLkg4zrfGPC*WpB`sm0e4DXA@B(<#y^KcCLDr*pVT7fY1Dq7>0*$S{SG z>q-kpS4h>IYRE`M1Sut?YjEFd;bO*Ok$eiU&yc5-Ua@7!KTK6p?-I+&w~KA{3^=bx zb$Gd04wQ-Y6l9*y;1imUE`d*lu$TyV#5LQi?wKz8td35n4JU_D-EoHN`aW>(a<6aY zokPoTIb6=1@|7e)dF`3Cp>25=RxourT0v)gPQ$S6Fw`wG(is8edI?Z2Z9noO&xm~n zNXs-#0IrK=%F+EIBV-o5zJ40%dYS@(*JSw4jsXpbhOzCLrW0Gl9NDG(-eHcZ+v0^4 zbiZtZKsSf>vyCJMGH9%OdSJ(Z8ue@-0Y`~%`zFwIfeOXEAT~d_$v4~qJocE<0!H@% zq5=n5;<3h=C|fd!y|y@=^-CyE$YJBb?+LfhCxpcuOKSs@I=&v5PJr|nd5k?6M{F{k zqV2lmFMjF5kVWfGY$!WgWkb`|0f9rngPGvZ-ZXqMx|)sI;B=Zy2M=bm!3_dy24CRq zBJZLhBxhr4J6P2L>UBFP&Jz5!6C^0P9VQV22Cfw`X2e0tfNu?8PCEr6E?_kili<^G zR(0*zc3nM64WMtjI=I2Nn2`ja;fHa^Ldy@M$R`0+W!1F#3oES3rwnidfBOIa@AKcX z@dz)FJZmx!P~fqRw*v=QXQ^j8sTam^h*23{;9)=j{Ixeh=?VZ!Z2>Snq+9?%9ETxRB#nIKAy$G)W^;G5K$^%{4xk989S9`AL zeGOOR+$H?roU6+(99}p^pd;GomPX4kS^!$`(KgWYnvvSY&*)kYezt&#>-v$My0#Su z;6q?VSazaEMq(unvvu8!lOV?O<@_API=*+j*mZ$w8~8x41=j<_p1I5f4s{4rT_Z8; zp|R8EFRbu0pD&HJl=kAm@dFBBll&ZdzO4g)-XIuzFGe(2oH~&oxB-B54Tz>VFc@S^ zLwMasRO|t;BCFfg<>>0%JeW-~C9&;c+-Qvp)^0jG`(kb7UbazzM%@I<_7PtxkLK5O zeI1-5fnzcl)t%6l2fA=}g-9pP&N^RVY~QvmY+j5iJFUyF8C<-Be%+&LpPxy9Z^Mg1nYt{fY*1iZQnr3PUptfO1_qC%Jry5l=!+Sa$ z*bNsqXX?h2vM;74$-CRw;+ei{+7^}GngW*@7enM?;rf4Zxw;DHgUh*?ol@Jwc! zyGo@KYs&#tc-u08sf2P51#>^2M$^SKT@rfsYZxvDr>N*Xytqx~4NF&SBT!~yVWC0k zk6{unE~05TPcV^93^ZuN#?x7b8B)sd6^NVrK|3y44?U>6zNg;1YDbC@v|DIyPTWMQ z+iGV$#cEgWi-B^-6smcxDabJZLusi>>O%wwPnQpt>{CFS-PY{*$^-4@K^Pk=L^{oY z?0wCChmPuark5XPAJ0<`##D%qV{9W(-WC-zq1(&$5YXWdGa#z*plk*-8u$uaT)!e1|Cno| zj1Nl3>2AqP=;?;(xu|QGdN}M*JqN0+8ygI_f`A1uKE%FfcoFTosy5T&g%xe)Q*0Wx zTxzs$KwREaTwGJE6gMPP2@7L4^yq?uB4QRUT&O}sW)TK6iQe#@vcEDQTUIq!WE#)M zeiRu~r-F97`1R*P4YTQDxT{b@l@(i7!23Tme3H@{$0C2%?qao{mTG&fyUhp43pllHgiV zq6r?gi3ZRIHoq27EhvP-;A2}Yw3`cnv)lkB^$uFOG$J9gaVAb?sx#!1d`P4It5Eu@u0mSE%fVk23(WA`_PYWe>Cmi-E@_0CQXbp@h4PS`v-xyEw~Tegq4=eX(onSSq%dUt ztmq3i$~bzsQs?SI_8wFmV1z;pGdG6PKz*!fw@W#I1G9~>LsVDHarxz zA&)E%o;bKEQ0~+7m=mRXXou#S9W#M1BY+DrMUtqUxB-~mgcHMnj{|1V0A5G(X<)!r zIn?5X6*=@M@SsHN^XJS$?`FUub0rL5L!fPjV;JoSz=B(Fv@cUvt#iH?Ku~@N(0=%R4k_Q8p zVJIBpc5;K{#G~!Nrc5A@zwXYavQE!3k@;ZAw(48uz-Zlw{uO*2AH%E%7rBLeBa6KfLIGw`Y zI(M*4UXnw%VcppuT|o>~w`bSwo&b=bC^FBsVG)P32ir|a%6;j+_~zs;dG*pddGwWy z|KA)xdctujS6A4L_YV2W;#eFlse<>t(~eD`2iF8*fZa!=6j zk&CbPc>7AIPv(iX+c%l89pw$X=jE@HzzOkoIE98bKcjaL`U+3BZ`Yk(`T0ecC{lYr zIr<9CzIpluskS-0MN2O1FtttietoG$o4$3P)V^%U+kZ(cNP1T_UtdT@9yP_85m6DS zv8v-_RoU?+us}W=efR3dIzEjZAlDklkB*2XJD(Ziy~7YuvQRiwd69YQYJNdR>lC8o zo{rL)F)4XjIC)mNiazHcr+AF(5V)4jQEg+9m(xI$V<9i;o+U*Uu44;;p-ZzfDn}cR z3A53LnRs*j=;fP}(-6ILH1Rgu-uB!&zAJ|-zB}oDKN~iNsFE5fMuB! ztZS%E*o~IG`XFCPRPzo19fUj2hNZkczB|XJJ~B>TKWG?0S!^Li*UHq4;e@edF#rl6 zinA0mu=cH-0aPl-e|OHnlS#s_?>KcQr70N0^hihX58{0|Kc+vRatc7}dAKf>E*K$R zMMD9VVoF?8v4r{C-n6;ROqjLBtknD>XC^Tt+uzOR z>fTtJ8?imubqM1I_Q#7SkF^I%FN*oFp@6u7w~h{!i#`46qhnO0yabO^ra(eZ%qv=CIE=#ka*wT9G`MkY#$RKP>Ly@E|YgOE5(=Z zbOJI}6%+71&P57%$ALllOXv+{Z-663Im80WR%CJ%pBFeZ(Kt_#l)vYffkVW()>I-g z28PGe_^d;lS3%rSiHIY?RVon)bHf?n2d43eTjwx zTXRL_o2J_Ne0oC_onRw`;DMx}FUb5r0*xLZn~ zsdcsj+6lD&MP7#LgAYE?9FH$UiQyFY;;bgbdNmH?_17EKIqat#T^2Za=Nq>PvPkntv!+ggp`#f0L3zpqC) zbEwu<%z$;6l8~m`9V2!TqKp_s zK6^u1D=>7+g+8S@$~F~-&FidT--_qux?$Nr{d%^!x5^h%`w{)KYVbN5V3*wVs(WOoZCa8c=8R1(reoFD8xigrU*;a{#X2v>C;wTY@o3Gmbz8KPS_;*k6yQW31hm7%MF{W&Pxn zK>LYw;#$tC*MK76TFXIGTUEE`Cmv-zs9zr3hF4=bxld?63mG#F$G?(aLnwT}<;25+ ziM8vJok2dD$qwvfOp*{-lPPut>|P~f1^g|x1^k7rBAoqEpnyXE=dDf{$%$db|Wqx-bX zv`uiN4(K8We--22DYH^U*wg)t-+TxZXofBdoB4txaDB)sJZSf%S27D*m>>qz#&BPIqw zw+LD~@v1}|FC-f2K!Bv2PVjWT6U06f(=8W`p8*HjQxq*ELfQ?)k|6)Z3T^%6#eE7* z)bI1b0L~6a31{qZc^|#JW@LBMT=AF@@bRm^(|dVmHT-9w`GI5s^cTkzG-54+HE}zc11>kHAF>ZLT+`PU3{cQCUvhFeL6Q(q zC4rm5YldR^_*RmtVR49wN+%2LL+$bLiw7F_afhgBay8=@JDhvC2DAD>$=-hmjNHlU z%~N9DVqekO@`3h>woXF3Dc}1bN2dW7ETNoY{swKRJ+rTV-1W~zZ#J>YGSY*zJFD|L9$~Z7)Dmw( zB3?mCqZI8WiA52WF!==!J|IAEt|#O(q7IGkSI)8n?cvFjLouZ!pE*;2<@lMvmNzK* zLSL0QE`{*m+*~1vB}D&-(P?&zHCp}(_j&#U{+W+T%p=4pXGgw(*^c6qG|-+brcftI z&K!f>q4q4(387Maev9aauW7w#U7=tL0fc#dh`oRq4X!kDMxfnFCoGk=rGtrhESEmn zn?Apd=A%Sz7bsHM_YYrSa*7qx+R zDQ0Yf7?qeut}Jp5#5Ks?hGEiuge7OtE6>D@=?t+Q8D4>KhC}@z&rRpce&!gIH{v0( z@oaeFJ?g-AM~b3EDSxVt#t-<1jPyXI%zxPK<=|F()pEDtCFm!&ipzeN4TuCDJ-&;r zug71R!7_UF^(uK38^?D5k3K!Oo{F04bWKy;UnN&E5tp89+S(az_ao{4I)`!g=*{t0 zI}7)2uFjr0p09stV=%pa-`iKMG`3d$ucBpl2Uvv$Bur-ym_n?V3rwN2KOdM%w67CP zq1Dz4rZjEu22&dE#}B3u>{7>Z-BOnWZV@6^R*#{HrLNX6cYJjG>CtmAU^Gn#zW?dv zeSW4PYL0OI4{+hw3KO76kI0o`E4T@^fWJ% z(rPlL*mF6?4SZCAts@pjh6)r?xwY)#sVSxQox*m=Z$^DW;Er?*-b12kpd+QmG{{*b zQ?NM19^N)8XYdCbPYhBom%2(3pBieFm~oSOxQWzwC7F8f=FSwhHK zfLvQ8d~mV6O~-6FqcVi&Y<4k?Mh!ErYFm~=ma-$hp(0X8kVmvZmst!EvP@|blt;Av zB-=;^@Si5Lj3^ELNKYa#EK(I+03;*zVqh+Bo(e@^U8N{5HW8O=S0;Y!esvY-$9FHyw$BZqQQwyy^?(?zza@oX#AV(nGk^^1B! zeUyxKioGKy9?+bSOG?b~Y~>lF5*f~-^BsE2$yr7(}WcpRj8@OV1u zO+=_1T$5R5DAIQ2-$J&C`$AKJgjY5>k~?cTCr?j~@QzH!d9jMg(?X?cZ((Jeji|(E01}`ux9@oHBT`w`=?!qn9Z*VQW5Qcn z)V@IyM$*T@;$lZ{#Y44pD(~G&aKqEJl*zNOsbBc%BhqqOD{(c7Q7HwJRKlY=%r-!F z*sc*MXfn~1-Cj;F5hz0X=DJ2y{-?R1@SQm(^a6m;^}-I0zhJ5QwYcUT9tq8vQ}jZ zoz}|BI$c>Sn2P|ILArPrdSbtbN8~^sCJV?GHV7x@t8qv{lMRetn;Msv3T%bKd!(EJ zsn7w~is!Y=lg+vYKki~cSxQ+_Oq4pYpF$%=!mJw_ZW1$}K|f8AR)QS6NKb(U#|%=) zb8sKm^8|*mHwY=APaHH9?DCeNBXD_b@xn?{%tO9u zrrMX&s|YdVDp*%aMc!HsC{FvSJD zp75~YmP!yKF~L}pjTf14^HIDIF>%>eg&91CX;WNNyRR_6SRkQ&*mz1hrOK4B91yjq z`=+I2uFLI*#cIcA{En=&?!;rVKlL}{CfRgI8!=4NSB`-fm%qIkou7{}qIJ2V{M2r+ z;$EyY?=)K3*NQ~3kdNf(u3zAD%2y5L9~e!8ttOu?n(Y!J*a~ej>M~RYDLtYDJP%g0 z0SE?o%?LnwHcJ5og#0Q(pY>xa@mWcF05%9I_C}H*-4wa_iOcW|!R%pYx+zOjADBxC zBPF0ldNhAwMS7e9JV-kZui+>HZ)0oV4Kl4R2m=<0FLZh^^RGZd4YtkQhy;p_9a@ zQOOkSlxN&ZSF4gCwcF7h(qW{L>JglvgD8H5Md3Ds7qHChOJ z4@^a21LGrrqGk>AAG)kw-ni4cWu2@n8&o975{i(K%O>7~I<+wZ7pKbz`?J|1)io?F zNmVnWIPi8NwT#FX`&MG=k)L>gAn{`W6}lemgTO{bE=HK(nh-;y@rWgJl`Ke%*a}c4 z0T2le@|6<=i8w$|1%Lt|8XX%*B9W)_w3n(-ZSlg2P!;n7cSM4SOp^0bqQ-jUK{Jd@ zUx&uw#XwyF*n{C9g%ApwWkXLkkRxn=@&??qoE{)+wJbwzw!$E?JvJ0ewz@Uqt041!laby8KSx*zs_7bq21N7w7_XAwU zSmNOnGeST*f*M{}W#j4eN++03$-apJ+&|CtOgl{Aj{phO&eoGyPeLE6TLhT|I5C|y zREUm&pwBca9fB}p9*C!XU<$^rtd^KaGU@?21p%IDH(n9?V6hG@E?*V$HQOqe1C6JU zPE~QA#o8N&Zvv&-F@QA*;AIjPUHzIWEeMXum)z zCfGR>n7=^e8$u6q=_y6+yJGRib5=|Z3aBS8;kQr<| z9mNbrG4Pfx9pFQ-(Bh6AJ21MqKwXFF1xf`F+D*Wl$A2h$u<>*hGl=UG><~$6M*#KK z-2~W**o?T`n-L|s<3Fwq%<4_Y%xSV(t{wwa zKOl5X$k#s*E^a&>#SFH%6I4zTQo}H_Qb9LSLPf{@0d-YywQwEVWj0_6U`2)zGep#x z?g1*y3R@}Y@`M(r@%uiS8_&+ZZs8QvoVzZ^w!J#5<4Hn@+@;VgP}dDNG?)UF5c#7wPsg7c(c?ES zzWe4g@{;L;-|m;WEDHM~Rc5 zIU)R$HBz-j-nMoxOQoPeDl54i2|?n2J(^NB5d0{JE=IcBk_NaQlUQ&8t)b*Sbpd6L z!=(vqiQ6o+aU07R8)Gsup6QmGVoCeSD3P*Um@YAA{9FT^mX z*f+FL5^5V#DBHCUC6q1q6GAAdZ44cJxf#nV3%ol;d|ga=a^T5@_Cv;_A0k!YK5_#7 zXz`nS_ceU@=)d}ba*pHa45`l=K^@?NPbt@k&jUsPK!f5XBKP8O93vD4Np(C!Vaz7y z$O1)n0#6ha%?<=c1riZnBllKA%G(HSrmF?oBYrUj5CNiVmWO#~et-=TS#J|TQwSiU z8Qs!*!pZForEJ65OR<9DQ4J`^zQ|)6|grr3^E`r5@hQkwQr0>LU?!O-26Z}6nLe0Y=$)DIl>n4a^(DF07?nZz*rEi zklr1Kl(qpBj0>bmU>cDa33(_&8v*mNloKkFc0r!!405n4z-CZdjHrnF3-s1PO?8jA))v&-V!?iYOtD|ILWdTxkBNkH|y6f)$8kQe&r-5up#X z4^O69<~7edx#7zLP&W$t#54f)g-_gShB?ALjn=nFzWtoCl%I&D`~h!?XSZ02Vohl^ z`FCO_Xm+#xm(4o%LB2neY~Rpk#5e#ki45Zc$Ie}!F^Q>Zw+%iN54nD@Ay{~BC3OW&dTS#9$Ly5dB zbeVr~COjTz-0Utwnkh9H;Kg}}v;3TaD`iS0NC}`F3{0Rd6+eLgud*+5EW__>V3|+^ zC`EVDaJ*o7TuN^>N|aK!r27GLx>lckuW!IMT~uDNr#H~r5dETRyO<^VuJsb?V!$TneVBhRgfegY^h0p%g4 zF*|k-3x!sA2aC_bSJdJa7+WdvH+uzM{PS)~N{~=0;Mz)?h+b9f!D$=x2WpNR^Y~k|WDlUlDj^*Qq ziu@R?3LO}mKm%LilHK+tMI_!1@lWKh{0<}m%?ib73P2|yXKp{OcXqQx>n#+-f;7E~ ztM@%$A+88e`li#~v&w0pU&0D2Y(71^mnp~6ek80RH1@qv7eqiUzgqR|ZcgXzkVFV| zR9YQ+QkG=i4#i)5{loLVI}9LG#0LmGjrx*;@t@;*f*Wujp#I^TGkQVKp%Y;uQ=&_u ziF=?+WOBMoR9@Z(QBEhPDz9KYdn?Hd-)6HrraU}E=J)M!P6sQ7m*9}R!zH4BZ!aXIy%Q^4v4q|2<$FD>!OqaOec|2#Io$1%khD#l=4_ zRuMM*r*n*68yEFz#niW284k zHT~*9#{ty;hq`N9-q9_9wW+V4i}h6RRuI1Z=_v|2N$#Cjex#+ z{OrrD@z$&&Adt{Y7enP`N-R-~@>b*5-@S6~zB|4AB_*+m%QG#7GK$jD@DEwlqBC({ z!C;W0HsK&DbjWf0UgluPFX)H-5t)6IeGtwCMkovn=|yl1rZGxf8A0k%%{~iJuSV)3 zX(x=_+M;?nc}yd@7i=W$VSlaF_aVU2;PyN7vsL)b>>_zQzK&jhb^G+ugS+FqCl;D+ z3%}V6F)Cly0}o8?|8}#C`ebe&+%5=(r7LgPJq%}^L?5?9L916NPC(l2f#mMip*xk`*=0B5^n3)*h&mn*&d#a zouoVaHg;0(=H1vyw!430E9rh7j;*Anfq?XM#i-C%02ib{x2>0BYll^0)aSxGv0W$M zefkU)S_S3Co{p`(R#g~2BaM9>Tgj3|A3l?=-j1!biMQA3OAkWtsg{IPBQ8GyxU&Wh ziQaF>&Xc+qNoPgxcSu6rydGO;AN?lpNiV<0))#c~d~7ASAK%B;R}?16Hr|h|B*ivS zw_#)d$5y&MJs?|Y@5u+U^&RiR3$pcvef%I>3HS7bY^A-^7h()7{ZzLOP2N|WP+d3?L5}Ujs4chMThcuwD*ya)0)*c6E zJD&&~CF?#BDx{KyhrsaukVq;nk;41&E<7Sgdft;qgm8TSbMlB_isLn#9UB*O2rVB?hjeF5DaOSi#x)IiPSq8W+WaM+MBq=u&Aq1(0}dCIvU z#E+30N^7z84SJX9ExdbDdD$yruGH~t8ce`i-qBuOl+Ev!_w4aCa*B!*9HXKyp%(A) zHASu#$jj^4Ug%3=&GV3`+JZm{IfDga8jpC~HdrF7q(P_)h-4X0<4YvK0sMF(y{}y7 zD_pJoBY9ut?{h{DNcEfiku&Ni9=x}jT%xc9f$|AzXA#`7!nrHgf;%}YI}2V>@>_}u znP(30fp8B{cAj>MHALn`f|v*jIKwC4M#f06r98nDX_olL=u&;6 z1dc8}kr1j=!W%rimvcRa*$&Nv49tZQ5zV(bM>j$f$Q}XEgFs}+H+wHHAZ9A?=#OY- z*imhr4BJEEia|$3HmXNpiuvuIPA9jh&U%f$t%HbG9%wgq;W4cc=`;ht@8G?!LYkPi zPuR?qkb{sJOicNO!^dM(&$<`@qZt+IF~|m{jI9*FZL{!}g13m@#o_Z1d__?}k0*%H zc*IhwVoqfr@atIyER#9+v&fdY{F>&7PM$r$Ia58<9K~h>maJzJ(v=O5zT5;tHVz^^ z!!|5o*pzr<8l25o8*a?*%UjR7ZP|NN^T2ILQ+Vzy?t6}4L*b~5%RRWmWz?vp@f)}WD zj1rvKDDH@P!L+Z-=F*Q{ShGZ+6Kl#IS6LGURsuI5F_X#U;$=frL}*ynalO$lcEl0T zjvYB}mq_BimzZgy2Qlz3Oh9}Bp%Q?zgz0Igabo$2k1#4THvAGZ0=Uvhf%=&SmXUat z!y*ruf?xEe^@eMEXd{n}L zT+mTp(q+IZ{p7d5r69>N%6cASX`Si%z=n;%)*|4wu4V$A8P~2A!OnGnWi2|(*FNXM z#uKnFE+p*b{D9mJ^JWFUVVk;gPSP!AQ;}8r4Ya#(p-Q$B6Uv@em=LE2R3qPp!k01O z@oMnp@Pyqw8_h_fG&mMZEz0b-8OzOZaD%6DwM27MUzVY_ffPDQ>aN6Z1N2@g?|K`4 z8@1gY-cWhvP`q(FVq0yih8S)2ZCj(VmB?f!0?~De!^T%ZUed_eg2|vOpb}auk=TAs zi}gLKD_#p;KLr>{woMN4C2f^86bg0M((1@fSY8}iDfZGnKK<(U_)+{zklMD%^$iyw zfJ7T+VCX$UL#f9t3&m0sbhuS`Xz4ZGL%Qn7^a&F!)9V!~S|)`Jwx@8>HM)I6M$6>d zhIy4+b1NNof(RMe?j;m=-g0{x!_qH&v`lkj2J!E*YBvrV3zMB-VgHwn71Ppl{8uVFK6iwrln)yy4gX>3{wwf2KX-*)xEcgtZ6* zJk&laURTrY*?f>a`q9T9pJC0{^I4Qc6k9(ueR96k`*6%t!#&KO`Mn0WDxF5OvI{y# zrJ{!!S~LD_XCYw}-$FBkekv2~NRuv#M6a+Hi;FXT*P3K;5c9ET{gf8n*5qWvp$k3U ziH$fV1>g1K0QxSFoXR*Herw7XhRCDKPJ zP^tA&2~F#fv9`*9+P1waptjzRBA`;-s0KW3mq}t9sI#M6WJ}$aNTMH~ zp4(4Pk?Hl-FG-otE|$feQiZZo`&m4(GigL=_OnRYmJp##)XySi$6+nha&^Yk2+U4N zX)3XwMGEjxVIOLId@5$B5(w742ikZP;Sz#7!^IMp0Q{3ckYSO)QAg$p6jz0Jjo(%t zOp^I@lpH`zP?|{YIBsCrQWvj~O^uUHYMQssF{z``JGG>asG363C!?f}_LAe~V&R*D zV$~7pnmikhhmDr!cr?-G>nP;}x&dF+k?fNjQb(_CN=O}zewiSf zD0WT&*+dYRp(0woF{;%jYTeU4>L}*dzfL$-brfZ!WBcTeI%=fq3kWRmg_?%Zl{Hiv zAgQEZbfu_}CZZR8_mgl@*F$OArA~?^ z>$)nUwYrbExv(oa-dLqpq(XEhSx`{vmeL=(k}eV16OvTja`j1_sH4|2W1^1a)!-JYw!hl&Ib~A&Q|6sy6+7(KSAXL`1T!hOO$F{^%GE9ShkP-N6UrVI{k(FP-N=xs1 zZy6E>B5?MWB;omp*Q=ySOi?U_LNzl}*3;}`0S** z&5ToNYb@i9+8f?^Gie9t=X%e2P(pmd-p^vmUJ@fw=;4x`g$e9bnIQ_iOTDHjaqbvX z;;|I2s(>}!p1i)iJ$ZBvE_<@m#?E_I7_fF4*XjA6nS3$i^OlPR%!v3KEW2H~6Lw^! z_0LSM1Z^m@^9RJ_yN{rEW9=5nsSPfRYeJ&2m0NAs+PqzA+}o~QqP8!Cc8Tb+ttGqE zx~mDhL?p9@$TO>p?Ycy-o6)*NqNlaGM5~XPxY|{lu<`CQ}=e;wH4(rlk?eohsTElo}hD>qzm& ze1wfH%Ox^oOYH#xRHD__mRurMXXND)uZb%fhkk4rRV!)_2hYoz+yi%SH% z7>Y{-_G2L~k?dv~E|KVA6E4x|X$&sW+LINyMDtyke@iduWA`l)>S^#T(b{V1HT8k+ z4s@F!aSY>7H@1dT>xYhoL?C)*lciTYvI`PN?cgpGZ_TqiY`ZlrwiZVYV;j$R38l(~B8eVD3v)a&DQ2J}Pu!lQiXeGz zD!U%B8>tH*YrPq=PpOyX)B_%VU!mNCupD;b7|iCP1-8tV{t^`sl$v*^j>^W(QwDzT z(PJPT74#TsbaEN3MR`ll(IRhLu5g+zh$Be5{e^X)5U8tC0BC&BW|C7)F6o;F{j%j~#4ydJZHS7O+v{)fw z4mGXLwIyFUqySzs%80^Sy5#!vow~jYWI)oe@eJ%M<)7dh@|6D#YzS~A$H7LHZ1_3_ z8q#PosYBgRf9t}GYWq(7C^}o=M?i5HzG*se<7bZS{7u92$(&ZR0Uxfl*};Dva`F4{ zAGWP)*hXl2zGEjr;Kq6yM6nfn_$71$!vVU6%?Q>g=RYVQw&j`da7SJWS9ao}apI@8 z8#%rOs4_P}Hk(e;x5|GlURdG3d}=^ha-Z#{MyN-L;{9_{(JaBOGj^jTGol#@;>n;&Y7(7F!#h{wuSCzOePYAYfn4JBq*nX%`U^c z%MeMqs|zvu67W>%$1aRkBG8G`M1L!sW|=Pd3`5B|t$5XN6eEFnHjOc&2JBYXu*`Ej zz(Yiv;7^Ge#!Z?doURmraTU_3rXpo#r(8L&;t{(-2J{lewwZSPV({eQv*+3k3g&4~ zV59;n#FFQNzX-1)itypr>wXwzDA89{i}+!>OCEc!9#}NLQXog8@%VOP(m}kg87V(? z*(FNzPJ1NlYRx8bd^6B>LMsuVbn;EZ2d~37&qR5>X1k=eWqF%aRU;sJJZ2YnVFD~gBx#9xC`s+LpSy768i`I^Df?Z+mXO^B z{*$w%`nuuO?I0b^7t6s7izu20BWxhWx05I{stDLCYBx%Wo`XYHr8#HJvMfI(>K57q`l}TO0?&(!5neJweIP?bujT_guk*+nLF(7;2!biRwohLFrd?3vNzb$B^kPNVP+Wn!CcppC7|d#57g zjr{)W=+OJ+ZS5=<{9?D^pNk<~c^5;myU?rb1{_CDn51Un8EI+-ft4^X^_)mIn3Y&| z1Z6gKQ!k=u(Ol5SA!K`Mc#x*18Q5VO$4O!%UNo^RW|($thmH|OHriA*aGU9Y0T5a% zv31>n?heenBn%QAFrI#ZGXv*DnuIiQ6+!^21}gK z)0v~2CLmR@8(a_furzV>bklT&Gl1s+*+&Bc4IOW`@Gr6)ka3@zVHY2T)n1+ZG*j0{w+ zb`vXz&A_bPzDJkSNjOeMpRblMuHovUY+z51nPY{zM~Id-WHk#QN<07_2Bu{&SoQ+f zN+NgD2EJU)M{{jFy$s6=UGu_)n^q-f_QpdmW-GA3e=N0ipfrbR0wElPffq-*=fjo< zXkEaKMwUZYv_97`l*)J5ZEZ4l1haxX~s)-vs8u(E8aKJQ#8W#sKIg4?4{&oe~rhQ=g0{e7bs$Y$8 z1)*9K>iJ5TgvVXQ-Y zeRH~$k?)Gz8xOshE$kr}2EgS2{npbEa|9*PM*^MgdZxj2U3Z}%bMxhUo~^RhsA!A0 z&5b4lI%~S=jkToS)si%x-(pE3_;O-9GJTfVxZ%Kr=bAe6;3R^22fqsxBOe!-wEYHt zAL1ma7bmroPU7SlzXot2!WWh+5$|d>8c%Jp8lD$Go}_VT`WD=6k(YQ$Y{BOi_%ZMv zLpa@HKVby1USSZzX+qs0?GzT)RWu!=0FiQW$4xD8EH_EvaPe3YIg#r*VG0v-7@CRi zm;j~=onVt9FThvd)l4-Wb}>__=|a8ILodS72g3^PHz{l^aTxdkGcj8!Y4jo4(0-q0 zs`0RknX&^Hjse?GLoYR;JGj1{x_$~(KE|C8<{DgqusdpxsQ--jRO4Y6GiAV)gn}?I zvO!nZ0S4=%(nJi)8GPk_=p*=qp-hEGHu>MDJ=J*F#Z0+TXz4Hk;vR?-0wtqD2p2^7 zgeFvW#Kw3&OM|ff2K^rP6vAr|eg?x0;)!659YM^`M>nH|sEP7UZi$U&q?p9O2vFB2 zvTZtHJs0c+7(c-^rvko`F3%f}K)HoDK1Du7${* zK#h<~udZGXl5lYmO|hkf?p1OGS03o%$Ey(O4DGSI1HgN!l(fO>sXFs7@Gv&0cgodYZ0u`aP4wSf8#Oli*1{f zdW6~oH?>;oadb6KZpDn0xK)1Ng-K=GPP{3*Sm8|yvV#vKC|vCPJwrs%jOhPo$XLNZ z8n9tayB!=C6mIom^JE-{Xoj6mbqaGbP>|FJa9V-Y3>?p)Zo7`ofRMs2X161c<3ZQAha6 z$H4rp21@<-=l|lzfABAV`j>zC(?9&zKmMb?`&a+!AO6+<^?(2PFaEoq{?Y&RSO4zM z|LULr-3QN}{Pn;2cR&5J|DhXiRu?p9!^RU)s2qT~f>iNs)Ouq!oNG2>AmWfwn6abd zABhhyBC1-VuN7(aH!ycU{n=ms^l$&^kN@Pq|MB1a<&S^w-~aeO{%>Mh|N3A3xBv0a z|M7>{BV{@&iFx$&G8(`=^*y2H#unx{-paOA)QV!E*I#IE7E zh#5f&1!^e1pK1ON|Ifev>HqkPpZ@Lt`XB%PKiK>1G#+X(JBYk6Y-FN@iD4r;5kVdZ zrtx`XhK-v(m^y$H-6Ns@-Zr7wMDK`E8xOdcqZU&2J z-%-BitoY$aLf-xKXMg{v|K%_CzSSDf$-dN%W?`c^DGVfND3O0im|i7sW^9fOM}DT3 z)Q|G7U6hbAg-)u7>~yUvLh=3thA2Y0mA4J~-`ti%K0-wCu-PC%0Wu7;fpXG_QdwQ$ z>c?I(0v^($XrGZCiu$fSqOxj_(05daTg?|Vgm)D{>M8-G4|$p#{S!%NwTUB^;~JK4 zD*NdgRgu}oYOLZ{bid11DwFQCm1KWwwi2#V22Q$sE1|0H?dr`coZye)tI_3Xa5EjJ zXP>Xm8{RUv5h!mQ(iLJ1-;QujbF}Gu&?V<+Aa>NOkDTB9_ zLIqIlHH2mWyCeM7sew3x$Z{PI7s2=gq5o#187N&Kj79ko6Rbik-aWlMxsF~Lv*d{X zdmK%^(oarb+Q)a7Z;l`EQbvSbN0TF?mCGA}h|6^?6PHC!Uz*3K$M*5-m%ECbnj3O$ zu>%lU67+yX6co0jcO59DEGxyT_@NUfpNV(Pb$F31d3djO(9yo9rgoXt@djJ z4(sO1r?V-A=ELoLC{9kuBP4T+zfpSmLjEme%Na5Iy`};QGbCcilQRUU9^T6fsps`S zk%9wlV1~N)Z2L1paXka(-ZUQZLmBi=o}L_`y)53kiet7|P?@z`1Pjc@(_5q^Ar=g< z)yVxAkEb`3%l-2Cmy1IREBILZ^^H7M1{XM14pdouAm;V}(cDE<)Mn3rq-izO2Z&l8 zh%AG)FKW=V{+&$*QH)ciad0ylCv@N*ELnU}o`LdjA8{mZ1TO$}M%oc~uR7gc_+Bz> zH_+jgaiZ2(^*#LpWPngB9G3B?vqHD^1 zjs->s({{~lGg$yz4zG;^`mY|2XBQzEEQJ~*CPpVntd7HdFMD+StXCrmZg_2cj z-$y0N2=&s0G8+3+fF!}bdQV2Dt-6ynYp>;G4fmtm9O(j^ytm;>-Yxy4P1PdnJp^JOy#?ntT#1UKnuEuvLUc*QKfXW&DsGxNxMai zG~j2#+ZgyW2*1dlKt5gyohQqgnax=)d_`XLmLt;g4^2-X`QcC{*}YYL%B1GuufL}; z&7*KU-p)aMU8_tq)y>M2f&fIeIHIhv=R3cVB_VGQY~IsF^lI@1Ip6>2bVEIs}cQ;Oz!hRh%1=ifBp*>DJXt#D zKcsdzVVp24j$)*wx(JA|tq3`)$h8I-9CMz1dRsL)7!V3T8>n54cbRy=MQOs-y zBS=#R@c@9JL+>2?8&Nktyr!t|)R6g>i2A$KZl^1;;o2gWlvgfiwZ8)Ltvmd%}T28eSr)8b2GMei`IAXiyj3(ZLjI*1gm!yd`IOobu zcCi^D26Ome2q(xQzBSqel`#*YC9#fl24qPh_{1{7K`HX_5VsjvCUTS$hEOqdJ!dnd zb^srdIbPzXI(XAhJODLdqa)mfa+_f-NFp2+Xj5ggwD}7wZ1y6&S|Q~6Q+OXQ$f+f{ z&9dQPh!O39l4-Vss1}D27NmphafG?S{SX@%gl&C-sRe-n_7eykq;mpky@C-AnO9Jm zA0!D`+zPXw218#t<+t(qR$9cI;~EcsUmT|dg+5s{JiJXt z;T`=S6TN=Ot^eMI1J`MEV#KWH6-Km73%LVG?#&so^t$2V0#Q%+-{OF~>NzWCKQ%G&Wl9BnMvqlFo>I2!a;VjyL8ex$PT3nBhtj)ZNorN2ZTauS~C(ZLdsfe) zx_vEuWpZr|e&yEf?SAF<`!WBOY0hCBK>ST|mJ5?i@7-br6hadgf$yQxE#YDW)8{A1 zcnV}sNRrGz2P4|(e8O_qr~FI?1vJlVo~Z6n62QE^!A4u2eyH1rHZQKc!^z2OG>gt{ zGWPLDYW<*3U!5F12kX)~dCksfXlImFTzGY*i*$Mg^c8`yN%_?Ad?dW`$hwQitAuHQ zLVZmLdK2z7r7Wn4`XFKGUESA42kb!m;c!9Ia`?l2jZ7I|ydYnz5T{FOyLRuQRVwLyOdmevInFt7gBhpyl>rr?n0G<%ZJ`?jzK>YnZj2^jDc3qb!<`zH) zie+MPF`7)n!Nq7Ep4S;D)_?CJve#*J)7`SJSCuye$Rbb4EewXG_YE(RW{Ih3pi9-X zE30bjMnhk3d7nyNF9xKGgp*`CU=$cRB29-wQDxA4o=LDg4$^#G82>`p58W7_4HI|> zFl8X{%CJ4$RxqUeiWTA_7PtY*JUe=12N9x)62zO?fOSK{jOCcjf|-#=Sy!)EEnZl? zV)5OBuE@Jp;QFxahL)AYi4O=^hPY;c)FG`~r&vlPCNLKOI;^231K_KN+KQvp|8T|V z0{??XdmO9<`%jqM*B0S5TWBEwy_N)`b~Bw{3IGOR)QxZDeo15jT1P3*-Cc#rJa z^aehrWGFs0W9QnI+Zh^(_R>I71=d8LDmg%iUhs$URgx8PM^blqh2CYnY*-OxhynOC z0p?{I1Q7~Nq&`xDQK*3|db&>#_9b(PV*#@VrQvM=ZbUF)0^#0A^e9M}F|Z_Hr~pES z6VwCU+c2s`x(m2CWbOb%1-6=yISGS9#YHk8QjwU$P!Jwntnl)K$pSd7+NX1Naiy9| zB1-=Tf)l{#TphUl=#`DUBQpX#G~g$h83pim`1U6eS{|S&rns<@fP*zixY6=fTOz`O zU{EyFLxU@ENqCz;OA`@V+RX)<;1}%}Whjn#gCi=PLU6ahy5;v`X|T%mng%kxZWH8u z+<3Z*bOeB8LdXUQ3Vr}349GNqQqpZCOz8kd2`$59Bp|md=$r-Z5eKDn#;S{m6H|J zW9VvWxEe1BiUIQnKQ~3^6q{^6^VN9p#eB688}Dh4K~;fmN;}4Ejh@NbA_W*ZeeYn- z8c#r{^Y#8cs-uU9Z?d)cu5a0%V$3XUevGZ%=}33e?2yWiED{7;f}A#5O0tgOfUHIn zdL&*lUH>8OLQBSFCB2GseKs}-d=L6qp%H|)fV6W^%B^anReowWVqq##ns*v)*43&y zz>97`{mu0O`KBR2EfCep2*tI*IZ$m@)&#`Ko LHW>B$|Kk4#LcNNH literal 0 HcmV?d00001 diff --git a/tests/queries/0_stateless/data_json/nbagames_sample.json b/tests/queries/0_stateless/data_json/nbagames_sample.json index 9ae75d64f846b3d2d5f2e3cdd7a6cd631579f12f..5082ca059b3c6fb4d0698478b3ba56f2b099ad94 100644 GIT binary patch literal 4914595 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

8WwyMrA4S+08 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 z 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χ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� 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 z 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 z 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

WC`zU@($* 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

uRQY0i&Qp2`-TWvoO+~Mgg>O0;2vZlYHvi{l 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 H|Mq_YaW{ag literal 6381971 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 D{@CJN?F5U(&{s6Z=Fm;vi$GM=?8p2 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 z

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ෳ+#v4E0_{x$@9%` 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

}=_)i(Xi2m~_VjkQi_wV{{0cD|H@2F@BX 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

F;f4o@0`5a?cN=aJ*M~g<`^W za^lYsg11*mh<)ckP9Pux7C0nTOp8*k8$)V-RSFRiRlx5%K@>hx%K{sXa0opp3zIof z_6`wZ>O)0|Vs-!FuDApe;hfr(~RT!Z91}Gowjwsxwhqk z9hYl33vpP4h|*aIE-MRhYJvOSgN$kC{lh{#Q54b6$cwFaMxbG|Oyuoq{eAZS(=vJg z^p)IIg~BQ)SotdF3b`j9Qcj?-6%MSybWZfr43W;kJj{+N#XJae`OJ-?icTu>0ZWhP z#aYJyyfzN!Kf(|!-l{<0AqB#OVpkvv*FoLgKCpHxD<_rnbP&Pq`s*j3 zYv6meO`uXrhLmZQxrPhvnF6FFV;EyOo1d@K?4fj!%SEzVs3b@paYu_$Deq1inj#rB^ zo&y%OzjBleejBY)qadmT6xeFhX^;aE^jEl@^&;y4_hTwEkV z)RQUwY-0|#K_OQ0n7y;vVFg#zS$@iCwu*nx5udTw- zAp~-GX$^y@BVb@8K3yS>j|w`VR1(?CmEn-hNBjgp&k7Mn8c70%F{q5g;WduhN_zvY zzxvR=!v_b%ejo%|s769)03?9a4zXNbMjQ#Toje2(SapIB$bccnv=k$4;p!t8m-4o? zp+6FjcG9@PAdsucHj&#{AVBWf=0e#Kg1Tld1e@r>AgeImeJ}U+0-I}_0D>wF0R~jF zW&)YZ%wI%eG7Lxie#g-M{L-)p0~V+_^v7FKWM>ncH1&S93S-VZ-JwPTHB%%){D3=( zgd+s0OC;oKG7@?5kq`o{DTLU{CPL(Z--w&wm5UtoDB*_}n8A;yWTPWIHi|*e1w3D~ z0e}5dhLZT=O<_YARm5)u1GJLkLE8H8a+VHWFNPC=w*tVHm%s_{Fi%lmBT3K zqr)hVR@irC_IPo5vpi?}R@u~}*Jo&Vo3qB{>3IMpoXH6&nj<=Sz(UX{o#49dwI~iW9MNMpbMK3$@678}Jd@ z?&E9S+p37asvQ8qj)UAZ&VH=R_*D@2rimFvf7%+oh3P_?19_DqhB}n)oVM-^Blrmy zF`&eiyA*~@R>v}gbQuLB5MxA4uW(x(Mchf45VYb3*}3P{`LlA$8rfBgBwo{YnGOoz zm2D(l3OS@_un9%vhFFkUNRA4G8)_D?5I$&dgkB(zMu?)&SR$8r$jPN-7LS%|e}YbD z-(37uu?Q=B9TuBtA$7IkR%=q7ofE-$P;`*Gnb$!r>_rk-yCC8)EX_cBHJyh{LVuXj zZXa0t1BFo2JP_N30~pl)(=rTEkR~;lGv9HZQr2I=0VU2sWjBxj=#CX~JZG95yo9l##wZY|v)YKc5!~(`DMA+nS%h$ ztXy!Wu^()sO$K^By3&6K23w!PDEs)lUtE-fX$}N1Cp%VL>KvDH%k@nd{J{o6a7`vj zB{2rv$(covND~E=#u-Ce^`AOl&QffR&5ZCejWD1vbyP`KG*Q48YFQAygSzjAg6W=^ z1K+Z}IRr^S>6^JlO1D4H5L_>>i>clY1k|slLNJFm2>7eGO@U*oHbxNmmhC|ZYupV4 zURfZO&dd3j#xjZ#RoHJGHxP^Fz!6?qv%mn5tEm83NWmFu_{hW_hkyZ!Aw&R{&K$6R z(l5(2ar4Sg<;4eU6!2G5gfhdDY^EAC`g!qfmMku9urd3&cLwCo&wqv)T9(6}@toys zyD|rcq78v^<^WFgnB8BDFxowVhPNa+@+%+0`QE?>u05nP$euiTPz)R4MWRsUEHV6D z+k*{~&q{H?7b|ld^oJb6)i%6F&HT6#8oK7A1uG*UjQZ$acPQc!KfAo!EgYvrvD&Tf zP|T-pExhnMk>JOwO=x!|Wtjhhrm3O8Peq$p^fn*Hpy-VqiBcOAau!s@ZHJ-r13wfl zkQJs+nCh@d=f=EEgS*Wo7`~6#LBdN>tA4@q`6&jTpzEk}lv4$|@N+wWgQPDrm1ey#Kf^NLaanjT^wz+%VbH=hHm*&b19^#p`$ z4{ern-)?6yUgor$oup6G1d!{`{*?93axI5Mm;}<+3~65=AtuxGVVg)%P7Goay}cjr z$F(St1L7fuS8q5i!3A`v@Te0DguqK{LKqA*@V0G?>BZrR_Z1zI^fof0kO^@gcqK(>W0W6;SjhuAk(Oz^{(oLz z`&LH@Jg+$52kJubSJj9xBWl>$I_-O2 z?r{d(YeJw66o?S#gJ=o_zNL->mv@Qt2MrXlG$4qpks;a!Zs)u&I8#(XoGCFeXPS0I z{Fab-yjpcOGsa8nm?CIITPlSHVDXMIMc%M_r!J7Vn-xkU5CnO^A(7uN(;<=HK9|QK zbmm|H!M0trVZdL74szABi%t5_8(JgATTvqHT7t3&9K13{JX(GD@I58LH#g-}QhaID zHvXFNwQ|rIO(`O=JrJQwga$#82te?#@prdrJ*PirtnEJWQ;VlU4!BOnb@~13&m3dB z2uqdHZfGOBoW1$9yqsSwF4MY#`RwF=Z=uqgXFox%T?Ps}ZfBrCu{q4f`G2aB__=E2 z5fBrrIC9AsUXwhir3*u()XqSUj*78&&M#Cx1VW6QqH`bR(sgSbEE2omA(VNX&2Lu2 zL_GHaA%@VFzfbR=kw=w+a*)3Eno?tkq=P}gF&M_YW=^OyvgS`)k#+PI_^^75qiyHY zzM9{zmuWTY<4=o)9KDqBfg!3o;8M|nu_!oU1_B_j!LT%g0pSi&WwBQXhr5Ih5?~sy z^7I{vDyj4tjNm#^CLsi`Oeo*XZ`+5LI*9-Y8{RX3ffp+n_(2XM==j-vK7vMc9HhO^ zKXrYc(gU~)B7D1fj{aV$M_~;Dekg$O$^gj+&_7CZJIe`6oh%fE$*S2;zQ8AiL~wwy zj36>*EQiG*l^pYGqmj4N5PqP6GCcwssDtVSt_+P=tLwC;@74TrRUFspq3Ez91eq|@ z+EnQINDk@6YDN`fP;?jRh=L5J!gmM^xT7${T@kvZU~lr-&Fb^QPuA(oSRx?OMH2?u zaHj@=Y?iqi>3%2m8UvwBIi#PbC7we_Euml^$t!y@)f5P?=_=Hs-xP@3dZXXG&J z(I7J@C#pIIg@8gR^m5?!(4?Iq`H~s}0+eTWIM8lQYP?(|Ffgspu>#btkw7J~VwR(i zn@EBCI~YhW@8Ijqd$dI&n1=FL%!d`qahrMBX8E!S>UO&Bz9n$K;WC6VlijVZAMz=0D zZR9PFso&?`W#Y+n0;)ZlcYe`O$9&m=4}2Nmsv~2dlgD0MBf!(-xYzmaqtT%kimKWu zY^QSNL}v$T-rs*f+DT-?Xk8Ep7CJ09697=~?8`&H8PrE0z(Y>EnF_wWO~;OU6D>9` zNI$59-u*BuA0<;LV95#vBQY{!0wF}std);+iM67ER%=E!QNHo<3`git#V7i3)R7Hp zr{;>w8jdjR0=R4OX6tPVY@&I{j~p81dM*%J&=6dP2iv+82j%c1H4R*ua6P@fZjQ+T z)EWuAMujW5F(9o-;HMQYqLr+1TGFPR7sE3R2Iz|!3-wX!ogu%e|$Bo#Ij;SUC5s{cbSOvZ? z1_KE_y^r8{%ZzwLDdX}!S_1=J7>~0HIW;5YK;?J~YNkjyLO3M)W&tj#KG^gH{BpVn zwF)XD@RkX75xl1n0%dd{yqaI#-YjO1R({_Ouz8dWDd{O=I}6|b%AVA;tJG*u>S}Sd z{MYR4Rt{3Gg2^|}UYEh-J;0QM$#NDCTCp8Vf?sM0cu3pdg_8bMK71gNq4aT`*|tZg z`!0q$F=doR<<3Wx%M|!&aT3K09*dyZ_m(qURyq@&G}l$V_@KJPBaSI4Z>}M8egY4E zRBM4G>|PUsMFY`{~>1|TF(a@TV+?w6hElo!fDgd&g22^4rP#|xqF6lH1#PMC4LSf??! z-epB4hqtktiVgA3*%mIasq_Sb7JfLYYd3sAfBhaBd!}eb$DmV z>Wjgk0GSnGysga&{8fipc7q}W4HTE{eMH<**KpvK1q}}`e@mMz$2EPB6EzJ~MCm|g zG$(SkF|fc1AKift`}h4QlaOFqS5Taf4;aNT0uIm9q_$_bX~(bivgj~H%|=Bc#7^xH zQtFSQ?`RlhrAssgb>$3Qem(u=eUo4Tz9tWWZ$mQp>gKp}4DZ2;TjKFW(&H{I8AcO}fIY~S{pD4RX4G6y2F(TWJ z*ac9}j0j${ivyP@VA+!23;>_0>EKWZb9EdYaH-LQ)O~lmxMMESO(kd@<|dw8%-*DF z`Dtfq4*?#kr2$n^A|zK?<`Qo{F>bHAh#!Aip3gt7*gxFv9ex}pMLa;Tk>mMoJBPXU zP^pODYa_^bqy#RK+_gt8hJKySq=>^}YNbSPG)>4*KYn3N!}a5`{Nt;L4gS z>@Y?3&a9i_KECo8?@|!Zf(io5C?P#9Xu3gWL({HMyj#**iD(BewRfUgE*9x00UU;* z3(}A=JpnL6zFwnKc!klMOK!-xIkG2K6262qA77~f!SfQr$<=hFE?kxy

BEJj{kG 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�< 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

dWGC{kzzT_hew< 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%0AlW}`J2UUa%h&b*SD7o4+6Av4T6)1 zeh7$fRTA+VlVN{tc^pbE4T(U891TC&Y*MP#2}T;f_iLI-DJ=eNbTYJ2Nchgd0VR=5s#;x^;GF zqL+%*=d{!9<@2SVe{~43+v;VdUn&A2H-vZAdVvkSL$G5M33E()ArL}6{6L4pi!+9?*Z2r^_*f;drVOLh-@x*Q%~9(Qs;v&5t8 z6P!HYvho)g5d4Nt)BXWQ$cVv(X-dV*ls-?Aks{Kf5ZSwr=$RseQO_14C`U&Kz^72) zQcMKH0)ZmZ!MtJBkn(_|%l#8kprRiH1(1wxx)}+3k?;Yx)q#pNU1*p9g6=sz`6w;) zy`H^Zrmb$v<1_Fw)e(fD3NiKqL|{PM59G#)?&G7;mSKTL6{4X>bO{s?u?`fJ2nq*Y z;h=c8xw=jjxM_A}yC|Y9u&MT>$P_&{EyuXKl zfk99(PJ;b}Q!2cm$XMk0BBgCoxb^dT@gKL}i+V0!pH0mn%pgewj^n+k0c1p0MsgEl zjzpQ8nHx1GxRyb0(1y06&)3WEsiN!kdh?^GVRAwOTGeVJ1RCgb?NEsP(~1z2W}snS zgBX!YX%sVWqABo7KIf^S&sB1A+zmd7icv#~{L;yqs{#vfVbrPE%egWvgda^T##qtY zBAu$)aNsKh1Kd&Zi1l2!CE~#=!ys3Frkbv_YecbaB6=_d2fVrF1pc}+*cip3;DacL z1|OmgLF*Nakfbs!FfvYWUfe9xKIt#g=DS4@4%XCK6Yt*{Zs1dDQB6w-B2)Pw5QUiq zzG@d2f@-ktqYJM4X;sr_)M;$KmlhO1sCj_DW|v~083laoEywRQve2yT z>$B$yK7?OQ(;Uwz|HjuMqr0_Q(#m`&5}KIl&VF}+85rdqx;zyo{YP`M4--OQLm(Kc zC+k(Jx=rRPDd^IL0SYxUoeMJ$>EaF=XtI>cP{B?|eXs0>06nBO7+U zl>vC4s>j}3rep3?PQ>{!PBV}Nm5L0608nFu;80G-An!>bQXwn=zbIv9Dk2|nJFCcG zE6|%}c=Po3DlN)Rl`;$byA1{2TL-**K>>h7Ngil6dkgmYI)h?Z@+Fdiam+}BIVDpP zyfUlFGexkC#}7Y|;1_b?2Z{sPp*fJQvA{zr7KVddH8tffk8*zOtMciU?eE{m5<2#t zqQNV};nfoB``%op&GN5(2{u?zn+$Se0HQ1!GGG2*Ig^kg!2iTREn)PN(6D&sI+a)8 zKmPD|!-<3^%k@ofdB)?PFUr`09(g;q0CvrJ1g?ct)c~$$i)m?6A6uxNu*C4NMoSm; z32W^BFwekv*Y9&Alh5|#`CN>P2nKgw63Hlo3r7cL3Ux6wyRM^-zvtk>4f`o`fNEn5 z@x?cC6F;goq&bnYmOxZwg~H$}3JUC+kFZYszBY3F!0=ILH;>M{Tf}z*3|bBo3fcGU z@oMW6VW$xA+GILxLU9i3pldY5Qi7h8>9)Oy$^l;~im!|9@;S{hbyeSKK*Kl@(0H0u zLrRijhm#O)VTcqF!cb+5gA;*=YAG>#h`2PhC4Iuq%=1}qUImeoXGXTPmDxBAz9kWm z;5)s-IaFC)zF4fi-SFo~(pXeTgyZS)P)!Yydr)Jll%VIK3Qf?If+Iz8(TpG zSY`JzFawPhcY+)-Igx_XM=68j!SFkqI9d=Fu^nOY4$y9ZVQ7ddn9PgbK?;1G^Cr3q zBc7wsrG=)>-!4+B^pkU|{O<7RPVG;`goG0j0G16&y1YyDdDP3E6JrNOwlu;CG)6fQ z15o1xXyqj2aq_ZpQd_wV5|FFi3H-I4jX=8^lt_OS7|^l<%CPeu%HnF{^AmEW^WbHp zjZLw5xlCLAq(yC)pKiMQ=~5c1pey8L@KB8c{wgTQ)l|6U6Il>2V9#6GC>C+fepz09DNY=A5VRFS@~=w2 zT71|lb&hkX64Ab;aPFsG-u$PRKb5{MlhN6?-M12-ON(_FAa|;hq=-d=e`mN=GR-B; zDn*UAST?(Ts%OXQG{!vuq^?ZV(|cyl(HN1-VncjCzfIRHd$&#tosJgcqdhep&7adG z`c!!wc4^VHm?1zcO*@Zd0HOn9w8T4{XmVR)c(%!v^ILs0MLp`>h8&^O(704mSiqyp zkf(#uTa`eZ`(WU<+NuZ!ZYd#3Fu2*z^K{rxSTlql)L1y4#Le&lcg+lQZ0U%$J^eAq zw!08pbe0KG>DW3bq6fpdgI0>{aXN6fl|AbEhdbGe>w5MC!#w*}OWF4cJA3*(p##COftE~M`%og} zV_>Hyr0;09lMFPWD6bs6HDQDN$VfjJ7MgLlCW8+e6eEXH2V;&OilPWkZORsYPieAL zfbQ4kdy4`tW`lxDK_jeQY8wz!6C`w7G{z`VZWYIBP!S6e5JM~jT19;ESTM4oB^s#| zA6wowasl{B?c3q6ibcqdfIhW&2nRq6L1n7>FcTT&1MKs;fXtqqk&a=(E0YmUyuQEP zUKeW;{3>krUi1W|MM#nKMDXyoiC60%*L&qnPwu_Hhv}d6Kd8(9p8mOqAO7cm`Mgk-`|)Cad>JaRKaA#0U0L{)g`RWfL9%~Y)@1aqL7c^wKz;$FWy)d*)4sPn||Wlvx1wM6_lvb;?cVb6tkd03olJbpb?P1>ls1 zQk}7H7$?8d6S7*%gQ!P5D`MSN4!i8;gQ8|kH^;|I`FhioCOwsgh)WxRUOV`0FKzVo z2pDC>hnFH2K|gSftOA0MDJ?`rqU{GN%YiSn8aAyGgN>37cus9-L;{lC_AWb%UcF0& zo+%XQPi9Iv$pkf`NZ?YDknAy#VAI>o7&9AZkkpiQ0|-D<8_w!_}jr2x@AH*S-!T`l#*7i)LIS3tpLP)m!`OS32P*syZDl_L^rgS^&iZ^2ntT z5dffx`C@~j&4~VLPjbVd&|2$=kJW6zFO>};0z;E(HUPYTPY$`eFF@#gbEzvjqn&4u zt7*0ngX5vP^LHJ7r!eS5kVF)Py~cmv7<_D{XPX81ys@ARGMr0a<&vMLEqv2zv5T8U zDjoa<1^=7Q)-KO4egUbi68oTxGAHkKT);&2XpY5^p>rqRO*8z9-mb{7sq3?2znW^y z<$pMr1$i0+qA8-ON|zrWP?ZhcnO%M#{-fpD<%c(;qi`~sPj0i*QmEqmH!&FX>k8BD z@*?=2x7}HbRUvRZJ`=zQ0N|ao-BKuV@nv=6XFdG{uoF|q&XF^*0k-nN=-}oTM0m}5 zk0DX!%B1*YqRBc5l>z8a(`4bGxW`F!eqiEjyD1l4qEoff#$S~v!E6EWT5oau=*EzSE;9iMOPn|i`#!dd#ODE4Qt;9zg852n-8Xpp&)on z))Bo*5lWp=p`TQbo1Au$c)r}EWjrsq*Mq|WJg#+RABVQC#Ph-iiud&FNN?+3lFM+2 zDgw7vL&PJ2Fd*ti;L0fRdigEwT#y34>yS!DC#FyWUl^l=XwJ!$D9tGK46P^`)`tSO zJ5T_nCKRcnVe=*Vpr2MZ%TLRNufK%N8|6hPQ3rT67@`~CV#?KYFpBwUk&698zp!w_ zC_%^4C;=@o`|EQ1X_MCA`ZWtqOHd@L2q>XYI{rT|KCc(oX=(X+fS?Y;wo)y{AsnAJ-FZ7Me^;7KSL|HPy>CRIJv;G24w*t zR;%f2S4MoPXg5WE2KV6T?9{LFJEy-+$*9hs&1ckzAHj;6R-}O*s$5`nhe*SXI;~|6 zHPCjo4yO!#Rjqu(2>aQEjw?k8-sMq76y!$^g)-hiTc;*XPrKHWn!@BFCx)JUS}s5P z#a(lNuj&E6$p{%h!F)Qify?Yp0d}z)5;)z}aJZmD5{HJ{d9mpad|B0&ry)l|-Ox&% z=9O+K?)Y4;=OM!s4h)FGfsbTgJ2+JUtyY&DOcF%A!s&3_Klc-GE~PH2)8NQfMnnXC z&TxdiP0%J05?&cOB<^^!NT+gK6&19$P<}-3h`Ilw=!;w1RfKm#j?qwJq(Ys zrU%a{9 zzVz6u~}D!}@iJ&Dr^-YAe5| zVY~1-O-*+6_N`Jr2Ix8{xXhlOar4yWlu0qamEREdO0AhZYRdR*?k9#Ha)2cUf}!$B z)zZ`JmXQExB`IDuczXB`70ANVbC&y*#;WJ(q2)CsEJ~a(11b4OE&F)pTC)=h>r=x2tV=&>~u2TQ0mt-I`cMVrZa|N(!1X-l8h7t#$@$kf$a^qpUWMoItf*LKc|d>A;)WLa^SD(^NO?_gvb54 z-|f;ZNhHmj>dMMq*nuy092;~*WCRa6cD&mlqTS3MuhZ#K<@yR=KY?GVVF&*elfC?2 z)8&*x%_b^31JP}0JK8)ivC~YmFas8XZ*rLA&2t443`oW#%s)_xw<~_0Gki4su-R9=8xnNze|F4@QWlE}kw^2=w=~ zk9_iUzN9DcoG$UkZ?b&>0+K&+V8jK9Z8Y!$Q5od)bjLT(J??OP+nk8LKdC^W;FSS^ zjV{t255N9a8`wcOvSYCi0=sNT7JETKh%iJGjuNHH1mxM<3#kG_g38k&!DX3P$<6K7 z93|R}Ku=XXf(>aa2(uvv5+eHy0)=>0fP$|xC`{#wrtnyVYD6?t!~=~hRK<_kUsu#>5lU61gX?NgzPG7QBq9)367Bd^%wj^5y_FM%3 zvXHYvcsxr0Re_4qH;~-tn1P(4fR-r=l;mB$Hk;k{9F9uG;PR;yFxUMuVTNXBA1Vlg z0f1K&ilKEFDSA+wOs5!FueR4)=Ri3;Sz@I8$$0ApkLU4kv!3aI}>} zaInFJ8V(K~X(0re>`mo3TkHj+S~``H6}fm<%mtpytO$kLgn&*2y5(3ga%3-lQ&R(f zRf!1;z<^zig^385sj)^>6C>0xn;5;R{izWTswD=kIHPw^E&XG~0&TA|sv$IYSm09C zg>-u`{L>xF!L%~i=(4m3ae$KQKr*RknG<1p3^ z2A|M8}j^tR;UQnk^*9)Z^K_(pzf@#MgxMyC0iMqejzw$Dj*AP>7RHq;)uigxoG1 z1d*v+FylcxIT427P@@SFY4gf-B2q6`v$ttM6O^k)8hEC56!2G72-O@@?>ySKsXXd> z^^e)bt(??QO)b5B@iRU=)DWFR`Q_+t-jP9HKf77S0x2NP*TX~0uK)4bThSYlouv|@!bqX&{5!KGYuw-H-1{A zM3|FKlBO0?A<)^6Tin1?lKlWXI!YO*n{%sq1G+SEsz_ z=X6|_V?<}YIzF$A2vIKjSrY>2Xf}*jdudBF&}+-?=IMOUeEAXa2w^{(CE`I?3=HgH zn5wel?1A@Z@rydB3F6Uag>($!!C^c=Q502|=FbKoqRzx^RTTX#9Rm`Nm)q;KWFr;M zY`%Og=hobOJo>3%@KTIQaBT5rr3NllMDV;&LttrAV@yQu=G+H`iPkh3!R^8>(#*4# zEURgCdZLX%pAdLnF#sHbfm}_-;J8Bwg6kwBr<*HvISy0;{ z7`fVP5D;NPNPOT>d$_1Wra*-A^Z9lGN&)1vV%TJ$EjE~zg z?~W&HMgYZL%%ic*?>VJ*750Qm>q17R)E?cWqMMsVDlz%qDdc7scI7L ztk9v1w(xgR4czNlhg*8C0}c?f^XNwW{^(>Hno}D}@gN}wW2+N(>Bq7VMONJt1p4eI z4Mz`EkqQR%e6mOc4M_{p(hN^GX?xAp|G7oB@zsBPU6eI#8X)$zCr6SC%Ici|! zD(^u!GTCx=cT7j4d~IhgTB%IuX@CPi6jlV&`7U`6KN1vCO#*pE0-db=sQs*`hy(e- zwzu8NUHr)N$YM7b5Q+g6Q#!~GH zoKV9N3b~prC%t)uN_C!`I75n&%&Z7v0;)Gz@pN-Jd$&qOGXB zVjL#J&;h#)WktfI(&^YdOqSL8|P5~^jbhj5cRi1*ny8I8jcjW zywl`TZyr9N5dv~RpTXF-gze(%?N!=P{lf=`g5PbEeHRl#9V##c6wu!q1!2N(=3h#n zF}%*SgcA!iBqOk|Sfmr}X0JBamkYlOEncKVz-28JVUn?p0Edgp0r!8yV1uvQg+MpX zz`!^U8~e_tRZKA_gKvyNkgR7}ucpo{9o|&AGaMLYhgeNIke27YW=D7Lc?B4K6!`m+v>CDSr1_xlz+^ptEoPv zsqRfIK#|oFNf9C+4_$bATAYL9&Wl1voSqJOQ(qwzG!tY*)O4ifGHqm0AHj;J6dJ&< z$na8hQ(rRikn+KFlUz-fE6A)7IT0~Dwmx;TbBoG$mpi`n4$P4r6yC+pcjB1O8 z@y+2)@LO<8wIsfwI8c~(MK{wV!}J5yjalyK&*HW^FmXk?;Sr>xdmgRB13#{vn2-qo z7iu_!43H1nxOVhQJ=dFRD>BEwMXhmHQFP9v^(Tfo0l{msHSKN-<^%-K@0?B8NsIyw ziShuhTn%Y}qrA#Z90&}h@*?i{iUv00oY%|b+5WQGOxo`!q(s1*+K<=^h!IK{>thz3 zWb2CuZfE~Klu;TC6ckez-Q#(IxT*`hSH*+;&|oh*xaP?2kwHHFEo;Aj{d8B~f^#_VGds3nmK;cu4o+tejefA97?7rJ=pH}nRVDSKz{AU?f9*5`9#U3t{AfePy=vkyq9KmD zH3?eDG=O2cLq{St3pF?X`&I?Ardt7 z^XPQ$_r;Q_3Wgl84PHRHOI>5h3PGTsNuHR>Y#!A+Z@UvtUj{D|udgLV_yBbwDxitQ z7&FQ}1UY}AOSb|JS)7Cy=wh~@`({RZCy@HOHpdGGMF>K7LE#i9gs4!Qd45C{Ctl@? zcY4bj`5v>R{ZwH*!3#fZ3Q7B5T8v`Wr|D8f1TRr_8uI8)LeOiK5OVk~`eHzdmA9l8 zg@edC7`hu`9q+3v+GnwLa;6T4k-|2oDsZ_o2#czMW9@1`OE5$~K;rmv1A|f~(t$f! zIzn>7_`oaE5*L@7o16MDPNydD)|wD|xtNB7Q<>6Fb1F>tcZyaX6cMRKVS51)Clv4_ z5e!}#5Z$9`Jt^>;8jBE+;-Ok);;%b7F{U!_#D}0PjSc~Y-ubkS5BRNOKsW|Bd-rZw zhJjo)&BiXd80r|PB&bQLBxsXNE{s;{W2R=SaO_*vhP`F#)$sU^>Pq&%@~r|LfLBci zu>g=~m4`vJoxi<59SjB{YcLFG3JQ3xje=1E&$#p@cZqwIcAZ6Q)C0#OH3o!3=+G|- z$3r>lNS7iKZ1nV`L`ek#Nh$~$gVz5TRWYXCq;V5dA9`831==~m)@h7Dx9%O#E6Mk zIO%-1Nvk$eRYWlZ&bXqMPxMA%30^+#jOr*Spd3t3hTI7?-$Ir__|o1Bei@J3{YqG2 z59XLaz`)REFuG-i7(WNbFPrW9YWDbO_NP=Y;$_tNx9ExT1fNhm;v_>`X^W}`F%*QB z(jGK!$Jg)HR1srGj;!4(%^eRRG1X0)IG-j>3a4WQ(qR+62Dc3cUeX2wFI95jp{y#> zrD%$gWC_L~#X+>x?4HvR-L*{^R2K@5Xz%Fm8xR;DM~pXeXm2`_^y|u(ip)XQT2Ro` ztUtOrWru~Z0b~HBI@55YSRDIfCM@v5Hyjj4IsYbEQ|u1_?94AdrFp2C9PqS}&%YS0)tPK=GG!uz*(( z>0zY-KCAk{0T5Ds2O|{QGLT?##D2R^Uy_iV*GKp&AV7H^87~6ZJS13OT-*D$$nsj`;U4Adl?}mOKwUt#Z*$~qFo-=LBa;?T3XMSU7+S{KUw(l})q}m}C zMz9%TF_uyqfd1KUa#liS-IxVY$6=5PbDPC`l1JU`V#ndJH1qzJkMm6n2rtn5n$~uvi04 z{X(rER?~pWCwxoy{Ys5ElR}@7K2tE5?LCIMMO^JPIJFQeGtm7S3Gtrq;56j0NoL^* zEP=r1yziLRr~rX3=I|;^!UIcT0$$;~=>A5s7{qba5bT9x1prf4;IHC59LkE`PH?2w zE~^-82jqI{aIjW%mw^Uq0sEIqZu@DCmtZ+yOJeD~>3X!)MS)=~heLo#P zH_OQv85+ZTR7Io~Wv4nA3=)DOLSZpPI=hnlJ(huC?O2D2CD6A_d|5rR80QP^Js9E7B^+w@NFI!vgr471i2(tq&6AtCS>FPxL0`MHGZKGTf?%s?P} zj}Qa5v(5liJ%c{+mY1SIpP z!XeJPviB5_pfa$#Nfx{NXL%=ao*lwZ139-P#SRduxAVoy_DTuBa ziOCp)B1*`PjdjtkgXhxU_6WvyfWh{CWN3sHAqqu1nw~{Er68R+K6|xXrlpSl zWGcwGa>5~jo+&4S{n*6`!DK2DqD(EFJJHenpE579(Ok*^Lg2$+zNZ7D*Nb8`n{}Uk z79y10FK5|?eYZI+JuG9IyfNBCsKOlj?Yn^K1Y@K`gxF{QR!|2M{Zf5p<-nt(c|J)~ zRJCX|yM3mIv#YA+OJyXe)SYOSu^-CPyXX;3PiNtFBZhmMP`%2L1>u;N3am~bb1FCpSFaSS@Tvk{n6OL(gy zgH9?i!K=kXiUdBTNXW304C#-ZG~t;0QZBc3(~SG;rQ=W-V%93iWM=~`^sH7(^yx&% zg98Jq{SFE`&x`CZRc$sz9}ayIaUd_uPW5)k15~xWCNr8@V<#ARNa;YIGkS5jzpw9- zOC<#a#*NeplsKmpa>78w0*ueDOIU5&1!CF;U=E02u5qVkg8?DBVyclE!dU@=+LJ&K zOar3LhL}319MGeuY#1BbTjPP?wLst{ZPkD~wQ68X?@~!QWCm!f4Fc*MgJ7hfG;C9W z7Bz)pWD7JG-Qc^~fEX4bDFlFPI+&WIb!+F%cb*$^<|kOCUS*o|64&<`AYiHU>pMGN zb!svkGlB=_n1OGpmM~^W;;<1oXI;_tXwhy5M`vre zPM(ZB5v92o9HJp$Lj{;79Ah>#7g-1tXuG)fe4PnOM^^;vi64oO1YNZU^{_Ltt#${fPfQR`q2ALzU!i!EumLr=Bw_S0wY zK_)BToWnZj0JALL#6UFX7CHB%Jb=PbNsz4^#BZR@Z_C0U&YcPO)6-&Z?H*MOttAg_ z^^;2FG9`Y$5n#H>MXtKZ^_%RvjyY|zx(H~y4*K{G8R&bh5@pH+;xHCsir7npEdpc) zGFPRlRWP$4SHpwRK;pI<$hh$t`qUH&X1`u9R$o3Wi|KYh^V-o3A6wQ`^glM`b* z$DT z5@gNK&jl)4OcJ=ga4qKyE0YmgAl)SED)$%kDg zG)wxRC3{g4c(Gn@G2C=MygE}iN$EeRi%ey-pD?a$X&tHt$V_I7dETbcCdpPu5= z=Gxwa5zemdA#*4AeNKs+MHHjC4QBZv5VagwFeXXV_RP^ZR zceL>sGh3&5vQ0cXzHfg$)nBMZL`+ZpH60Z(`_p=vHhuQiBqsv~97IHZ z13$)PifI~6TT;M8N#IV$ox`oBl6buRk)Zfxu}x=2_#IsN!CFZ;D1se#P~c+8NYl@{~h)fg?%B&R4YZqkzI*~QK3YdTWp*My0e68uW3 zfy+AT=}#aurG)LDZazwC5Yzpw$2=4wpbhFwlt?g1l!|O`isg&=+9(7e5zuA?(7TJH zFJu{?LEtmBe&`hhkr8G)+56{OC{Yz9NY}tExt~;{R+yyeq;ocm+qN zx{P0x!kpf(=Eazebvp8Xu?Ifa^NU_6{A!l;s3?#Pc|8ggPPPc(v&ucbk{u?defIFH zVHUE}Aj*(_^?~V+2YM`u=8UOlsR@Xc10dI!ia4MVsuxc~%nLiyG?yeZ5?y%|v`AV2L`0$A|v=(1|ql*1_ZCnfWBOPnY~@6LmR&>eU{7zpH7z&6wwy_h|6(8 z`VS-y2{=;x@r#Pd0N|(oU@CY#SKtSs&^wWS25r7i(f*_2LZ}4 z-(9Ct#7x7koH~n5YvY#R56OS^U*HfHt4JUCn%akEwYfdFcVHgqY7Mbg3^~PvDMCJO z)Z7aB&~=qSG*|t#Iogv$KKd!D&8n#s{9Yvz)<})Dbce=Ol+$Dzb$aaAS95E1iFsja zT>nR0+0!7M(Cy6x5Go)ZC&plwZ=2SLdDp%(m4fk9d}65Me0#9FLPR_|0>ZvHR#;~` zOLI=niY>0qhha=<&YZnSXo1`6*TzW|jE|r~d`xF^Z_3Au^*SX>oy2lNOBsXTX2#%B z>~@#|XP#Lpf*&X#0s|;Qa!Ybh$zr*Wp$;{pCCF>tAP@KUoy<@R@u7-()K zCivw6{%wwC#MvjNEg;A(;RL>(K?t0{E#U;OOj*26d%i8VvnQMD>!Q#S-%}9KznTj=C@ zbwmhtAbK?lA_PF;Fe*5qp|5W+$d#$pygFU@fYvJ?_TH%@)uN}v>0U4a?}P%1cNB== z?>m`5@0AV!PW=4?=}<0d6k7pY`C`+RZJC&dY#~X|3VN6nnx%b>KP(rw|8OX@>3|L@ z9YPuzcWOG|ErNm&W3r1i*w(-XzRpnSPrQb_kjVw!;51~~{(bW$Ipv>H=<{j0@ZJQN zH%f?PGfMye=f!7iqoCa0h?*M2Vuxj z$DT7ybiR}dP!d@`3Ijml(-DyvjGY=yQ6nbyWwp-ezGvrtXX#$hLEl+j2$DnRnb>n3 zbvjB?m&4i&m4LI+`YkkEQ9ySU1t$=qAtp;iIhDZnNYFv2%!x#~_8%jWov0uaXsI9& zWa8B#ZKM2U_UOaa?fQ=|Q;fRUIt}6XKf@1e=OH@T=^;e~pHxJQ7P2aH`V9R2(<0zN zPunH=S*2DcBbMYFBD^x|DLbI0ZKiKN`KhMjJgO!X!L5YLQEN+at05uItyG!}5fFPak zG80>pLbL=p7W75r1a4;!JFM=*2)7l+?KageExvpxrxef|1p=3#*;;9ELMfZ|FC zVLO`6A#5v(Xg}mp6OrR%zqXBGJ-uu+Y$Roa+Z{B}EHxmwauR|fu4O9F-)z1X0SBNR zB}T}mq7SvU5FIg$WE+k#ZIKOx1RSO|DR6xO!R-u12)%GipgPiL~P;eNhLs15xd>vUKR|9*ZjNrCH5f?(EAx#;1boAtCmhx723ckR( znh|$~q33M}7=pJAW!OOhKWw6q;*Q(x?D_50m)q;BZ)Ke$-dBqUx~zIL7}GWw`0LII zm#8g-KErt1ZH6DBF+nrF+(d*@RwX8a)-){eYcCwD&&xFN^t{-UAJ5bvpnVp9l|hH| z@vDi4i{;|xCe7?z+$K$QvAJGdwoA<}o;^ZeTmXQ<$N|8<(+=GAQ|So-SN+XD%aHg8 zKv-)T#JH7*=s6pca&_`U8x-}0?a2pP(=H=JCrx--PCLL(s{*Im$`OF$A@jp(xA1r- zA{DicYr+ zxj{c`n;yJ8ytoDfKNUvM5{u%l2r+19Nh{-3ejaMLO(As=5np6dI_!Wce851c+Byk# zi~`y!6?nefF4FdVFP8P{1;5p;L&QmJaB|SP8WHIns3cdDhQNWdkoz2*OMQI$K)|5d$znz-TgJOg3^_OuBDm*suG+%S9X1nZlLnNI7`;Z=2g< z`6EWH77Dzi4FTGu5a1zI57Kc!Fv5Z{2uhiy?*woK9roA2K~uP`cFXXS8U=PMkNMkqrb4QqbK zd6tuVVL8v~=se4t)%yG5HZ9JWJx=@Av}3F{e-4u@b2w=^#@ct1#o0-i#OyS=Y@xH1 zDiszP4f_&^eUO;M-G1PYY&_@B=`@^(KWR@sIKD@@QkNRz)(WxETGa}Swlu_I&sF@< zT=kK7DL&HaXoQ8{){;OC7FUFec$l*=_`jVhrn7RHf~f?#G6b?M6$F4!C#W!y;FW2{ zw~O2L>}}fT>szrsAOjf%$H@a#gn$!@^BpDde5ORY6bDiv81$Me>e^)?=f$}yBpLZY zj+wu3luzXmFc_O=G=hRaW14p2VkOIYHrJQibQG7<559T_5Y{nga2XsRc)s!_51w%9 z?g0hdT^9N1;XPl{#qVW2y8csiCt14lLO4cn zUQynThyZj&dDw&9J>&Wt?gj~w2;*%^ zR9zOuZH^b{Q_YK@F3^SAw**K#_2(EbdP#L6=5%Lv!$o(3gjqhi{v{rAyhz)FrCosj zgwqQPMUkGWd4bO>FZ!iCPCkqlGSp2yF@{6#Uko!SZVre3YPV3-gm#Dt350mG#**sS zX%o&uKA@Ir9GraYHLoDr0ZbM|CgV`1A}C`M5;7s&LhA(sUYV}sw#(1cQcz#x*G9lG zVJ`$I%d{9G8 zDh&y_nvBGql5-(D$)2||FsZaH75~0l{lv5>!-**Y2= zSqXe-jNF;zXLG+0_1uKBnp?^qk5H2p_QK6_ZV3{nZZ6DoUSxR>A6Dqm-0aF?L{urC zGE1)N{TuX+pId61ZfC1T2)WCdJ1gB=G1zDTUvKg`*!ap~#q}GE`C7TspSP%!+#oTw z-ma2g2Zks}enQ336Js*TpHVL#9Y8w{%n_EGe7bTXQp|yp&AosEwyMsG8$;oTLJcs$ znenW%P(@lsgpM^GM1m=A(?qxtOc?v&JiOtod3Eqas?2ZO^L*-oY?Tg=ix&(JwA$hE z>PMQnezUmr6?YB^%8aNk{4jH)TU&+aRcnyYv}Ba@>2)K$5*i}xNRjotYKzo@?ArxH z#;&(~{^!eUEC9Qfq|%^A(wk~C=3od0-6_u|3~cvw7;^WbYZqXkcPJ3xPPXM?+c?}( zm5D2}<=i`dIZJb}zZSb7;RmB2^o0U=C>Mm^chwTbPT6w{gmpu`L3}FT24j{v5di55 zMxJzgx!GPVyr0+EI-EMAIroUp*P)L=B3F~$n`|V77lsDq&WT4E660eTis0^=c<{=& zk^H-5Dzw}Fb9L=)h~GaBG*LV2fCxDf+!@P};3XXkG8X%k0s_`aZh)^dAld@b4}|d| zCm`Gu`R(E#WjWPO@d&PNTSu_XcX9gj7)Koe#9hj)5{z_vs-n;oVl1+2`~0MZ2t_|1 zfQKrZA&^WKio9?s0UqB5BU zaFa}2SmIQ|(Zgezj#BRlzMrUsGS(si#CPIlo@By*=$In_$Too2I?HrGtYyZLlOWTb zrcw{M9e4R=GYU~7dh;0eb}{n^u$^U)Y*3m(C}&(dAr@YvZgen@xKo=){8eJ_e{YofwX+ls4E!|5SHWulD{E$m%mWQ(5!z^o7LbGt zji5`&Jb2&}GNe}vh+(S|Q4#oT#-Tg!7(^tUJd?tTw0h+_Ov5@TXeq0*gb-r^q?#8J zU;+tI98IISix)XHE{2n@BpT$8(IO;f94q2UBPJyQ4U{jmc5TN9jK*4_s1eWCV3?2y zL7HHU(V~|_-(PjcYz#mWKLW58sx$4(`lGeb4d5vjPDap#j*Q^VwTy7^#G0o22Lu;o zI-MbpL>Fk4v!l_FI9|lvB@GR<&Y|&ivHhN;BrR$3ex(ny@Plk(aoKdO0o@o9Z25F; z(Tg$m2jVzP%d`9RDWC=%5HFW$?|}EWX-i_iCbq3B2#MejYzXeuIEYZ((T3cusB!-k zL|VJ@^M8A_*-l%}6m;e;J^-f!B%>E-?5`%`Mhbm}x%uz`do$hKEQ&1lPDX^{gf=7a zS@E#sYO=yC6A;pW5R9)g%R!x6W$3!DRWKUw7C%}x1K+4^h7*e9N|e(~kGDy`tbbfr zvrLG6{gFrl?`>@Pe7aJp|c z2SV9tq0KxWDI!h{Ugq7qQemIV7*O147;QL?viqZM4PMlWd@!DxGR4a@JIszN@GQm3 zY8kJ|dUjVHoVcu;ji9pu; zI@SVkfE63?L!sfNXzJj|;7+ZnjSqB94}jwSiTF8ECL;iV3iOv96#2+zfr6N2EV>>p zt+-*4Z1+?vZ|VB(Dwc!>~Ndi=9$e&EF!vlnK16Gfp=)u37>9$mi3Qh_qei9i0cgl9GXe+Q1v1BZJeo1LIo1`3{3Zk zV0wcJcPB&Kl?lSql*+R!SqWMu^u1j!*1oIN2lteOy010x0aw*ns7cUwW-RoNd4NV{ zb!S}RaoNKL*frUSz9W^_R4`%RsUi^ilyD1ko;b?ZVUs;&@3N2Os?c<%H9620Q;R?j z=R9yxs-w!G26Z^!AxBgTy>yVmJXx9!gkFe7!t45KfzyUZoa2W#Y+B0mEw-b5vAwBb?)g0=Gv;MmMJxC@R^0aBF|LK#5+!PKDbMDH?+d9hIQ;R70ts)Qb9?mT>? zoieJLb9_tXMA6m4jv>=bxVSVN#V<4qKa&y;X95q|$!f;*1ugT#+Mp!0=g3}k&nj}c zXq=nT?AF!(5SWx2hCxS2L}eM$2h?+MtRs1 zjPA@POT;o6PK%wI*h6Ik5rYb1&_d(Y>f>tm53!`>*X4&RKQyDWXf>K=IuW|#fmE%Q zZgd}=U)w^)cDwnPwjzXOE@*piJP(>8SA)?6Kfc-db=m32z;O)Hznq0dLK$@b7 zelHx}F^Pp7YB;ecF}l03M3G2kH3b5%kZ92bA{fb=Z?ZJj8gX~rZGy&WXb=L8Ht`Tc zBTSRWnOZXNQw4)@VVf0q>E_AYFL3X=;TX(kX5^sNWYZxM>d7$VX7sJwv7E_xg+etB z@ARf2_QtoWtwcivsI6*gGcg@Al5*8aS{fY)an4Be`{81gNkV96Js`&x%;!KvB!CoZN_f$?8 zcTk{}$;;wUO!sz7AEn;XUbcCXfi5+>W-LO|9HkbQ!yeNfv5K{(VPLS%(AV=PcKrecuY z33G9^fAZ$^|3r#UjHg*c@VM~6*+iWxj1*;ig5b*38{0SGrVkmqEoMxkB^x?k&x9?o^lNX zjy_Y%EOH(OCaTlN5X_YG`0^MYlGGTlZgM;y&3Rk^0~8GfZ8_NEqB*n8AwqXnr#(%2 z!Ek<1UNcIKTX0iem?=3-_NXK}E)|E*(DYV+TinR5lfoP)&pvv=vke>E!=MREf#J-U zVU8rhJv**_z)~heY)+23Kg&!LfA>DCM z;3A`iF89auZ%-_Cp2(C2Q`As|>JR~-T7$ICU&#*lGHIn+{sCRGs#wzhFvKVXrz(iC?Em*Z5oG!au{6pR)z<7^FWg=rlnMCu7lPlAj(-x zxTwYff4z_I4l03{n&7%)42PdLF?fIQxlK^+Kf zLjO3Slcl>+6K|T`M$}7h8X>5~H&t4YAQ=!2O@98X47>D};i6iH1`m}Op@#)$YBaKC z;GvxqCx>lqA6oWG(;K%^--rdCm;(Gjj*JCf+X*K3xtDz?e_yZs@Hz(uO{4073*jw3 zLk)&P0OzmvGFdLmLYa!>&f#spKbB}@K0IH4!RifTL+czPh(}W@aK=Eu^~rzAp-KhL zcNj4y6=nXPK_I$)%kXRnB_VQv?h_YzHmnz`tqe&1^66HVhU&~>AplB~*cuWRXc=I$A9 z7@~n+H|3H0brFNbC$EtBLEU~@#vqVo!l!xNU)jg@Xta;*d~vZ|e3Ahu8%{o8_`+cO|-t*y~dQ%zCOg!#Ne3bOK<5HBL5sTH%DP!YGbh28Dk+eBKTIOnaQAAqNWAOk+;}4M=M&HCVSdVM83cleeW9kHfl}O_Tb_@ z!>9SfBWDPjqD*v=^KK+fdCczN$EEDiy_BAV<*hddzmq-SGi)Gy7D|Um61T1OKs_U% z*t0WfZvCegN#;zGch3IdAURW|0*IIr&Ct<^ucOLxW1Ew%tb|)}V6sy!K)X4Gh+BC92 zz~J@>7kd3Bc&Cx688~fF#KC--4?N12@p^GC8{xt<>P|J>ul5#bopB;07x?Ce2A*Pi zsq%0ip*Zq2xv2v@0CPMo?uY*YBM|keB0S^^!&*=USNptAA^ah zBWcIUIy*%7dwz=fBfqocDg7VGNZoM$`{4A@uY=7PObxT_Lm~||*QZ%(WY0z$@KC7c%0I+OOqi z5x$=huifz3A&7H8;0NZbRBsW)>3F~CWuN)69~Q-JwY0xL#X8fX+iw#0TgqsVAek1_ z={KvJ3)xo2?>=?+;K4BD901g$$N{aQGC9d9XY$d^T8VFeSkzGv>}((bi6>jETk&GG z{v=avoo1s6CLN9yJZySyXv&z=qG?a(M0YF@-oy!I+d5)oj~}UZ1QcW>la0{oFKgoXPZ=_T8YWa1CYLN4%A-}-`#;jsbdAL_B z8%IoLX$T;Y3iT`{Ts5i;eGKp@Gm1=xJ(Z!vfR?p;JRiab+5p3+Dt!1wrsQB#nc2%* z8E5Xv;EV#F*^GjRgHgn&b_iYn%yRirn38fjS}u3nd(O_*tIx8LCtF#S%wNZnIU}eP zQ}0|dcN)nWh4JB7H39L1UufCLG5G$Rsdk2EofJEYoRVhhI%#V;&p9|fEkbKNzY$s^ z*j1OobRa2WCwgRnZkjkgIty=O$^iLDR*_NI*H@IK4{h{NT64`WV{2ChiY4=|K0IAs zZ&o)m`OkkYWC<|uFmSs%X<{XnfXIcMnHL*a3Oe^a`kvFvh z$Z^n$uFrUdP0HV{K7GDgm0bvJFz^O#?+KV{r-8q!_uP{iJNNPA6h?$J+-m&gelT zp7;%;?!B3`vA|!A8KH8_sUkHs_yL)MD#JC*o-CcgSTZKOQ78y@}6Hm4dH4ub#!0<)D;#qeSA8RY+S7kln_&Fzb&vfVAEpMT-& zdP}hlPS48aeVk^v;KEr+h`7;GBL*%?PL+*B^8wEum720ofu=?);q5XbhLL`idiJM2 zQ%7^&!TtNzGM4fA<=2HQqUg*7Z5s_Z0~Ss(@Q?}%He-4!TIS?7sd1oI27}B}An2vQ1?IH$L;F(C?7MTHJfxH-Vtu4`1@%H z`c<+%#qJDRT-K(Hj>5`m{(IF&# z%Kn`!&)J)0vi1cw;fII7XO228dYb75S^6u^5pOTqacTo;6aah+Gs+n1LOKls9A$NS zA~~S+JIEm0n{w+6j_;{mmJ{k=lYrL1K$u|Sq>=>S@XI}fx)dj75hR03_Tcpn`lZv* z#g(DJEgTda8S#8ku4?0yiA}FYMT8PEE~+V^JOB!NhPcNk$LiPV)~z!I_lq#3=ua7u zE#kYld?#L{DbueO+qHyrYnejnT-712uj$}SUJxOo5%_$34G>Jl?XsEt*d#V_JD7Q=kDV*ig8nLj1wm4^gCAoq>~43A98-Px%gN* z4X2ghb&4x+s0GweNJevO5VYw4f%e=s4)qGnY%kl5It_Wq1Q5E#A?id9AjE54%>KUk zb+MI!3yuno2{^1JQgWNJh>XbfudE(F9<3ff-EdaL*>Ziex@gyppZ;);1`k6q4!I(J zsvDPMF@Rcgq&0_B+s8+snvyzlR(s!_4cK80dy*+z!monrP9JxJY2GS3iGzoyejy`{ zqizM$crSGmEVQMvvEK{;FOfLUVNkuFegF%W0amkwSBS)pk$_uhSqMy>+DTBc_k}wAU0Q3wEJk5+lg9Rv~FAGiq zqs*{e%)pyuS_~Sh)WAC!HR3eyE*P(tn8^C(;^kuP1M1Fz4BVz2Gcf2hEP$9{k#)jj zf!m1N%pdhGohTOWp)sqk2%$p^s&P62(v2N(k@K25k`5b+ICsI~f!PVJPx^sF^O?bE zIzz!nGdO^Z#?*ZC=}vP1icXV(*zS4}*R{giwDm$(SpGJ9A|voUC-Ag7dLkT(K}aj` zm5mV&0{!;14uUaVGi?>K{for0I7$XIXY9#bwb@ULu;-M+0qrs_I2`&tDGmo5DizEc zTqrdd26ew(Egxo_C=L^;a2U)XQvvVg%t1FBK9_3wO?N_uLjm_m7SWySj*HA7)C|z{ zJyGaQOX2ODQkLDWK+A+7?!dx0H4fBBKDq_m1M6ZMEEEUqKyRZTW6JmM444;9#?gfJX_vu zF~;Ma>~pZul@zMZl4sA~3cczA$n6T{+^;IZu~IH4=HQaF#*tmow6 z4jCT6G92hunb_>vSu%fAELB7-X_)G;bNlz`AqeUumWc(u>#-k4Xi%-s4w}$S0FX_e zagkxcOiXir`QsiMb$sdvnlociG6ZLxSykmVajIOV1McCBluK{CUaUU-yewx8;<`i> zIjkf3IQ9eJ)y@jIsC|sohSejr%U|0cQ3@$Pt$OJVQRs_{vLiav^8^eJgae78mmOyA_gnLltcT)u<6G`0BH4kg;&Gjfd8hz<0M$HWWedgg*g^UMPzfarJSMs;UL;yc3|TH^{Mr z<*Xdo_9z4)w*z@<2$TYd=ABxS&o0@|*4^l)z7Fq1?$TasfzP z>Ey(wx2PLw)zt^QagxbysvD4aj;`gi+wHRKE^!H-!vVB1N`#`|U6j~UCzBh{bf3Ps z72pR(cpO5O$JR5^#g}n9iEd@-V#gjjP9)oOa4-Zq;7qL$`0Kwe&kcDFUZyDxoTm0- z^>e9_xZE@nhjnz{&vL;Di=ys}fW{R2WVvCTs&4DguCQ6`TPX||s~hgp{4%+*EM~V} zv!nM9Kv4My6#nn>?*shszy90*oqhMeSC?=qa`bN-J^b$E=$E6#;qh^pb0N6=7rxCB zt1HP*I3DU+mL@8;qD)wZYIhAq0^TjKR(IV#snj4gsE)UG+Olg1c-E zsqX}mXt6OPbP@ou+FfR?*pnFZW53_}Va6etNe;^EG_yO_BG}2u};F14+V>h4W2&j)fxwep=^PA(Dg<)EH>XArpIIP|nMueYFDWHU_Z^F%tn_ z%*o}*v;v2N1r^T8305jRs_&rUOjF9ZVl-M{p+t$r$XpYbWC2R!1YuFT z2=xbCWSqd`Qdl8}_sK5ykF7(F*`)*LcJDUD!V#hBHgJJ#)psy$ip68FCPlV8cN*Z` z68vbZ;m^(l{Qx$vxXH%oyz!Zf{j>|G<@eJj#eHl$_fss6VZ@sCms2e8cV(pR`e4iS z;BG0nb*!WBPQfkRbT7Dd7Kz{|u@LCoE1WwmHuz&Lt!0wYY2&$8^q7Za4^1@$aO5-^ z3ogcK1%A^m2MlhK;@S|tK!arkC(F;1$NG@K%z|#^I zVJ%LOxGC42sTS}MW;J+bE!A<4rZy5vgM0Yz)WBE}i$L^)xsU+jjT8tTWgF?tvv59( zj!HXFc&I)r)Pq2q+D7h;L%F`3GY@&34{8%$b$}nV0`J)*M02VIOle9)>rlX9@*H?s z)&nT?jeyFnkjSMbu54PR6n8w3FUk3w+MxQ{>RB18-`|8GnW$*Wc< z(cdttKY<$W=5XjuwZLZ|1tM5P8wmXMUlZB~b;OG_y@c-g`7-PSgUd%-UrnFheWJ-9 zQ!@W~v}FG7YPDWmF4wZU%3}8DVQ-P5cQ5}AOB@CxJ;qm0X~nJubNA&TizWkZg(7a$ z)){zmmvfjO`8leO7>LmlYyxu*I3E`4G|%x?>K)3Y0(US~q#{^S;pomOC@DU2F5rZW zH`~eG6temN6dxYE7DF|EoZmNaEX2@_H=)F2m(ZVwI1j!tTLRi#D8a2P-6cDPT`iX% zIXNkfIdP5waYHSNVW=RkH!SdslweWHsfv4oQPzIknmoLp2g6Xalp=HCyLsqLBnMap z!`nGD&aR|iS=QuvDw$T8m?$ZFo89U?IbUANoIDw4zFn5vOoBYMQ8+4ux&xjts*`el4=R*( z2h~MjN_6kih3+;WVE6TPm3#DfX1T;NPtxiMe$*5RWX0N{5t#RM(Uuiu4U*G z^`{zb|Ms7+iU9W%9xesAyVlL=<7$2KWpmbV+WCG~Vl9-?=G>5w`H@bM)`FPZw@Pb5 z*^8eZYMsP_8Zf67;AS7r;-|%MY;=lnn*+-=y$(&3E8&H4}icVGx+$i~<)` zL9Cj`WJl562Swo+m=OC3aN6h)r(0wsc$5|5#d5n?U(V{~+*x#}!El7=D})0Bhnm}r zC`9xZ%AKK|2W2^AqUVeSV!V-BMu6gPvZTB09{?a5*pd4bc37hSc)-JDE3-(s%bi|y_8FC`qf*(fan9B6J02j7@s zgdR2F7*oqqCrFsxbz;|!Rk)1ZVtcgG=ui!YN#VQ1^$hwi7cxOx6cWS5)A4tQk53=| z`-AzvKlo#c<`;Jq%{R;I)o<9^q@7K?d-(&vAIjy2T;VgN6Fb(+kDVp(_ok2hyK2JN zN~fb=-&R}F@aa)j1P=W6^{>PetAF7;sVS7jaTR5iQJ%>6sY;-a2c+LATP;FPEcrP71KVh%7sdY3085#eRue3Gn>3x5OD!0=%xV zfe>5ui)K6>i$@P0Dp^?cap{Dj;{1pW+_J>dMUinl65dsv1U{exLzmxqD~mDvMHY^o zD&o+10*9PbA%qSH631kbuf7iy<%(tUlxAKrcp8I3u1kUBuDvMVFTTm=F4p(N_cfis^+`i<*n|NW86R+HFz~$@G4Q>o!%!|-hOeM7 z;2F+ij08_{Yh?UVMS|`l^MUj8WJAhJ>yEbc0-{m_;Y4C$iUq#xkz$omBp$Co=+U5- z5eS^_5Q5Eb8Aj?`d?!=&%4Lagx7vB&(;6wlk`Fjjiv+*oeMpgPUjvDZ1)sei>r^KguqINB;biP6&wsZWfU0(J(`+PxCnwb*d2l}8V$d0s>0Ld z_FA^EXl#@e`%!hqAJRdIy5141rxKAauhPZ#U8P}Lc!A99ZmT8q_T22l>p;&D2 z?y0rGP}*?duWBfGf$3r1{{Ad3Sd;+>e0aAMAM=mp_G+{Ib?NKq_=OPy&8W2^41;h8 z;HMVxE7M^f8s<&)=m+;&uqe*2#yhH21R4N^EtcE+dAYd#%}FKX{Dzy^s_SiLwKyo3x#t-8R=iDt z(8>TrAjR8ky4e8Z1pV~%*C}S;&|mC*SyDcw^udpph3&YX3m zl1k-DkGrupUeh@c9axCm!|{T7L>*G#I~y;;cznE9%?ol_b8|VrM@Z3Il7aT;U?|5M z<2B87#C1x#HuC1%#nocnDw%jJ93^6*#*K&_9(xV%inRtlz~A6)TcNwLe>F@YcR;+`w${^qr{RjC8v)APN%>s zM499Qoha=j$J=KzbO(D!%Xs|jrSF4t899DZCtyJ?aZwEgywIOgSthqK6hl-}$>m`P zG1-110os&u*_f07;6}|ObhvRe<8HQ*XIGq^LtufO^G9$Dm zfvB|5iB71EADiRYsm9LlMkExI$zoY{Jt++svjW(RM1QpBt~gl!^-6;A9lBibB8Gzq zW+=2OjlilpLijMs@xj#PBzr;x_lKOiV3LBiA6NrlQN$?)ci1)q3cyBJwHrr1!=gC0_o=Suq?vL-G+WiPPS_s; zysQ*F%C?bKD13J%D;)R$57!wAY`WD?G73Q^@Pf5@C}jZM5bx zffPX}G7@N_i*>Qwlk6UhT_Qat+J=FYQP%q0M^g=vdm-Vt^ z7~S|TU?2)9^Dh6fU6gqb9x`ecJCPxagQ77RgQR{M@T)Pv%7RM9fFGw*z~3E(8Gv{q zle;z>-@nl20ae0WMcEtM=0V0lkM4{1&5(jhHu*pAe0OL+}sw+6TtP? zRKQJgr2juK2H%!7!I|0|@YnnJ3AGfeBX31H*qsL5i3<2AP7=6s>FlWtGW)ps`sJhF zNg5BU_0i!_b+TAu^H+AV$b5*APL^jFjUsbe7r!piLW*8B0s7gK*8n?rudp*Ab+7C= zW#Pz$)9_{~Y|5%QcamU-S^EZesQ!We&`*FqId*(_%-~cB5&Y%Bqfq>dn$aHJ=I(>u{88~RCVRIB>C!DI4fksR)`1b9trfCs_OGG`fE1<=Xp+H!e8b=f@w7w3b0fo{EV-w@ zaO*$eDXumY$$`@eiy)U2$yNf6eIjN3j*lyy{*<7=o7YlFRLpaR@Bycc8F-f2iOK@L z;(fZ^=8t^0n;Yk*vN4EG!~>@j9wFDtcGi$^MEX;n;^;rw~24gINCL0l|7@@%U@>a7qaZpCxHjhXmuNpsfChY40%`C zwV-ir)v@qwc`bqN?CtG`4@Lrwf_;h)I?&HU6)#bl$J<7P$%W(SMJ>nQ-h+F9h2 z_42pb^Xm^HPgjnSoSQM~uKN1qpimCLU8(*~Mq(fe4RdN;>^PWa*65&1?+<=FkbPvY zefYwM83g!YtxI9V3}{oc0ca>2=w#F&^pAamP=m<^aZ(JfJEY%Jd%)eZKn)}Q)g17x zQ$QC2Tu|360!KNZ``hAX_F4vI`{2dzvh1MX;UG}HA_9XoC~%P(MrH$`x_585gFywt z;Z<}k0j>@VcsqrG7Ls9*@e#6ULjl`ge z74MO8;4KsaoH3C&3R+2NU@;(2Ld(Yz(1n%JorU1GwdW8@gm{jD+irE!MJqd%; zr9C5c)3dA9#o~jc^|$MFJB~aH%cAQDjZPd11e;^hxg)22e{j^qK}Sz(V&m)~G9YF) zbOWwxdUEXJ$Wt`}%C07SgFYNQdaOcXVPtlkMHoqeF|UbtNpYkfoWigneQ~@{iX=xz zr#LgfjSU9AFi}v~*$kf|2x>98Y2EP{yK7`z5FEd31`jWm;xJ^Tykcqe9ioSj;Q_W< zBK7Oy^C>P(G{!{XeyeDP{zZH-#Q<;P0;sfb0VbRj1IQ5c)P576%P11od1-S3e^p1J zcuYp2oCQl_F_hG!%$x40l;|O{JQ9-}Km4%O+Mx6@uD7eOCOY2U&>#frHYt}HQUtWGC6hhb1Vj~g8rbL9-WoI$ej8r7>LdjtSZcrQOFajd4zDX_U&EmqZ zuIiIeHopoWf_31YwRLEt{#DiyN26y>@F;VFi#f>Za7(NS4`VeAb;jX9;Ne|#K+7w^ z9HGOgMD(W1<4s(m)d?Iz7ZbmJiwCkG76R+-@2l&gM+HBqjRFE=5)lSpJELf#ux|n4 zVX+0bo4A9gI2gk4YrJSOiO{*!B}5vh^!;XgS#}@b6B-z3r}!UJc4Ne@%E0}ms)-2z)F5bEMd)wDMPt&SU`%!yL+3QBF!%ymjtXpu zSp`lT9S+0d33$<__dH)+%1SrY(uocTw86N52bf`mv;r5^K=6~@qeh$^iI$_}AqoU< zoIOQH9sZ|QB{s_53;~a_L^82@Df4xT;k~$MlnT{g42$8bBJtm^FIS7}g-nCF=uJ5N z``c$|LoO0OfIg?-z8n#O7i-4$ocL)U0k)Z9dwff^$hjU)=Hp4RKHDi-tsWaM(@&=9;n&YVqF}xL?1ti=!cg!w}Gn2G{Pb&&9fI zRusn#L;KrAj4Kx6D>TFTm&@(XSl@TODwn70%&BzJ9Lit-wKhk7H=5(V-ny7KwqM78 z@KcTnKqXtHELL$X>z6D)m0Q`6FJ_mNBaPnBAXBCw(T);$Ru#C6q`PBYs@K7-Vm-vV zQKE5rs>l9Oc5!)9&p+^!=+Ls117{?HzlL$uq#%Py3Z=(nap;wPs5M!mBN8~BoK*

&=XpXO6Yc<+qoCpy;zJeivi;NTebVLG=-J@Jyx^3DRRg%E= zk-+JMMCeA!NZ{oh5<1EB{ATrealQFaJx!01slLZ*j@)M(saG|Q>S6!GSe^RPex zT$jOd914R3fo>zfA(e9(3p0Da`htyaV7Hd$&?nYlpvgv!u!0B6Nwt-z% zaVed6feE3^aTsGvyC4u`NLJ0W^-8u3kYVStQ(PEKcc+nrTnDtQfgqRv3?re<^^F9l zlaX{?NMHqf5M(gjO_BLJ9MG6Lv<(i#nFkI{EcgNMA)8qatuIAxJ%JFRqm?YscuMZ$ zbV4SXE@k~=EHZfg<>%Y2FN6TnQPT*j*#;sLLLr%I8R}&J&~YF{BijUN@M5vOUf$d| zX~0#Z%@-b&ody=j|AoB>W^+I+DX?GpGj^nMl224AijlP1`pg73uI&FCRZ7Y%G`NgI%3!iJCQ3)R$Dm*ducYxpr#)}+3C^S=bAy0&+ zHsB$ukN9XlZ2V_b1qz!D6L5Mtvi88;jh z3IKu!HzdVuW%%@C$wpe7#aspN$H0uc_)s`fAn-CBAjkw-2lXO*jaQ59a`|cYyw>Vq;?Ndy|+oeh1t=FRj2X70_8{et?Bbp#cy zK1RU1jmhUKd}gV5+msMJK+_F>UXx-Ow9dZ3_^|v#+^*IsZ4lm=-e)p5!(M{>Yzq|E zaLi_kmvd(Nb#1%D%mOm62pq( zDp%lm0%F%x==I`UX0wA7n@^tu7=f?uh3^&M%?q_;`*)9NLe!79X@NX*Ml>dXexEQ>^c7E>IXPY$$7N6#-W zMJ*cz69)y|heAQU&=5DU!9fA&Oe8WCY9W)MIDY8aK(E#;u8-6Sx&w*uO3pBTxRH&^ zu|e@?-|ysbfVd@>ibKUA^ugVQgWAVr9PZyY8)qPAx51-aFVR3()`R{E^|s&wj=vTM zM~47|lSv#J9h3yHW+ldC7>*zL{krLcnf%f3WW#7DJV)KU53lH$fPH9Qt(WBxLx+GP z0uPl4VG1@rbgd2g`GEkQxo1Gx+g)NO6oNwHH_fb%(SuAozWLqJz(tr21T@O5A#}O5 zLEw8*AoXZ64Ti~0^p-?&Vhx}hLlKW`46+#bdM1lT{t5kUe=rJU*6zm8O?!hapa**P zO4d6rM&#q&O%8Bqs>nk%hH6Y*&gTBiUblzkT%DuC(O$PVtM%8#?Z>6eytwTxarEZz zafu^{SV}O<0e$!c%`P`~#h4i2=gB)}J@iW)@k_c2&@eZ(GwHjm0-Z8PQ*&Vak!A7V zVKG_f7%{hok7b7&{;rz90dgt7^yBSu=j02~3N!x`x&hPDFOWGus1HA?B{74*K&PEu z4*q>=#aP8*NXBDch0_*6$AwC02(9wRyT$E#_D()@xy*5=UX0rqIw54jhpOSovfzAV zMTy~?xBFmwQ&p53T{LhyivTi==4RZ`GB&;Qhw@-2rR!hhhLP#)_WC(K>d?3J7%fkc|E^t2jG$}#)TN13r1bmn ztJnt`0e7{EjRd~Cn<)( z>lhQ~qme(FSUWCl4Vc90|8&#ruI{58?X?~)Gm)AH`=nLUXWM!HY2Yb8nzNo3B>VCk7r+6GLqSYQc}#wvsVN-ka$~{mn>p9C?_~ zlcO0Pbh3xO3}z#~Qj+r!Ya)P_La!@mlGxDjs`f~U)CY^cI@puI)3Q6MGM ziT4NL;v%yM9I9I41+0Xwf9z*FWV>77rp$J-Sn@u1apACAJ*H`7F7$fWKxLx?eql<9 zXPY#HEEs2MgU~jE4cfY?(vVF)4jBq446a925{7Fkc^JybY=0}|<4V{+$yU{l5BPke zMlsPQ)HFi!ckJIxr0Km}256@Q8?fzzUEt?Gef|SqUfZx!Eg><~)*D!$Os$*zt$xY`Kx1qAo~Dh>oRJb}R0;@Xky>Mmm_AvnyA zl4YfA4cV7ek#tP4@QTfX*!N4>vHs0sE&Hl^bwspROG7_;gmWEpmb%!bhL05^hPXiU z3KiANh=+%d@oKhgW`Bc#{xpr_(EmrmUS9ak;`;VRx@R|jW4=4%hB*2jKQIUYSp|U( z!VCakEP$8V4XxX=bR5WjesroWqd$;9?y=Zhnq62tP3%4K+gG8Rj|H%O23diIiYN$(u;GwF= zot|iSoXRB`m?#l?mIy#gA!HF%A%slTi2*>*C7*g}@ z$Td4;2-P^eqs9=Ru9FAsSo!8cYX8!c;-~==MGuH~`VNX7KEE@X776o>9@!%L%1k~} zsafMtr+b z3vQ1d7h|n8!iU9c)Sr%n(2R^jphW7l*P?>TM$azX}{OJKxVV z^-JcF2Z{!uG@aNf!sR!NeU1E_4vjG%G5|%LP`^2tTBgLvAenApgD>lFkYx%!O2E;W zspE*@pm4+py(+k9j2QT3r&nbRic&I_34nr(>q6lu5eJFjJ(Ut66=t1CIvKBv;wg-N zib%9!(2tMz-V=s<&CLkaW4uCBBYs?bYef?Pa})xJ^vn6zPq$)M>u=Y8X8HJ07?UrV z!^r*_FE_VeP&@u{BYc<9C(@*9V9v`Q{sVu{wc}$jWNPi0>qnU(AcVBofq&NM`ou*K zMu)-k55p)dx>RA!r%z6cZgvSy*)nyGU z$*CqJ-O=d%HNgTTPmlr2Fa%jIf9;E>KI3qJ;MY?;r#2lr>1-r=&O197PLI{2L^$wy zTx6MXRU5(S6k3Mb2wp)cf;V&&dAq_UH{Xh`S6rX0M-EeNibD&s%Nh|VSUXSr z_0Ay)+SGP6y*J{RFgvYCPS&(S9&0$nu^ITZO&osQaGCfw7cy_d7t0X47!XcHc&I>x zfC_I`1A*(UGQp$CRidN?nv^p>o6rdz^df^m<;XGi_bcp0EyIn!6jdVds>Xm;q8Nlq z8D6i(faGOR$=9DQoV{^Mc##pS!0BWaA&|glQ8o~g421M2AmRFPx$;)whptf=?uxG4 zWXM**z<3WJj(l&MTSJjF%Vy!+C(a}gLUo2sZ)Kfa&PG&HLMmB1q}-Jae!F%bXm49B z@erc~E=na$cc!#F1(6z~BNA_*8RA8G7xJ%n-;!G`*AdlLF!@v%QFPS}mC!#77aNcuw ze-Q)%;3*C~$||W-9G_pUH&7ajyz#8sBpeE1w6jA2hkpw>@v4rMbLr50BI|u!uQs#u&$pdv8Rt*V@${Vi zan@VP{>mBIc#HPHAsDie5?|6jhx!;==G;j&aG4b7&rf|R-Sw@Q6B`IFt0ileWDy-a zrD|2tx5A&92PZjgpB29M5s3=GInpfL`LCt65nh+EFvabBDNC>G>MGthTp0RWO%5CQN)BV9&yN|ro^$_ccl zetJO`fZhakBApEdpYj(q5}Zj`1Q(XEz(o!V87?zBm!TrR%Dg(q3YYcay-YnE5W$Jz z%$R}T{B%+{jOfI87m|WtWe`GFEUrsHbjKfqISvS0)@F5cvnb}Mz!FE@c^FoQH!~#g z8b%5A8K4AsH64ktQX+Ua!JEf^HrfL-o|yk)q@`?6^|8!$oL+)H$(P_z%_7vwaQzq? zSoECkJIZ3nh(x4fftm%rU}8hJDui$4*dQ|!WW?#s&DHX&4{3bgD}GTU(PsmYGdAF- zRfvo8K9-{mXWFxs_hF*~{AxS4&TaJMAK{;ZFjhx2Vg`A{i4uyk|3rU=Q1C zDFZk*IG^d*z(Zw&^gowjz6bGqX0xk z;FW6Q$c!+t1Q`0qT!|P%AZ1efb-V7`+o-GioXd)$vXP@7_Uj~~Z5VwXpq0i0{raxy z?r`uPBPi%8a)8)TCiSTNdBuS^4IV$TXbMM}1G1Xx#~Id?U41EbH^mQX9ynzPJ6wasTbKiyVm_MgLRXs}c zW8b6HUE~){v~L2nFxc7h#6AZ+dp?YR<4b+v&1w`f2>T8vd{}HNdZ^(mQI!X}c;z4k zHmcHmoQYFh(+T%b2!dhC(u}gc6>^=hBw^c85vO*}*G5BmfS1>>c5=@5@X)V=@5Wa0 z&UaboQ7}(%O>w~MI(PM6rW4-G-pk~rVyHF2Hq!)Emq8dz zOBsRIrT{j~(aAv2B(mQ=yOLO5Y5;GSi?ts$ht?Yq_-!hW;86JxD(1LtZ5-Ns&_Pvu zG99{mk~0qQNIdezAbfy?L^tEb%Q;HOe2gu}N-frb6ri4AL4#0I;0+9mPy)b>Yb>&9 zC@Pb&IJB`pu^h6SWrS`dHl8)}pb)P&w?c>?w#9;_O#pCzba!Dh|nsI^cuQJ`8a{hZmQH~DE zE`!u^W|8_?R3LC&LZX}V2R=OA{LH;$FnYyBG5Ex_O*l$~;bQm*H6{4v?lYov*R{VR zC%ja4bA5_tmP%O$@lvL1RcjL9vYHZrF@+VoMD|%8G@@wMJ_f<>#Zo7Q_f$5(;vz2+ zf0P$^*TjpE^y9Ufk;IGTb|K3{)_twM7(_l)CK7U9TvSs-HR2v>k%n2QTBt_gc0n$O zGNVG_#3JUtqyxo*pk!hosNygkXCJsvZ6EkyCPf+Lr*M9^9;NyF2e4rI2Mze|^6vxu z@W1}s|DApJzh%s`G*piMZKH?ZogDpgv^YFI4KtQbMthWog@z~XA_Dq$G7Nm_W}lK@ zOBlLtb&umr0>9dos%NhM43iMeDpXZmhVj^2h08FGcz-9Ck8LXfi>ERf$}wx137m8? z^eH(}EXJ%schhGd9kYhEnV$}>HNUBVQhy_j?7I8IUoN6Z- zT=ToJTLil@4Gnx}i>`TS*;Xip;8d-V{C;$w3e4n?vaF6Cl3o)-s)z>Ow21~Pgx_ZG zWKr@9-=#zwtlg)>A}|AR*HEaosHZn6ukujc%w{?;Xakmh@%^j$mo=Bd}p|&1nX+5=V z>l6sQe2ODNq@97lmvVy9+gt`OKI%Y2pbbT;r85KJXfZ`P%ZZKJ2@f#waa?UC$^}j* zxd`zk8m5#8NOX3KV1cSe0)U!N3HxT?*|mXWB=E~UvaiGWu`(u5Vs|8tLJo>wDiS;@ z0xIczt~L+>UbRx-YZ?$?MVU4w^y}ZlHp;+~yrO3E##tl?mf8i*7#j||@PHXIFjgWX#nOo2^qMbzEhGVqI03J3sYSUm)>RsHFBKtyP_pq1MR{VTwIyY?c<&YQ11Me{gcB zr7x=s;bA&t$ozS}^5Kb2-M8=-H&R;m!ds4#O5ts9xhsfbif+k2qwyEmm|x8m!ecPt z(dMgc)lyu%cLlvbfXRd+K&Y}wW+)Yb48V6Wz@;{mnz+c>CA+p>FIJy^UKXX}9Y#$B zdBQiZb(*gnV>*-U;Y;R*7$@|C;rzk;qzH4fnexJn$gl&W0)kd2w-pB2X0fK#da+)w zzs=rnSD&StzJRr)jxJ}cl&C7^53!5`1g~lQz)v;%aY3&BF{gkPAbLRtq`TZNn(Q2T zf9L7rZbXA;IfnfG%W84OE!h_ol>~=#U--xt^t;e51iHB1_<<)>p&etf=^0SzzT666 zgv?PRU072iAb}TcMl{c{$L!hdc3IXA51kvsL+ifq(7E9B6Pz+6aComl=&1;%!b!uU zD~mQ#0)aO+8;RXbcq0V@RCbiWzRS;UKP`&sg?M1?%Sa7P0)sPm=Fvof4Vcb{UZ@}F zkS)x-hl3$>Hf0#_N)84Y7J;&QJ<1XvxP}7Xp&i%Y31%8jDFD!)LWlrGnA(R%rsytM z23}4H!J{mi94_-_A$zj>qPkNEw6N}U>*qXwBqPdkw|J=uQ+0yd$Xo~ryx&NOe|a?oemGh;es{H6FD{p|;=*b%d-Slk3*Ebye=lQemV#30xSZ~c_BSiXoc(FvABLEM z28|UERG!d!RTps^NquuzFt`9MgQ$e&(c zc~fj%RKZ|zX8SI-J{heXv))`s3z`BjoE)o|4xJztPAX&>hq4ON53q+VXVgdF?M)fy zA@u`%h69eWGNvt5pDwl^%T=#^)wFFIN11-apO4Dg@`~a_xk>Jy^_r%o^NH|iXUa`7uUrnsG$gla zUm~;dYq;O;yf_N66kt+20i2E(@3nJbakE~^2IVg8^7TTrs0JfM5xA%ZgI|xrp<&h3 zBGEx_S^^C%+eq7k9tF9;2WiR$$DW_xY(6f1uH{GDIzr&l=0!(_p97CdDHM*$ASBLf zia{jlK7wsTp}=V~j<`o*779|s3FmtGN#?@W!L{#@Cjy#>6BiAsf>7Y;H6i%jA|cdd zvO~=c=@cf?0!CJ>k|#}wEh8)NO3Dhnhck|MG>$i$F9j)ZkqIW6SQ|!2xN!R#2W>LT zRdRk0l}KZ96aq>OIkCG)9EM?z83!I^PUueDlgB26@ob=6jRRkoe9)+AvTfXN`g1qN z#(Oy`oG&kBdZUzMwo91~?{xCcL?Z+fZ8qSq8cXQWWEAeVIh~CEK$A9>8lmZ}db+H! ze6?7vWw`il;W+Wmb+UoK_L2=B+gBC!VbeBA?56BLefR($Ek*vj4om0$K*mda%%s`0 zC=zpS@-(<$ANr@NjtLbN+4q1Jdj_16;~M#Efj!4Hk8H6|tBc^uM&!>(+*}x*l_GyO zy`f5o#_S`^M<*f!y4pH32z=e?WuXxA)7sg7MZz`TO3m7QG_4cz%C|s*)&)o zsx~CQ6M_)Xq1^@n?w^EG4%Ky$#?vLD+yzSwj1oZ{@5CT1V1k!0eZ*15;7w=qZC5nL z18arYDbL9Up;kZHAnr$m00Q2j2|{P*={6Jaz0DW`6M$JQ3d(!1SJ5B_xQQ=_+%@*N z7tWDfnG7Qu8OMjv7FyvM$$?&QryWj)F9CKJ#i?P#LL+)`Id2LYh-`I zEsZ2&FnI%Nw5IJV@M2~jc!=?VuS=h)M^hz2sX{Jj%LhJX42BA9#f4ovR9YL6<8h-r z*eT=9?cb9Jr9@I=CisaRbDRkqPoqIb00E%vO&M~SKeIpOaTtgHXtY0Nubo3!_35Nk z_>9fo6pr^X13*A+2Ea}h3l&DH!~=&rwVzTJAFE@ayi_UGkq%!mV}NqBQYyTQc}x0= zw010PH@N}aI#qgjY$Y!;-@=S9cnLpJ2@f(AhEs5?9-Y^PC~Gz?oVoG7kGnW^X4QJkJA> z>Zr9+bj>3G@ndg~2(ZhbphZ;uCn1_{L%|m&C17ED^c!^Nx&|oP;dC6UhL$u1GcB>* z+B5`Ds!0KS?u@7L(@G`C=IMop`%gvaCs@QKyV1^05p7CPFjOT%qKVdzSqG>%of6q8 zs7&xKyGPdjeF=kQ^!5yKD4>C+l{{1w!fJrPwssmy0)${AC`^kj@nYJqsE`bm-i(-q zmU5vvj*w^Jt<*kvlo`?7GXoKt8HPi`@gaDPHXkw)dNe(nDAs$MNQbV&2mnmqG6OG? z1)|KidRu0^yV@+TSHEFxcXr}di`l+=`2&=0n3{2lLT^fV%F$y$yP5C!m5mUwqV8@DJ7*6YxozPRjMmJ*^**5g$?WfPOn9Z{2^2dj) zT{j+)`S?FDQ-1MfsL+ieG2*%-8`Ojy8+KirA%%XGLdBsVXk62UW97Bwc7`>`3N-La zh6bQ)METv7D)7_FeeW65%^wzP91~NbkMH7Rx^5Rze?I_HB#X5!-1>GQ%ke=h8bjv* zV(qy4!7UzOKxp&fxJE=`v>srK7OD5Ry;HCm)8*om zHx0afl2AFUEh9uSK*um}mT_MU4i4=@D+F#nKE=d2jJ`&MerCLqY6Oq6WxU0Lo&Q)| zZ#)bjUJZkj%P`d#DAzEky8snNTn+tZ`Tp*NZI{tK7ux5%DE!hvBdY zV-9epmIgdeqp5!x7GYFv#sY8Tib674Oh#MJWO7PDiZ%}Tt8rqd@LsI}cCjZ8$?Bs* z@^-tZLqFpSIHXbd?_@ina%pP^g)1f~5Pm3>CGMHW_ zXv!i_vJGNqWBQ-YpF*&QWb2Td$+xpDVAsyJoKylj0Qbzc9{D|WA8RZL zI?O@YBCNDMHk1#XA7t6qLy*V@Qy$_D7GC4eX}}&^ZeN|AQOkksZ!eJ1m41flfE}ZNw+A`m@2EuK0-YnK4lP;3nVS-M`FMw+uKRAD( zsO+Q;`m5Z^aw8dL`cq3n^WZk{HqC_Vh0IEkmGIW9GOFY(Frx~7Yhfi1RV+i9&`|>y znStm?Jy3biUX^kuJ~w``S|Os$G@=3e1M@(1chRUKM>Be~l;5f7b@XhJi{PHt2-DJ<#|c;*yd zI3S>*#tR(Y=|o54?4n$l1%s-S9Vl<1AmEGB?K(D5)s0Qamd zBP^Byh#R7rx$s91XVtYxG6)Bciv4WaQ=3d9qDOf98V*2e zF6A(URcLsP2T-~fBYKMgC^rUi&B?mb0;dxg!8Y)sP1|_C`6TO3%kn(yrJn=uXDi{i z#tf3AshK!aBZ0pv5_;5hAtSb-r^d%@we2E~Tf_64PUG3_rA%<0J>4$wU);<>4E&;2 z2d9%ejoQklp+{2@7`m4C&Nf1aLI#3I*<*0!?Q1Dle)G|U(@0!jD?}As=UA2@uT*uf z7oV0;_V1qDtQXfei`mP?*UnA}Pu{=AC&&>lZ8Al;yUt0W$2T^*5Z5jBbfT)wuVEi% zFsp+h>DTG#5RzZ~JcMGagu@5G#bO#g%y&AmO$F3G*^8kDdQ`-?ct<7YF%NA7mDeNK zb^;&oo?_h59tC_ng8_{+hn3}t#)OI*yIby~#K~W~lx;VPh!;91)(vUq zLAD7*D;3uD8h@(l0=|q)sjB9ugc=E6&ENoAj3WB(_bHs+YnlAG$P<-{FyQMrX2=E- zOY!9r@@w~G>RFJhYCn#qCO^JYAvqh$p2=W#&}t=aat1}kQ6dd1Q7fVQO|Cpl!bUTi zuKd~NV)o4 z9SKm0LkMqik>P+>to?`lvEx4YA={I-qE+mH!%-kawh1DVgBnePUt^2a4_IH)p#j8d zQV^G>Vc`0j6nL^41{{llp?}QvqG3T614NmWzxSg@enfJ1rMxbSLQyoKy&Sg$2%D93 z+Kov9)FJ7k(jQ;UrfkqtsL?x7NGfllfIIj!V}9fV>_;p*(p%_FGY<|<=R57l=HhFz z!mnmnBoEjAqRq$+~s2b}C3hJE)edcv(W>sHGcylDi&Wt?%BgbW1U*)igW ztrRLQH?yBMoAq`TR(676)LsJjN=bRyzvA$~q2a-|W`>17?!k+4ce*SOyq&X;Br|Fs z06*DBNG!5G;39`cs-OR`2y4MPB=FRv95}SDgb-N6x6~#=zjmKwvxI{DYQ@!&8F**I zqQ4+~Wg;?!OZFsNV)ZlUHSy5eYvRWSMW`0y*|m}I)ro}CqbZs>KG6CUEy35Pit%i& z457dbhB7kZGi*yny=<4#f0Z@yHrwA11YHGowYzF76OBuLTZN`SH>gMCGSt84EIu^(O0sRP%;oPQn zBXH?RlO_B<#rKT7s7rpwWi&+G_<-}BGJWKA=@G+!8e+BM^66nQ4;zG0Wh&<-&{L^O zL)xqs%9b1KF1)7>Chg&P(q4Fv$JIU?53_=xHGHZa&Wn-wwh0_=5_CCwZJah?j@w1x zO_Y&PRu{pH^&qfU$N++cS`_2cpVBOWVhspjQb73r?fCXiPV`(i;m+cGkdmV+>FGm) z1{IJrs>OZ=vcrPBv52n30*KdGWCPKosS{; z3&%pa#QFb)H(Fv$tOQqFUuPJQbB@(`B~v@U{k+_sZ?0Dt?Q;3~^C$QUc~}mMf}MC8 zpR!pmXJ53D04AB@Y1T9~o+gLeG`K5vnwR?v)1)+>)|zP!%pcj}nWm9h9m;q*OGCN8 zFxqF|oq>@RH=Oy;M@Qx0N3|)a0pJsjU@&3|VV>_H?=n#wV|_GB0^ZJvqis9>a>=6@(!jXj5Vgj_zn{C5B@|Z{^&$IRsp{$^+cFL*swR3}2b(`{qJM zmadk5d~GM5Mw64L2%QLcJ0k}$Hxr?MqlIWBG1+mJ$(D_(1-hhNb`@Dr)i`iEdCt(C zlGPG#=ivB$A#)nfS06w5ZRmV20wuBMC3%)QZp+}P`(L-W)MjVD} zSY`xpb&N=L(RWv}9g**A2AgXroD1D4ir`ly6pRR`YsE=#c_Z3gX2nRwJdgq)HiIdQ zx0e1C*|)OTg|0IM11&RB1oHq!wRz+`V+4u29BCO+I$aK)7$(E5utZGcD9Dr7a_76DLxmFhgibcji9ERka z|JW|di78GYC=05Uczl}-ZH3_LYFLF2H{C2sg~$N~1t(iY^cgs9WH<~RNtq0IIj0Z` zMBEs`S7OM53WzWu2am3$G6R8|>;Xit%U}W!fe~yz(@sK?8G$Vczs=4!K_BpiYsbnt!GNAVMYG9nh*OTKp;a0IaWqnE09;#n9(}PDxe&1;~tFTOa7~Co~(OL^y4%u|W zo^Hv~9=vZ-C3zr-cqCRbra+DlV>p^O*OG|&1L3r5PXjv)hF0@5&RI>3zQ>r-f z9;eiS1*#lq$aYbgh~n7Zb6`E*gd&IZkv3kOl9B zcT!I9D5D`W5I9`u=~_~sa-oJJJgt^2hev<|20R9bhIo@>nsW0Lt%v|!;_O5sDZCm8 zK4yyRLT5q-10T>C$g`#Nddn2At(26Ubo-*IGmt(IPA_ng8Auk*5g_i8i_}Of8mehD z&=`qq;zFKXIL;TJX0j35$8v^B2Mq$F{R;g)CcJL)A#$h%^$|4GJ*f9kTgu$ubxOh* z5`h?`L#w;(ds!Y%_MX02Ui%HeJQ8@jx|b=`i@@DF#=}!9B=nEDOFp-v?MK{smInwb zH3Og5sb{|M&e$JqYG#6%aawgZ`T1LIG(yCSi^kC4i>r7>H1fz&~D*L3$|+IMa#zyY?Z0*mCwSvZB(5L8qrFi%RYz8#SQ1&%JkcROUK_GK0bZ; z?+@nx{$Rhpg`dM9{GUhr7HmUoS=|d0Z#n_?^Y>`8>sNrur2soj_XU635w?>AcnuRr zTQrmbwlf3cLiq*TL!}PpkNg^mF1Xg!a-82hE!HLA>NIKzWpIr)s2Z>|oPukv0AimT z2$%@6Ad-UX(LM#Vua*Iu-^(a!PXx-XQ{7s40NSZQR74j!#PJwe3eZ#+IXsnB2xhMr zD=Cf@p@WaD@%8G8Y20!eQf6@AX_dEh`PLLV9QV=;6~}>65e%F*U5qb z>-D$U`|axU?Zro5N%xyapmBFPOgy6I2L7rJQ+0o;I364q%a$;+)vi}N9MCv;{J;;a zWr~x~*i|UM-z;a(Za*!`qA74St8qx6J!Uk)S<<^26llNkLMcFGRLxJzO;Dgpw_{+Fb@Al#lNMLE)IJlWBL5y$0(9VPMN! z6?Co=`C|2RS(d`(qco`F>E+FKvyzV_<7fOLHh;gqTrI8_vv-RN>%*&Nm;U|jvofrG zfDe$u+Fk3$_>D0Ud`VHQ5|G}CQqoE8?pVZT{?M0=IY`{Rchsje7S}S}9N3kSE#+C$ ze!O^!Y}s-H9%_^#TPMi#(c$N~&`?0j4Fwft2DW>0u^bWMhM%iE<>)2tuUb3pFd%|* zLGb(97^V|wyr-c7U^SLwAh3r#m0f-88&Eoo zvjG7^a@?T|L=v>@^W}2;b90$S=d6f;iWE>y(Oj5Kh#TNjKKRDBh)BpAB1DFR1fkI3Sm28 z5F;1-$g*A>Wy`>Bkx%L|WT3WTfWxF2IMlEuScOwchk+AH`Q;u)(Hm`y$N2~@jTcab za5iximUF_lYDRERx8Fn{ep+nN7wO30qglrWG}4d=0UX*~n*=58uDCu&X<81{A7vdZ zlN=SAR&BH&+sEAj`f#8SARTS8G{qz^LRAngFfedvra?vf*M)LHCh=lQi69TU<<a*+)@ayX0${_&))@}p0GFF6%8F#S)A7T&t=nae5Nh9LkUs)q~lr=&I;$Pp$!d4eo zvOInn)S<<-R?<*ZCqitG>uc+1>V!d(=|5D%+r{z}B~)EXyMYmc+iV$u74M~UO?psf z=QoS%FF)UI{rpj^Qwg9@|JZJ2Nl51}eaW0+pwdW{R7VkpTr=peg&~Iy0M!|;Mp}4{C4yijv6$0M-6ohosk&juH>3y?Cdy>L#B~Yz&CY{QvwJv zk@w5RhoTbU6Ad=Kst|_Y0T+#-03PlUQkF>uLEXJf8q+PnuT%iB90>20;$0;Fmd!1H zEtWmU18Xi&GMWJ;o=~GeaU&PlfaxLBk##1kS&&dIt2ihVPdwI)BJNR060}NFx-;MT zr`3(mFYrWz0c@|;A#6YffNB_&0-&(!Ce^`sk=1bc;_a+6RUZ`!x}n_(5htkN;YtV| zWtn`v{DQ3-&ojxSk;od?9-K5x?N%sAGD5){Ww$Y0 zS9y*8B3A(p*vD3S8CO3q7q`DTN9qz!{KSZXMj0HT!?mrI+Hw#>k0!f~KVawS5LRTV z;8A9VY}qLLsJy%li^l@}nis@Gg(3j)CkaJawguW6U*d7jebVnJ9dO1(qQCD}kjw9v z+s!8l$FEj5%d6$WdryZ0?renMq2eGV+cM?AB62cVw(3@Sz4;=gzz@r{j4PIu|Feu9 zZI2mx{p1Yoae+TrnF9ZNcCHXOO80z(o3T`;mpV-=*2X{OO=+r(+TDiHkl{=j|;?U4%_F(pSJh}%K-rLj)hnD={R@G2S1tv$iW1-AYDq-!|jTxdJ za7xwf`ksdsE1@t70FSbHzPgn(`0Yye9A4cP10wJ!Gf>J?74i377|h6^(6k3iMY)~s z$;$+YQSvlT9_JW z_Pki+;N8hn7BC$ z@*?FK&M6=WNO^|$j-#^^oDJX+RdB6g_Ea0_FN%j3^I2BuE%CGzMFmHJA2y??r!ok? zIcUjQ1e%th!J!obLYE^xjWGhS7#12wf)IN~lqV059TyHYpvL`_6 z$q?7qLZJZAbIAD)Deej=k8SI5B?i^E6+jHPsp82viwW;)jsr)T7ZOl@6*SH^8$Ybg zu>!v|q2Qs4X6TM}nh7eHW@c94mmMg^?4ztxW&7amcGHRAKk!OT$^22~J~y@|cR)DB zM03r11i{2bwNPYE>%DwOX&ZR+ zDLo6_X?>Kk&op%JPf0IKP~xjDKN#(r9?KNfQBtLSK*!2yXd ztqQSzn-~;WqCs()9^v*nnl!k}=9NY)8WwovLSm9vc zp_)s80iVCN4_tqry7578^lJUB-XW+Fg^HBidibjqR_^}yA z2xLI~+HI&gKwU?G7!sAv$eF`KUnt8ygLKPaIFZ1a1jMdITsqI8EXkennbw`5r|D})_Yr^?@T?NQSQx<%RV0G@c)rDy^cUOP z>t9MZ{89z@wc)`-tC;OF!7UrezJl2sg&VNwkRlXD*!tE0J6MN|JT1c8c2tKiY?cwG z@8C?$2)^fCE@SwT9YP#G@HSCcw11ED#52#*^9wm}eppht^Re$%kMU66s_4j_q|=wnA=IdkwV4 zC?VNz8R(~Y{?F`Hxd;nB$%;~An@KD#wz4dww2bx8_UNtiIC_htl~RsTj@|R4vOk$R4NqthcFSauhE%HmLNB!Szd zk50d6?58DI)I|RGk__C~V8Cyxx|rfI*%}@m`&lgBpvh3?qb~#G61WS@I_?mkDrK*x_(x1cT>I9b(dj zkJZ%4AD16Kh}(RBwJb)n`8f)}&wQpsBg7E6s0IU%)#!T9l&c)Jq^Si$Gh&;0(GMz* zgWJrs0JWUMc)d86nHoT1^XYS-Mmw;?JG3({G~2+y*EK82%-Ao0$lp6wO-Z4QMkjy> zJxusfGuz^N!#|*#>9X6&gdf+O2pJbHsyTr#pq$tbhJ#+>NwQ@WMnGz)C^8JVsA9vOntA_GZ2j(6P}SMS^UKTjYENy$z=vpOT#gZ-fkBZO zK?9#&ig_;kj=Yb#8rV$nr!9}$~ z0G>OG5i!74jUBwg!I3Sxt|F0B&z;R9E}8%kRVeU&jutwV=h=4o6^diMj!;DlF>tvd zfqNJwq8pVnwMYP;JCPXkqGdIL-iPsZU_{o`D)Ec~HvI)D0VEv^mRSw_gXoMqs!3as$QPRa5vLJYyD4vxo-T79o=uMylQUZcqcnF70>$?jam`T)4P z<^uj|T-d2Hh3l0IdNeh>RRYx_--sE&>n+3Hr&NO(;A&*Ov7&{F*9vwV}-`A3)4ae(_K%iV}4~{AOymKrY zg}IyZ_czO9^K*(LQ^>X-R>_`1oqgcvgB)Fs?T4v)h@Xk5_3&^$2!qpH1r0G}K6%>U5W7^wJ!( z$#o)-U1}3JlVX>U`DP#jEwCK^%UhYbv|TOz!1GRl)Y(h$*`P~}1V18?!1<1|8Z(e? z=1YuS7?&(bp}=z!6k!+uJ$0)n_GJC5EPwUn5_^=&&l@AA=&Gw4KnUaTVg>|Eq6+O5 zk|rg_fJk9#ESd+Uh`|d^-w8zEgvM}hW%Rj^XJOT~`QJ#4%Kn*Nr>JS zB9tG;hh#oAA3|>{8{gu?Tdd^z4_WuBpaY&W3PTV}e1I{>u^$ZiGbm)#?{*u99C zRGs8e_8QMGW##?xI}a$D8gk(l?H^kDv`1EF}X@ zC!6Sob3oJu^iO4-M46k@Dh0XT1Kc@<7C6-0KSZ>S5lzETSSAZZ8PY2RLyx61j8Z6f z!U7jLEY5W@pDgoRvO=yJwT$2~91b`%fxw}XLXRfnklLrD$T$$zj6>URc1IuJ*A4>N zJadaV;_p^BH({%#CJOkuu^|kw#hKbPG74!$8x0rPH< z5KUkqgBhPM%6?S5yBPp3uRX$HkV1T&S_IVe0hbFBA`h~2>kK>T1x&nq*28?C%1QRS z(V#0%716Ey5>pQRFj~KvlnWNnjzo`gsD-OHIJ3}p1B^X`g~47}^& z7J@F~R5NPA9sn}DJdU_%SH{ss10t{jU#Mn@np>a2}%_wU>Y;7#bmlY@?x;0W|jQGAT#kWS!*w zGA|BJZMuqr0TWMHgibWPl45}-I`epidgz`VES%V{Gbk|cN@w|U1O@fClbfS zI+1Smb+whjVML|C=>$cv5CXv5iUi4d#rvyU!Q$y+Rg%KjUuYLqvK_h;*{_qFsJw?c z4?Ooz$t(zRCPh1ljKkBiPJmsG5SV`=tBh_gK9>Fih?;589ux&Y*j7xuRSg2JR}lEt zZJoHQ3RPwm**bOuB8=X|kD8VtJq4nd=NGrKETA(DTwhCs!yyPJuCE1?FHOUs)VFcq zm+Xwbxc>~sxOGal3vwgdh4iyu%>KUkb+O%C`z@y(BhbhcW8qM9OzAo*Luy2@b(g_r zdxLeaWJfPCy_xJ3`+IMJt9L*A2uxh(0bV-AxI1?qK#S~?xZsXUOer_#XiqQ39hO+r z7*~aD5Tb+mLq84URCNlzz&6szS3W8>#^VA!Dp^I0ONVN149`k2?gKR4i0ETnt{s$2 zl7nA*F)n;UZK2tD>GD)VO1uju&k{Yv&FU;I{%t#q1!9~v`wsKHJsp*m(Xp}_eL6k{e*szqi6o^fXf zYj0xhBsn`kZw zh@w6_|NTq%h^&Z=%&hKeNIGVtQ3+LDRq5s7amgF3ycP)DW(o$lerpyqLIXLq&q$%} zstounuKk#tQ?EpT_pTY>TAzBA%7`B%(nW1~B5%0;XKucIQO?CUzBgJ$f4fkLQ9}+R~$gyIv{&G1xOS|iqK@$f= z)>zhclY*2vYHSb#s1+tm2ndnz|*!fwN~p z>l6+AzK*6tA;S3)9BQ5=>BN>iYs^IM6ixTH&|1dt8AV`3 z8w33HzbBOJx(vLMGYBb0J;x57KDWeGb@TC8ZGII?YUEZGkljM6vscMmcXvm41unRt z4xGPmEtk%;8(wf&qKfW^eL5JG&>5_ z16?p)yFslS)Qjw7tVAAqj#tkH2qI?o;W3$hqmdnZ#cHKC7)HF-w$ev%;ug@*;7z1r zK!ejcybFnrsT5l7*!g<#adqBEb$qWMeo_Z_p%jFRYCQPHqy<|s-HVr#2wkL0YW15N6NRJ@b8u7JghG)MjG?3a|XUHTp`AKN)7oTA3tE!lEnM{xEPLD;*Wqy#5 z0qP%ZBUcE-HsC3<6Awe_3<(~Y6HmS32>Ks=xVT;a<3$>4weWRxeuZp3>F&x6Vl(u7 zb?T)+Eo(+P6zO){h>Bqx?+v9nE>NMOP%;D`ONB~Q@Uj_|zz>{i^5gOM)B~7$L^s9G zqCUvO+bbG)yedhs6r35e6g+>Qx=<1Cc5yI3H7QO{Qy>n*pb5052?Y06dAIodq3~$< zinT{`I0T0d+SWLjg33|TOrnAcWcIB~1>HwLxgo+71wpvHGdW<_bLZmIyZqx1nw-=vpuP(lp2_bk; zn+R^8QV|L!Z7}!==~U%tDi~%xqy*YHfe~Tq4qib-f=A{wizs9~2TV(ro;rgC_^oSVLUBt?^~~*oF2f?BAh+eE+3z3eNvG)oD_+fYS3u4u3c~`t@jWcpNLphocqbx0kE+;$oRf9;?Od!Tnyo z@%H&oFvua_cnFu2(~TW#$n3G#?~kZSBL}w$^RbH^NMyIE>edxQ4~ya0q6AE*V;%Ya zsjmjG@F}WLW*hjK(1BGjbp&j}7}1#m={+K;0M+Sd-SabLv)04hcJ4W}}Mn&1i)U4{^CXEJ#Jn7{$B zG8~~B9HOw zP*8yc2Hag?=vNQXBnJaG=T75sKNTZ0fLfN+bXdpMA=hva;7}o;;%%eEsDhsO_0X(b zMHsh15G%BZE1$SmJsSOOc7D`xs@y1HX{0#1A_|(BBv!7(<%nnf6~xL$|J% zX+?OvkGfHpWl;yjXE-A4lvo%Fax@u*p}fn)!X$yWGkX{!kGcfWt;GZ+-g3#W*PE|C z*F@8m3v9Ze0Bg!&Ry97u#j;gl{qY8SJI|gh*Eg$kKBt;>`1t2Dd<6?~L7yDt?pjml z&}Zc&FjIBX&=xG>8ueNe5^J>x?_gN&yfYxX*bD4bJ_T+nU99e_oa$aU@>Lj~Hlkdp zoH{HX>Ut$kk-`2P$9eGC*V&74sb#fcN@$DMbwMs}n$WP|W2pBC1Y*N>dR`c(juL5D z=MW!Oyo>_`sL%{_d1P8G>oj1$BWInRf+@bW5;IOG!l^ohF@L2b7~0^#7*na^qDDx_ zn*pwcg@ObC&GAd9A>&Pi4m>g>UM{iQ(d+Z)NwGW@POzPk;t7gH*jyI3t$85;kjA)6 zr(QaI&|dMlz=OGn;6a9&X+%75I^z-QA;ye=$I~q8O;b!CaZUMh<=dohz3q)G=hFpwOe+ggGb&jQm^Qxrw5u{2m8cD2bu;~2IkcK z;42dhVG6;JKbme>LpuD(QM_cx=FjA45E#3Um z-_nYAZ*D(+>_FN+U?t0011Im3XSh+jC7!{*oDCW$Afep%m# zP7lOU41V(9{-I0))c6{wMG%TQI`m0cz{ckORQ`v4a6jYo5Vy&GVAoYm098gI9ae=> zHHP8U$7G;eBc-gE2^{2bqKXpY6gIPipap5F5~AuiW%lofAm9gE%V9vc_K*B<^b1nw zo$eUQ{Q-2wFN1VoY)FiFhPV*CL4i-^Wbx5@`TOkI)yE`@K7iy_44EZ{1?a6D2^|V( zb&Z91ge|ec7%9rJm0}1x%VHk{!eJ59`-67}v!}OLesPy}kboa%BPrK*LAqW8;G`j) z@8nlw0QAik%P4Kt6@9OVEkqA{c715f`TX2wt(g+6=K~1JgvE4#^8!D{En{f zu+2;Cy!d-A<_Ib90dpSFjh^v>P8t|ArbUnbSg-u%!oCcHUu;by(8L-IVFPSgaGA`D z>;__1Ns}{?Jjh9x0AbGZhyKd%!8#mU=Tp2!eHJ| z7{R;jo?gdcduWM-PdqZMe70siyV_V7ysK4$fHYCS8AZW`QB*aF9@6=J97b7;!%bQs z3_2rZ09dLIVY&`psEI=wp|x!7xs6*X4s3kYi4xf0aKNFujlT>Bp~c`fj5QSy-K+|) z>2-3wSY4+L>A!xy{aQ}WaFlRRplR80lraR()P{kdN@OiZQw?MI)O*=Q7X=c-%!0eG zCqi7_HNBK{uIffgi*e2#VOO`+W_I@Fwlh8B>`~d1ba)SfpA)@uycE!E=6Ot!^gBSS za)v`arESiIp3N^|aJR>T%!_%qr__8}C?D%$x`PJ~{9usY@|7I4(@6B#ay3Nw1oci# zCzO73MsUjIukgiwycF=M*~l22AP5{y494QQZtsb7_YRhsrXBm?Vsy4DQO6;KflUhn z!EmF_8G8KNhRH}nw0ci0PKsroI7CO(I%1J0=ZZ+-b7m-lebOphGmvE< zsm`WzVSZ<|LO`l42~|LJSJt#J+n~TsPkQq{5F%0*#O$uu{lVr0#iS}Nho7>4={qS$ z7K7YsG6Y~-%7g0_3p_)GLJ)vC@iR`xA~RpGa2<>Rj1b%68)RC99whuwECi%=&g+*n zSLb!AgIq4Z6)~Md0=HH1z_-uZQMxWXpk{@%{|-TZ&SC@!Y7e!NrsqQ2?%2v$127=a zEC)o|Fa!JPrk!NJrQH&pfpnsL+(@AaU9D{>Of1Aynz|W%2T0{-_Lb!je2ra#JKRNi z5py0|MyqF$%K0kI#db(IPQW)PCrA&8aD!4fAez=8t!n}?=0JMGV;CJ7CwL3dOPo;v z4!b20Lg7W?*RZ<5en|Ag}k337uUXC380*f)6z&1R&mH zz812JTVAu4-&k`A-1MebnCGKZ-VHZ{zPp}Q6M9@mc5|6Lb4grgT z5^aHSj7afj*_Y&^`oFV7DQV8g68XO@zFwxDbBtPhe4BPjO=GhXgw?3EU(O!m@589I zv0MWfv~vy52Ed%fff0}-8{#^slekaf#tkVQoj+`5v4`YaZ)bKZ~T}B-!m63H(T;+VdHyFah`aB(gKH43y@W5raO%i z3e7ozFG20g1WsoxLU2h0hy^ZkF%^S|dRcHJX|?+VqUtz;VB#ay%#dO!-`p990AvOt zd9D$FI zKN?Miz656!z(YYWqrmy;QN%$RNm&|Bbd3iG-M)mFh2!h0zrc|RW$IN)29d(4UsuZ_ zo`NH&`QYRsq#2G5c$gv~?S~l%F(%WY*S{pTF^GeCU@;4vR(0qP&%!G^DBf>Ary;(t z(;%&Ke-XzCw5*OSLn$4ktA)~#z+?B|M45F869#=TPPDZlE)dVAx17b(+lw@XZiFB(283UiD@kKY8^GuP}tS#mwWKCuO*g!9q&5PFj(K zxAJB9J=9bO;~G|#)96-WKs!AzwnBesZcA%sc4axSk|T4(N{i^0QLm~Mo~0hj&pn1D zW+#nH^b5>KhfINTqlW1)z!&x*KFvzoFXyaPCr5szC&rjlN8ZQD$L727F`P)f+ob(e zWBB4nli~V0tPO6`pG~|Ne{4fGUEOf6ZKa3{Ddo`U` zTHa`VF?)P4`)8^cI!pDl5S*zJnr1IB&L}frzH@n zCfqT$#g`K-0x@1LS2vew_>jk;Q#3^rvt$Kg0O}eDi)ZlDJ$%bZ_JpDwV2RJ!EFM#Dsu2IE zTN|Q{mTuX0~Ay?;Q3xJ4~9)`BoEBXXuJSm3kgxGs2eBG3wHo?Tq5mW{be4h=^LJVDV2aUIUogph_qBODquZC4-~ z^&Z7g5p$lrhXK(hM2zdqEC`1Y;^`{wBlvoirfn@_q>o1`E6@aW9u9}V3cQ%&fQKk6 zr1ii-5NT@V7!GC5L+jc-@jDE~5WG!OCesE;pVC~EwD$$BkolfyYHb$egm{av%C7?e zhm~32kJCj`uwj9aH`u-Lq5OegH{Io{4L<+uEUn~PPC>yh>c|#<&2FOXX2ch+ErD;n ztq);@0WPv23gpr5D0I8vaUbU(9;e9u_4(7yRoW?|O#(K&8ZZ?mr{SV83aqS{tS(^i0q(E~RN?;BQ&_Kb!lOqR#FWQrG zgM<)oft#qu3?TzPn5qS?S85mzQYmTotHtsQZNRPLl>0@hgqvxb8B0XNwBm<2KBr5L z*SbRJi_P`L!jD7XF29NheqA#o7z^57`%nB-j72R3B#Fi{5<{3BQ8@_kL}nay^9pjr zyy(mCY5AJhi}OiU(vVZ&8`LO}#xcW+C|FY^!xHFB33`=tu@<|ozenM5sKek5nv%h6 zv)X2hY5u5@1Ta8s1p|%AE;SwgiIfnd81fV|kD+i?X+>N&*0chz>9m5Q*U}K3KUT#K z%($v{Bu*@XX#nRM2l>8uaW-LkpK~t0icXjdA+ZbxT9;seGdbH1^%vtpu!3 z))L279S5m@>f7Qr?PHW8+;eeC)tH#qKgI14K%N}o?%ZqOoE9QFwMW?iR@7-iL_@wg zuXX&eSg@2KqbN1~oAL4B!Cbb;5>EC8;4?Il4?kDe;kh^g3 zMrIgop^o!x@gpGxKACe?Y1gmS$Jz5uits%Uh{$Uoa2Hc5zp6D%qK;ss&0Cz+wg_f^ zSoECWN$p;PoDPUWpatr+;&>23z#1`b=D@(ZB;RLmQ#b5+(SZUY)w+!zD;mLR;aiTO zF`^aQ(8ygQ;=V16+1*G&IA>ts77mQJi`(_=Z7O?wEk*!vK%s(xU(_Lf0D~@H(ZCO~ z14)NsBztCm^ZViuG~p2d2CkWb9GvQY8Wk_%p3^{6j3huIt2n(|e!ohijlG%pja2Ya z6%67c0Yd0b!Xs*CSfykFGiV6Tm6rSIx*kSB#+0Qj9C|wmC1kve`cfQOa3gzg{}W?{ z3N*l_+D`D-Y$qYs#}jHeq-FS&eD&!u?y!C&(?5%G0}?S6#_22>0gA4EGS2%kjTQ1y zu5%+43Gt{7hX4cat}x*G%0fn1LHX~DNGNw2ve<&MYzETtAfYeCjDxf=GCV>z!tB-R zYq_^DIIUc87~s*$g`8@Q{<{+fJ1=NOt$d9Yojvt=qKiF$?gjh;H87-whUEW-8RyWBlVy->yy-GEnK6{U5595;#S)tCUMmg0N zX3#9AAA=`q1}@X!pT$$m$>DZ=%#2yB0nhRCwNA?MNumW18LqG6>V*fVT4vQ$1I!m$ zD8?uCs_AUHG9S{DGYvdYsXu33P!;tn-oelHbugd}Y6)&X0C5+S1MD0hsl&u$B#;s) z%t7?WlZJr@<{)qj=ODOT$*aZc^M_@bYiw1K?<+THh5$JR$R>>~M9&a1zO{$3*;2)=`W< zaO1Tm;1SX*p+*M#8jByu@#*nHj*!Gs z1OX~VdYluA$PGNL6F-2uf(7p8Eak;!nO3{{ypS~%YQMp@SMfuCEC#Mu#V}&*Ya_*Y zEsGy^){Fi?rJxtj(pr$SC%4zjazui!9Xmb%%(jK#OdUuW5I8@5Oony6FrJj=gAecw zjt>X-b@3mO3dnS(L)SF$y&N65GUn^W<>uPQlc2eJ6t=zMLof?)Y|Jd2PykjxVvE6G zC!P$NDXj+%gw-^2q=w#2K7(2On`4w3!?pavfNd=Lwt==*wn6KjE)nH8d{?asSVWD$ zX(dIRl0Yi7hOWKeq;-^^r1{?;l5je?bk4L5MW6*9P`gsT@V0KIFCTh=JxuXpKR5`d@=yw${5B1`~hvs)FaCzr`( z&fcVj=!?xVKw=dL{8U3u9%?^D8A;$wEfDytU?7~B9ATD5VLHhhn?4XL(MX)h8d>(N z;1!x2kc@lvp`5!1HjN^XSWu=~n%7iaE5m4}WO7sHWE|eZSI9ZfuH7rtGyN2B(^;R) zD*gIK`dutkA0n0B`bNHc<&;_{-7CD4eUgI*I(tDr3sWNbE=A4*#gUJ~4w#{L#qkeb zA=d=)QL>}vJknmuvn`JE10#f`R!AR{rd;}~Ql8zlDHaLwc!7Wn4cb%GThxjCB}5Qzg(aIQ8N@lvk3q-8!zXeXiwI`x2pxq;Sjo- z09Gy8cps5$334Y(cF%c>c$?64YXbckA4obFdQ&pC5+VQr;A#T_`ga1N3~q%5;1}h_ zOr!0)4nurzA`!UInxBJ9>gb-vA*r#a{#}wB{f%A7!I@x3miIA5%3&^0Y9i?`hH%6M^#)9Kqec*onrd#AWDK^ z5WK_kKG(}{MX?yIu6clFC=UVvxW48Ao^%%;G!r}C)Hu*~3Ze0AGUJ2L_>oCjxN;PN zdcatoQT`WpAkFWExfu6HJCNQizs>$*lO|lfyh`IM+8s!5{^KP;v<{?^wPL}5W(N|- zq$vZSnK_p-*Eq+YwEzgZ_{!H{$Xfl9ODzJLpA;jt7?HB=%P%v=4f`LO(1=%xF3V>{gpP(~D z0+L=!WMPyzdFZ!Db&D49_J+tnEzPde!!=}@hrkg(R8HW?6f%vZO*7T7n$@Q??;p0J z$#-XW5Zp)s3E`sy1oDyrk+y+Lr1SKOXqibkdPFetnvnvAiytExcqIV?7dbG}_!CUV zNShCqV-7lN34>eNWrP_Sctq_pga^O^$;loa2J>S1BDV`8Ma2;#6HKrG@|hT+QceU~ z-s9EgHtoUq^R?eD#1|d#jkAQ{aNDpXd@bdKq}G7p&sGeQ&B4&kE@Qo+ONl3!Y1_p# zqw~#jvG!9j{0J@lxDiH$Fam(pl;9gn0VbW_gA$qbl2lNP={DmCdv4JUsqtD)Aks=87ipE$IL95YTtndH z;ZG}*TMpHpm(!zz0Aent6bO8C6^M{)qiLd*G$=oc|E4Yt?mEjYQ4cl=c(>LGv5Z=sQm z-RMCvr1ltB3N4G?0zX2E{!12GkdBfZ!x3=p&<2?@_@iq$!5`JybZ386ZuaI%U?SJn z{@kyy)ophf`S0cR)$E_^C1xNvQg*tx9WedL7>FK}5PV;%^qv7si1mpqsSuIqm&b!Z zp$ScadcM5=&|IYzLZ&QX`>URl&{F_|Qc?i+9N4BqiS$R}+HGoG7KhzvF|m<>7&IRt zh1tXp$DtBno;zqY${>%fE|P{6p4%^4gqCRx<46(8g1Bvs1pX>W0I5A(_wjw70Xy@+ zo45pcBmwMCF{VJ6+e-VtrHz7T?^jj zBL-#(EAX1?z~ihG{7?)87r9{O@%8tF#4jl$PURD)70!X<)7C+LaNv#=cvfW}`?5lP zLDk0^kZ9XRoV~`j(}m-89SUjH-m9Bg8XuL`Y`rM$1K?+OVnE>W>P$igj59SOr1{8p zL_H_hM~+YZ)^Ac*pk`8oyV(w{TR9Oof1^>f0-Cd%v~c9?>}K_4akcp^f#P`KeF#CQ zgfsXMU|!?F&qoUp;b`J9(7Q9}Iwy8Q4nj;w@JOc^{Q^l`+6r$aR)U*3esIWf>QhPk ztUD|aDAYa#KWzuO+n^9onoyA6osn}x;I&VON;m0&aybOjtj6WlIarbQ1pIJ&?bBeq zx8i`qItvb3fs4i{u^$csQ5Yn}TbXt6n#zTSzIIay9+}%93w~T&U!_Hj91ZY{y7~C6 z(x6`hz(p#RVh2zN{BgPiHNU7@iM!AocETW(3h|q!zc{A;CL6!`0%a;!4(wzOh*LIgKq#t{h7+Gri> zprYYGz^85-2F|ER;O=S{kR$;Cf1K_ohxOcq4!j-NK%$vdM2W!Zt;tnDp|{UCT9)NA z9o7L;unauA4w#G%ax_^W%1PZ_B>H2rj=GT(l_Eq=^$z1sD%*?*(=EW$8V8Yu{UfJ? z!?`%a$Osb57;%sbHR3bS#10|wz0_^u$Z+UwFphiG@l)S4@MdE`>}eXu4}6ko`apge z5YaSnI_H?(^+Ab=A;E$6af9)#dtxSQaWa1>Q7=Em zLn9<#(=jqhlvuDx6dx_LEc;F@u0P_T#`S)REcqtI9mdhwM>A5=9prw>FvXuT2wI8zcy=9OqT43xA)zS)|I3 zLxMemH56W<`cR5R<@*GcccyL$|*f&ntX}&cqiS@La{AubL!>1#{0X z(gH45=bx_1#k^cN=Lq3!BTT+=gunw-B@Bo^nGn2PS0tQiL>!C{6i&n84K|Vfcj`3p zc7gY=>44j-S%hTIq2ROZY>|n^fDnbVbL(KN5kj?%hZl^s< zGs{ap;7K(S_ze3A1c^M|FnZhLL_TEiB0%6%XQ>QM!+<~wozr-n#$lumMXt{BrR-K@ z)o)ZScgl5)7JC{;9s(vVRJbrvExY+nKtoooP3wf}FeZ(w+Hy(3kS_P&Hh^~RHl+D@ z^ZkG@cOXaz8E`*5&&eeNaiIjxC?&d#AU8}Q@>T$E(-iwO1i=MWAoHkkB(G797}Kog z@9aW39qmFnTby4nJ}=YI(Amqp_Gz`6*V&^dXthhV0ChXn0tuR_7CRu61khJ?72IQ2 zRMM~J#V_ba-t!Z7I#W*`_@enK$f>yo)yC=M!=q!z1?EUXhBDPc>m+z!*qmpz`%%=m zb1n(PW>gL5qp230t0DlH6al_3Q>{Ith6fLPACmPT2@n=X<|L#J8ba_y1E7}(a`0~X z@naf1`u=ix>)oXvU_cS5!pNO!<@l*ELE?wW{xTQ)G`Ap!SSJohm~d2nq8~Sq6s8JP z#EXkUW3!w#;1x3v!BMdJw2nZDG~Oa*-tW`?4}R{2gP?62 z!B>K-wXdX-Nl$Y+zeg8JUW!U=gZyfBp^S7Kgt66Ze5(M#dCWhrKP;~=!dO-Zg|iJO zpF1Vq!ht(vS;wcoG`H8%c1K|hj)8%OIpgTfY35Vw*uh~DMlIqAweP_7BAKEXlO^-C zz`}e7K{n4hK_~E$#d(6s4vL>|(u5q$L;2zhQym~^Dk2df*MgJ$3+$uZE@v+wf*0-T zgjDFBrs>TPoFTeM$4Ur*UptQALvi~W2Yxr|gd9yKL@v9DPEdBJ6X5mMkb39!ak0wb z%k{F{5Tz{-REnnS#F;S!fY5ZMG^%SD!G`agRrDc%tvYkS$kiEEzAO@Me6?B@reeU4 zMHa}>R2E3Iz0bJ3ZemGm2;o!OPX6W(X9IZI(Z*MuN0z=Y%lZFiKU}431|RE(rzt2| zq#1yV-{>8;KT zlW#V}Xa^@pKE6LSZBo}|SLTwkgtZ*P(#mg~GLe+pmE>2~gmz~M!sWTzLorqwe+ACI zD+%OP7+}j)F>v2lwp@yq@KBS8q&ca6XMcaf1-+Hg@@(;W_I7z4rc`@i2!`Z04wrry zi?>xEaQ#+iZGE`yd4lsJKgHaQ5F^7343jY-15Rr|8|Pf$vx&zJXuR9Vo_~+mi}O!q z>BDzBqKTO+I25rCVJ*IuasxP2kl@iBvEBwr>9Q=ejr7RZ)%kBwExe!rf~Gmmews#9 zf0{jCq!7l3_^iyTaFG-hKSK8bZd-$4N#6(uW z_Ulac%iXC=N|p#U4ntQXnyYZ&D&>ZN0F9B#x1@b+iYp8q4AoG~0jhtZO69QZ&K94@$uF_H!&Z}+T9W#XbcynUEhNz2m{#mPPjy8Hgs+X@r>YtFqPculPPfLH8VLMUWK_8@ zd`(Y_VTMIpMza<~OX1DUQbOM=9++9t#e%4qp`f;wY#!Cl(5Zs=s!1VKpjZ%; zsS&Sjz09cBjDr{(At=9s0L~~G4#R{_lL)+5;XrQI%U@?_=a<*Z&&kE$tVCb9ux11r zYjwl2FF^v_zp^XgFf8lzaI`Do(M^gLZWhTse(OZrkKTu9yO@ko4%tG>+x-aOx)Q(# z+x%owArmsRtzj^H(FM8GBIuK2A6`AQU_vJ**p&}-_=b?7yTvvPN@59iALMMmn2v!K zZ++yvRaXTY!kp~0eR7al*2tX^lil7NNB{1N< zy+v%&jQ3UAbiT2a(J>yUMu88NF~Xrn5+TZTkpu{&px}|BlRlEb1qq*_F{W^xxr-;g zMSOt&*4jv%k6;=R5Rq*ef2n#KeaKB+sG`gO2A-gX;=qt*Ln$S|nyi$)zIf5h0nUT| zN&umfj2{X&@NSM9@2}H-rYQ+YGkuHhCID8`0?k!gggP>At3ZH8$_jE>vh(!Ej-^oV zyZw${E5tN_E9qt~Bg7Cerfehu2%`jE(*f}^t?!;@e6K}u63=z@EC}hG*Olf?Of{htQe{1a+Nf{x6Mx1@QO>4g`KYVZz#P(j;5J} zJD7!&QHD~+20U-8OvX@(mcSe%h(ntH|Ld=_SFnta*oe#_u{ER&rE~`b4l6zgB$N42 zc1Mdm4iV}uR?){I=);S&PRPs6)%n6N2LS@ARRFr$c?NfZi)yPdI_#+pc}SL6g`uz; z8$zE7ex%V9jx5XKMj($DHz~Y!L;&|{2yhb>h5!MYSVO=!rA6!qL9__oWkRP)s7@IM z!6II5(tQ6vHZvWtGzEv93NnU+98ETeAt$FW;O(UV!P}WZ;KhHfa;z>Bh)2nUv^`E7 z^^L2P3OH12;Gu+)Ro{Z9m zeNhalxV&0o30tY0 zWb1LF<>*0NM6^QX7}wWeh)MvA5o6f~#)BfncPpL|Y7=jBcB&WYm2!|D2F;*JO)&C^ z+n*Po%HHuq@V{1ZSe%MU=!nCa8W6x#)lKD(Rt^|bkKUwP-ovoqEhh}$Pnf(vF)wl zWXX{))6%Wif9x_?1kZ1Wc0joX!jw}WnH;Pda89xrJLgmZD7J!(>K;(rH&8nDe|{{9bmyLgQrgq}XQTCb>`+PS z`Cs@jOUy>hf$uPa>Br6bBCS)LmT$XB)p0EMxRJ6~HH_)UvtQ73OE{Q2z#;PHbpXWL1^Qm%VKMUL#GishQ%&@@bHKhrU8VBWid-bx>Kl>oW`1C zCN@J20F+ZrM2pk_?lbG}B^-EMZ4c%sL?L#<07mC`oIffCOH_&A4!6 zaYI_z`eTYE)9|m{)*jC8MhKNKtvr$t{+?2Gj2&(Te z;vgp2dlL;EmA_nkEJ{P2-V`)iX%a`N_(i|a9<>i~nRf+b7{wx`5z>v+*u8k%ACr!^ zb^JJ6FPC4wr^Ti>-#tIP;W!V9A1fjun83GEOTl4PHXTt5+IJ^4?=G8)mvX^`(+Hf& zNk+)aajMA+3_*U(wGy7B|4*Gv&Q$zNPX~o3N9jZXQY{*0Dr91g$dRX6>gH1VyBK3TJjw_R)!ox*g#mP1=(>85wnfJh!@N2&F2(z zT&`}Gm&=7$3E$@k^y-u&xDh-=O#|0gDzRtEQFgAldIY|UV?_+KJuSLJxB?t7kn1#c zW%XgXxc%Mh1SC$WL2;fAMOs_EQ9@veGtmsqpO&Jc0qWx#3oazB5`$93<3sc zYLx(jsuHQwu}nBn-bz#Js}6?0apnT6`T8l)0JTnzP7+4?nG5)CsXAbh`r(oCP6ktn z(%b3zLr=?x7S!klSa#)u`!Xd@Lwt|5n@V>gZ zMKsVzHIjbF8;qnqWr3B6S~L1a(hl%UGlU>J(L#P?Z9FWhM-#)F{^l}xjAKM|j6SXz zMPXuqHvt8S3JrzcK6yJSMIQyckwc+5X`_t-{+gqVvM7L8s>2FtJ0t?X+@rIlbREQJ z_b@l~HnG_)seHQZO;mvC)m)%TNExvztWTM!uwPyMC`?rNFj`lCzF`KFMi!rcTBg|- zsXZ%>5Wbix%ukDX!D0a*mW1z?_8pw+ zU>~iFAaD_VEW&H1_F5~$YvuTwP1jG3pJs0W@+kAi*FAzBk9mhXL=I&knJo}s$>7W& zuz*Z3FbIB#K{jw~*2&&&(wZh|%ch0 zW1&MiLc!ICc;`Mba5`fV243P+lNhg--_p`1uR=ZDmqoxSH5;@iTTSUN@EH^dJW7cn z?Wb9%Kknf#%EeWwHzWmbY(VtqYs3L7T^yb-J}sA@XFsnO|9ShZ=#A}E4V{sMnF@G@ zVgZ6E7BuR+q~w3XkglUJRe^Rv7m62kF~qyY`pe}kC0~=5kqj9*o>21w2uU6~;zC9( zaomM$j?DCwOXF>?J~loP6wgX@ry<8z9E@W{mC_3GyQGA(tIrm&<16%nhstCd5FOTPPb9O1B493!{k9WuT0BoTo;q%fqP8`yhs}d+_lC*nzg?{2t?FK z-fH(;D}++kd>&cz)5d&Pzoof-803>W+={7fxU|LqEmaJvX$zX&RJ{skOU{l-8)~G* zOU^b|tMhi|bN1{JnmlAaEZgVAXV(>xsOk-$Mec}Yl28)n>Y-&eL&ze`qyf5t*>l}7 zLppjMSV+Sm4BkLbciJL))k zfO@MrO2|K47j4t|?ta#T*K!h-Mp`b`7qjQf#y-@}Wzj4p^}$DOTPSW_Tc~{gL0a}p zeU9(>WY}%COX$pR^&R+eH=03%93uZGZ77j?0Fw(}T&*@g8+XA@V)i5&b14)|UO63vaGJmwR$M3xSkp4Z&eEy2S%( zM*L+!;GLXa($`f%-BAF6?u&9sILwjdSv_x4tpA1HMWqyos$HNdbwm?FTRfrm9-^1f z2}$QgC`1~qQ`$7I)Ae>zl+9fCidK)Dc@#6>s42>es1HU#*qF`yhir3p<+bolp+G)n>!kk)|xpZWNQ!-uE$|8Z~rk9&VkztZ_=ztZCk z2FA^vEY~-^w>T+gYMe3} zr6uSvediw!Wqg;&0k8ER(} zV(IO=M|Tr0JkJG7gI|^AqiH!h2qj{(2YeQ%hH0E_+A-iPO@_V+OXar(5kFUGf+FC0 z#R3=Q8W5gb4OWsrTEsL4#)G3`WR5@pGYhFi^bI(zXdHz;XJXJQm_JT6kW>N*6S+DC zVh=?K5*!w2s$v0(2^4bFbPn5WV?Lh?T8x#f@IXk-Q}UWRjt)TJN8%+2iN#8AlCv}` zA*~r%%vo`TLHsrw3=W&sQBZQsK=9Z-D#T@BkZAr1o-$x?cD}i}NlP4El=z^0ls;5@FEsUnCs(M$^OTely#XzKzr zux>w%S8Bt10+0vnO0?w4ExYSNoWTWlH-jdbmGO90%x3f6gUy%J!OKGED*$yA3j9E2 z0b(Ikpf&H|F3N=wct4s09V;DH*#{V&?*bj?Q_zNS#Q2_LeV3Iwok{My-t zhkA42Q3! zE*x*GzWR_YS8t6EuEGpQqtu(z4D}0sg`xSiukg6qV@Ydqt+pG7WRZtph)^WSkxNZ` z4iEiw3=3p~`wsK3fqB-bKuK^+AmEV&vu_u->)G4%mA@7n-8g}wDOOzsp{oQ9sI{7s zNt3^R)#;&^+sLBPO8PN}32_%?N<75mh8 zHfKjG6^h`v929s~mF(gC9yw0Q3*xzZjuSgf*mNm?1Q62nzwfCYw!H04B_s!`s`yUv z9DXWva2UuRE%zUa7-}DQRX+%%>`J7ONi7K1nb(Spz!S51bZ6P(qdG>&SeWOVv_zga zj&=`PpAcwaEt&$sVAyTjh}pmV$V9UY>=;-y)4t(8;x;@OA@?)Yq~9>Dc!Vm*?9~c$ zOm31%D`q2CD1t!2}wA>X?h*A1=c^rQ6_K~r1?*djN0K9i#x@Z%L7InGux+&C?A zd%arvjT8JDio~I^mQWG^<~1ZnkUhn-xB4?(RNqo?I)f1`h4w+&2w-roXpT^$O_iQCsW7&QcuCN;)9Y913OaW45q#gL4FvN(Tjc=*v%LG7L#v~2F zxY#ZjXieLLI6mMa^&nyx5R5%>D8)ipFhpv`2SQnu3J-%_7zQMT>4a2}-z~pirNyE= z3V2{$D58NhYlV&tcvuxujG(YhDDLD-<9>>U1dj}fyl7-x_;)K1JDCOG`4cOKcz1Cf za%5(aX;Zn55M`1FEpcGH{d)6hS@y5tIiq~2a=;F6?Sq-7LBHG)_)p~J} z2A5o}7PANUwGX+Py!EzPe;MAjoq__FW(s=jbOHHM)&+hrrW}501mTB^t3v)I=Hou| zvF}J2>twsH!&QV3?Bf%EQKX=Zn1A@R5dus! zMvNoC@Obm#!}qjKdpTgKlZW=Hfcw`}pe^5}t0g-J!GX3#D&R%DNOYsBxFUdwM8M(6 zdignJDq8!NPquQ#=B`w5oy;0w{cz5SHJ0OjI z4;-pH=Pu$x&G|@?eUKWh77=$}XfJk`IK0P?E4C_Rwb=N<{bK!JpxBCdK{u5wTCEN% z^U{PnXNl&qroQZ3=taDE^IEc5UJ)4f4)RX?mMg4VHJMoz%mx5{IPTUDfs*rH982|T zu}TBaivr^IRi6&~dWCP6S&rdA8qY@2^*1Qm3V#r{ckIwhBdWmx{olF~u6eBH9O@=L_xGLy0GIc<@3C@W#jy zd^**NB?7d_kpoNLKE3_CD28DBg&P2++6_c{Yjo#`VWABkx=*BA5(BpuE1{wo5Md%0 zBp?$b=r>-e8QVNdL+oZxZm*Z+((ztF94!cn2uLWhLl$dV@XhJSC~$2P*+z@9cIK80 zk7(qwtC$IzoY4r&hNDG-242gt;-{~x#bt8qo6n2Fp8?t0p*dcJ`nuCk{In8`z2)<$ zkWVOq5QCI6Vnhq^ScD2Y{YI;Zmc|yPseO%T&##Q;xPdmSl>}~p1!LUccWiTGEXXN& zK~tNM0|f)YI|wC!m7~P_O)9WINh?@a5l%Q2qkzS~&I!fSrr3Akl4TKsu9fVRd ziRAtu;KiCCa5V1g#pUMOcemhawN>D+ZMAefKx-=qaDET9EQ4LK1mu;xo!JDbB+`I0 zDh+Ygj!6UB;dqdGT5e{Kmm%}PooWd1SA`(eM#@N6gW12cpq%D}jBK&-YV&pWC=Hfc zFVp%xY4sZMh*g07>QNZe#DOB602?SaE6R+dRSOU)WMzakX@D&z!IVdB!UCZo*KJSZ zJGt-W@d14ft>IW$VK*u_^y3O-LWrWG45y}Eli@?2wc)-xo{__A7MI049@F}jKUG1Q z@?R^WfiNM-5R9y4r63#{2I4G+3!{s0QDv+un@#Y@m&rb^&RZS=XsKDy7DOD0mEaRb zHsN~31COYbVFZsc50L``4Jb_=BOSVvpJT-kKNLpLZyFS``tUEC>zhlzSD7D|jFu@? z@Z+|x#5>l^5SxIg?Hf4+D9l^pt#&FC^>dA&l#jn(rz#OAFW}>7)zBvz_(3)r9IDNf zOMw9+MFNM)2^`)n1??gsrZN~vC?kV{Ih+i!11R1k#mhz7z5Vm-(T9uM^*>%DNnQAX zES=%|_}1n;{ESbWsjb8i!F$}fuH{9Y~(1UTzHRWXqmfOUfrIT zITu=1`w)jjpa%F*TZbWm^M9gskaK1oAr;4CbA%a2Ef^9!G8gjb;K{)(b-5I)fjJa# zsH%y!v^Bz^fWyi__}c9>V_P0xj)SD7O-MCDPc>eyshJ$u_4@qBr60Wyq-riW6sm%< zi)yQS^4sL4vFk*thb>m?+2i%%k6zUK_UCu7PFGe&yK~gL>qvgYR!U8@L_Z4iXbpO) zG4ff&*Sld9!!|Dx^ir6LsI>zBVjD-t_zV*Mm7C5UBjs{tiWFW7!5 znm8yzSsmBc%n%X)3gHMtfBEvp4Ev(JuIgS76mM@fVmA^)!RZW0P*0-<-o_9s=2H@MQ`^iy4Awl!^u3 zzmEQ^xHrePe`S4n9tJF@@L;6A{L|INYH_ugyyQKQFa)-fm7|; zGNe!`!2ZiD4yFz#_yYULLosaOA@4#ORO{uHLzNGq_F@l3VVQl~qLZwM4>2|xmp?eU zE+W8Dx>*o8^Q{+TI}Gr9g+Q7OQE=`;u^7Z{ESj1Z8}GP2Sh0xV9-(LknyVbd@*!HP z2;j*4=DSopd^En$Dt@cBfakXb0nN*7NQa69tKfHvEAO<=WJCe4-;AVwS$t2czRcdQ zzG9@A4=dZ60HiYxA(8@G3Ix8s0-=RuaDo}r^kkzfq)PV!ZYS0;P@)}1MIg|sCJ@h; z*B{cF`Rnxx8^q(P+zXSA)l|Htq`!7>KtNl22>e#!YoW$u4>6?Yl73pt%Hf2T# z+{l?l+MM_*?N`0T#Ay!$T9p+e9jaO2#|lH}YQY0)vj9f~1-}1uGITeg;himD7$)0F zynwe+frv-|K4C;a;_0`=_p2qAnq4nezCYT>473LkPj4D!7lV@s9I9pDdcoqq!!Tlg z0sNYVA^FAG&FahIYV%uKKh3kEEfTa7$vt;s1sP1S+|zB8VYM64#XB1-+8WW{Nr6^k zF5}61l{)9sAcf1t^+h=}na`~41JBPgQF6lBhvNkPDx8p`$tsb17^QQ86k`Cv+Zhls zp2q1MPj@Rb_^eJT9$$Y?p5qs6C2;=9kplXrNU-^pb;Kf7y1v#+LqarTG7=>xD8EEP zFd5uNe^N^vrOoEEL=}O+VtPL=uCJEG7;Tqj!@~Susg@VS^aM za4Ta&+blvc2EP`8;E`EHO1YO;X%frX&Eo3ohudr4FO5rUE&xBXigMhFhVfM~{g=hp z%jA+URsZpA+Q1=s=X959_{cA3kMVa4@$cb#=MaC#LOKhY`YG@gRj^$l{g_29`50=c z#;9RFm6SsycK4O^L%)9hLw;dW^N3E-zRSTw9fv1Qth?$b-cdfyArCcjVbilF0S2WY ziy?~t@n|U>O{<-_ndXQS-`2}B*U5F&n2BJYQK@h`d-87P4@jL-{g|fUwL&}GOYuRQ z>QFzFka2x&p?u-Hbb|KQgyxNn4P!_ITV?xOgDsN>OWVq)^}Eu}P{pocF1&-y)=&gT zjwjU2z)%00@Q!yjEZT|{JA=D0yjUg_UN6>Zsuk{(Lw%=Kl&H#cg<246vP=vh z;Q7<50QQ~LHgFf}!)_pS3&(`Rbo=$<>h>lrFShZE*`eLFVB^6m82zLV7v-c6uS}EJ z4}u|j7X&CcqL8?;(ZHZmg-oY&7!$@w7#HxKP8{--)Hv@BUsREBWWa6ONI(l~agcx( zJ{LFXkYSrv9vvN#@PdYAz!3WpG;mtcI1YmYfM`4ENg>_4v~$44uUPA2yKzuAC7g*9 zxY6Jm5K~L%JQN#qp+nB!8GzX<8%GD47ey3$I6&e;pd+ju`@v^(e3f+L<8dj5KA$FNG(n21UqF=#Qa^ z4#beavm6pnQ`WP*nmt{7FB}LSq(D$8#DO>)30*5~Af#OY!llD(gYR@3cIWO4*Ese; z=AlRh?uoY<5e=Nq5*ji=d?4XPu#s2G6qSelHny)7l{`rq`df(qH})#b?~V2ACitmc;&D=P z;+~O0hj5rJ#medv?>Md!RxBDm6s2u|nVBCLjjdo=yWljTLK6{W!Y z_pl$UpX!AMX1?H1gNuIXjmIe>l9hu@`;K2f>CJp2_xc3E=?q6mODUENE$B|nou*kn zm~Ni_^`DDWZg(E_2v^n~72mFd2RkBbpK7jT0!3&GPBzMMEY4_ncf*9fxr#1g=!qW* zJMbK5FK^P0ZnHP5-;2D|yAd{DTq@Y7NQ7}LxP4a8beIJ+9sYOMRfCnV^`r$F<8a^z z_BX4~Y2~e3-xGx|SaSmHRU|@`1rF7WkdHeA0@Ee5WCOj?gyghas30xOHd26fg~2QT zPQ8*>X~z~HX2Ia=D9Zs6$~I_nO$l+100KaDGPAL8bI4KHA!owL8=F-eSB45ynh z+9VHJImj@Ke^IP8?)#zG`YPNEBmeM#ni1j=?!bt0>!8pkT5tS79-VF~@_P+qI8VmgOFDYE`#zu;^RE9+b@EcJ|9+`2x+oZKnez`2S zD?zJAt)g0W(8ab@x&7(#>bJD<>YLk-AA65|ZCwON`di!6B8?l#o{FU6&3;*Gd|_qz=#J1MG_&oIddD&od%vM7*3#rS6Mg zC65wt{KHEq|6mMRof*?9o2!7=X%ud&D41#PyY}C_So@F5&Pn^B1tV#old1m5^v0v*BzffrKDHWQq#x|n3+B6LdzPdOr`D33CfYlF0{c{T?XhPFK z|GBuCy;>#%asuVm+QC4v+EyjOMcFXeBB-@k$mD*}avFQzZRMV1aa%A=jc?=ZGn^6> zh=<8k8e5dcPgHZyaMfrW6Otd?zjoh30^q<9WO^KP(i@eG=Z#o~M;TRG8H!i9TLwN9~F+!R@+|CrT?X%)I61?+@M`q@{3* zg|u<;C>26*54))W;2TSCgX+QX_O4*Y*Y8vgADsFL{cijS^}`^DNia@ltLSEZfeW&4 z%vl;k@_p$87@zYweE>vlnMAW|FvJ4_06Chh58dT2$uq;ELx){qc(&#ap6_o{oL|T! zFs%bQ2SeDP1Mt=`@MXyfVFzL0*L0K^#(pR*aI3;wbhaRzz>02X9A3~_2d5)G`z?*2 z@Giq);V8jFaT&or@X2c|#3(=shlK#-Jm=sSbkst?;y6T7IL#=Z_cU4zn2O)P8)XX# zSkNw72{0E_d%n2(W4-d@iu_tpq=Te84vmli<03@^7pVi4h64?y!$h$#4bURufCTSs zNVE+kbj0Dsnjys7W$K%43|au(qmo$-)t69yx03q9_xIq_(*IC5{NL#xl*ecP^*_>9 zzyEiYRt%R-e>ZaY!^zRFM~lPxNjXq|emGiEf3y5HOKa(;83?mCz1-r>i;!E~Lr|D= zi*gtbAZ(`=Z35`n9ohqa+e!Vm6;9{JMW?L9)1(!J*LZMndU))(&|Ov>xq^C5Ff-TE z*>e5jOed7~Xq-BRlhL92P9U8bXayZFyl*l6{)tCGMn_5FPgorS{gt%mA%sFO*9;$I zBaT!iE!Wzg<59Ie06+!jXr~bi7EbP4Ii5f8F@&pkON8rZGHzkalNtD+fl%v;bbiUzkMh8AIeIYT9kK5s8sYM}h^Is?MUnqBz}#g_YPH zucebrn3WiKYNH?&+(jDs^YZis2gYA4&(>gQzGE1&JUNZ6wSxMv&O*Igb47d8V(eNGhU%Z<*2PMiJzPSw||P ze@kej9K496(2UwP92lXu4R@_+f$Q&7EIlk%RAA@bR3L);pi#8UBbCrUrGTUEiv<~L zC;*W9kIJ@K1n+E8;Q}h0QM(9iz?o)n&0yl^|MhZ{2Jzrd8f!TW@Y5QD zs)YXdI$75G`&Csxmt9?FPnPSO)j4yzYN-0-pU?2@p??0*hqybJ&%s~iBLqT|9PX&2 z9iFtSPPsI%&!JxfcPJ9zhkomv2PRb--qHb5@JEB+upu^b{fx>g`H6b-rL`JZ!#L`oFi#6>eh-;~&dci&-Pol$}Y;@o%Ib}xncwbx>jqF6Yo!ZVZ> zA-KgwH7kS*kZa+`bS!$aI0Th}Swl!v2X|Naxo+#UpB?;M+f&XpkbO#%6&wtBj>14wkSYNFIt2!?g`tKsxhBNs2^FN_!>zVK5CRAMx~U4> zQSD_pK*+V74X)arrudZu@+FD+J9`d}Mtcs<(&VH^S4r(xo7vfy+s;V*vqxoKb;$nQ z+;O{7d6cRi%K{ysdn3oL0FmPI2 zM3Gp@Mx>Hi;SF==L9r|W{8-Md(7NmmIki*e^ed>?8HtZ)D-4j6yF>{=5T)i$MdY2$ z45A|9bj~M&F#tp{1~k-phhNel{MTvd#pUuFGw}?L(?kzV`mrJt0!KWcj-e$w0Bk~y zCLhG&rDv62*o{#ea&RgA2mrXBqGDWlcuxw4;v6`jC}R<#Xv2a>7COqZx2v1;%W|6$ z-*tc&RG#413PyhdaFZ8o#$;s-ykO~qv><3ki?)M^llsU58U^0QF(NsLr7VH`ZL{&S z99@d(P@t=jDsf0Lai*pOP!sE5#bh!HMtac)-i0ubVg|!OIZX%G<@j;eWc$%II+K1} ztv{z?nDdmK6%!p4A;Sd3b>w8$v1b6;9kEAAH7E=-wT^wTkgkIbdQ!^i@qX|g6A5vi zJQQLC^8f|L(AbX{!93hRC8BF+9GvJ%asq~{!o<;g_@Ss~un}4Jr%`%vc_!IV^`wMR zYvAk{6he`vY;JX!7;tI@-2Dg}+OVmHU!K zGs&vmT}Ox|j0Ze2|Cv?^n4P8R@xN_~+3{%7l=P}i1%qJ3Cg}Qh>phu>K`1|=O=1fH zgZJ2Y1p|Ap(=sBC2Qc(e9;A{(nP9kpzUo1Fd%0O&t$qjEBwN*g^7i@9c=*tNa(EAK zoa6j*j1XGT4)cML8YP^64)aByVU^spNzGC}i$!EPI`8zKlrz#FSU6MnpPUr44{)V; z@-oaf)8tlDIg(||6?&*rj^5A;4d0Hb%DpHbUZ9pH<0EdW7*JMRr-3=%POj6PVJcE( zVCD%`;X$FkjHL=JRCZqsmG8RFu%rpWPkJf2e?d;J-Sl1I*)sl@SW{WAy<+#6^ z2oC?WM7Uh?H{H28Kj)xdEe~Ts(1K<_C;f|W7O6Do=-{j6B!Pr;09tVfDG%;nFU*K6`$frq*7smR=$7HnmZJ+6qD#5Q8(d zUIH2c0iLL%mlned5OS#jQThzgNcbUMXA!>1u2=?6XUhm9LGW#a5#)xcMA}{+^YPQx zqs34uc#RqiJV3z+nIG=2VBn%kA@1TlviXZlxcPe|TptdcRygAFo}@&pD!|%E3P~<> zjSm&f?U`_>6FEGYpI-95gI+Xmpl!U=pbXCaT%`oC#v zZEOD-JW_cL2)ak3{_LSThl1=8gXw|H#cdybmuz7S>`;N*ZiHmD#;m- zY@BemIKN(ePThqYjvj6&TW4{3BaW}m$<{udD)2H&1lcy1nlPuX2^EwT4cFNAob&sB zTrEeHiA7MsoirRg&?}V?c&0duGTTDHua1*ep>w_c&~lhvra#_S`G3NAp_gspzGKmY zBpQ=LsN=a`^2^P~5N#N6jLL}9>MM61cK>eq@nhPx{r%;#Sfhk_ZEX)gPmu}HB($`K zf-iiROshBcVrONDTTwA`Y6cC9>rbX1yDmmCN^Ov@k6YU0>h?CGJe7`aG`b%I@fW7)5x9TNsAi z-Q%Y?&DlTzS6%${YH_wm>mzQ7pBy95nyeaS#_1S=i>kPKPaMj6aX+N)yUqS)ydijy z-MHR=FSqV%TZU85Ff^&H5yl5;!hSyEdJ=MH!rG+Q+kt zizJzKk4k5QX56Pu44^zFngY#a1IhI_$+gTtc)OjHBE(bpp&${AgcI1_Uv93y6r~8X zs}>4pAYtk^?pos@W^so^>sU7%798k|CkRF8cr`ZQy$YeYPOJE&jV-^qa1x-`?$a?L zNM)M|W*U1+M45HV_XnVOoQtDkAc504>F!pg0u^3tma~`ZWx2wa^B7JkoyQ1K1OTdu zfb0K~n$+$vgc>E@NDP9suu2SFXIf+U<_|{(JfPz|8`$u@N>r25W$l?8teJPyTte=5_Mh@@oL(E4A89RH4vKuE;`tMWICyrflv^=;! zm(f)c%5W}BE4;@YRH$j2dD{fXKDeE zciAJxFQ*tg!@%tvEwTj(5a4qLBB(V^H63?a)ArNs*`ge9kE?4!&~&5*64V+^A5&|w zl*!>sSqzA9Xf0k z%Ob9IQh{4`DS=m2O2h&o-b%2bm6+>#y!kLoi?w_$kU+`5rUdX*jp&E?cn38M5Je1Q zUy10g@g-t0ME4^DghFs{5)oi{e|eiU;_+fts^uZxyheib5aT!uT}wEXov1-!q}bCs zvh7PyOJ=o#+JRT15qPW;qMrfdA{W@E$tcM-&dzUBeCwi_ttt^H0pP}rV^17|Clfq=Jh zL`cr!eD>4gw?!H*wA#u9ut-6e*n5B%=*T2nuv3pS4XkAmZ4kO0&P2o1@t@br3+%Uq z5v2|STve+A{;CjEp*`aFzp~HZepth4KH6vS=w_V)!$lJQZ=c#729MsqLVGQvV3nht zQ2_hq=q%2LQ2ry>$|W#y2Xv7Wd?Y_{kx=;3=qYbX2FMCg&P$%^LU0;5SqNG77vS$A z2eM3TUK`fO1-K@UKZ3pJ_nuSzreze;9-tt@$@a)7?)x4C?mi*KVV&si9OP*+^#J}o z$Bx~i58lto!P8Azy=j%UM8I-AVF>AobCXavMTm#uCd2q@z&Pe5aefa?=#DmLDB>AW z;Njs2^&f@_%qfC0q!nr|(kjkXkD^}{lmwBi0$^sYlx1R^si80v+0#e#93_$UNE}O6 zDz*WtXJUl){z!*bcJ)4m(McoI*2~4PVi!X?92_M=2TD7w5PjGZO^>(&M z0jG1|)QuU?7$*|4_5;^F>;OSSsB9txkFd4cCX5RL$>bEXw-MU}AVP|1@&LPXK*&yw zX%XqvtB93SUGU)C39UiEaKS^!w^?f0lNLih&>7s@qXwDQrv^?dHR52Lu7#u-pBJ-V zmLEPiD4a$(UI0opkPu4ZqA_0ZwWs^h9t!v-Ta${zKnajZqKIG{n0xSYb9KJ(Yk4^` zI0T$Tgle2a0B@%e75;js5>)9edNPND{c38T9K6fdhsB*YD+L4><5C$1%cr0c2BCpxK#rI_i@_z3hQ?Lv6<b45B1iluy&oxk$=*7)6 zXNuyvdHT@zns8qZk?1nXp(rto;~VBFD8A6eiOV_3aZ)tC=Nnp9o2A9E`)+~ppx8ZC zce;Z%!FhN99v0Is*oYj;hK>TnWt!;W$jp=dct2LF)E?uj)Vzdkt92fRNDi`IgMlBY zOe+rtjde3}M2XtN>~q(c(19Oq!l=>XfCI&eT)_J}9QI$KHgs@1Qs6MVD?Cns0KN7I zY0CAy4pAl2Rw8SP8`l9lNH;rau9E9oS=DCrQsOG;YUr0 z=q*r-k2fk20R+6?7zlr|VeAA#T!5hqLVI0Wm+r#Qw(9otHS{ZDh^<^dW#^EZ5+f3w%}j^oA?X)k%bRsTrVCIw-oEJ>rQpd zl-LCtpism$yzqc#cJnSx&1&p-;0Ie10Z~bOS_LDd{fliDzM{-=+9*id@!C!u1R57n4&PiTAy#Ccx;IRaH{Xgx zsE6T4LI*siK;qMKRxi=(5`O$tO@oJ$>jjm>nVJpwtGG-#YD&a5({%1b^;qc+< z{eRq>|Ksr9UYmi$j-->(j-<4i{I|vJr&It&n8bv(8l3j}r_hyDO!Ns;9A^hkKkz#4N3fY7cmDS>DvGB zNWv^>KlNRG#XN`uB|%cn^is|u&Q=#`O5W^sDu$(ryuZ2vfM3T7ZBlqVIzcF5FNz0# zpsWxSw&1Z%A-cUuA{Hj8dAzMaf-jVljL^Aeh>#POc)nfSu4iu(@ylHgI^NUyjgVsC zwlx|;cAz1~($vebv~ynUq~&sO`XNV-(;^4QSI9_o)iNLIb_na5*+AG)SPj?4{ot-?nUaUUOo^LKbE`6=guL?+aQS~5% z0MpqB4s#Zs4z(J=qsgo&lW;;r$&jPLJPb^+51h`?Wk|x={+41$Z|mdhbBX&p9};Z=Zcn{d?T0z-l3Uv<%!L4#T;iB_|P>Sf>grplnqWGr0H-Q;y@+~ zMD~lKl41?G9UkXE=!e*c!7lJ}0z^>CmuaQ_@3Vidmh0ZG;`nI}ws0tBk*uN&v4?=R z>QQ*IPCEjpVN(|=l>cq9PP}V}yH8#{!&kMDQ}^($xmRJwxfq9_v3?PNpMza9P#^5- z=NT0DV4fG&lN3+{&Y$-Cf}Ao~5;GNxwJUe*RKU+#!7f^^#)wNY{vcK^g)rfp7VH`b zE}T(2wO7w#+Y9)M5!SAf9^(Dzy>MDpJ8phw?8F;7srqGey}p<|KA5H9gnq`HpE>C4 zl!uxNl+iApP^-3lei)W~=*f0kI&!xxrOr1VK#gGVd`2UTsWcyk_j72xmMy+g+3ZWP z{v12fYUu`tlq@0G#Ti8dUtev+&~WSkaLJtw4cQv{_t=4F?j&9P-2m~f4vu%5w5CxS zI#rAjDZ1m*_1SW8D9i|M%wd7H<`7TX4QkNHr`OHqCnu5^NM0z-$Ngw;F7nSDs&b&X z|2%DjF&-IWInc}H>gF=-yY4N-2R3-N;@~VK&e6ep)vk>1%@B|8JspQ$U_*cnhK@h) z4yD7-9Tzz6{PE&rISB!Xsa-e>csO`5zX<|x9fLshlPV#&IJ+3y*)ARqr-cqef(9L; zP~bw?LIfU}Fg#vf&0e2B-CQk-=Hsf-=I>NX7Cpc_?@5DlJqFs=?lcI2zOkSI!P`w5 ze0`HDzQ9S!iFo-M0{m9JM2Pco=FewKYjKFpWYG+j`D9O767naMn{OK z6u@B)nk;IXvwqR`koKiT62)YO4}35$!=`&?4H{tEr4R1O+y$)(;Yx83!_eAx*d)Qy9sEOYmt0`&G6|AO zi~(mfSc>ad;cbKrFj$Ac`-67}v!}OLexSJ%Mh5`yu0-hPQ$SjYU;qduCTEwuJ;d+~ z2f#s&rvwDFFGq~QOS0+AAP9#A3Td^2R0TRazg&D@76o%Ws`it(k0KF<+yf&ONnE5z zh#`OqBbnuxINU!hk}2GJ!sxwN8Kn)hisip7zH@!|&6lo001!0@QbUAcr}cSoy=Wxg zf4W2-9s4z#WLPLAQVQqJMHGvwGZoBc(d}sjN1a)4i@`L#{g3s^kGl8ngZ3ajC`6^1 zUOPhIPzhmB$kAle$Vqc7km4E6G}_t_hvwi%q78T(2g0*8W}wWfaZ0eB+A8o@wTh5O zIS}v!1wmK+XFwRwlGh(zE;=-b3c$Wd(=8`P!6i_WG8o!U4W+4fp^ zHRXjvLSk8%$eu_%IP|@V=CJ}2=I1r#cTj{%Ab#1jkj`EpxL&mbhgmytDAI8lN`Yv8 zjRcsY**}jad#=(tXlB$(JkEu4ffIP;%!#i5CM0GXBOAmxA#K}7Ki6@rFtrd=CSy_d z{hQwqRGi!BjTq|>!pFNgSKeObzZ2pUk_jQcS;vTKj^%tqS3GN@W*vAD&xt%7xz2t= z=MkCEO8c5i{kPT9p)g_^xJu=cZ_8@Xo+7bpKjN55?40!V_rU0ACcbT3GoANvaL}L$ zha5GnBZgLTsWHD7=khv>EJoBK0D>26%4TPyn6^?lEOzQYGAu+hnplikNSOq8l_D|& z@0s(zP$0r92@tr*Nd?oMdW#s}qln+u`CmU1Zn6S4+R6WRM}lxp^B-Lth={q5JZ`Ms z5Ci62=YRx7RI|!{rfi6@=bVJtmGWS;E9KSZYuaY~<8qz$jefQG)ElSu>QR`Mz%GiM zeU;<1(EeufRAN9X zY6DKIHpJm4xQ9RxY~uCeW7=jGk;tui*{AT2zh4lV@&V8Ixmjm0*Xaa^nh;IdJ) z#YYpFSXHQf910|`_omNyk@l4NI!hzhZZ7>YkUp$JLmRPn$VMGC@B_6FzOZ;uFmWHT zJn}tltb#}}9h&d3h}>{~<2dN0fx#ow%d~*-a`}1o=)=YB`X4XS45x+fY4ZD1wlN7k zO?U-mh;tvN8GuX?!Tr)sz{tglYTaF@2h;7kpNv>b1a^V10;j&`4MDS;Juk!CdU^7i^Bl@LFFD0VBw z+twbm-+J7>ZoQFVPwC97VTg1(9uU_)4{$p3pbG>cG4pu6xJ?@oE@!W9&lkR+?5FGy zfU1@n34?NCbv`cFX>;Y!`393# zR-lo!Y=#O29$vG;RC5H0u?VwN2dJEACU0yg^mC3lBA@MVX~XN)&H3f*8TlF$L-`uiy?_FA~xHod>`Op7CJKV@2&?kqwyLL4ASQiqXV_hOfSMC=& zlE0ecilGfq_|?s*JIPZPsMvl^0;%q}`QW}^=!kD6W?FVM*hgWUl$}#CrIMhlDB*=N z1)2EvdK##uwQY*ihNO(xW<-H@=TPXWlvrvb3J|HnX_cyZC@Y(R!p2-K{B9$YaL>~$ z!y>}NJB{))3>(42YdDM*thr1#(Swt@A1$G~gaBWHW`rEd|#L z9?WVd`?7-*UBXvg8BlNfvO#<*J2?st%|wGFu}JUL^4ls^Ro0vD-cAky-Y5{EPp%Dw zNe0gEqZq{&%fbb4i?{0w22Lw0;%3t(7=aZGZD}h1v1Ms`Mw*=PEs+6_(>Mb^7;XRGQ&Ao!LDFkbX?Dk;>pY2uiGnOs@a%HE zaR9Ul;H;n;m9LR(ig5q3G5M!qO#bO;A^B}8esRL@`?L;2+8k!R_@h@$e*5z~wB1G6 zP~jY5?^sOckQy}tFhBcCi5ftCzyBJbOd2_u!7zTdJK^=%nZrZ=oLtydUf(DqD z3$CB6zh5k|JLK=>-l?4#zs@W|$bd677LF0={GC0e001ahoAyu?gSv2CMk4e|lL4#) z1VRBG@GG();lKb`UM^jH)Sk=KE0qaH2HB;i)&;}v zih%)(vzs(+C6x=;<$^A*N`@cQK!n7z4TObHFv^Zh3|T>EK=Sc@KfFs<1b|jhgiI?8 zP(cHyRV?Dn1wg2t14kA~FqmBY9@0)1O5m`rorYM-X+_gSM!*mc*_`id?Gv%!UFbmN zXkdh0C_vzJ1|rbH1cSz6Ks-rPT@g{H{>ZDPFRA+hEclIrL6V4xgrVvV48UHMB=!U2 z;7-HT`+Ly^>v*xe-h56Q3?sYnHLA8w5Dx(%6e580m`xKtcD1Jm~R7$~I{DvCD9ajF*j`DUl~QK~Hz@>T=FO|GychRuT(JnVFrm!K3Sg&L;CjJg#4>i*Yq#c;z+&c;J-rwOFI2^j+exr# z?T9~ji-uI>Xi)FxuiYfmup^5>BlA;b;){{X2BMW`3zjRc9H-5fLWX7%~Y zexfGgv?C0az^f?|&P0qBa@5QNqhJbr_Qj8NX$C>VP0-yPj^N4&LUYXe z=KAyO&Fc4}U!}9YDV0OyA~f%Bb^CSoC%8Wz1l+Q5A4FoAv%JxFKTPvHvD z{=XON-%hy3$8)zi~PlCx(Q z-xk-!T8?;c#Q{H31L0xQhXA3P6uACQKBPCF1CMirh)Ez$t5zI_(itIW4WW6rxlVg3 zT&{{Ge;_)ebO^~XV5=3AZ_CK)PoaY}en_7z+$W>NbKpT81aL|NDjb;?{rQhp4vfnc z0z9~mCi)QIr|LnC3HW129{w_m2t(_-2)tPS`s?h;_2#R077hR$DgZnbQ>gk@TtNSK z_OCn~?O(y3*s~XlKmGv9Rci6C_mA**OD))Y-$^a-F`EPQ*}0+ohw13Y=cpmkfw}XP z!U>oBAL>{mO)cmE{h*A8zBc9t=*#`h4$?pb8NMO5Fvo+$7>d+_b#b)>gfc^)3d-9` zd6!zyQRd1hec}$O1!$ruNONGedzQ~n?jMVV$e3qYm z7lnq@&NsxN*9HgP(82L2r5B5mj~WN^R7BNJAoo)c6jH z1RAYI!jDH+sp>HB+jYKre@S$GlUHe3%sIYAtV3?gcv(v5tSmWlh?J5gS^j#CkC4`LiV6l#R7HZ-A@2@waN;dE2&#J*^rjnrXAZvg?`$NA8F8vz5K zCo4ra-NZ%CNK!X+5{k3)+w1E>GjUlRQKE6#yOy1>jv7F$q6R`s^fMYpdl zs6|rF^Vv^nP5(5RY2{)IhXk8nxsQMZ+B}AYVA9l!5%(dd=tOyg-Caje2>e<+2ahbt zk`!aJ@v}5=$*AL~`VtV#SN#ZQi}UL=kMQbdGkcl0^Qi*;v#JjP%9;cHa_kh|s~zV< ze-wRuI5kNh=i|4XG%xxtku?*r`F%eW{S*(7$gUncrCv@niW>)uX?Ej$gx)!ty@!@7 z?$D4N&Vuz>iALjm+)PmbXB7p$FGCoY>nI%7$f3g19uIMJTFkfPok&LJ4kpu4op4&! zsXrH&ajsGF-7*cTU8WHt%c4l?=P5gr#HUwu`lF{D95@tl5@4Dp87Uz@GPJtm@r4}2 zg%J*%Rybm?kFP8i8sOlv1;1=I7hzz8V+$El`S4I0#6>kbgcI=L{F2kP`hKzTuIow& zP#olrD9wAoK!qYM3I*~D6!^H#Z@pTaE!JyLV-u$*_+BQ*4jyW>8x-5&fy1mB=}_q5 zVwz|zBZ_@+eCpN0)z5hovlQM#u<%fXC>L+mWQB|ec>lc|Vc6+k!d=uxLh&40SGz4- zzcu6^1EF-_jFqVtv?IeHng>p2PIQ+ysU7&IG(Y3R^7Iea>6^an? zLWFVHk~! zmlLG`nuTbldudRg|Y;W0H2(4w|dw(Wv1`{#9~NZSV#O&*9;7B(9HkO+`BEuaU|KI@ADO9vN1ak za|Xu3g&_AEZ%sLxk z%!n1sm%GRHN)ikF#}7{>AXr>W->~feEIvL%doh!HKw_)rgY-7vpLP_rov4_f`DG|5wj)z1zA zdB{oP)8%IQNjeF|Qx*#o0J@okOTbXGY!d#gB|Kjv!KR}ojD*zNGK|tcxZwnqh)kc1JOA`~Q4FiNa1uqZJ_-WU z3>@(48jWlstcPZu3Q-<^&DnuTraq9VpM+3jC<-nGV<%?xw~Y^I$WnM&m>Q*aePzsc-R?LhAP~5|f9vc9}(Km;zv3>tKQ3{OI_&Xc>TMkv|*Vx%T^~+6%8u z!|!X`6p{ZSimMI75sIYKth!mH3vW63*p&KYbbJBDshLTYrEu?OrGpqNGXbzxKN@M$ z{)(8_O2vT?`j^CvO^TaspHpnfxCr&bP$FoDRK28eH_!KS+lCk{`GXjiF#XqVRI zOrj(O%9)@D9mv42saF3}oY!)LZ9Eoo%&OnU!v!{NEOt`vY#&Y}R0DFXizX0JXV{|m zvVN3vXRcg z4CPXO&}=*!zppN4Z)K}bub++@Fn6N{S)v(0@FaMtf#LL12>~;4VBjT!ORmGvGty3m zy8A`*MVT6dxoyQF3kM45Y~}s>^Gvpt|16_$-mUtzJZJzzgTOS=z(X}P*mf~BjA)E1 z=&_%vonv2eE(4L-RY~Z)JJx{0IV2uQ79eBwo)V~TofJAsgn?lq0kWrq0(;U0!+A_aiDp(4mChgQpbR*0d(Om3l~m`eQzGnk~A08 zkTWaH>8U@bxwj^oL8JLl@G2!7e#Q<;p8OI60$hzAVE8b7}J9^vDTcX z$^cMB$y~oc6a?H(;bjYE2Ur2|Mvj)yht5t!9q0$%vZ8S|S zjTsA8V!s%oyW|s<8i5114URa4hl0>r)~4sWJzi}JiG(54(ts)%Pr^_GzFdRB*1MCR zxce;iFzAv!CJB;hVSCQLU2Mt&y!}LVfS7D1LlIVp1Ed-Xwj80*^kZ@=TK28G(KuC$ zEDmheHQmY0#wb!L&NMx(vj!|1MO&7;FpF4VNtyZQ3UQ7F93^q5M16ViYR%Z zdI{x3nVeJ%T^V&u8S<|T1Ip%t2%g@IQ!$I>;qWgt4ESkVDbV<}d1OkcfHuuz8zp+Z z>_FZ@5uFHbCld*?v@;fX$YCK{A;}z`GwHsP_2GV!8x7O&K&6Zpyxc|$Jd^?pxl~%P z9jANLluoI6C<2pc5j&SrIJJ%d1=f4bWGRP?yp#@AelQ9|n9+m}7%@=iD$2(Fj#i9? z7D)~x5DH0_%>-DTX@u#1T_9w|+XtCgU#t(uS85PYzZ7qksW=32%sRd^8&ozk2xWK) z(>BAHhfD+IP&N>b>_##2bRqMBC7$>sBQP$&azcUMY&8sgVhjp4;B>?2b>5L)IqM>& zlnc0HFa!_Ey3>R5Dx-iQ>Uv-nqF9pwKQ%H`%Q!T>sRmn~T*@|u+za=KER?yF-cly{ z)mn}xub!bEIrX`RBBazOOtV5c+PM#YWGw-HCW%t#&D_Vegi0Zq${XjDs zwNJO0!_L#nPoCO@3-e(3yf#ZQ*g^p|q4K#8t8VDSOQzTb&m>zM9c*dyF~|FR#&t<| zwEpw#!1c;i-;zYFKE7t8+V&;r*%)tPU17v zR>`1b$#uMctOo=b7&)pV%-K2*%E=ReDuEG38Sn*V176`gxSXXXoym_6W`C1~%1)*@ zLRVX9KcK-EYCQ0~I&ik*9y-;Vn@!9z6eH109DK@hh0-}JUN0|^6TiRRd@1&@^WBA% zDVv!nzcy}!c)yK>6AGfz4DKknodK6#jLR2iC`P92ce6mWjzi+*a&_}@_Nrh+X9x~; zH59^xGcaw;b1657g8B1o0crN2A)(MUZpS&9XdV~iw%ylZfFTnC-*GVXChNC-xU-F& z##u5S^lCC6dbwW!VaOL$GJ&oIi?f%x#^~3 zMX(JNu4VpHnS270aKmcMj3-A`xhLGjptu+g@ z>S#9Q!(@vX{A!q!%hzRv%wSm%C8bFw(T(s)iX7Vlh_`FmTk@vJbeuV`_SLN1oq%AQ z(H!(@G7x3DN2Q%Wh7dfE0s{fGQ}4?q0xfBWCFAO1^@$`bm>)xWRx@`sbd-wqe^<3(7$aXvbr^5o;{eDOi1 z8sA=Cc9M!0KZ5@*setIDq@tX`1pu2l1%rFD12j^~_H+9mj}TxG_MVq~=qGT^@2M5g zyi_2wLw#Ted6_-H!KpzMNd?c8HDN^Lod#6y;dR#L2v$>4fqI+$pKyk$Dakd;;5V7Y zg9ZZ%nP8C1J9P>UQA7+AcGrWLRWML$_7=-ZAK5a0^G8_D<;;O_RDuxt%~3Ri0?!*1 z8Y=;|v9YB{2)w{g$|&*Ru$lUZssp6hFo3f+OdqT5Rpk@P2ynnTiZrL~r}gHdn5ut- zQW;qg_|y?Y7*qj*4PU`Fq(-7mrhCk|_m7$cA;$Z%x9Im7#|eJ436dj#A#)HmIQjkO z#iw$|8$Yb#=s{dmEe}I1*+xTE0)NslrywPof1L1z@M3}0O7-}yA3Nfa_?W7qYyhgd2n!){l-o~Rg zIwzUaT+Bww-ecUU(a3tCS4~Q=Ej#IVFSy)^4sjrwCef0L=gX_5?2L7#OGeGZg5)(H z90EH@CR^)mfe5{He=!xv ztUeI9Z9s&43*}TCc$IN@zFcoUEN3$5Q@W;H!qo->RJ4FAtmwfVvk82`!U|k!ghdih z?w(U~q03M!*jXNfufVUH_2&}tv(K_F)>R%)kFuazB5v_~HH7fX;`*bmjA5wXJFEJa zv&ZK2o4h@aBoRw9F*b6~^Z)EZ32Y}8s9HBP^s#c=`^c4-AM?P7m z4vy!3K!tlUY2w3I_XQib6BgZgj@FT};Ldf`p1^(|C&4aWjl?o*Km3hnYUw5-8q0-w=%8H92yj$kV7Vs~ zB3Dm)OSSgXaM-!?JSBhe)HJkZ4F!tQW(4lkQ0RCoimsqcW<XOhohc>LQLIpbmzFQ%zoOBLyC+f*HkRIudDL_1Im6k9Y@~l(p(Tjw_n*!)ADk zg$b|EUyEdxyF2!e?_H78i!?-%H6^}&gqf#~mI5JckX?S=G+NH6jN|L=SU zJ~fI&=m%&cfxoIy=+#tCXuz>gfE%XJ;q%G_US)TY=3(PVTE8p-kJajcznVH!vt)8C z`&ag(OMm;wHc06(x7i-2RkNe86JvuN%^r1sv;qXtw1HagpS2RBoIq006TJv`rmQ# zSoX=m)DRii$TN+KRzbQsQY7oD{O0bX3f)th{h}VKqz<$=FhU<0idmb8(g9$MWL{&$ z=pN|KH#;!W5Uqj%s4T#aqYC(8+jZ=8fH&S;+ezp^ZZm`J$2fvv;dExCR9l(B9q1ckosJ#sb7eW-iMT5!L&3RsaD z9?UONJa9W@Ut#W2#)DT`G@7SY`&o{JK#c_DY%2ypu8kz4p*3tqRonWj%E8FY4N}e7 zN#aliMV}f0iq09u&X?c^$;WoF0AMv1iog&Yw{2t_7HOX!wG#?*Q$Q1DTg`;V(Mrm@ zXL#cmwJ&jY66CXuM)oCa&^8)l@|iY^P$blu0$hB~#aDcVqJTSQ9P`ktjJ8p+2#n|* z;q8~LI8Hbe!W_po3M}j$@-GEwpR6PFV4@%vUg9dNL;JjHJU+^SD(6V?ebur4e0_N# zGo;RL7SaXuiv)42b!T?|^Rr)2-`uy(C8#OxFDKHVfbFm!bTi`wX;Rn^R$JJwmpe(7 z+VmjDvPFE+wVqjNJ&F0rL|-#dyhyoObgi=+)4Uitn!WGKF$G>pVEU|Ik?|eQ*kHx(vnF97E48m&-5TW`Da} zfAbR!kARnP6a_GZT$mU71@Kw}1SlFYG`PD|Pov1107ix0(OyUBaLfK9cz+}VqzMprLJvNipAABZs8K$U3ubFQ{~jLoLY zmFwV8E#+u2(~-U-!$W2!nHGB0lnu3mcAA_js6e0=Qzj*cb!I3-lMQc|;$;4@+*)E)9;!e_uFlB<4Kq^3LoK5H!24|mT z=?31E25j-XF#!N3mx9Y?=Q@~EV}QS^2hpp^Oz3TnrJNY_GNwMbZ9v3X`oO3e+<*=n zEWZ48xw!q8!vc=G_8oXna<1hV9PZRm;IDUrqBM%^I%s2=4iO66PEdsDBN>XIlNRXm zyylO~h4-Z3a?J||M(83yON@cR(oYZgQ%a)>L2^+lC-9;R2HxfkL>6ucF`lfiu8JA! z&O%uIYKm?^0NsD``|}y4>V;a!LYAR7yGu3k?ua?JNFXxciIm&@#FPMPX5LbUJE~m z#djb=lj?*c%;<4Ci7%u~lo)IYut7=zDkuK#RPU1`zd)R&(oiZS9MNmwwt0=Xg&<1W zbf7QgfctMUWViZqd;ZA}O8N;ssGNa;rZ%dC#cmD^u*AT?<()ieO0(5zkY98fyR)L3 zXb_aFlt{jw-hN(``v;=#weQ4F4Tj(`P_EiSXw$S1{IX*qW1J{YKcwzV^qp}&E^VTf zXK>e>SBsTwrC9h*(94iu^()^Qk2=Q}#-JDxi!mrpY`j$&k)a^fa!kcnRQ-l=+6J1d zX&BFN-usi=&9d~HF0O1_MI4pH4{8vU1<;6n`A{r^)yZ;G2@%E@P!fd#M(% z12=ZZa*P1@TO|Sy)mQ*Wl?ZjGlk<(!9u~VXBIrZ53j&h$;r*I})StinDw+v)CBN!| zO2-Kz(j0ekFyMJpN{ah7Cpu~u1q?Z;ydw&M4BY(a^+L}0^WkLMEQp3eu+wCHmXr{D zZziB5zSlCPBG!2;ca!7n_Qv29&M3Hm<<+{}3JYpdXPw}YIg2n#@0fr~V**_pVPLVR zrx(L^{|qnqI%-2iA!VnE0*aZE&ajLpO9Qy>P>{ieo0+VSE_YY~Won;^8X63N4Gsnr zu?ijbgdtTg_DG>Njtnu3aySHqL^+#D7MCtOU;SFb;Bn*YsUGc7Q$3(+E{PR4-0@<=-Ji2@ z%wA!$EH&ml0yXtawzAkX4G~t8JCi|1h;z9-dP;D|u)02;~uc^$u zeY0F#7PC$9i<*IrIM^ z?wyZ{G)2lz6OhFl;UF>2n5^|00f`|JCImP@JUirhwGa(uns|%_Fy$sUZlWDfcjVwZ z>c~C}A1KemHxZTNjaI0w^ zm`oKHs&_2I!LZXpHx-4T6jNa6ovy)mWEk4sbKV_K3RdxcgOu;RMEiwJv^xNtO^Dkl z1N{`x|CQrOqW>e~NpC-{E*BSaF5Ab|Vs?7Jx5w<;xE<8UEH)TbJJ~ku<8oQ-_u|tIP~8j&-)K8gCmgsmim=FxCUmH2 za`M&P{D<$$?&IL0nM58rp9Pkq3L`cGL$Ls@Du0(WC98#Zyc21CD zj4&xjjuPE<8*vyqn@3=T1em{mlM$w?0tQg8hJjY1LNRd&T7BzeI`jf7)WN&bL>sjX zV4lLuAetElJmf_4Ys|GxPb33duN_xx?X)YpXoxE9VmBDNNf%nyk>M>*TzS2|_R4^d znMpVlN+OhTwvTG7UiBZZE>?@H#q90kych2N_~t3vbLdo`b7fiTRSz?$fWY>6*ZD1- z;zY-FfI zWpyyh6z{qg7~c~KFRMctRVG*_-R*9)RCCT4?YbVdZJtNn4l~Ah*?VIv;79d|wA_Zt zsELvpGWc;j*2P1H1S*|kUAfd=WS#ibhJsb-OrN@6oGr*P4~_hZmvdXCUZbEXkO?M= zA2z!KUMx4iHg`j6r^AjU!GRCaPr$cda?B|*4I7O@Ha4;`5ifj`<9EI_4 zR6(IY5a85G=Hy?=5}xJfGNki!>R5f1Z5Pr7B=C?Sfy*kCVeBy-iK7$0EtDHuz(>41 zl%zll7%2{e6Q@#-#*LsH}6;1aOPlY5)XW8+KA3pk#Q2sK(&|(2N_( z2xzC;%jEbjRZ+uSd}PAPmDruk%C~5ttJcqMR$mrZ>)+)ZHOCD6sP^h;Xagc7#105N zWI(9@{1bpsNV20z9j>Yt(57S~K{(Nrsun1lQ;Wx&Z(<@`EPC#@dvvD_ zTL^7BS_mE$V;O2O=0ZwFxG^{~EW40wWp&IS=8klskR1l4Lsh0#$;Qza* zY628S8c@6%j?4=-8gl4H<0*W~2biVvWO|wq2@w^*Qc3_+ zrwvcn5@oOCKpNy8VKUDVo~;!Er7*sPAQN|LsZ`UTmB{@LC|YC9$XQJ{XQ6bV%wML( zmq*>juuxlvhKxuqWwS}yl2+G%S+tENs9lD`VIG`k8wi%1v4pzO$( z?L>_!7)sO(s&s!rZqDnwjQsdCt6%k;MI>lhe?}Zp^qXbP3{b?V%85oy!cZT@B8bM* z^|{1UzgwqPO2E*BH7D@?>^=Wq94WMrbH79!@zUBhG9~tmr;-H3e)SMW1lNJWr#L$V zm(&MpXHW{=zWS9+%f0##SAYV$8VoYThT%f`g%B2*~|6S`NF3hu*h03ofip{)lsY(1z=;{R=k=l6Z7LE=RmUm2%Lzvf!juk z2m>qM%tXK3Ud(=3{`#wPrfsj`PzZaiw7GC+6nZNc_~Oh3BBeaQodiJe7`SC26|Qnb z!L=KYWrU^Zo&l7jMA*q3G6Zb7$vH-DU<)OrRL$;)AwsQE&oB&|Vc=B>gABCb0Bi3r z92HQ7)WeNS)rFmKp!HG~6p^V0;f#SVpdRa0nZj2z2pJYDO*7zCuKugFOlA6GEkp7= zvB?<&9;}&wzqZ{3?uQc5QjQ1)f-&u z45>JI3Q*v^H5BTe(2V;+(HmT%++|v{^(kgG_)*hY_Xd_w{!x(*=^dzIC;)Qn2+1h0 z)RW!y;Dyy&18Nm%d}Aj*#Hm6Vh+rH2aTNKKAwj9o{0=oU(+Ei5&KMu?l0Dp2FOJ_G ziQu`jW$-GiL}vsVLRT{aziqp1+^HFnC4!APoe|0Ml@V_601Wh$=yr|8Q_D$&W+ZP;x-Hhgg)cEft4uGyoA2hNbdN)f^U)#3zu(CIUOz4V_ycrV{QB!g zIzSgUE7<{06zhk-zkh_k=ix=BG@Wb{Xf($c{R$osD2=RXl7$Z)Yv$Fog&a4w7w{aP zmJ=FDE>%bs%b^qG;Plu}Xykb^jg*shR4(YH4KVUQQgfrSDNaD0ObJg$SMZ>gbr_{} z2Mi-9(3(5b_>La<1w8v4@^}=+)3P=2Dyzc#kGGpkSp>Wa=TfkARbVw2&yi=GHT zm1>2c0k5yIP#ypajiZ_hF=iXbC!Kkn>NEyzh^_*+Q&8OvpU95PiI><2tvckA*w;SO zu_Ejl0pw~VGAnd)>hx^uVR7E4qXePNl!#E^c7h^wn1gl72~@|K2ll>_6YSywV83h$ z;MF=2W+%0=VB4|Bd{3R|?x0CC%214~jSonW3a!MGBPgHJeyEAY{+NVM%EBY_6k zLov(jA}c0emw}*(saoPrqC*I%vqbPJTZX9R`RvEV?~Bd)YK3=MKQ7*tJgQt82>5aG zr`=o=prt@UE;X~*lMctFSZduNI)pc)5G@0@6BHq??(#v-ZWF^eJHM5)3mg)D-X7~; zO+5%IfkKX{1YWWSA4(5O2Q)RZ4zraq5>$&!3Z4o4WWDx7%!q($t=x$a0K^EPz5)$6 zg2FZr+DkVBCxS$PfkugV@D8irk_c|IBL`7(p zGPz^+=Jvyf-bwCHpS{6%hcN#k0+|%$my-yAax=*1@+2c9S~1xsYHh~ptW*D*rx*_? zT8K-K-5jaoV;|x^%sOSAhJzmu{XuThSTU@`zgsi|j-+uV7r~(tNtN+EQ>5|Tz);27 zDz!G?BMUy=b)OvhDG#<#3-42@8fuSL{H>PhUDsp$ZE-V`88F3m6>}HJq16l$eAo~P zfgCDp5a4;^fwn!0Oih^%L7LNIeZ^UslnVm{2W3D@ek6?!5iMk*8Qja6%re@4CiBd{ zExkqhot_DRinNob&{2$s3=2GDSZJCDER-0NgW6K02`xo>H#T&`S>loPnFok84zS1f zYF#2Xw1YTgISvF|CSj1vJ9Q8r9{PF3Fx)9){@sKZP2vJsIT}u8gw5WRi;UY4;HPF2 zp&QKEgo8j^A3QKQ94vaT#TR^CiwA?JQ)R$&$s)R|Q1Fn0;r+q81KINX%FimsBQ+0D zzcvVE>}Ka@nc5-#N-hKF%*I% z-~%-Z_-Pfw8Y{B24R+t|2|KbG6(*7R(iD>jTmXE{+>TqgKKorVeiy7b$4MnnWpttt zI>#LhsCy*}8p2H`!`+VyIShe3s$hWvuChEnmNj~t*}KK{=iBSh_krKkmO*-`LWV5Y zfq|bI800Ur+&!a)Q>^2JO&b!Zq*;eU zBFvD(oiXbGJbPp{y(yy#$zWh@iRcd`qDqbt&n_`>Sa$r9rAQlR8>m!G2jZc05ZfpN zd5zg6l;@u>%wBE2Z+j0m1?7KvdANU~p z0o{#`6HsiNJ)EBSsc9U(P={IM5Pl&Nn%Hs(t-7^0L-mwJpmydIPB=-}$a9UF`ISg* zPpS36vm@d-`1;Ob=5mdN%Op?(=Pk#&Izj-MMFB11>_N7J#L-f5)~xRkr4dw7bcmkt z0b>QekXV5NQyy9LJu-?Ssmck({z#xU>MOurhlCt0wfV4`J-=Mvo`3u#^~G%+R>F4^ zS>&=-$dF#)%{3VKtAa7Y4a!?*3~2~0xL(t;YH*FLD{MoD+tgR!yD66J&PgIH*>UQT zd~X&qs_Jm?bM?>y1_Y{;Y^LlB#9PN)#eS^FyjQQOWB?Gm`HJ8$X%VeHpGTJxK+PUq zEI#`v3UH2+Ay@`pUt_?M(lT&=4|myHTfo;jE+o>_aYN`B&M;6cG8cYYe3KK`K7WxN z$cs!Hja$1+{Mg747Fo2(kgdYy7KTZ78>tqZuBYyqDe6G-d(wl7hVOWYNk)c)R~Zi3 z)k^lho4uFay?p1e-%1C+NDd{#5juz4a3~1iGPC9Big|qMmu|W(*e6J4=!1d$HTz(g zWt_=^)^cH*?}BkMK~!vdTHi+SgYV@%(h#!Bgmywr)63vSLDpuX@$5p*?YlbvRB{51 zX%^ye;HBaaM%)2(EfpY&`VD6xsvo&?cFb?2O;IBZG(9I3DHl=WfT}0A5qe@!q9zQF zW!oIt_koAeeF?ii0RB-hf)fQ@YB2EEJ4F=bYDHq(8ax@vw}KC)TDE#4-pKgs>>si{ ziuWEswH8fp8l?vXS;kN>9t_TJ$6l#&NRgnndZoxJr2{@>bO=U~0pL|u%Cu?f+iI~p z9yAnKb&W3Z*X%mVY|FBnYUJd_nrDH^ifI|l)}fhdhSZCn|Bi|biO)lTn)03r4|elFqGl&K zQ$*0#36U_wi>6aX1VnUDbM|hz@`o&U_P_H?DTNAeH8Ai{<-$k681r4n<>{fcF)9^d z&eX^`fg*w135g)stUm=C54jBR-9k1?pPel}N7vQ%<4&}9^5fY|U^^Y97{g)+g2NFB zffEr5+)hw*V}2CLL$SV)PzJl4m2-=o6Q^3MaO1~jBf*K|PHiGue+Y(RGPw)6M8ajl zs+@xzwf)y&5DV75MTl3+uX3WytIPGb!Zh%aS|~tG10i%Bw?R;o2M7wsR1k7A@0A4~ zhRIPVj_O0Oil0`WXFQm`>_7*r41_il!e9cPubGfR(5og0+r)C-Ie&aNGK8@N{HUpu zuU9wcA9;ex>cfX}a~3pUO$gM;2oW-2M+iJ*TKRpjxbJs{%yLPN_2m+`O(Wuzm<$LC z=rls4VfA75?BnGcW@cSwjux!H3Is1L^();5-d@v!E%#^ij_}19hPFNgdB^|&B?o}+ zf%rlW)+u%zz*D1^5yn&65U|1S1VIr~qFpScBvDcuh!SHL-L2^Furk z>d_N`J>*$)4qdbpEhs{JdJbO)D34n@&tG_vsI;jYf0AvgSTxCg+$;7gu+jZlVZGVUi&7cY)Lq91(&KeE; zRaHT8nW_rI97GMCx{mT7%{x{s5U-|KIwV*b3zW!V@kBd}UoZX@^pSC^5e2`l1u|ru zz-tVOJ#(xOO)DEf%D{{0DsVf25u(X#8id6W13SYm zurj_l6M})angs3`7sB8>Yu`#L{w6{7C)osb_Uz&-wi0&&i7$@wAtYGaU;u!3hJje_ z&WA1xBu4g^uVe~_>}DoYbe^v_7llaTi!}`R>lBg9Y|yKzffQR=rGYQl9fB~Zn3({3 zcNX#UAFzjbnid|fYwv8KN~~NSQw<|MU0hx+@9eDj;;c;v$+c_keOMo8i61t@H}38KiyZDH zI}Mi0Mj18M+;og3%>L95u+q;8h0Wr^RQ7qiSxP8VGwXS} zl&zb8!&=78^0PdF=giHvxq&(xH=dv&`!L53Ho)$GrXR&4P7^N~|w0W-pgZ$$|W-!YH+& z06=QV{C+4zLa4gt2(mae|=p4qmJ;J`~Flwnq+O(z)XV zzK}Q}mv`zN8-U`FGc}W{NJRS~6mBOZLJCSLX!Vi3UEE&I-bydSb+Hry+%TF@4K$#{ z2aF{ls>Yp~7TGrRYO*+{$(nKeKzon}^NA4@ZYLnZ%smpJ1;p7(r>n_nD6&YUh@kK~ z0|P%#HiJv;L=VG_cxVg^XCru2VyU4fOb>c%w|Wygl_0}AA{yR6g2&7T!mFHZ$#$61 zjsE2JGfuDdUbEO8F@phq85kkB#vKC#mu4br`v|V_;Z8I;21XiFRc4T0G!cBmxy}9@ z{Friq!6ulv%24QOYmYa}+al${Cr3#U!)gZvTHS!q>i-EqpgsHA127JlT27JIN+rm!arOMBEkujiZKv5<5!#M74ak{B|V?msd+X zXQXgQ@KQ+;+-MsKH3?`0?(ZR%WlsdPmtq-6F&K~<2O7*c5l_;>51WD2qf2a!@M?wO zCeYO4&aEO5aBw04u&TIfPaIOWf(is}jX3Ni5OGp##(-DZVZ0Q9{5JdBYFTmtu-9Bb zO}1JE%2#1P8c!dJPZJFk0|GfQww#9`0;Ow`fwAT5^{3_aC%+q{0|Gxad2mJ{9-~~j zH6(e}pxc|}*V#YUvPbXBtL~WFn}5Cp6^A*6r(k2s{&pR5<0@DaDS&3pF{d$6r8HC1 z2C=ruu4zDBQy=B8yZz8lt9!toYdE6~l%Kr+K-cD~iLz8`qvenr-e5kQnV|LsvgV0{ zcykJ69r%Z%tG7_yTB^0W5GV%bZBlOY-bWAT>e!g{xT%FfrAA!Wad2H-!G6Bn$jD0L zuvnh~I)HfDjP+6V8W0wltWbVT_Fbi7yS`&Wy^HfY>UIkSxq7v}l@%&KZ@ganT^h)Z zYCs`GbpXg`M7slUe-HOPhzBi$CPs1K>$+S3^HN9`dIPdz2QJ9Wp$%qA$d)dj3J2~| zV8Cd)!AmuZow|&(PN;!Q=fhp54aMb3tUJ2`0w1u``TLLS%~d%jkJ_4eI=|)U(6Fu5CGh)Fw}Rg}9DpkPxMX2fy%Oo;%-v(43NDLZ`MUi~Hkjf?5YM1Vx>sgz|$fSYZL^0@@~;B@XiC!{G^M|UDsfI`mIzPgcpzhs$sA(nVo zO$=uoVe}Psu93(xVQc^>`o~NR^^ol$=)3KH)&&8jbz;d~jGwH3LwM`hfTwB<@K@7H z5r{IVOQGAJIhL>tt5i-##}eG^uGuSDaGbf68;Rlw&uYj||< zuO^1NN*D>-w2em8O8wCw0S70gp-_4z_KCz*8fZJU z6oQi>dHhYz#*leBa>lf?6TkBpDr$B@lhI%*WEv==p@G^MH`s*gI^>TX(Tr&5j~p7E zoQu!xWGY92A1GlHjMr%;*Lq#fXYyEDFh4VQv-qD8W6#Q;f?`;I#?tq z3q{*fb>i@$ z_6TYw#Fchl$}pMb(S)6nql>1O%WB|y$HSof+kIpjZ1E1hL155R~$Eh9Cw!a(V5jg+l?C6&aKv6XL0|$ArFzQ1I1uzJtj54g5Hn4lWgn&_RTU zYExl>RWaoL9?U5HhRZYPd@?hJPNpiXjImTE1}!E-@m@Aol?`@f|0AJ>vl4#PSV6a; z@s#r*A*{rEYbaRYZT-n(E;Jnn5XTw<5`2ZCfIDU$^N?j^Lf|1s2%F6%UKFQD6dRnh zM;XWtvyO7R8v?f{5JP)*dZYyFJ9SBfIj9uO)&TAM_2-#P zRR1ieE_=PAz2i;!x~vru3fxX+5<*QH2ce+B zWM;hM!i6&&K<%M$sh6V$L20TcK3xOBrlVBs3B`(|PWiXS#n zz_JZFaz;kp9137S?Kkj_whMJA;Icvif84``rr|X88)Ve($!F-J%K)G-&TXht{zEni zTY7uIQ#AzmYa0T*zqSYb)s&J~Q;CobUNPYNS{Mvor-~xFdr%XRtP781zNd82ITir$ zQ3#|rCgh)*>s6ym&t*Z(QpUS){cSUym^r+uw4-T2-kc3*_{DGfp;&Wr3`^H2^%f zc_$`^M#AIK?SJvIQBG>jrjqjD#1@~MU1pW$`F{7$oq+DJI9P$_5o^O^P1QXeHZ{x*ldqx}?g6h`R0+3X}6_}>6Y@^7~ue4?Ae&1d~ z64XWG>~gvMBFoOgNh8i&P$4rHM~$6wVvF{{4TYr%2J~B;J*%pMn@ymcF_GgMzAg(# zc6*gOi!;_yGv!544x2ynd3E#A`7{^iIvb&cSeV;Sflx>j4z2$GQ6T1FWeJ?5$f?f1Fa4VBHWq|Mu?WjCordBegF>75Pk>@)sfaxUC{a@?UM;!*>67(Ud1Nlv0Oy?-m9^{Z&k~zs$Lx>Gh4-YWhVcUMneQMjgG`iZz|V_M z*v0eD9E18TEa^BM9fNwjMhnlLEH7_*!%vTYJ_7@C;&B9oQsS}e@Dn7}Yy#0=3Ntek zj-6Gg6X|!D>7&_so;>g;GM#4cd90WD$p;S(ol5YSlSbZw!m3#?Xib|#vEtU?cqBDA zQxI$M(X<1#t>a3q4XnYXUS=3W$upHZ!FG3F$q;Pk7pYR>w%J5n&Ol9IuuT`5)j=bO z$EzZ)-9-7?BmY zZD1UR{-VqZ(Ag>FQ*6}SI**3X)(wTq-rf zq(=t@o;N6L<|pcp2lnuwJI{LTFAEJ&WFsLcSuO1J)3*y*MeZ|>PB1}O%uGTw;lMz% zCoqV>9k58rWsD|vw~@FLPPP%ElCjX8aL#01hnzd%_Z;nvNO~|z^~5J?UqXL(m;Uv# ze?sj7&_)YMqtxrk%4845h)!20={%rDhAZ zJFmucqMX~6MKgd9MH9D8C+1TIozP_^d#@Hk;rYP&Z;P}Y6o4)TSaMl)(%?~%jKN9d zdURro-rAN4c!aU1%nB67v4ShVX1^>i$}R3)H;p3(e%p>MP_mjBceajRY_UHO_+>K# z)3Xm2*e`0UfjAucJ(-RbxV%e@-B_Kd~WPv-WCdnL+F^m z>&Ifv{k&+zfp3|JL+Gr^IPfZa4jqn^-igh{Cpieyal*}Az;8@6d8uwxuqe||&HAdr zDC{^O4oY@9oxNGgP>Z~*nvD47r#JX}&Ia!xEKAwoKEqI;jHwl)BPHgsYZ1E~^y*-6 z*xHw>DxYtc!%%acqhb@+ftBxNPg#??G0r+v1@DbR9pPgsA!OZCG>1~Aa1M1!!o(QH z7<~<=)LGn*1~VMA!gy9=-e%;FW)Kx`_9h<{N7V43`Ke)loKOSpw44}MnV7okrR;+m zCf+$(I%pg+VF5FMtxc4I!hnWN*Pc-0>`?KbAi4F3!|u{5S0qf!PWwy!V-|!eHB&;a z@j+@V6RnB>&$%$_lsa@LSs}JT&1)By@le)Jr-rR!(qPxk)CK>XX^>uO7Pyo0pO6fq z_zDC05m@o_|MPM!d&1yV^+tyd1gBLY;>VpD1f>G(Lp}Or5Ykevm=zOUmj|ZdDa8SS zV8S5`JK=|l10HhLfnC?JkJ{yG@!8L!=;Xu>iMaCvs#@CzQ2Y)7UNNi2buFVj+es0+ zOYoznZMlQ45im6o4gDoBz8Z?GntQV1=z*WY-R~aAa${~oij#N| z+XF2x?#^5~knbr8Nv%V+g0!-CgGRX_#HscBaE^I@6pT2U?6k z(T)8B6tdmkSJ8_n>vb`CTdJ0VF4SKgse>ZK{@b8X-I(k{QV&SWpb_~sswHu z5P=RThgt@&vS!M@gTG>a&&^GFvNbTR34tFQ5YoLI5}=Jx>hjywZUb>g@9)9g%RlIC z{}1{19)9@W|MtIUKm6B9M)Us1Os@WYt(QNX9R7B=m>KSCp4O?j){o;; zKOFZUD}-$|ke^I(nE6qZMLAKXUnrMpB~2qu1H|*z@bD+e0`Ng=`D4nW8Phdd%4c5= z2FQoO!16NX!2Lb?)^{DK4+@FznnlD}fUI?E+S|MJx7iCxy^2mE-?5Hg8ZM}f!4d`; z+M%VkJC$LK4a3rCWrJp{xrvXD@2OvQOw*@MydDj%WvqcKDne?ra8JaB2e(3$}cy_&3)yY7}myc7o1)nJGjDCnXv zpkbZ6c)66BU9(pO1f7lM$d2|{3%+a^06xP&ErOhoKki{0y&hD2&UuRt1c3=CSd$5_ zHPMhL>dVTfpJ>fdB7__q7}rr$HVoj`0U-{|Dsq|brQ77le=DGjZWC2bga~VVG8(+f zezUi^0%$ynMo7lnGQpOMJv92qoNPoi6vB+gN!crbFHP;RiW?AS&E!>vw-Y(Krh+0lwcxq2 zzsUSQn4I;}w247LR4jsC0<{{2tQC8rP!7Xs-61_BS4N?&6>$WP)ov~OdMxWN-md?@ z+vQDfDAF;(VGt57+^O|aYmP$ihe2*(4X^nYQeiI;@FNSPaFuNWAjoQR9;obyfF`UJ z!hx_85m?l_3`&<;nTeoi3@VbrvUpNTZ{`qZ!lDWa1R=>lyp!2*a+cNCBKdB^fL~fX zRjv0K!ue{D<;lm@`Qn3|<9&O1*$MGq{D>wPLi~p?#}wi3Ji^l9BmQh1AsXj4wJFNA zn(_ej!Ew1A4sVl{7T@J3AKcR^H`*eM#I#9@2p=^xUb1C0z-PsceuxKCe2->NnH>ia zjLB7e53gG5l3F5cl5S@D^nf%aMokiBS6@Y*Z_}lt?#ux2+L`1_*&J*3dU5VgT=263 zNWW@UKrl$OOpO37NDWf?uoDRsx7@VdWy*@k@L)7c+)iF93@6YSTX{~})8MD|=3-Gq zbgmZ!l{JnyiUg01Pt=Gg!T$tKsA&vX9HbThY7Zb_f+F;Spa#v@HXSR5xx~epls?91 z{VQ?=m(_+sn|X`NiUOfD%GE5xeD*6)AM`3eSHeMhCp zFx~u7?wkeOYe!BA(TFZ2K5c5?TU+DWeW{^tJyRnM@~fr5jylXhSxIKfy>lcCYOo@zTZg#$2d`Tqbn0&bp+XQBIN>AOcOVR>Egf< z`m@iQWv3S%Kdf~#coH;EZ5b>qJqar?-Iv}e#*Z5XX9Q4M#{_IFID5PJSJ_VnP8ktU zj}%_u()vV7acD!J6-UdB1XN>0NJQ6gB5Ngim5IPtC<$;U8ABL*MMavz@O*iN6|z^K zdZW+|0un+Y*vWgcq-23!P1eWK7D%cINlq66l*X|@7By`?$XPwhjf_GAPD^+3*fv2Z z#}6!s{}YD~PVR+uJP${Q51#Vac?lPPUt$-mc4F}~9?ZgBUOJft8lkz99A`k85`g=u zXE2lC#Ib;??gtNsTu!@-+41FP>Kyw+IUZ&z=-jYu4q+p?BYa40qR1@R7jE7GrAJn0B8YY;Ih)N=7`00`rXED4s6GOU_;_WQS%y`rZKpwMbx;t^yyZp-^K8t|CHlFr3S)7NVRQ zT74KaQg=bnC#0V-XrN8By2V6Mma}IvZ>jJXs6kB%yd+soi39G`T0tMD`KR39BX&wL zQS21M=iDelX4Tf<39Zl!B7c(2|F37-Gu90sXcg6jzA(zx=7cssIHByA>^pn8h4!Im z-jrjlV3mnQHwPy-ayZSN;zu8DS8@iT^PYaR(c!?$31O7>#Q+Drnv6rQS0->`B*zLp zGno=7k&7dqE@j)+-{g>*kDKLZAr0=@kTgD4+Xvoc_7PHW2=kausHIHCqTGzssUJ>QNWO8Wrb7lpucpg{ z?ZTyQRJCDXSGJ3w68M;zMI2ViVBjG~iNAl9H8Z*UMuP$`?e&0a2-mtpB=1_D2+yCJIeJDTlPLrd-$qiN@Jg8V5B zET@p6Hq9)M`-~YS@$=LxraBE0jc({LZ0p(10*{Z1h1%TjO_j=yY0T|%YMZ5MyKt$C zlCw+$$w$Vy%>0tSzK60K3-O475AS6T`)G883DvC)QzJQAlJc|Zw+=!otiQ@NJ9$vd zzh?GCYO0~;2h)j#3W4)laYOOU&0wCLQ}-M=_-W0|&^yHb`x*|K5=C39*wm?*6{8w{ zZ^1)5p4ieJ6wMgHtBgk1Q2X0kpjggQ(_oX#J1*0}cF!?>edjFDcrsLD%!i#E7wZ&M zslc{KjMTHJ!~kR|oC$+X1fZ1A)ZtW znEP&daa^X5C4-n`Bzi~Mwj*6fiZIfIqSd6xZiJ0E9f?6(83(hMkx0cGY!5Lb5L^)&=+vl!~q)?KilIo;_u>&`{q35YnS4nJz9 zJse_+Co#Gl5al-afqI!-h6t}s1uFeE?=hwiy$+Jy5C|)nvNDhq&K^4FlWt{0um^mg zRtA=pAgEAR|3Th>}D@Sv}o z?l4oVXz{fofcFvUj75JvTU?+(09rw%>cg9bbQ;1;EEn@fJ2`dWrS&6+0VlM4%?xei zz>H`fxkY<^bFQp6ICAo}J2fI6nHp5i>^gptU0&ogr`TiWx2;C`Yi5KlGsg@(Z_LO+ zCGMMCpe$Z4#{6fm%Z!+2Vq{3wNO0SXB=#Hv!)6%q=<@f))$GwlxmMoA5%{IyfZCXV zgiUYo<(e1SLfC}UEu;*t31%y#97LzminuXxCIkV=gy2Ml)$IA@`u65HMA3k%=v{e=M%n z-hH}slg(evd5y^yURpzt4Ps9S${l7h6{t1Y9->I%c1I+$QIHi`9UdrCyA zVc;um!@x(z(7^qU%NTU7<3W34O?+iWWMpt5s6^K|&XyN4>1pg-4D)PTe9biLICKe+kO~0mpEXP7j>rnT=H|do!5ueIxwd4X z6^#;j$iTo`?$nE1_7d4J6U-hh=JVn7pmJdZ3{s$#{|w^`ZCcSCj3e=!tvs-;_mmzG5`!cT#&zlOMvg0;y;=RM*wcYq6V{;~n%Kw@ zzyRR2H&Y4R-TYPzA%mDMiSC@cJ4DtvxM6?svkxF&ug!9zM673}J>@h5$G@h2Vx* zPd4jo&ji%9W`aW?47lM=jQ|VEI0ES*sS92172@EP3 zc>?0@5Ol-I0Kw0Hz#e{*gl}r?%Pi+F8eW=*wLHI$4lkXd3-n4>W31M*voE)u{Oat{ z8E_u*t2swzQi4^^;({Ht$CwZtnJmI+Q^y$KRu6g1RH$tUF=oPN{FI%OvRjBRB^UPG zC4d=&zh z>D?oR;}}V!;;pPg_HdE)UpF@&mtVb6aL+XZhwf2($WS$dCiI>=N}$E6WRr)o?%^u$ z7hT4jKd2M9R3^Jo6KQA(u$w5-yE<&pd>bTU z+1u7J7C6oA7%CfGqT$do^s0*mZYM0lywi*YuX6MtV=CBl7ss04lnYqU(gp_Upv=Hu zjTs|-r_M?&tpXeh%w#i3=f4^pStw8y7fANU9^>Jc3?W-q!u9c75&pG2)7g)i=y^5u_Kk(G6!79d>&h2j=cluI*;L+u88}`)7>gd}KA9u*Rz(>R3FUdMHQW|(y+uNVtfs#27Ean>SI?%=uH4`gX zw?+Mj6cvqToD-*+xmn0@vY~qZL5dEJ?-!doXqP!POAR(ZdHe}Im+GI_7jY9ZD5cM6^Y^(YpF%AW4OsB{A{zlXORH-Vii@J@c3=SZZSRt1h%#5VP*&KC=7wyq) z^ij?kVaq8Z%ptOJACwEcKrKV$sM~)E*c>8HF27wYXHPfFe_a;4I{1DA{KVMe5}?qD zjApCZp@soQDDNi=`0=TqKBM_{D;pflOdXjcN8I0n0H}SGP`v(j{&8{HoH~NS8#x>p zPQ}CMqf3p^wiP!3V<*s!+`#vI$5Hnn7N%5=8|C(K_@Z$m2L33ax^`5^aYF)OhF(&a(werHh{sw3L6grfEx8^ z{lv%dfh|S{GQx*31kxCD9Bbq292HJZ{6?crCL#*iHt-5Z1wo;a0s2vS8iR@^O++)m z(0_)9YLNgW)}zWRiiGk$&sWbeySWj4AiKxjEHm{d!*j&5igx2}Y1t-7j7*33%Z&^= zA_ggK0zaq~0)Mp_C%6y1wnjpE;2fyCENjs5rDePexYcp&1VWsO%&NCKik>VkFEArv z$594SL-`OoN7{T~VQCl2jHc6wI?1{^A3C4wyd1R+dLR0YAd{I^RbSD(JLrUOIpg?g zCHq>$4fNpo>UhFI@s|Ytsvi3cH+7RAnnpGViT7npM&>Zd;48jn@g~}ER3WAMWz3)A zdI|V><6azlN+ClIppGU4lGklVHumXjQu*8FSj+{bJ6_qL|fiYzsf(I8=2{>!A)|u23P{9vrUG%z_AsWE z0SSPq3K5Lrse}*j*3yF<51jF4;S_=vVpxPU%drAKFfi~vRR}idbh%8e9n&m2YUeo) z9?pFaT`}0UI~uZs;FYX*{8o4ln0ZYLqM}fQ@mJJ2g%cTxY#(~nRETX_dAAfJ3^Jh{ zO~3K<_Cj{>m*Ykj_YF>0{gPmZ1b%9q(E1PFe>x|6O2HRr18F;q zd0+#6)I{O^`m-E8^IDEbE_P{$3Dg)kHiX;)cj{y_W1v?}HjMd;k_j}k-Tg(kgOXt6 z{NmM82AJgh0zbHfM`~-pUsLE%isUv9jMV>6wT3Y2%$n0#puo;$zFcCO%IkCVMJ?L4 zz{+a~<#4Eyten!+<0>Clmy3(#rOYc|%uerj$5g({2|RFf#z^=ovr5K<))O?LO+ato zMS5J!AbQ~3IAqid_Ng7?Y=`SLe$y}`F)I*?Lz!8o&KQDi5v3T==~^&z9K;&vDGUJ0@iPT8 zj~AP8?g|q{Gga!7QWS4WrW$tlbeMnwhKa`Zz;6VSF|E3Pe5AK^02CEaI8?TBnwXq@ z71|vK(ar%4%IVNZyFWeoxLlSe3ZU$@ZlMGQM!*7}sC7HjL&Ll#J;ty&wk2yC&-B-} z#po`Z#}ECJn$XG)3|W7Q&9dLicEB?K(rK5Udx;k(BoGRh5B`_&Y@T zc#m@vI?5VPqe4(r`%BV6v)-K$$fod}MS-u&qCj0yUBn#=qC(VwJL({KmGvMkeEz3& zg?w;+5|7mw;IGDlD#m~70{K64Fy$z$+_@MXOnJP%mSsD$C(Fy5)j1boRNEpv{y8q& zK{Y3ir0^KcI;i%k1+xH6`PDk|DD%NEsX%AuQ1{%Z;>mqKSLs2P#kg!I#!kH7$}R8; z%PkmR+um?KJc6yHeh!2S*6`z7!{KGM9%^&|x1fwPThV0ipTI^ z1Oc~GZqdzsgET(H0X(hE5jbpNmO)9VQi~8WxXc32S0Td~ErzMIN(+T?sOQ0vEo`@l znsGTrlG#d@hzJO7CqTl)V|+q+!K*A3xzz@C`7^jDR3oMsf zC@cegA}es)SP?fy$gBupq%NWtl5Ke`z<^O+gqdq-r&>1HdUr`LdO-w==hBOa1a2D= zyU$vaQ%34TS6rG!->G5&I89B%&@14raZn+=L$+Clli55_CWk{ilsF8QfzmXS&7T-f zo~_P5%A^b*OgI#rWw>Bsr+_M>0Q~kDW-E3j2h>w$DTQ7sl-?XDuCh@6O(x~1wSCSc z0J>R(!+@8~5jJqJW&(*zi%>Ks=U0b!!5}QoKoJxIUS$ZFYrkB{L>fFXwp7Q}Ke$cc zJ63;Ew;e~2#+||DUZ&00Wsljmgwy|_=*i-n)K$}@z&mV z3I#B3(q&tG&#EUGBJtEC`KeOl$E!G90&@%oRb+6I&Skn?mUDyL@n{ymWB~f3-Es8+ z6Pwn+mh^aVWqz0_gz3g^64w}aSE zvUXsg`Aw|C+!#=x7HpQ7=Ao`@vcu}G%UA!Md68zNYgb6Niyz{q&$y+g5wPHq)UwL< za<$85$9*K6i8xkdB$OYMktmZK)dg6b3U~%01-%LcU`nxU=odtZnm}+nn?@foZPC<& z)mH-{J(@jZZB76b?Hk;a6XnSXQvF$RSjpTs-3^jIr`+6{wBjuv2KOs(?a& zXRFwq58c?V!l5&FuFVLi4`IF-;4+_qPniGAjMx*2UVzKjWj2hY{qYn<{8B|Cm_~D2 zDLjlBh9d<2YJ>Yhlsqs-FztyAHy@Fm6x8tav4g_Wwwu<%WZsosLGA5!cSk`*^!^z=qhl}~iaTq(1l`bQP>gbu4 zvY_DirEKP{b4sewlc$ef0pwvB%KRQIIb~NnZhFSPd~1E^W(uUUCfXT0v;k8E7xAQ% zbK2eH$A^AR)+y{zJAQbckB_HMANZNH$B;Ail|^zj&k-btebQQY*4&yMKTSQrD6f(J zK3$^m=Nhf#CuTVtz;6r%yy{Lvsb%1pt4|zvlEWB6qm5Jz@Q%V7dPlRnK0s76VS`KS z{|cQSppj7mDqvt}i~!&i77{{LB4^uK*sT{xAIOCH4zbg&ePO*L+S_=b(upd&OeW3T zP*a)gBT849xj~#WHxByQRp=B$4VvL}=NN80Z#F|avHpmR!)`e@xlCs{0>ri`au{w? zhpF~4L}VF_%&%%bQj8^OAMAr5FxhWDU2c}Lam!*;o@d$#CLJ$A?BF!RnTZk}MaM6v z`^|%+)1pHPFJT`cUzd>>nUNH>JVQB^7XgToL%9*h*W5tel4g`P;;_J_Nk+y(Nix|+ zN?K$aq49YvtZ!XO;it47cB2XMBeUYsWt?>0$+_{nHV7zH9Y|$Q`kg`G>oN#qrqN{t zTF5z(=3(`K-MByks7|1n4Tip5I4)$pbatTxnczNBMy=T7$(ef*C4TA7pluV}(;p{JM^^!gw=YT#JQP+X3J% zhn62B#ho(GZvPyKk+t&gUu8Mx<>FUYeH6Ur0xD@Xu@e>kwCYdL%HBvL%H~YsHMRqs z{j`wmtl$B@R0Dw@XCTT1RFl1GjP36?i;wdDKmGv9Rr2@u_mA-RA^AH6n^W$$>&O}x zi5Lk{ZZk;Tj#!5d*x9{X&!9TGfu#pW<%S$=TZ*-LNSg-@6o;Yme1%pVcTAAt7QT$!T63b9 zDmyUVg2cbfWuk2FL27{LLs1VqU7P@87h!jUvt zY;pdnqy*k&l%Qc$$zDJLAE;v%HX(%pmbOoFQydcMCXz-IC|w%mQg_$$<~mK%in~8zGv-oiR!%B+blbThiMLW`Vuy8*3{>jNLLLh)8zUvf4tD z-K*mc@Url)QOTgeL~=NBE+tJK@wD*&wgC|zK{@q1)JS-CM614D}_=W z3>Z<0XdkSvTbGiinrKIeO2j~_j7Gff94qDNf=`k6CWF6TwclO z;_S`shY!7t?w&q-gBBQ)%=r4H)sKlrkhG;vKUUpj5P^!dH|I-QoN&U> z(LBpFxafx%+h(9Ha^UUsG&A*d#vV}+acdBH6g&gaZAMS;58fTjp59*h9xoKVj-;Id zgt!T48V~Rt;{mfF(!g(S7io~)d}my-R0Fqz_HH;a--9;y@0H8@O${{q|sgcO~uqP5}SMa?8g&+@rQ6b<}&M|*keB;q5>vBjH z7GFn>4uX(t!;oqS@Vw5#fZ^xRk&&Q*WF%5n^~>V&Q=yk_D2R&6Wne`c zifkAzdZ3-}IDD4oRj6Um4Yi;c0+328V-HM5B3Oq`M7fk@tA1G)-Cb=RsO?sP0Msdt zA`u{Md*aZWz^mkN;ggNBDGtCZrBy*CP=lsW%Epf}sar-=Wv@ejDx+WU0O-tVppu3} zh$L{wj02z>5?cR3?#fFR^)%wPP+X;%0Q{a|D!K-W>GJ3Y!%-$`oKi^)L zJ#%f%bXbI70sz!ls3F_|i!z>~?zF69L^4B2HDVpNGRJXQ?rOgU_ zck4XXZP|7?s)`S3jzO3+Guqj900O^hI#Hgc^z3)(s&&aWo~}ir1fk3_W&Z@krxsjX zEk1Ko^&i{`OH&Tgy$9l^jBn?0MHk`X_hz7O#ojR)r6x)^ooEkht1Q%~G`p^ka>3fe z%+0xqc$Tb0V$1kY6gAY|q*A}z-<(x9>`|c<*YjE#cr=>vp*Xc^q7-+UR9a4o>UNs< z9ao%FnoX0^omHxTKu%kwP_?%2!i(#0Cfla-T@@WtD;gb?Ik}NTbf+c><I35(mHIm>mkp!1bm70JAE8q-+H82$P-cY$=mS~J-b_1cC z^#wxokI(h#j>Ew*qCdchGMYqaP|OeQCOrEzGN0v*>*K*W#^#c75zy)%{Dc7bmj z8~U*=zE#C^Y9W(Rm=~L0=17LNll@hY2fkoajKV{;*T_hyJDg03 za=<{lm}nS*6EUL0Z6igTOA8ZiLeW20x=jn>(#-uF7(gHe5^||76twB2!P{uj-4t~< zT7=%AObcFBe&gxlYdAu9j)tsF#9 z*N}P2X$D^xx1W|WXIL7$y%Xf? zAH!Nk?&;RaI|1fqd3}4S^YLZf<>Fd9Cm;dIcLKc>Pi1L1R$5Rc&68${dyr4bZY zIr8l?(|DjfKz%tj=()|~enbqW*8gCLA_s~Wen-Y1py10^|_t)#IbLl(v zYcQCon{9v&<}&amLnycmJd~Irmno3IpA{3O$Yk%?JA@ML<`@y9D%{?R28!ea6LZaH zXRA-2d$ZR-NCN^tH6Z38<#3Ux8gL5z$at}Vfo4wzBA1nY;C+J2K#N?F zP8UsYnx`u0@Sb)+5yMOTsENfBIUfGQ?8REP+b@uSjn{6J3~Bbz-~$b*V5LC|B?y&5 z*yYghm5JyB!~Nl?d+nqkxEj*PH%HLGYZ4kkGcqsmHit&{q%GHZ zh4-3%P9=s?9xbU?(_Lz@Q6_oeDd==p@lUub^-zqnRaRu50q|qUX8ib zJFO4sszk62_GCVn)J9h0D3i*3C?KPH<77;?>VbzJC2|Z z_>KAvyvNyt9!2oC)$;Pf`wd5eJ7B<)GOp6AsTkyVTo+NX;^5Ry5QKjH3_&2l%cV?v zpPhX!C%@zIQ8SP{yc~NRQoU;UQI=D0)~g$FM>rLrodiC8_8u*nr<)dokL7ezl&zTq zG72;|orC>H7d&rV=8njE{GziAty|NRwyJSm5GmX-VxUHe7;>o*?w*NH8OM-*n)onI zbd2bBphhh4!)Aob$z`t=tIxkKi$I1adewUEpom+!K;R7vJXLut5_>mx;P-yzPMQ9& zGehyv5HFJ>jq55oUJf)2I& z%8H>?oGjh*qGw&JKZFCB7}?D!65w@0A}rKEL7P78r}a{%XMbL7JPsgq%?iB3B&2U3 zsJoFu&0=slZBmSdF?Z`u4qlwGY-=I3E__|c!Kq#(P!EHE^{xV$uo4=tubH6j4+vcD zr}W6V-xvhlU9Sjkp9;8bREXn{nF=(Ioc7642v@6RYY$nNSS^^Shw&kp1zy|$Ln{t6 zP=<~p9Ydp32!#NzBg}m;aC<8ldJyAEM|`tJ0v2jW%!6s5&NUP)`u7X&2&YC9 z@;MjZ_V;?)dE*jv2FMhLfUr!16YS|$WJr5cGl#)Sw$HVj^6 zF4)0B@75Qe7ajz>s|EpVYs+Mt3ncFyxS$5ZAYZFJDDE}@g15x4)kmO6&RahDD8nx@ z=J@-nIG3|sef%}qLfH#~JGCkNUs!ztk(*x~#QDdslIw6!6^pgo^>@u*jj~xT^Jk8* zot8`a?$1X@*xoF^&g2Lf=?<6Xl|eCSp=!gJH$T0>-(7Nr7%z>mmB|$<-%PF;Sy|)b zp%gKymRKNvO#`zQKe=oVhk7^Up>cDK(FHDXX4<8o$rD*;@#|Vyke~{KLSYCxM zn;IU6c_}$w3ZC)j&875;uCeLe`dCLF+^9+!<#1SQFhR_(Co;A)O*bc@#EP!`tpyA9&G;~CB?i)lF{i1H@mDcCL zNK3vH43M!CHc=s48v#7J{B^mxnY}CzlVYY{drGEQ8ZHDNaA(X;0MvJkAET9|#KTD8 za0p37#sMXAF7xdYo5;8wqH$YQ1a&hkz_!{%LIjD2YAg_vt8ngVA?0LvcX|so$djVC zd?(I;M#Y*2qCLej&{%es`_2adX-M$W#@9k#(Y6o#K%v-=7CDX9F%-U~HE=MvA>{?? zo9rWmQfM=U0%$s3yvOMjk2mYDK8{2S*4E*1C<7_Hvt|UosW9l(bT4w^Pb@|4wEIQz z7`k6FTnYnjCm2GnLxv&vkaUEtsAjnd-c;iNNMlg!X&mJMiuw!)aDZYMd{ZP)$%I7k zrud-}f>x4)ODuN$b~$Uz@^ny;3L0zR8y0E=1yY@|c1G zTMZzEnqUZFJS_`jsK4x?BxluJE_dl@z)y3gU5=-Ti&=lV{B~6hry=9}=X&#L_VTKG zKE#`UzAQ4nhlo27+v)>w5TA5gFu#c$qnOdalJd{FV)Ak{4aggqTpIiu9A zR;p^>&u@Y<(J|2`gNx$ek?du3^L4ZO@bLyf95;)QZ+3xw5;TPZ^|j#TC zW^VT+v+M>?I!uddyKaoYWH#k1u9?;B+NlaEo=MGx})mOKBk~h#a`cS}t2WuDrVTvV6uhFIg-lDxAEcf(KB6-Ca<|`nB+QyLt`K-~Q zJDU~-c3nZ(URh?KY_7WdZSTYeJXEtmE5E-kWP6V|@XgyyB8Ve?qihHmygrwnVwrd$ zt5al0xMhh%n-F-H5u%z!n39{na)9k{bb#&c$JOQHVtM)H<7zQGy)Q#;(2#13?d^*n z@%KB9u|Y_T3hj(*bn}!ntIDDWRnpA&lX;PF(eY}+6&Mja#c*3qWAYfA%eW3vqvR79 zNcS=>{HQjFtPAvP({*8hhn+y#MeM8#aeyrwMQ{_Z7rL*}laI@#u6j(9JAr{oBtC1= zB&ue}1W(}zfv;83lje=nu_(Jo=R}lT0QN53I!HSxSc;LU@IxG3L)Ds*bvmr{@nZ9- zoTA0Gj|K-ZP{)bVB##mB0BB>>VDS|WbE1y_DSFm8O8L~dt+TDOdF;%OxVSO%BZ%ft zx0kEi>)Er7Y#v!8pe~qlc#tU?Tn9MtUV{S<89mSvcNtDO=4AFUZphNF+m4+XN z-gA^gQ6L@}1$G_3yT!0Pyhu_DaG=Hkjo!uqgsXAT+N0p)^mMVR5No#7WN1FmP#xfy-)uP5+p4t<3697Jis?gtVZs zO$f8Qi*wM}F1S2fUMwz`5?^kX_E;Onw+WHi+}aNAfB zXYXaXGYP7*J6UN@2+#K;H9c%=(@z6+B~%WgI!NIk22rT`VX(mNPy12 zDF`S?0wI_NZZ#$1$)%i7F?+ZEHHsyEQS$+RHIWDjIPTOaG))7K`VJ~q!K^~>W%pU0 zc{LG*&`F1PD+s*GOwdlcIHk8OlXRd%msB~p;)D8XfaS-li`C+4F?+i>??wARzIh5P zT(pl0PaR<4KJ?ZU_`Ru=o{`3W(<4TyZAuPu+X?rNPyJ*7H>HlBEn+;|GR(X<6iwM# zhWjX@whG^noRnX$#NJX4gd3l4^7m~ zhl6)!p)t#)9CI$@qPCy*Zk5tJt z(%1S!vH9kVMD$&_JrxR0J$|(=!+gBRa6nrpgTbZQOShv8KQ*1ePpfD~S(2lfG085C zLo2_t%!l?RauYgl8}1e4X_NpZ(#R#tOW)mWcocN@mu9%j7-e@=n(A z|5NvEyKx-LmhbZwjg0~3VQ>hMY>L#p>1NB8WDBCs_Sp}EL0fE#ebi!WnxthJIR8Gm zRzy}rMrIbfnzr{Iz=q4L>Z;0BD^^_cHa|S|)}}|jU)6Y;1=pQ zaAZ1>_6|tHBxdhc*NAoT)a+F7lToDzlIgGj5fux5MY<5G-G0O zfcsKBVj5_U6ffxTkZBrkQq)nT!+w}08mi2|^HncGPZMri>!vwWzIhvsF};`<3qY9z z2|z^I#OaQWpfybolA_(z(UN8^T`sm4B^q!@wRqBEL_9->ESg=L37#xwBCt&MroGjl zD8R-F;wg;4nW;EPfAs7vmWp4morSbBVzNU}2$do{yru+SmIfktOhv&y^&ip6U~Is9 zIlDN&xz!#gKf$xD5%{TEMM#A2f3! zC`MKQ;FIGg27YA!oaw-HMLa3CpML~K>WFLJ&}87??14;h5-I48VKdhtn~~|XB{o|> zHtw8b1Lp!xSnN>VTqBJ0YeL}76autb5s+5n+CAGpKP{#$NuzN;dS2K3oO?*~@ex%C z=iLG4R0E3@WVOs67FXqpRzN_3p$n+SSjWnsL&9;ve4~(JstOF9$)bZ$XCZ=k$sx}) z!K{#oOF^Jz&8R7@9{Xl>_5Ne1h5`KAFQQ>8hhc^e-m&%wc&hltJ%Q-X+akn{65Xjv z$K9dE_;yYhzh9)jgWFG^FVhN<)Q=oJ;?-+ubjA`QX}nqug>gb>vrQ(&!^1=89^7gv z(LBmYeRzE}kDUkdr9j~(ZRwbn-(Gnryl^l$5c|OMl@%dca;yN_DimZfm6FWfLnu!R zB!mkP3i8cZ5$yw~6^ghaJWh#y;BJl@hb-q?`XJ<+64a@cRM4~)=B<8(GCpZ{KVsNjRv7UF`3e)#BUArf&9 zEON>us%fl{qd_%8Ny^#BVd!BqEO=z@L*}PEzeq!uilx3dx^@(aAe+Ewj1~Nh(^+x9 zPNh&kCl6YaGdPbgtrU%5(%A;CR}Ap_btoD15*O7N0GWH$qe{yVWdON&W3voOYMoMb zM{NbGU|;KtG-@lA_kACu1A%rRN=ZD1c-j{y+aTbt_X43TH{hivOi~F8(6i+&Wzc?< z)UmiKlj}P{NKA-bDU9K(UX*V)>x(oM=KN-HvrN-yx7*dGGj!_P^PliZU67AYpM(5e zXRG+m6#QO27agD``qWx6P5De#COsGyY?8qtqHHEW^GAM=?ITld?t1F0Vy7AsYoLz@ zi32M;Q{YF%dzA}-{KokOz_A~u!~n{vg2t=ey(S) zZ`Y|{>ODH}%{r0}bHMh58{U-xMg0`wm=`HWpvu@y)(Zn1Mlitxr58{h|gTp z06)DmuDa7EirA_@{gqgWK;k{KJ%oaC7YBARV&lHB^tDq5G_v-b)uM1eEza1aGdw`Cg^bc_OpXpz0p)~ui|CTQQKdX!U!;KvN z?d0f}qs8G#>{pqO_N$y@$Y>fodVc$Pxjo;cbpj}V)ufg4=Z^uR%e>$nI++)~ZF6Nf zCNRncSW%9#O%qO>LJCD(<~3Np7=&EveCA=XGMp)c2HkdLSwv-GCY&fUFDDN8zPUVD zR7%NvF@YmouYTc}8la+jjZfwKSkPXD0gY4`q&>LSrJuO}t^+GWL0wA6!~I+gH8O;) zTN}YUdmpj+G)vPp(jwDkeaHn3Xj+|h_0_>afxC!0>nbySn z$L6*et;G^);8#-73FYWz^h2$VL6^khhiCO4$w?o>McXuV>7iFIur#7GHQ1+9Ckwp zw8IJI(=_ZmxeJVY?shGp0m=t7Kv4*MXrmx)N7MI1!9oKqSOUP^VFdLEJAaP>UcTCZr`65J zZ}S)QuIgud zlez_vea_ycJrLKkC+o%U8oXEO-kTra;=^0I$J{!nd*x_4yh=0MJ94fHx~}SUDA5~u zIAzij?%+q^pXe|-G0szJKFN73dNq*y;OwCyP&2B;S32 zqtRYA2LgVhAmC6Xn!a|AkpA$IvrU-^#`bF&#M? z-b^_@af+R`@sO_zPSD%7;TR09*O}5;--uwF11D@%HE7L`qe2s1YJ!IGis&&7P#4>b+9gMh!gvpI~4`Bmt;n<*k2rrYDEvBQx)r=}d=vZ^60Zg(VO^2cs zdwP%(2wEC}5J(39VR5i%CQfU76MNV2c7gM>6U&GLPG=l~J{S%_)iFY5IMx}DhXOxV=Rs7&dHl;nyF{|` zo?Yh|i10Km75OF2PfA(e)za5NaGlzO1AvGBUjPs$GP2q9mpn2{_$EzwPI1&GZL_t# zDF$NT!hb#j=1XPDb9$)>NpBYgFxlCGjzNF2Oha@)DD{-PKv3p7Ij2F#*#Ay9%DrfR zWRKdTFjMJdyhm;Eew$XfPb>X#XB2Y0%CF8JKSi@Gzj}ahpq*a_&TAW5_cni{dE;|8Q`6RxG*={chw}GE0dj!49{aV6o-O zd)zt4&3GSm11F;i7Mfmr1!)c&eh(1(o7nRH<{S>n(R(Z;t8<8}LeLb51CVk?@phSp zpI{xI<*ipn?rT*G1F;fm3~>|A)NvEP+I{+v$^j^@RL(nhp}^rYC&qZe8kicP$L>SJlm{Z`iieDz)u*SJ!^kBfL7|aaZF&*c%RGWa*L4OqVC4JD^>S78rQm_1D5MeZWn6te zM6p#j!mG`7T4dnEa-DW@N+aVE>pHV_UR6OZL@EclyUy03*Kc@n85jh+oYIRx=zWx1 zPRpl>^UJXF!hf1_qRKIRWh=_%=a48D4q%9Koj!9mOwRCeeWoIZJt(cO(X!5%F}$S; zw%Mm}v{@e=)9d4h#k_nmO*#N!=^*+CXSx=aSm_}el;gTkET(Z1gJ7mlmltU}m6ZDa zh8h4~OYvd%g))?g=!iN4C(OyfjceI9G-Qv%wxL>z+s=G))TX`PXsGyc#z$VaPW(y@ zAY=w4ltWCn0BWgQ|Mxc8QC$)0EO$0_)mLsB(9ug3(F@J(GjuVze!@d$AGwcw3WsWtF(wkS`pkC2b!xO;DPE`cqkEX9|W{lK>*_S0-+52c{_2W zxUqpSCKQ1VXo4U?Vps;02NphEeDGNcG3*}aeZwZ1_W-hhhmnYzX8G984w*d z?CLpQrR8lF7-ySSZP;EEi@@PQN(ekXM;bU3970DluCH+rTiD-o*oPKBIuVHeC^EdR zbD`XqjMH?SO*ks>`?oru%YfHKwSQ(Uc@b*K4@Yask1<~7W-)uQ_#&G_RE6Zn?_QzV zR!C;tkYns}pbn5|7m{5G)k%Vz5Pw4QiZTi@+_a3r@+F)S12RW(QVg*jTlwmAF0rU+ zB*S{~6y>xGd|Y)C2yb$T?IR}kr{yvbUN|$KNpCO220*nT;IE>LQuA#4hr8V6!w1E1 z9kT|V8*g}>&3#nKKsJY!K_H?0O@Vy2N%7MvMV5_S*$8Vb4^#?~hfpbMqr&PIV+g#( z9x|EN1l7TnBp4lr6iW<`)BdiO-LfH(F^A#CSbEQS*p>+gMI4y{zKtixdOktg)0> z1Tf$`w*`am-=5lOS`x}dyq(dZ4ME&2!KgstGziibb<4C(0M-NWR)L48KH#tpAA&yM zqA?7F5tD7AS4qm8}Vw1t%k14?b+Ojr8XzR1TM!39I9R5uu8!BJ;$~- zl?w*DA9`AK;4kh;zrnlTWgKye27c6Zp9F$DFDAtgLOW5nZ&0ZmC1hE{Z}A?XE=FiyNWId$a^ajo@+(1Aae+5PVxklX5hb5aLWjHxqAVWY`G;{6_SEM+O0RXL!QN^3EJ^(P-4CvdGcY)m z^e#-UZO1M51|oNtiHnkN504jE5W_c|&T&iVH(>J_w*X5Qx4c;{w(GQT;Pqva=rV3$ z_N+9)@9Tg*sC1ha{CIa2%*SYvzqTg33;^h`Jfm;|Jgx9=MVPG?SZ=OX|y$B9?Vl=`A$%~{3~ZZsOy z1kJ=f6%72eDuVF6+gR+bnFd3!jHnULmBy7S*!Y$Qd4{DT*J(-gFCWWVh@Y3?Yy&M) z+X%#PSm63fCGf}T#Zqgdk^*<3|De?wCxT1>G^IowUT9bVFh>bl{`yIpAzaK^0^@5^ zI3Pmii-wL`NIE|qh@r|MIFMNrGT&epct?>+9+}TbLl9<9H)(l-g%=4tt%d+URW9sQ z9K`jK`{EPq0YR^SQ7mK#C5$tom5vLc8^Nf+BZGnKU%yLhWEL|!aibar{8V8G0VdAW zOu%371A{2XADZ#u`#M9&z07H8hH}^eUVRjRD(T}8&Gpx-9eNfI|Lwtk>%PUF#naKA z#kBUuuS+fl@O1I(Vx88nYNwn}Up)uXF6D&ciUwXGa|MTzXoc*;)nvee zY$54T3`9n|HnWQuPvX(uKEm2>M0i^45D~$r)0zy9oWn><`J|PE)3ULCR-Yf-iJvMM zco7974DQ6Isy&7d=>#`$mpwdZZ`m^<*4K&juuP4RWZ+Y^bFJ;-B88K;X|0UyjmHA4 zu6+kl(dtYHB5+Evz-uZoXw;Hvs8RqH)eqzN5Gsgr%B6Pt;k?+t6C9j6&^1h2p@mR0 z@O2$CI6(iW<+WdzzF0>yU0xSw!mv)IEJe}h{R z#Owoc<(o|!mvNKUeFZ?`TAWzm2Z{p^n^hTHUrQ%nm7E}-+c=C#XNiINQQp`v7@!m! z@Gv!xevSdS9UGpl(sYg2tE;qJ<}Yc*OrL$?Yu3Vv->X(k%ro}G!ns?9n7qsWi3SjC zCK@l7tDDQ&tD=+9AwUX>2ZR zHxc2TO}Qfyjv8^S42(vMgGc7VUT?0`e3cpsG*tk5+6ra zP}tY?toeW!P(L2x+;#$FNC4SRY&V8P zw?8&O5lsW9RW*-7K8O#|G>ue6{<1>haO203fr7P0pg9Uezgz|kt4wfDyC{J$N{DO@ zs!A+{4mgt`2zd`RfjSAC935USu5QyNZcjFTa$nmhD43#>As2Q=fkQ=rugvgPG@_Xc zk5QqQ{RJlMZWL@gQ6L_sk!h9VR2aCux`@FoNIq&5ArW>+;A`Z7DjiByKrm?{F+}N| zdQlFNq)tM|Lx~{0oJ540S$ec`;xH7`%`9*W$BD;RH<##hiz`0)en0eC_^Y77SD)@Natj3sl52O55wyW5!6TzY+A3j-3DXe-XB%ipo%;3F0Z*tHfj{mc zlVyiIUaC2!av)XZFoHlB4uK5Vi23#H_VcALir|{sEQp5)MDP{3z9xb+9bQu?(KL%O zff%YK^qRcg?nLN@)`Y@{z~Kl#{*RZNwBj#bMoR#Ar@Hntc0nm)(Iz?RvU!)$$R7#xvM~H=`<@^gb0Ld zf3HvBIOqbKO$2ykX3^Qi(=X?OMk+Keb_mkY4kHZ-nOoDYK-^7;Q$L5xO?ejg>F_v{ z3xyBhV9vlpy%a=h#*&?_JUvzLTg3z4Lz%Kug2DHtfymKhsXRXOo3y*drzPPsBt~`` z3W`acY(-OJdwCuq0#e;{{J>uokFfF+K&vgq2}U}Dbmw& zh}|8FP1P_<>1^ZK8TSb@Ycm69Y9y#^_bDRx@(g?(H;C&XM;rnK+L+_Y?n*aJAR60v zwmIQ6BaGR>tJO%{n-eFe-bNry&6ui_aRuwZ&qXLG8AgZp9(^$DI-GE35%-;HV_>=| zN0W7;?0dxX1p|U>Sw^%AM~7I6z>7A4Xm8-@2XN6As%m}PG2%0a5I;D_qMKd8tIS#&6N_NT8oQnB!Idg zA(%|ohkK=5-PjV%a2TN1HEqtfxk_tK-FuhMGAX#d}yEw9pi>e&ysA3pRt8lOE6GngJAV4U312mw+yg2=fF zV(yBwi8PK=wHku3!KyUvW3=X%gnQs;FdaUi_DgL{EYa*y_ zb5A4Mo`YBNPMs6}o|Tyu!CvCm)+cjT(zMA|nPW4RCj%fx_YWUQXNv@J#ZncaForh~ z2*507oR8Pb-)7IRKBQgoE}e1uF+*sj`YcDwxHN;q0$3_17;-S4m7~d69H05og)#<- zWT5u#qSZU^Bg!!{kJpQBxorj>R2wKhigF~RIL1dPQra5HBb?+)G`%%0s|`8uJK4E#>b0!>vALOld;uOQ%} ziVVttsUVc|*$f2U&Ok6e2?{u^pt)Btv_0J7>(WoZhM?3|(FdYk7{c{p z6>LMh^I)iYDGXVCTy7U(+Uv z&T#@BN^H5oM7xYUxfpc)e!KtvpyOJ=1vzXQy50y zbmpsQ(jd{b-&lorGAbNAJS;X=fr}D#DAEg>x%y7pL!PgK|54(@2D16PPku}_R13NW z8~uEhyIdxr-NO<>w-TXjbt}c_!P@_~dC2|EQJ{5B5mHs~DlMt;`u)@GqUdsVH8I>* z!2x9IC_-HjPpB!O5YX9E%BDNb?iMrD8OMgwRd6V#`igldnbTP^uI7>XiWiHI%jKuE zQ2ydSZ@(04h92Q*wMwGZipOCXrQ-lW%hg827=Q=Zvj;hjwd+j#9N9m0zkG`}(dt-w zy}Egywx&-}#42sPQ}_(OS0P%LZO7o~$JtFZoL(qThWK$TqUw#(0r)Q6>QDQPgV$&t z1cR^`HMm3HGOZ^&HHHY@6UJ1>5YlGQ0*~E;7QHPzc{^t$xg$>EDZrHDscxw(*vR8F zO#UimpNlj<(vM@jrG4po0@|9B`OW+4;9S)0~NWs^=tFQ5{uWf{HN?yp()S8_LDwA>EfbK(%O3@X&z!{}NFpDk| zo+WXZeUs+yc!9uuY7dIPW)E8Svf<3XQscYhIq{pesR8h_w-``nn3~Zs z>q|R!4n0Y3G4|Q36ti{~CwTQZEPnm~vYwN@ou{oK7gr|2;&Zk~ze*W8mP6{0IPku& z7Pmg=%)$KB_aB@A7#RYgQ}pf1vm>AFan_v3Qkm^RV>R2OCg;v1yqKa7PoEPSehKwK zOlj1Vt89-WC2E6|_S_?&pC3!JG@v(!#00^GZfA;=s4^f|Ri2092U;o!z_U1IdcF9N zb{DFp$#*8vCkrzPlRy*3-J{Vp6!Pf-g>(b$k?TG3LxQ-_l8}K;++mTOxL|cksJ?*@Uu<_q#P1* zXylOkm>Eaeo5BDz`|QxuNKUlUJz3c3r_J`J9DI&OtKp!PYB-=k_S+${#}8_Dm|Wm4 zd!#tMk#oGAabqNsjXjMZxJm_%967L+%-hAMp9}p4`n7&LD>)2FuOkIWl!Y@LN}q}= z0VpQJ2enr83dX%9@$o(`jHYhV35O z2)!zJtr`hjFT{|esd2rf#SCr;=kBq6+)xJZASeJ%XB;xO^GVvM?&Ic5xo9LFSzCz1 zA>_T#q8bN&w0qR)0)L~0>$Jx275Nfw`HN+knWT&NQ$M=f1aH9841UDt5$FcYN|BQk4kXKhAZzO za=99cH&-c~kM<-uJHV53t=J5KqP|D?&>Ng1HeopSmqZBB171%62-fgox&67d(o?4v z=AbzYJqeBx03b6W9SR{_vJv@U&Q86iTwv{->qI0Cwyl?uB(osmpezkC_RsNDw@?aD zolbI*h*z7d58h|uOV^$Pzij(VoT(L3ngvJ64>_F}y;zEjGZ;GlGUOX(6l8}f}edmz5{}57!1Q#B!0rnC==q& zgm}58$CP@&`OWI{;%f723L+dM{Ja!GP(@K8_rgVEjNt1}XGB&2u?)0Q({LUQ7GxGy zrCxEuGhRgC2();bhVXryy-eK)n-AVN94{OaJd`LZL=QMqBVoL7;k78KISvwAHA2n} zEj;LMHpM$TVw8O;P>?JU-9k}7;-|&ew1n#H-Rk;cvGyyca8u`6C-AD-p_DcP?$uZb z0?-LTr5RCLxFk*#u=;}eTz8!lW|(9WHwQ-!(Q7;Dj%9=8I>mf?i6yw-#LfcTCF3_%`hnNo}LbASKxiHj|OFJ9-WPj7gH|c2?_$ot5g9liR2TWEV8}$wwP0SNMKtf zfC09>0n3`^@Y z#}#A!ENOy;uboCP%tiwk-(9a3m$P@tAQrwBaCh<(N@RFIty82jk#MF>euhNoN#fUQeWRw>H3uh;2YqpbgC}tx3 zXiCKx7P(R`GJ)?n5sElJ!AOBOc2Hnq{rYef+qaR>!;e4(Z|aHpZC zi%*|_E;AiGua*bgMlB-L0h~oN*?>Pz2SJR5>c|^N-59rWOvpghVbuSUC4V-;U)(`M zNgSC#rtBuI^t`y-Z2c@Ye74$E;wCwSimP2|4F6a5AN)Mpf8aVbW@(cB=hR`=&MaO% zehR3E%;JzyYfde8?M6VPtA@a0txAFnB4Ow>AF+kOqI+TWnIEHZX5Lcr6-S7?Ih7EC z%WH|N=nhiBYYnjhnxP*aQjj|m@Id|Yb9S~Xg|4Aaeo6wfh*}WD0&p>-;OW)DlOyRK z5oL6FMU17-PGre^X+N5yp0XcGQzXqIWWkna+vOL~BKI`|0R@I&NYq4!sTNk&!*EgU zC7BPA4J65QQ8+j$nBah*19n6>>n(BB-$n%Q?4%(r%Ydvr{pUXyse-n5-i3vUM5c;JfxfoD~MXAMJSarUZBUsJ3BOVi{00Y-@XKI;oJokvZ6+u z3GdLrZ&fPpjmGieF&n8iV&Max=g}yg2Clm^nxy|Q8%eX*(k2O5E%WlKER6X%jZl`X zAUG65>31jKdIbYilq^e*CTCf>jRJ-kMkPq_1M7|H1m&eVwJ- zdc>bovvmniyV1i_ALw%3QSn}7pl_dqoBR!dKK`!QLkn}&2Y*)Z$43l7*=st|f+W6` zaAvYP<@`nH=oT*B-8lPe+Tt5I>r7ppFwHbss2FBTplX?N(1iRSXKE}g)(2J{)4a=T zmBnHUW1`o})w3$?IqoiK3qTzh&o5H{+tvGzX*RYq(ZjX}$K%_fjKcyCQ0p*W2r83l zF@IR>gl4e}u{Ez1CfWk99NUIrQ*3@KmXZALhoszoK*Ze(9fwc`R;8o>CJKaD1yn+! zyU9T87}K@A_i@00DoqT6WndNf7q=;#OG{mK;yK`#RRf3Ow8A)JeC^sY7<^GBgcp-R z=k;QW|Ipg`omo&lFL*cs*(8@dWJ+!~31RdRda-Cyc;atNQ z-fvpPv_C8ars|ZEi`bkmILX+N0$d;U8X>p^z%>x0uz1jPzT-7$-JQ{6WdtEifZptE z8xaRU*({%P&#f1!aGXYH`^ByRmjZ#u*CG*sXfs0ead`9TCBtEr7nab?V+bS`NM*pp zHei$LF%CnQGigAz#4Q{lUZ&2Jud{E{Q2bSy^5JH+PT)Q&m;G7@Kv9_>m+vE&y@6u^ zi4mFT4iy5d4vBBmwp%wT*SWgbE`Luw3(h=TAmMZZZBr~l_Sw!@H(4P@ z0g~}{CYiJ_VFb?Px=^oE1=lzj-Y$N@G@Zv67l9DCt|kQjsvuMuk7hN0X1~fsn3wT> zv|r`*YW-z#o0h3b8&cuU|YGc==J^5tz{iLlj_mc_D_Hj5Q>iyNaj$$WE65g>+@M zdKNlfG(;14dNaUGOTw)_%wBBL#+BYk_&h}dK-RnnS!f#x6VMS88KuREcOhh}RMG=2 zqGI55Hju7*;+-8YFihiXD$p#qMODJ@_lx!@6g(8)(vP(PUG}NzP+Y3G$;nYwcghNF z&&0Ezk;k1~yB6{`C0<`=Pqxe3a?~$A;wUMCR)BS5TA=~~OVPuD|0AT3Q(@2!e{UeP zts?fU;73iXcy@b{Ml&V^7Wgl2rm+ToQ40i!)b^yf{$B}!;4HcTFp_w^`M50Sez%*C zzfNgBt`}1vb=!_}ga8A>wSbM=?JkX>KgA&6kyT?PA@$us09YZCsfasJ4sh%pSc z*R2LWKl9s7pHb@hJs8OQVqv*QAZJ{(;(YT~ED7g0pG{Zn@ebK3v2#Vk{9UJDqq&NL zl}hEPsmu`ryrQ2#SJsT(IAg{`CQJwY!Bb(pwGk75IzJ`F^CzpVUv-WNQLW7ka0Qw$ z9>OsKZBZ;-j6Xt%G25J<`eAg+04TgV??K@YPS1SOSFGh4I#dWitA_q^`D@y2`t|!4 z<;==sG_E#M{59)T7-I`MsZQgn3XKtFjDgV|Qb+n2D`NP9(;B|aLw^EZubKS4-Ef)8 zH)-pPau*R0sb&Tqk--Q73`n40I5UyJ9$!+9b}|zok$v;-T1RM>Q;G-(PG>;6J`5kx z*@=$7Zj7G-pGFZ0HA5g+dvW|##8Zx%fQ+z1PVE)Pgj5I5Z^kj_i%+vOE8+d}$}j4J z%WLbvr&2&I}A#!a;dv--V8$^>D+J2b6=I|RNghfRSywN0RzStQG`$87+l*~3?xZWAR5@KO^Z z+n@^8e!Q#`#&5REi!?0-?!xE%xT=N#cTosZ@uQ4vC4T)Y>*g1ub@Qi}tM`i!n^ZMl zuiN4D(-+^tfLu5YXV(d*(ezYIysk7 zs3^c&Xm+=!W0;@$&F47mO00m{fCu2w1DUd*eeSTA93_M_&wK-qOc7t}@Z#^&;K79- zId|gh0c}!vTtpqB1lG)IQKS*y)!TfRb2ywIyKsROBr=f*n{zlg(>3x05WK76(I2pd zPv^uz*0FiI!LThnQj@QC7eXlxz6$|oYAlQ!Al$us-VYgx5(qrcGh^p^IU;*84!oQL z;(79tv!}P)WjUad6B|ZlGOiHm%mkEDGZEW>N$pt=oF96baI;kKJP$=qO@$M9ZstUA z7-Ry|EL`NEc$$`cU#F=E*z~d}hj}o_g=(~MShfWK)U@EoyURp`|I){X+xYA|f9?GW zLZMdPg#kV9zoyN{(#Z2giXMt7->`CJg#!ZbnWeOhA8@?_f$NnN{B#6DS~xX;G8ti7 zAxr?rh_KU%444XMdIROeQFpLX-~^X{f4bTJzPj>b`0$`n>j?b@xL$DpB$aW9Vob&% zw@(N`v7t;5R>Ogu5)5!AW6({xgG8V{JUdTQl}au+ze)m#QSeYoF~KMt2DnHuz@hk2 z@gS2i82Y8j1(QnN&M>f`yCOpzxrSE~tqf$~5&&-&zm-FC@W@dvggg_s9}@>bWGW8M zZ}JAa^B`2Ato1<9$s-4=J=t!)`0xQ&k2byzn&C!Tv_z)5a?s;dE zrGBA24!1Wb&_rjKoF8@mIc?Ff>CH2CNZ`kcMA+r4tViTZD4&XuojO}j)a9qbJm3?l$Y*!yHeJ#*$3jp#fEgTqqX9Zl;S>f~O-1!X;t$h~+A&Y1k%;LT^5_qm4A*M1JiTe+|@6SO% zW1LjH+olrv>|GjdS!BI_KZXFGnlpX^Kr+cQmzYwV9oNzU?gEbN=`|WEYU2c6I?2 zo7n|B<&^@sNF_n0pE8c}lX`_2Hg@#j=;VQ9a#8`J!TT{Nr@m(VNJ1zQD~8yo4~i|O zaHBgi49LuoVYuWThpGV#L{tfnM>7m)NNotx9K0{Zy=@4CL3fs4I4L$rabr*f4GSpy zRpO9km@wcLP94*ny)^Jb`;f{B=lF7}4EVVMga#@;p=^%tQvgaG9b(2&!I$U?lhyiUxj~ zJxMy0xN2X?cv$qPNc*A5ff*sX#C18!4mN@x3KBeWHu5#?GPUMn!k^2csUL2R#?_J$ zA}c(8M{3}Hi6v(2gDQwqWjmcy9Zs`CLC@5Z&|y4o9cTtTj2U=qXDHue@3Gsfi(fbE zLO=0?ni<4J>?AM)XKFBTmwV;pSrnycMc>qlxZ7doVMsX)1iWnl0?p&u;!DWK!RJvF zLLvPw6a5A7^S3@O>$k zeBXA6_>+I?>ObFmyCE~_bkzbXb*cY+J;t1g9S zX|?7Bb~gKUiDGfPPvKd$vn+_8qyC+Tp2JJ)*TARFVlCxksOwy0hjf&W

V~PVLE+ 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

CkrRPJjK#AzXBbQMA1)$lZc>n+a From a661eaf39fc3859ff7ef5f36b3a53b8fdbed25c6 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 16 Feb 2022 02:14:09 +0300 Subject: [PATCH 082/132] better performance of getting storage snapshot --- src/Columns/ColumnObject.cpp | 4 +-- src/DataTypes/ObjectUtils.cpp | 8 ++--- src/Interpreters/InterpreterSelectQuery.cpp | 2 +- src/Storages/ColumnsDescription.cpp | 7 ++--- src/Storages/IStorage.cpp | 5 --- src/Storages/IStorage.h | 12 +++++++- src/Storages/MergeTree/MergeTreeData.cpp | 24 ++++++++++++--- src/Storages/MergeTree/MergeTreeData.h | 4 +++ src/Storages/StorageDistributed.cpp | 34 ++++++++++++++++++++- src/Storages/StorageDistributed.h | 3 ++ src/Storages/StorageMemory.cpp | 2 +- src/Storages/StorageMemory.h | 1 + 12 files changed, 82 insertions(+), 24 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 76f49013a97..30addeab314 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -411,7 +411,7 @@ void ColumnObject::Subcolumn::insertManyDefaults(size_t length) void ColumnObject::Subcolumn::popBack(size_t n) { - assert(n <= size); + assert(n <= size()); size_t num_removed = 0; for (auto it = data.rbegin(); it != data.rend(); ++it) @@ -442,7 +442,7 @@ Field ColumnObject::Subcolumn::getLastField() const return Field(); const auto & last_part = data.back(); - assert(!last_part.empty()); + assert(!last_part->empty()); return (*last_part)[last_part->size() - 1]; } diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 5113d94a648..92b454a2aa5 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -517,7 +517,7 @@ ColumnPtr flattenTuple(const ColumnPtr & column) DataTypePtr unflattenTuple(const PathsInData & paths, const DataTypes & tuple_types) { - assert(paths.size() == types.size()); + assert(paths.size() == tuple_types.size()); Columns tuple_columns; tuple_columns.reserve(tuple_types.size()); for (const auto & type : tuple_types) @@ -531,8 +531,8 @@ std::pair unflattenTuple( const DataTypes & tuple_types, const Columns & tuple_columns) { - assert(paths.size() == types.size()); - assert(paths.size() == columns.size()); + assert(paths.size() == tuple_types.size()); + assert(paths.size() == tuple_columns.size()); SubcolumnsTreeWithTypes tree; @@ -564,7 +564,7 @@ std::pair unflattenTuple( if (kind == Node::NESTED) { size_t dimensions_to_reduce = array_level - nested_level; - assert(is_nested.test(pos)); + assert(parts[pos].is_nested); ++dimensions_to_reduce; --nested_level; diff --git a/src/Interpreters/InterpreterSelectQuery.cpp b/src/Interpreters/InterpreterSelectQuery.cpp index 509833118d1..aee57e03079 100644 --- a/src/Interpreters/InterpreterSelectQuery.cpp +++ b/src/Interpreters/InterpreterSelectQuery.cpp @@ -325,7 +325,7 @@ InterpreterSelectQuery::InterpreterSelectQuery( if (!metadata_snapshot) metadata_snapshot = storage->getInMemoryMetadataPtr(); - storage_snapshot = storage->getStorageSnapshot(metadata_snapshot); + storage_snapshot = storage->getStorageSnapshotForQuery(metadata_snapshot, query_ptr); } if (has_input || !joined_tables.resolveTables()) diff --git a/src/Storages/ColumnsDescription.cpp b/src/Storages/ColumnsDescription.cpp index af0817c0e3e..8b3719208d1 100644 --- a/src/Storages/ColumnsDescription.cpp +++ b/src/Storages/ColumnsDescription.cpp @@ -686,17 +686,16 @@ ColumnsDescription ColumnsDescription::parse(const String & str) void ColumnsDescription::addSubcolumns(const String & name_in_storage, const DataTypePtr & type_in_storage) { - for (const auto & subcolumn_name : type_in_storage->getSubcolumnNames()) + IDataType::forEachSubcolumn([&](const auto &, const auto & subname, const auto & subdata) { - auto subcolumn = NameAndTypePair(name_in_storage, subcolumn_name, - type_in_storage, type_in_storage->getSubcolumnType(subcolumn_name)); + auto subcolumn = NameAndTypePair(name_in_storage, subname, type_in_storage, subdata.type); if (has(subcolumn.name)) throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Cannot add subcolumn {}: column with this name already exists", subcolumn.name); subcolumns.get<0>().insert(std::move(subcolumn)); - } + }, {type_in_storage->getDefaultSerialization(), type_in_storage, nullptr, nullptr}); } void ColumnsDescription::removeSubcolumns(const String & name_in_storage) diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp index b460faf7102..66f9513c7f7 100644 --- a/src/Storages/IStorage.cpp +++ b/src/Storages/IStorage.cpp @@ -204,11 +204,6 @@ NameDependencies IStorage::getDependentViewsByColumn(ContextPtr context) const return name_deps; } -StorageSnapshotPtr IStorage::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const -{ - return std::make_shared(*this, metadata_snapshot); -} - bool IStorage::isStaticStorage() const { auto storage_policy = getStoragePolicy(); diff --git a/src/Storages/IStorage.h b/src/Storages/IStorage.h index 9e106d8fbdc..b0e2e8600a3 100644 --- a/src/Storages/IStorage.h +++ b/src/Storages/IStorage.h @@ -159,6 +159,8 @@ public: /// Returns true if the storage supports reading of subcolumns of complex types. virtual bool supportsSubcolumns() const { return false; } + virtual bool supportsDynamicSubcolumns() const { return false; } + /// Requires squashing small blocks to large for optimal storage. /// This is true for most storages that store data on disk. virtual bool prefersLargeBlocks() const { return true; } @@ -598,7 +600,15 @@ public: /// Does not takes underlying Storage (if any) into account. virtual std::optional lifetimeBytes() const { return {}; } - virtual StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const; + virtual StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const + { + return std::make_shared(*this, metadata_snapshot); + } + + virtual StorageSnapshotPtr getStorageSnapshotForQuery(const StorageMetadataPtr & metadata_snapshot, const ASTPtr & /*query*/) const + { + return getStorageSnapshot(metadata_snapshot); + } /// Should table->drop be called at once or with delay (in case of atomic database engine). /// Needed for integration engines, when there must be no delay for calling drop() method. diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index e850fe2688e..6cad22120a0 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -2606,7 +2606,7 @@ bool MergeTreeData::renameTempPartAndReplace( addPartContributionToColumnAndSecondaryIndexSizes(part); if (covered_parts.empty()) - updateObjectColumns(object_columns, (*part_it)->getColumns()); + updateObjectColumns(*part_it, lock); else resetObjectColumnsFromActiveParts(lock); @@ -3852,6 +3852,7 @@ std::set MergeTreeData::getPartitionIdsAffectedByCommands( MergeTreeData::DataPartsVector MergeTreeData::getDataPartsVectorUnlocked( const DataPartStates & affordable_states, + const DataPartsLock & /*lock*/, DataPartStateVector * out_states, bool require_projection_parts) const { @@ -3902,7 +3903,7 @@ MergeTreeData::DataPartsVector MergeTreeData::getDataPartsVector( bool require_projection_parts) const { auto lock = lockParts(); - return getDataPartsVectorUnlocked(affordable_states, out_states, require_projection_parts); + return getDataPartsVectorUnlocked(affordable_states, lock, out_states, require_projection_parts); } MergeTreeData::DataPartsVector @@ -4378,7 +4379,7 @@ MergeTreeData::DataPartsVector MergeTreeData::Transaction::commit(MergeTreeData: if (reduce_parts == 0) { for (const auto & part : precommitted_parts) - updateObjectColumns(data.object_columns, part->getColumns()); + data.updateObjectColumns(part, parts_lock); } else data.resetObjectColumnsFromActiveParts(parts_lock); @@ -6098,8 +6099,21 @@ ColumnsDescription MergeTreeData::getObjectColumns( void MergeTreeData::resetObjectColumnsFromActiveParts(const DataPartsLock & /*lock*/) { + const auto & columns = getInMemoryMetadataPtr()->getColumns(); + if (!hasObjectColumns(columns)) + return; + auto range = getDataPartsStateRange(DataPartState::Active); - object_columns = getObjectColumns(range, getInMemoryMetadataPtr()->getColumns()); + object_columns = getObjectColumns(range, columns); +} + +void MergeTreeData::updateObjectColumns(const DataPartPtr & part, const DataPartsLock & /*lock*/) +{ + const auto & columns = getInMemoryMetadataPtr()->getColumns(); + if (!hasObjectColumns(columns)) + return; + + DB::updateObjectColumns(object_columns, part->getColumns()); } StorageSnapshotPtr MergeTreeData::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const @@ -6107,7 +6121,7 @@ StorageSnapshotPtr MergeTreeData::getStorageSnapshot(const StorageMetadataPtr & auto snapshot_data = std::make_unique(); auto lock = lockParts(); - snapshot_data->parts = getDataPartsVectorUnlocked({DataPartState::Active}); + snapshot_data->parts = getDataPartsVectorUnlocked({DataPartState::Active}, lock); return std::make_shared(*this, metadata_snapshot, object_columns, std::move(snapshot_data)); } diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index a8b46c0c297..3f206af670e 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -416,6 +416,8 @@ public: bool supportsSubcolumns() const override { return true; } + bool supportsDynamicSubcolumns() const override { return true; } + NamesAndTypesList getVirtuals() const override; bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr, const StorageMetadataPtr & metadata_snapshot) const override; @@ -439,6 +441,7 @@ public: DataPartsVector getDataPartsVectorUnlocked( const DataPartStates & affordable_states, + const DataPartsLock & lock, DataPartStateVector * out_states = nullptr, bool require_projection_parts = false) const; @@ -1224,6 +1227,7 @@ private: DataPartsLock & part_lock); void resetObjectColumnsFromActiveParts(const DataPartsLock & lock); + void updateObjectColumns(const DataPartPtr & part, const DataPartsLock & lock); /// Create zero-copy exclusive lock for part and disk. Useful for coordination of /// distributed operations which can lead to data duplication. Implemented only in ReplicatedMergeTree. diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index 9568a26f402..b1648bfdc98 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -10,6 +10,7 @@ #include #include #include +#include #include #include @@ -56,6 +57,7 @@ #include #include #include +#include #include #include @@ -588,10 +590,40 @@ std::optional StorageDistributed::getOptimizedQueryP return QueryProcessingStage::Complete; } +static bool requiresObjectColumns(const ColumnsDescription & all_columns, ASTPtr query) +{ + if (!hasObjectColumns(all_columns)) + return false; + + if (!query) + return true; + + RequiredSourceColumnsVisitor::Data columns_context; + RequiredSourceColumnsVisitor(columns_context).visit(query); + + auto required_columns = columns_context.requiredColumns(); + for (const auto & required_column : required_columns) + { + auto name_in_storage = Nested::splitName(required_column).first; + auto column_in_storage = all_columns.tryGetPhysical(name_in_storage); + + if (column_in_storage && isObject(column_in_storage->type)) + return true; + } + + return false; +} + StorageSnapshotPtr StorageDistributed::getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const +{ + return getStorageSnapshotForQuery(metadata_snapshot, nullptr); +} + +StorageSnapshotPtr StorageDistributed::getStorageSnapshotForQuery( + const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query) const { auto snapshot_data = std::make_unique(); - if (!hasObjectColumns(metadata_snapshot->getColumns())) + if (!requiresObjectColumns(metadata_snapshot->getColumns(), query)) return std::make_shared(*this, metadata_snapshot, ColumnsDescription{}, std::move(snapshot_data)); snapshot_data->objects_by_shard = getExtendedObjectsOfRemoteTables( diff --git a/src/Storages/StorageDistributed.h b/src/Storages/StorageDistributed.h index a3f1508522c..17e0d7d542d 100644 --- a/src/Storages/StorageDistributed.h +++ b/src/Storages/StorageDistributed.h @@ -52,6 +52,7 @@ public: bool supportsFinal() const override { return true; } bool supportsPrewhere() const override { return true; } bool supportsSubcolumns() const override { return true; } + bool supportsDynamicSubcolumns() const override { return true; } StoragePolicyPtr getStoragePolicy() const override; /// Do not apply moving to PREWHERE optimization for distributed tables, @@ -66,6 +67,8 @@ public: }; StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const override; + StorageSnapshotPtr getStorageSnapshotForQuery( + const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query) const override; QueryProcessingStage::Enum getQueryProcessingStage(ContextPtr, QueryProcessingStage::Enum, const StorageSnapshotPtr &, SelectQueryInfo &) const override; diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp index 5146f2a2fd4..54a6bfb55a7 100644 --- a/src/Storages/StorageMemory.cpp +++ b/src/Storages/StorageMemory.cpp @@ -79,7 +79,7 @@ protected: } fillMissingColumns(columns, src.rows(), column_names_and_types, /*metadata_snapshot=*/ nullptr); - assert(std::all(columns.begin(), columns.end(), [](const auto & column) { return column != nullptr; })); + assert(std::all_of(columns.begin(), columns.end(), [](const auto & column) { return column != nullptr; })); return Chunk(std::move(columns), src.rows()); } diff --git a/src/Storages/StorageMemory.h b/src/Storages/StorageMemory.h index ffb474cb820..003d7f1e8e0 100644 --- a/src/Storages/StorageMemory.h +++ b/src/Storages/StorageMemory.h @@ -47,6 +47,7 @@ public: bool supportsParallelInsert() const override { return true; } bool supportsSubcolumns() const override { return true; } + bool supportsDynamicSubcolumns() const override { return true; } /// Smaller blocks (e.g. 64K rows) are better for CPU cache. bool prefersLargeBlocks() const override { return false; } From edd686e1d9a6f61fe53dd0f07bdc18de6997954b Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 16 Feb 2022 17:18:03 +0300 Subject: [PATCH 083/132] fix unit test --- src/Columns/ColumnObject.cpp | 2 +- src/DataTypes/DataTypeObject.cpp | 2 +- src/DataTypes/ObjectUtils.cpp | 3 +- src/DataTypes/Serializations/JSONDataParser.h | 1 - src/DataTypes/Serializations/SubcolumnsTree.h | 2 + .../tests/gtest_json_parser.cpp | 119 ++++++++++-------- src/Interpreters/getColumnFromBlock.h | 1 + src/Interpreters/inplaceBlockConversions.cpp | 5 + 8 files changed, 78 insertions(+), 57 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 30addeab314..f653c322abd 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -706,7 +706,7 @@ void ColumnObject::addNestedSubcolumn(const PathInData & key, const FieldInfo & if (nested_node) { - const auto * leaf = subcolumns.findLeaf(nested_node, [&](const auto & ) { return true; }); + const auto * leaf = subcolumns.findLeaf(nested_node, [&](const auto &) { return true; }); assert(leaf); auto new_subcolumn = leaf->data.recreateWithDefaultValues(field_info); diff --git a/src/DataTypes/DataTypeObject.cpp b/src/DataTypes/DataTypeObject.cpp index 3ed4c79af07..b706e61b3c1 100644 --- a/src/DataTypes/DataTypeObject.cpp +++ b/src/DataTypes/DataTypeObject.cpp @@ -50,7 +50,7 @@ String DataTypeObject::doGetName() const static DataTypePtr create(const ASTPtr & arguments) { - if (!arguments || arguments->children.size() < 1 || arguments->children.size() > 2) + if (!arguments || arguments->children.empty() || arguments->children.size() > 2) throw Exception("Object data type family must have one or two arguments -" " name of schema format and type of default value", ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH); diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 92b454a2aa5..889091f9e98 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -13,7 +13,6 @@ #include #include #include -#include #include #include #include @@ -363,7 +362,7 @@ void flattenTupleImpl(const ColumnPtr & column, Columns & new_columns, Columns & { const auto & subcolumns = column_tuple->getColumns(); for (const auto & subcolumn : subcolumns) - flattenTupleImpl(subcolumn, new_columns,offsets_columns ); + flattenTupleImpl(subcolumn, new_columns,offsets_columns); } else if (const auto * column_array = checkAndGetColumn(column.get())) { diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index 4846646ded9..5e45533b225 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -11,7 +11,6 @@ namespace DB namespace ErrorCodes { extern const int LOGICAL_ERROR; - extern const int NUMBER_OF_DIMENSIONS_MISMATHED; } class ReadBuffer; diff --git a/src/DataTypes/Serializations/SubcolumnsTree.h b/src/DataTypes/Serializations/SubcolumnsTree.h index 1e30c069839..94266db39f7 100644 --- a/src/DataTypes/Serializations/SubcolumnsTree.h +++ b/src/DataTypes/Serializations/SubcolumnsTree.h @@ -1,3 +1,5 @@ +#pragma once + #include #include #include diff --git a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp index c60ad058bc6..b93873b22c6 100644 --- a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp +++ b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp @@ -47,12 +47,34 @@ TEST(JSONDataParser, ReadJSON) } } +struct JSONPathAndValue +{ + String path; + Field value; + std::vector is_nested; + + JSONPathAndValue(const String & path_, const Field & value_, const std::vector & is_nested_) + : path(path_), value(value_), is_nested(is_nested_) + { + } + + JSONPathAndValue(const PathInData & path_, const Field & value_) + : path(path_.getPath()), value(value_) + { + for (const auto & part : path_.getParts()) + is_nested.push_back(part.is_nested); + } + + bool operator==(const JSONPathAndValue & other) const = default; + bool operator<(const JSONPathAndValue & other) const { return path < other.path; } +}; + +using JSONValues = std::vector; + static void check( const String & json_str, - const Strings & expected_paths, - const std::vector & expected_values, - const std::vector> & expected_nested, - const String & tag) + const String & tag, + JSONValues expected_values) { JSONDataParser parser; auto res = parser.parse(json_str.data(), json_str.size()); @@ -60,42 +82,36 @@ static void check( const auto & [paths, values] = *res; - ASSERT_EQ(paths.size(), expected_paths.size()) << tag; + ASSERT_EQ(paths.size(), expected_values.size()) << tag; ASSERT_EQ(values.size(), expected_values.size()) << tag; - Strings paths_str; - std::vector> paths_is_nested; + JSONValues result_values; + for (size_t i = 0; i < paths.size(); ++i) + result_values.emplace_back(paths[i], values[i]); - for (const auto & path : paths) - { - paths_str.push_back(path.getPath()); - paths_is_nested.emplace_back(); - for (size_t i = 0; i < path.getParts().size(); ++i) - paths_is_nested.back().push_back(path.isNested(i)); - } + std::sort(expected_values.begin(), expected_values.end()); + std::sort(result_values.begin(), result_values.end()); - ASSERT_EQ(paths_str, expected_paths) << tag; - ASSERT_EQ(values, expected_values) << tag; - ASSERT_EQ(paths_is_nested, expected_nested) << tag; + ASSERT_EQ(result_values, expected_values) << tag; } TEST(JSONDataParser, Parse) { { - check(json1, - {"k1", "k2.k3", "k2.k4"}, - {1, "aa", 2}, - {{false}, {false, false}, {false, false}}, - "json1"); + check(json1, "json1", + { + {"k1", 1, {false}}, + {"k2.k3", "aa", {false, false}}, + {"k2.k4", 2, {false, false}}, + }); } { - Strings paths = {"k1.k3.k4", "k1.k2"}; - - auto k1k3k4 = Array{Array{"bbb", "ccc"}, Array{"eee", "fff"}}; - auto k1k2 = Array{"aaa", "ddd"}; - - check(json2, paths, {k1k3k4, k1k2}, {{true, true, false}, {true, false}}, "json2"); + check(json2, "json2", + { + {"k1.k2", Array{"aaa", "ddd"}, {true, false}}, + {"k1.k3.k4", Array{Array{"bbb", "ccc"}, Array{"eee", "fff"}}, {true, true, false}}, + }); } { @@ -120,14 +136,14 @@ TEST(JSONDataParser, Parse) Strings paths = {"k1.k2.k4", "k1.k5", "k1.k2.k3"}; - auto k1k2k3 = Array{Array{1, 2}, Array{5, 6}}; auto k1k2k4 = Array{Array{3, 4}, Array{7, 8}}; - auto k1k5 = Array{"foo", "bar"}; - check(json3, paths, - {k1k2k4, k1k5, k1k2k3}, - {{true, false, false}, {true, false}, {true, false, false}}, - "json3"); + check(json3, "json3", + { + {"k1.k5", Array{"foo", "bar"}, {true, false}}, + {"k1.k2.k3", Array{Array{1, 2}, Array{5, 6}}, {true, false, false}}, + {"k1.k2.k4", Array{Array{3, 4}, Array{7, 8}}, {true, false, false}}, + }); } { @@ -144,21 +160,17 @@ TEST(JSONDataParser, Parse) } ]})"; - Strings paths = {"k1.k2.k4", "k1.k5", "k1.k2.k3"}; - - auto k1k2k3 = Array{Array{1, 2}, Array{5, 6}}; - auto k1k2k4 = Array{Array{3, 4}, Array{7, 8}}; - auto k1k5 = Array{"foo", "bar"}; - - check(json4, paths, - {k1k2k4, k1k5, k1k2k3}, - {{true, true, false}, {true, false}, {true, true, false}}, - "json4"); + check(json4, "json4", + { + {"k1.k5", Array{"foo", "bar"}, {true, false}}, + {"k1.k2.k3", Array{Array{1, 2}, Array{5, 6}}, {true, true, false}}, + {"k1.k2.k4", Array{Array{3, 4}, Array{7, 8}}, {true, true, false}}, + }); } { const String json5 = R"({"k1": [[1, 2, 3], [4, 5], [6]]})"; - check(json5, {"k1"}, {Array{Array{1, 2, 3}, Array{4, 5}, Array{6}}}, {{false}}, "json5"); + check(json5, "json5", {{"k1", Array{Array{1, 2, 3}, Array{4, 5}, Array{6}}, {false}}}); } { @@ -175,7 +187,11 @@ TEST(JSONDataParser, Parse) auto k1k2 = Array{Array{1, 3}, Array{5}}; auto k1k3 = Array{Array{2, 4}, Array{6}}; - check(json6, paths, {k1k2, k1k3}, {{true, true}, {true, true}}, "json6"); + check(json6, "json6", + { + {"k1.k2", Array{Array{1, 3}, Array{5}}, {true, false}}, + {"k1.k3", Array{Array{2, 4}, Array{6}}, {true, false}}, + }); } { @@ -187,12 +203,11 @@ TEST(JSONDataParser, Parse) ] })"; - Strings paths = {"k1.k2", "k1.k3"}; - - auto k1k2 = Array{Array{1, 3}, Array{5}}; - auto k1k3 = Array{Array{2, 4}, Array{6}}; - - check(json7, paths, {k1k2, k1k3}, {{true, false}, {true, false}}, "json7"); + check(json7, "json7", + { + {"k1.k2", Array{Array{1, 3}, Array{5}}, {true, false}}, + {"k1.k3", Array{Array{2, 4}, Array{6}}, {true, false}}, + }); } } diff --git a/src/Interpreters/getColumnFromBlock.h b/src/Interpreters/getColumnFromBlock.h index 04b0940e243..26500cfdd17 100644 --- a/src/Interpreters/getColumnFromBlock.h +++ b/src/Interpreters/getColumnFromBlock.h @@ -1,3 +1,4 @@ +#pragma once #include namespace DB diff --git a/src/Interpreters/inplaceBlockConversions.cpp b/src/Interpreters/inplaceBlockConversions.cpp index 5c05cc06fc2..a21d8684bf2 100644 --- a/src/Interpreters/inplaceBlockConversions.cpp +++ b/src/Interpreters/inplaceBlockConversions.cpp @@ -24,6 +24,11 @@ namespace DB { +namespace ErrorCode +{ + extern const int LOGICAL_ERROR; +} + namespace { From 0a7895ebb974de4989b46d696b530650350c39c4 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 17 Feb 2022 22:00:25 +0300 Subject: [PATCH 084/132] add comments and small refactoring --- src/Columns/ColumnObject.cpp | 107 ++++++------- src/Columns/ColumnObject.h | 59 ++++++- src/Common/config.h.in | 1 - src/Core/Field.h | 42 ++--- src/DataTypes/DataTypeObject.cpp | 2 +- src/DataTypes/IDataType.h | 5 +- src/DataTypes/ObjectUtils.cpp | 145 +++++++++--------- src/DataTypes/ObjectUtils.h | 52 ++++++- src/DataTypes/Serializations/ISerialization.h | 1 + .../Serializations/SerializationObject.cpp | 14 +- src/DataTypes/Serializations/SubcolumnsTree.h | 69 ++++----- src/DataTypes/getLeastSupertype.h | 1 - src/Storages/IStorage.cpp | 1 - 13 files changed, 298 insertions(+), 201 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index f653c322abd..faa307e6dfb 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -1,13 +1,10 @@ #include #include -#include -#include +#include #include #include #include #include -#include -#include #include #include #include @@ -15,8 +12,6 @@ #include #include -#include - namespace DB { @@ -32,6 +27,7 @@ namespace ErrorCodes namespace { +/// Recreates scolumn with default scalar values and keeps sizes of arrays. ColumnPtr recreateColumnWithDefaultValues( const ColumnPtr & column, const DataTypePtr & scalar_type, size_t num_dimensions) { @@ -47,43 +43,44 @@ ColumnPtr recreateColumnWithDefaultValues( return createArrayOfType(scalar_type, num_dimensions)->createColumn()->cloneResized(column->size()); } +/// Replaces NULL fields to given field or empty array. class FieldVisitorReplaceNull : public StaticVisitor { public: - [[maybe_unused]] explicit FieldVisitorReplaceNull( + explicit FieldVisitorReplaceNull( const Field & replacement_, size_t num_dimensions_) : replacement(replacement_) , num_dimensions(num_dimensions_) { } - template - Field operator()(const T & x) const + Field operator()(const Null &) const { - if constexpr (std::is_same_v) - { - return num_dimensions - ? createEmptyArrayField(num_dimensions) - : replacement; - } - else if constexpr (std::is_same_v) - { - assert(num_dimensions > 0); - const size_t size = x.size(); - Array res(size); - for (size_t i = 0; i < size; ++i) - res[i] = applyVisitor(FieldVisitorReplaceNull(replacement, num_dimensions - 1), x[i]); - return res; - } - else - return x; + return num_dimensions + ? createEmptyArrayField(num_dimensions) + : replacement; } + Field operator()(const Array & x) const + { + assert(num_dimensions > 0); + const size_t size = x.size(); + Array res(size); + for (size_t i = 0; i < size; ++i) + res[i] = applyVisitor(FieldVisitorReplaceNull(replacement, num_dimensions - 1), x[i]); + return res; + } + + template + Field operator()(const T & x) const { return x; } + private: const Field & replacement; size_t num_dimensions; }; +/// Calculates number of dimensions in array field. +/// Returns 0 for scalar fields. class FieldVisitorToNumberOfDimensions : public StaticVisitor { public: @@ -114,6 +111,9 @@ public: size_t operator()(const T &) const { return 0; } }; +/// Visitor that allows to get type of scalar field +/// or least common type of scalars in array. +/// More optimized version of FieldToDataType. class FieldVisitorToScalarType : public StaticVisitor<> { public: @@ -160,8 +160,7 @@ public: template void operator()(const T &) { - auto field_type = Field::TypeToEnum>::value; - field_types.insert(field_type); + field_types.insert(Field::TypeToEnum>::value); type_indexes.insert(TypeToTypeIndex>); } @@ -280,18 +279,10 @@ void ColumnObject::Subcolumn::insert(Field field, FieldInfo info) if (is_nullable) base_type = makeNullable(base_type); - DataTypePtr value_type; if (!is_nullable && info.have_nulls) - { - auto default_value = base_type->getDefault(); - value_type = createArrayOfType(base_type, value_dim); - field = applyVisitor(FieldVisitorReplaceNull(default_value, value_dim), std::move(field)); - } - else - { - value_type = createArrayOfType(base_type, value_dim); - } + field = applyVisitor(FieldVisitorReplaceNull(base_type->getDefault(), value_dim), std::move(field)); + auto value_type = createArrayOfType(base_type, value_dim); bool type_changed = false; if (data.empty()) @@ -311,12 +302,9 @@ void ColumnObject::Subcolumn::insert(Field field, FieldInfo info) } if (type_changed || info.need_convert) - { - auto converted_field = convertFieldToTypeOrThrow(std::move(field), *value_type); - data.back()->insert(std::move(converted_field)); - } - else - data.back()->insert(std::move(field)); + field = convertFieldToTypeOrThrow(std::move(field), *value_type); + + data.back()->insert(std::move(field)); } void ColumnObject::Subcolumn::insertRangeFrom(const Subcolumn & src, size_t start, size_t length) @@ -372,6 +360,10 @@ void ColumnObject::Subcolumn::finalize() auto offsets = ColumnUInt64::create(); auto & offsets_data = offsets->getData(); + /// We need to convert only non-default values and then recreate column + /// with default value of new type, because default values (which represents misses in data) + /// may be inconsistent between types (e.g "0" in UInt64 and empty string in String). + part->getIndicesOfNonDefaultRows(offsets_data, 0, part_size); if (offsets->size() == part_size) @@ -448,16 +440,16 @@ Field ColumnObject::Subcolumn::getLastField() const ColumnObject::Subcolumn ColumnObject::Subcolumn::recreateWithDefaultValues(const FieldInfo & field_info) const { + auto scalar_type = field_info.scalar_type; + if (is_nullable) + scalar_type = makeNullable(scalar_type); + Subcolumn new_subcolumn; - new_subcolumn.least_common_type = createArrayOfType(field_info.scalar_type, field_info.num_dimensions); + new_subcolumn.least_common_type = createArrayOfType(scalar_type, field_info.num_dimensions); new_subcolumn.is_nullable = is_nullable; new_subcolumn.num_of_defaults_in_prefix = num_of_defaults_in_prefix; new_subcolumn.data.reserve(data.size()); - auto scalar_type = field_info.scalar_type; - if (new_subcolumn.is_nullable) - scalar_type = makeNullable(scalar_type); - for (const auto & part : data) new_subcolumn.data.push_back(recreateColumnWithDefaultValues( part, scalar_type, field_info.num_dimensions)); @@ -524,6 +516,7 @@ size_t ColumnObject::size() const MutableColumnPtr ColumnObject::cloneResized(size_t new_size) const { + /// cloneResized with new_size == 0 is used for cloneEmpty(). if (new_size != 0) throw Exception(ErrorCodes::NOT_IMPLEMENTED, "ColumnObject doesn't support resize to non-zero length"); @@ -663,7 +656,7 @@ const ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const PathInData & ke ColumnObject::Subcolumn & ColumnObject::getSubcolumn(const PathInData & key) { if (const auto * node = subcolumns.findLeaf(key)) - return const_cast(node)->data; + return const_cast(node)->data; throw Exception(ErrorCodes::ILLEGAL_COLUMN, "There is no subcolumn {} in ColumnObject", key.getPath()); } @@ -702,23 +695,29 @@ void ColumnObject::addNestedSubcolumn(const PathInData & key, const FieldInfo & "Cannot add Nested subcolumn, because path doesn't contain Nested"); bool inserted = false; + /// We find node that represents the same Nested type as @key. const auto * nested_node = subcolumns.findBestMatch(key); if (nested_node) { + /// Find any leaf of Nested subcolumn. const auto * leaf = subcolumns.findLeaf(nested_node, [&](const auto &) { return true; }); assert(leaf); + /// Recreate subcolumn with default values and the same sizes of arrays. auto new_subcolumn = leaf->data.recreateWithDefaultValues(field_info); + + /// It's possible that we have already inserted value from current row + /// to this subcolumn. So, adjust size to expected. if (new_subcolumn.size() > new_size) new_subcolumn.popBack(new_subcolumn.size() - new_size); - else if (new_subcolumn.size() < new_size) - new_subcolumn.insertManyDefaults(new_size - new_subcolumn.size()); + assert(new_subcolumn.size() == new_size); inserted = subcolumns.add(key, new_subcolumn); } else { + /// If node was not found just add subcolumn with empty arrays. inserted = subcolumns.add(key, Subcolumn(new_size, is_nullable)); } @@ -751,6 +750,8 @@ void ColumnObject::finalize() for (auto && entry : subcolumns) { const auto & least_common_type = entry->data.getLeastCommonType(); + + /// Do not add subcolumns, which consists only from NULLs. if (isNothing(getBaseTypeOfArray(least_common_type))) continue; @@ -758,6 +759,8 @@ void ColumnObject::finalize() new_subcolumns.add(entry->path, std::move(entry->data)); } + /// If all subcolumns were skipped add a dummy subcolumn, + /// because Tuple type must have at least one element. if (new_subcolumns.empty()) new_subcolumns.add(PathInData{COLUMN_NAME_DUMMY}, Subcolumn{ColumnUInt8::create(old_size), is_nullable}); diff --git a/src/Columns/ColumnObject.h b/src/Columns/ColumnObject.h index 361767d6e20..261df2ef7b4 100644 --- a/src/Columns/ColumnObject.h +++ b/src/Columns/ColumnObject.h @@ -18,19 +18,43 @@ namespace ErrorCodes extern const int LOGICAL_ERROR; } +/// Info that represents a scalar or array field in a decomposed view. +/// It allows to recreate field with different number +/// of dimensions or nullability. struct FieldInfo { + /// The common type of of all scalars in field. DataTypePtr scalar_type; + + /// Do we have NULL scalar in field. bool have_nulls; + + /// If true then we have scalars with different types in array and + /// we need to convert scalars to the common type. bool need_convert; + + /// Number of dimension in array. 0 if field is scalar. size_t num_dimensions; }; FieldInfo getFieldInfo(const Field & field); +/** A column that represents object with dynamic set of subcolumns. + * Subcolumns are identified by paths in document and are stored in + * a trie-like structure. ColumnObject is not suitable for writing into tables + * and it should be converted to Tuple with fixed set of subcolumns before that. + */ class ColumnObject final : public COWHelper { public: + /** Class that represents one subcolumn. + * It stores values in several parts of column + * and keeps current common type of all parts. + * We add a new column part with a new type, when we insert a field, + * which can't be converted to the current common type. + * After insertion of all values subcolumn should be finalized + * for writing and other operations. + */ class Subcolumn { public: @@ -44,8 +68,12 @@ public: bool isFinalized() const { return data.size() == 1 && num_of_defaults_in_prefix == 0; } const DataTypePtr & getLeastCommonType() const { return least_common_type; } + + /// Checks the consistency of column's parts stored in @data. void checkTypes() const; + /// Inserts a field, which scalars can be arbitrary, but number of + /// dimensions should be consistent with current common type. void insert(Field field); void insert(Field field, FieldInfo info); @@ -54,11 +82,19 @@ public: void insertRangeFrom(const Subcolumn & src, size_t start, size_t length); void popBack(size_t n); + /// Converts all column's parts to the common type and + /// creates a single column that stores all values. void finalize(); + /// Returns last inserted field. Field getLastField() const; + + /// Recreates subcolumn with default scalar values and keeps sizes of arrays. + /// Used to create columns of type Nested with consistent array sizes. Subcolumn recreateWithDefaultValues(const FieldInfo & field_info) const; + /// Returns single column if subcolumn in finalizes. + /// Otherwise -- undefined behaviour. IColumn & getFinalizedColumn(); const IColumn & getFinalizedColumn() const; const ColumnPtr & getFinalizedColumnPtr() const; @@ -66,15 +102,28 @@ public: friend class ColumnObject; private: + /// Current least common type of all values inserted to this subcolumn. DataTypePtr least_common_type; + + /// If true then common type type of subcolumn is Nullable + /// and default values are NULLs. bool is_nullable = false; + + /// Parts of column. Parts should be in increasing order in terms of subtypes/supertypes. + /// That means that the least common type for i-th prefix is the type of i-th part + /// and it's the supertype for all type of column from 0 to i-1. std::vector data; + + /// Until we insert any non-default field we don't know further + /// least common type and we count number of defaults in prefix, + /// which will be converted to the default type of final common type. size_t num_of_defaults_in_prefix = 0; }; using SubcolumnsTree = SubcolumnsTree; private: + /// If true then all subcolumns are nullable. const bool is_nullable; SubcolumnsTree subcolumns; @@ -86,6 +135,7 @@ public: explicit ColumnObject(bool is_nullable_); ColumnObject(SubcolumnsTree && subcolumns_, bool is_nullable_); + /// Checks that all subcolumns have consistent sizes. void checkConsistency() const; bool hasSubcolumn(const PathInData & key) const; @@ -95,16 +145,23 @@ public: void incrementNumRows() { ++num_rows; } + /// Adds a subcolumn from existing IColumn. void addSubcolumn(const PathInData & key, MutableColumnPtr && subcolumn); + + /// Adds a subcolumn of specific size with default values. void addSubcolumn(const PathInData & key, size_t new_size); + + /// Adds a subcolumn of type Nested of specific size with default values. + /// It cares about consistency of sizes of Nested arrays. void addNestedSubcolumn(const PathInData & key, const FieldInfo & field_info, size_t new_size); const SubcolumnsTree & getSubcolumns() const { return subcolumns; } SubcolumnsTree & getSubcolumns() { return subcolumns; } PathsInData getKeys() const; - bool isFinalized() const; + /// Finalizes all subcolumns. void finalize(); + bool isFinalized() const; /// Part of interface diff --git a/src/Common/config.h.in b/src/Common/config.h.in index 945f85970fe..d8d308c59bd 100644 --- a/src/Common/config.h.in +++ b/src/Common/config.h.in @@ -13,7 +13,6 @@ #cmakedefine01 USE_CASSANDRA #cmakedefine01 USE_SENTRY #cmakedefine01 USE_GRPC -#cmakedefine01 USE_STATS #cmakedefine01 USE_SIMDJSON #cmakedefine01 USE_RAPIDJSON diff --git a/src/Core/Field.h b/src/Core/Field.h index a9c067fd487..8b3bd425139 100644 --- a/src/Core/Field.h +++ b/src/Core/Field.h @@ -759,27 +759,27 @@ private: using Row = std::vector; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::Null; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::UInt64; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::UInt128; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::UInt256; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::Int64; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::Int128; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::Int256; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::UUID; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::Float64; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::String; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::Array; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::Tuple; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::Map; }; -template <> struct Field::TypeToEnum { static const Types::Which value = Types::Object; }; -template <> struct Field::TypeToEnum>{ static const Types::Which value = Types::Decimal32; }; -template <> struct Field::TypeToEnum>{ static const Types::Which value = Types::Decimal64; }; -template <> struct Field::TypeToEnum>{ static const Types::Which value = Types::Decimal128; }; -template <> struct Field::TypeToEnum>{ static const Types::Which value = Types::Decimal256; }; -template <> struct Field::TypeToEnum>{ static const Types::Which value = Types::Decimal64; }; -template <> struct Field::TypeToEnum{ static const Types::Which value = Types::AggregateFunctionState; }; -template <> struct Field::TypeToEnum{ static const Types::Which value = Types::Bool; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::Null; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::UInt64; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::UInt128; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::UInt256; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::Int64; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::Int128; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::Int256; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::UUID; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::Float64; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::String; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::Array; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::Tuple; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::Map; }; +template <> struct Field::TypeToEnum { static constexpr Types::Which value = Types::Object; }; +template <> struct Field::TypeToEnum>{ static constexpr Types::Which value = Types::Decimal32; }; +template <> struct Field::TypeToEnum>{ static constexpr Types::Which value = Types::Decimal64; }; +template <> struct Field::TypeToEnum>{ static constexpr Types::Which value = Types::Decimal128; }; +template <> struct Field::TypeToEnum>{ static constexpr Types::Which value = Types::Decimal256; }; +template <> struct Field::TypeToEnum>{ static constexpr Types::Which value = Types::Decimal64; }; +template <> struct Field::TypeToEnum{ static constexpr Types::Which value = Types::AggregateFunctionState; }; +template <> struct Field::TypeToEnum{ static constexpr Types::Which value = Types::Bool; }; template <> struct Field::EnumToType { using Type = Null; }; template <> struct Field::EnumToType { using Type = UInt64; }; diff --git a/src/DataTypes/DataTypeObject.cpp b/src/DataTypes/DataTypeObject.cpp index b706e61b3c1..e05add0b91b 100644 --- a/src/DataTypes/DataTypeObject.cpp +++ b/src/DataTypes/DataTypeObject.cpp @@ -26,7 +26,7 @@ DataTypeObject::DataTypeObject(const String & schema_format_, bool is_nullable_) bool DataTypeObject::equals(const IDataType & rhs) const { if (const auto * object = typeid_cast(&rhs)) - return schema_format == object->schema_format; + return schema_format == object->schema_format && is_nullable == object->is_nullable; return false; } diff --git a/src/DataTypes/IDataType.h b/src/DataTypes/IDataType.h index d8e51eb22d0..ae7d4e99abb 100644 --- a/src/DataTypes/IDataType.h +++ b/src/DataTypes/IDataType.h @@ -408,7 +408,10 @@ inline bool isNothing(const DataTypePtr & data_type) { return WhichDataType(data inline bool isUUID(const DataTypePtr & data_type) { return WhichDataType(data_type).isUUID(); } template -inline bool isObject(const T & data_type) {return WhichDataType(data_type).isObject(); } +inline bool isObject(const T & data_type) +{ + return WhichDataType(data_type).isObject(); +} template inline bool isUInt8(const T & data_type) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 889091f9e98..0f09729d009 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -6,25 +6,18 @@ #include #include #include -#include #include #include #include #include #include #include -#include -#include #include #include #include #include #include -#include -#include -#include - namespace DB { @@ -52,8 +45,9 @@ size_t getNumberOfDimensions(const IColumn & column) DataTypePtr getBaseTypeOfArray(const DataTypePtr & type) { + /// Get raw pointers to avoid extra copying of type pointers. const DataTypeArray * last_array = nullptr; - const IDataType * current_type = type.get(); + const auto * current_type = type.get(); while (const auto * type_array = typeid_cast(current_type)) { current_type = type_array->getNestedType().get(); @@ -65,8 +59,9 @@ DataTypePtr getBaseTypeOfArray(const DataTypePtr & type) ColumnPtr getBaseColumnOfArray(const ColumnPtr & column) { + /// Get raw pointers to avoid extra copying of column pointers. const ColumnArray * last_array = nullptr; - const IColumn * current_column = column.get(); + const auto * current_column = column.get(); while (const auto * column_array = checkAndGetColumn(current_column)) { current_column = &column_array->getData(); @@ -92,6 +87,9 @@ ColumnPtr createArrayOfColumn(ColumnPtr column, size_t num_dimensions) Array createEmptyArrayField(size_t num_dimensions) { + if (num_dimensions == 0) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Cannot create array field with 0 dimensions"); + Array array; Array * current_array = &array; for (size_t i = 1; i < num_dimensions; ++i) @@ -138,53 +136,53 @@ void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, con for (auto & name_type : columns_list) { - if (isObject(name_type.type)) + if (!isObject(name_type.type)) + continue; + + auto & column = block.getByName(name_type.name); + if (!isObject(column.type)) + throw Exception(ErrorCodes::TYPE_MISMATCH, + "Type for column '{}' mismatch in columns list and in block. In list: {}, in block: {}", + name_type.name, name_type.type->getName(), column.type->getName()); + + const auto & column_object = assert_cast(*column.column); + const auto & subcolumns = column_object.getSubcolumns(); + + if (!column_object.isFinalized()) + throw Exception(ErrorCodes::LOGICAL_ERROR, + "Cannot convert to tuple column '{}' from type {}. Column should be finalized first", + name_type.name, name_type.type->getName()); + + PathsInData tuple_paths; + DataTypes tuple_types; + Columns tuple_columns; + + for (const auto & entry : subcolumns) { - auto & column = block.getByName(name_type.name); - - if (!isObject(column.type)) - throw Exception(ErrorCodes::TYPE_MISMATCH, - "Type for column '{}' mismatch in columns list and in block. In list: {}, in block: {}", - name_type.name, name_type.type->getName(), column.type->getName()); - - const auto & column_object = assert_cast(*column.column); - const auto & subcolumns_map = column_object.getSubcolumns(); - - if (!column_object.isFinalized()) - throw Exception(ErrorCodes::LOGICAL_ERROR, - "Cannot convert to tuple column '{}' from type {}. Column should be finalized first", - name_type.name, name_type.type->getName()); - - PathsInData tuple_paths; - DataTypes tuple_types; - Columns tuple_columns; - - for (const auto & entry : subcolumns_map) - { - tuple_paths.emplace_back(entry->path); - tuple_types.emplace_back(entry->data.getLeastCommonType()); - tuple_columns.emplace_back(entry->data.getFinalizedColumnPtr()); - } - - auto it = storage_columns_map.find(name_type.name); - if (it == storage_columns_map.end()) - throw Exception(ErrorCodes::LOGICAL_ERROR, "Column '{}' not found in storage", name_type.name); - - std::tie(column.column, column.type) = unflattenTuple(tuple_paths, tuple_types, tuple_columns); - name_type.type = column.type; - - getLeastCommonTypeForObject({column.type, it->second}, true); + tuple_paths.emplace_back(entry->path); + tuple_types.emplace_back(entry->data.getLeastCommonType()); + tuple_columns.emplace_back(entry->data.getFinalizedColumnPtr()); } + + auto it = storage_columns_map.find(name_type.name); + if (it == storage_columns_map.end()) + throw Exception(ErrorCodes::LOGICAL_ERROR, "Column '{}' not found in storage", name_type.name); + + std::tie(column.column, column.type) = unflattenTuple(tuple_paths, tuple_types, tuple_columns); + name_type.type = column.type; + + /// Check that constructed Tuple type and type in storage are compatible. + getLeastCommonTypeForObject({column.type, it->second}, true); } } -static bool isPrefix(const PathInData::Parts & prefix, const PathInData::Parts & strings) +static bool isPrefix(const PathInData::Parts & prefix, const PathInData::Parts & parts) { - if (prefix.size() > strings.size()) + if (prefix.size() > parts.size()) return false; for (size_t i = 0; i < prefix.size(); ++i) - if (prefix[i].key != strings[i].key) + if (prefix[i].key != parts[i].key) return false; return true; } @@ -192,19 +190,15 @@ static bool isPrefix(const PathInData::Parts & prefix, const PathInData::Parts & void checkObjectHasNoAmbiguosPaths(const PathsInData & paths) { size_t size = paths.size(); - std::vector names_parts(size); - - for (size_t i = 0; i < size; ++i) - names_parts[i] = paths[i].getParts(); - for (size_t i = 0; i < size; ++i) { for (size_t j = 0; j < i; ++j) { - if (isPrefix(names_parts[i], names_parts[j]) || isPrefix(names_parts[j], names_parts[i])) + if (isPrefix(paths[i].getParts(), paths[j].getParts()) + || isPrefix(paths[j].getParts(), paths[i].getParts())) throw Exception(ErrorCodes::DUPLICATE_COLUMN, "Data in Object has ambiguous paths: '{}' and '{}'", - paths[i].getPath(), paths[i].getPath()); + paths[i].getPath(), paths[j].getPath()); } } } @@ -227,8 +221,11 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambi if (all_equal) return types[0]; + /// Types of subcolumns by path from all tuples. std::unordered_map subcolumns_types; + /// First we flatten tuples, then get common type for paths + /// and finally unflatten paths and create new tuple type. for (const auto & type : types) { const auto * type_tuple = typeid_cast(type.get()); @@ -246,6 +243,7 @@ DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambi PathsInData tuple_paths; DataTypes tuple_types; + /// Get the least common type for all paths. for (const auto & [key, subtypes] : subcolumns_types) { assert(!subtypes.empty()); @@ -312,7 +310,7 @@ void updateObjectColumns(ColumnsDescription & object_columns, const NamesAndType { for (const auto & new_column : new_columns) { - auto object_column = object_columns.tryGetPhysical(new_column.name); + auto object_column = object_columns.tryGetColumn(GetColumnsOptions::All, new_column.name); if (object_column && !object_column->type->equals(*new_column.type)) { object_columns.modify(new_column.name, [&](auto & column) @@ -326,10 +324,14 @@ void updateObjectColumns(ColumnsDescription & object_columns, const NamesAndType namespace { -void flattenTupleImpl(PathInDataBuilder & builder, DataTypePtr type, size_t array_level, PathsInData & new_paths, DataTypes & new_types) +void flattenTupleImpl( + PathInDataBuilder & builder, + DataTypePtr type, + size_t array_level, + PathsInData & new_paths, + DataTypes & new_types) { bool is_nested = isNested(type); - if (is_nested) type = assert_cast(*type).getNestedType(); @@ -356,13 +358,14 @@ void flattenTupleImpl(PathInDataBuilder & builder, DataTypePtr type, size_t arra } } +/// @offsets_columns are used as stack of array offsets and allows to recreate Array columns. void flattenTupleImpl(const ColumnPtr & column, Columns & new_columns, Columns & offsets_columns) { if (const auto * column_tuple = checkAndGetColumn(column.get())) { const auto & subcolumns = column_tuple->getColumns(); for (const auto & subcolumn : subcolumns) - flattenTupleImpl(subcolumn, new_columns,offsets_columns); + flattenTupleImpl(subcolumn, new_columns, offsets_columns); } else if (const auto * column_array = checkAndGetColumn(column.get())) { @@ -375,8 +378,8 @@ void flattenTupleImpl(const ColumnPtr & column, Columns & new_columns, Columns & if (!offsets_columns.empty()) { auto new_column = ColumnArray::create(column, offsets_columns.back()); - for (ssize_t i = static_cast(offsets_columns.size()) - 2; i >= 0; --i) - new_column = ColumnArray::create(new_column, offsets_columns[i]); + for (auto it = offsets_columns.rbegin() + 1; it != offsets_columns.rend(); ++it) + new_column = ColumnArray::create(new_column, *it); new_columns.push_back(std::move(new_column)); } @@ -422,9 +425,8 @@ struct ColumnWithTypeAndDimensions size_t array_dimensions; }; -using SubcolumnsTreeWithTypes = SubcolumnsTree; +using SubcolumnsTreeWithTypes = SubcolumnsTree; using Node = SubcolumnsTreeWithTypes::Node; -using Leaf = SubcolumnsTreeWithTypes::Leaf; std::pair createTypeFromNode(const Node * node) { @@ -438,6 +440,7 @@ std::pair createTypeFromNode(const Node * node) tuple_elements.emplace_back(name, std::move(column), std::move(type)); } + /// Sort to always create the same type for the same set of subcolumns. std::sort(tuple_elements.begin(), tuple_elements.end(), [](const auto & lhs, const auto & rhs) { return std::get<0>(lhs) < std::get<0>(rhs); }); @@ -450,8 +453,7 @@ std::pair createTypeFromNode(const Node * node) if (node->kind == Node::SCALAR) { - const auto * leaf = typeid_cast(node); - return {leaf->data.column, leaf->data.type}; + return {node->data.column, node->data.type}; } else if (node->kind == Node::NESTED) { @@ -474,9 +476,9 @@ std::pair createTypeFromNode(const Node * node) auto result_column = ColumnArray::create(ColumnTuple::create(tuple_columns), offsets_columns.back()); auto result_type = createNested(tuple_types, tuple_names); - for (ssize_t i = static_cast(offsets_columns.size()) - 2; i >= 0; --i) + for (auto it = offsets_columns.rbegin() + 1; it != offsets_columns.rend(); ++it) { - result_column = ColumnArray::create(result_column, offsets_columns[i]); + result_column = ColumnArray::create(result_column, *it); result_type = std::make_shared(result_type); } @@ -533,6 +535,9 @@ std::pair unflattenTuple( assert(paths.size() == tuple_types.size()); assert(paths.size() == tuple_columns.size()); + /// We add all paths to the subcolumn tree and then create a type from it. + /// The tree stores column, type and number of array dimensions + /// for each intermediate node. SubcolumnsTreeWithTypes tree; for (size_t i = 0; i < paths.size(); ++i) @@ -562,10 +567,9 @@ std::pair unflattenTuple( ColumnWithTypeAndDimensions current_column; if (kind == Node::NESTED) { - size_t dimensions_to_reduce = array_level - nested_level; assert(parts[pos].is_nested); - ++dimensions_to_reduce; + size_t dimensions_to_reduce = array_level - nested_level + 1; --nested_level; current_column = ColumnWithTypeAndDimensions{column, type, dimensions_to_reduce}; @@ -579,15 +583,16 @@ std::pair unflattenTuple( array_level -= dimensions_to_reduce; } else + { current_column = ColumnWithTypeAndDimensions{column, type, 0}; + } ++pos; - if (exists) return nullptr; return kind == Node::SCALAR - ? std::make_shared(paths[i], current_column) + ? std::make_shared(kind, current_column, paths[i]) : std::make_shared(kind, current_column); }); } diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index 15c8d8ed794..f0c9a73bf80 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -12,31 +12,64 @@ namespace DB { +/// Returns number of dimensions in Array type. 0 if type is not array. size_t getNumberOfDimensions(const IDataType & type); -size_t getNumberOfDimensions(const IColumn & column); -DataTypePtr getBaseTypeOfArray(const DataTypePtr & type); -DataTypePtr createArrayOfType(DataTypePtr type, size_t num_dimensions); -Array createEmptyArrayField(size_t num_dimensions); +/// Returns number of dimensions in Array column. 0 if column is not array. +size_t getNumberOfDimensions(const IColumn & column); + +/// Returns type of scalars of Array of arbitrary dimensions. +DataTypePtr getBaseTypeOfArray(const DataTypePtr & type); + +/// Returns Array type with requested scalar type and number of dimensions. +DataTypePtr createArrayOfType(DataTypePtr type, size_t num_dimensions); + +/// Returns column of scalars of Array of arbitrary dimensions. ColumnPtr getBaseColumnOfArray(const ColumnPtr & column); + +/// Returns empty Array column with requested scalar column and number of dimensions. ColumnPtr createArrayOfColumn(const ColumnPtr & column, size_t num_dimensions); +/// Returns Array with requested number of dimensions and no scalars. +Array createEmptyArrayField(size_t num_dimensions); + +/// Tries to get data type by column. Only limited subset of types is supported DataTypePtr getDataTypeByColumn(const IColumn & column); + +/// Converts Object types and columns to Tuples in @columns_list and @block +/// and checks that types are consistent with types in @extended_storage_columns. void convertObjectsToTuples(NamesAndTypesList & columns_list, Block & block, const NamesAndTypesList & extended_storage_columns); + +/// Checks that each path is not the prefix of any other path. void checkObjectHasNoAmbiguosPaths(const PathsInData & paths); + +/// Receives several Tuple types and deduces the least common type among them. DataTypePtr getLeastCommonTypeForObject(const DataTypes & types, bool check_ambiguos_paths = false); + +/// Converts types of object columns to tuples in @columns_list +/// according to @object_columns and adds all tuple's subcolumns if needed. void extendObjectColumns(NamesAndTypesList & columns_list, const ColumnsDescription & object_columns, bool with_subcolumns); NameSet getNamesOfObjectColumns(const NamesAndTypesList & columns_list); bool hasObjectColumns(const ColumnsDescription & columns); +void finalizeObjectColumns(MutableColumns & columns); +/// Updates types of objects in @object_columns inplace +/// according to types in new_columns. void updateObjectColumns(ColumnsDescription & object_columns, const NamesAndTypesList & new_columns); using DataTypeTuplePtr = std::shared_ptr; +/// Flattens nested Tuple to plain Tuple. I.e extracts all paths and types from tuple. +/// E.g. Tuple(t Tuple(c1 UInt32, c2 String), c3 UInt64) -> Tuple(t.c1 UInt32, t.c2 String, c3 UInt32) std::pair flattenTuple(const DataTypePtr & type); + +/// Flattens nested Tuple column to plain Tuple column. ColumnPtr flattenTuple(const ColumnPtr & column); +/// The reverse operation to 'flattenTuple'. +/// Creates nested Tuple from all paths and types. +/// E.g. Tuple(t.c1 UInt32, t.c2 String, c3 UInt32) -> Tuple(t Tuple(c1 UInt32, c2 String), c3 UInt64) DataTypePtr unflattenTuple( const PathsInData & paths, const DataTypes & tuple_types); @@ -46,13 +79,20 @@ std::pair unflattenTuple( const DataTypes & tuple_types, const Columns & tuple_columns); +/// For all columns which exist in @expected_columns and +/// don't exist in @available_columns adds to WITH clause +/// an alias with column name to literal of default value of column type. void replaceMissedSubcolumnsByConstants( const ColumnsDescription & expected_columns, const ColumnsDescription & available_columns, ASTPtr query); -void finalizeObjectColumns(MutableColumns & columns); - +/// Receives range of objects, which contains collections +/// of columns-like objects (e.g. ColumnsDescription or NamesAndTypesList) +/// and deduces the common types of object columns for all entries. +/// @entry_columns_getter should extract reference to collection of +/// columns-like objects from entry to which Iterator points. +/// columns-like object should have fields "name" and "type". template ColumnsDescription getObjectColumns( Iterator begin, Iterator end, diff --git a/src/DataTypes/Serializations/ISerialization.h b/src/DataTypes/Serializations/ISerialization.h index eb8aca0d37f..1d55155c8be 100644 --- a/src/DataTypes/Serializations/ISerialization.h +++ b/src/DataTypes/Serializations/ISerialization.h @@ -136,6 +136,7 @@ public: /// Index of tuple element, starting at 1 or name. String tuple_element_name; + /// Name of subcolumn of object column. String object_key_name; /// Do we need to escape a dot in filenames for tuple elements. diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index e9eb962dfc5..b306a3f6cbd 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -61,19 +61,21 @@ private: size_t num_dimensions_to_keep; }; +using Node = typename ColumnObject::SubcolumnsTree::Node; + bool tryInsertDefaultFromNested( - ColumnObject::SubcolumnsTree::LeafPtr entry, const ColumnObject::SubcolumnsTree & subcolumns) + std::shared_ptr entry, const ColumnObject::SubcolumnsTree & subcolumns) { if (!entry->path.hasNested()) return false; - const ColumnObject::SubcolumnsTree::Node * node = subcolumns.findLeaf(entry->path); - const ColumnObject::SubcolumnsTree::Leaf * leaf = nullptr; + const Node * current_node = subcolumns.findLeaf(entry->path); + const Node * leaf = nullptr; size_t num_skipped_nested = 0; - while (node) + while (current_node) { - const auto * node_nested = subcolumns.findParent(node, + const auto * node_nested = subcolumns.findParent(current_node, [](const auto & candidate) { return candidate.isNested(); }); if (!node_nested) @@ -88,7 +90,7 @@ bool tryInsertDefaultFromNested( if (leaf) break; - node = node_nested->parent; + current_node = node_nested->parent; ++num_skipped_nested; } diff --git a/src/DataTypes/Serializations/SubcolumnsTree.h b/src/DataTypes/Serializations/SubcolumnsTree.h index 94266db39f7..8722f14b4e9 100644 --- a/src/DataTypes/Serializations/SubcolumnsTree.h +++ b/src/DataTypes/Serializations/SubcolumnsTree.h @@ -8,9 +8,7 @@ namespace DB { -struct EmptyNodeData {}; - -template +template class SubcolumnsTree { public: @@ -25,40 +23,31 @@ public: explicit Node(Kind kind_) : kind(kind_) {} Node(Kind kind_, const NodeData & data_) : kind(kind_), data(data_) {} + Node(Kind kind_, const NodeData & data_, const PathInData & path_) + : kind(kind_), data(data_), path(path_) {} Kind kind = TUPLE; const Node * parent = nullptr; std::map, std::less<>> children; + NodeData data; + PathInData path; bool isNested() const { return kind == NESTED; } + bool isScalar() const { return kind == SCALAR; } void addChild(const String & key, std::shared_ptr next_node) { next_node->parent = this; children[key] = std::move(next_node); } - - virtual ~Node() = default; - }; - - struct Leaf : public Node - { - Leaf(const PathInData & path_, const LeafData & data_) - : Node(Node::SCALAR), path(path_), data(data_) - { - } - - PathInData path; - LeafData data; }; using NodeKind = typename Node::Kind; using NodePtr = std::shared_ptr; - using LeafPtr = std::shared_ptr; - bool add(const PathInData & path, const LeafData & leaf_data) + bool add(const PathInData & path, const NodeData & leaf_data) { return add(path, [&](NodeKind kind, bool exists) -> NodePtr { @@ -66,7 +55,7 @@ public: return nullptr; if (kind == Node::SCALAR) - return std::make_shared(path, leaf_data); + return std::make_shared(kind, leaf_data, path); return std::make_shared(kind); }); @@ -94,9 +83,8 @@ public: { current_node = it->second.get(); node_creator(current_node->kind, true); - bool current_node_is_nested = current_node->kind == Node::NESTED; - if (current_node_is_nested != parts[i].is_nested) + if (current_node->isNested() != parts[i].is_nested) return false; } else @@ -114,10 +102,7 @@ public: auto next_node = node_creator(Node::SCALAR, false); current_node->addChild(String(parts.back().key), next_node); - - auto leaf = std::dynamic_pointer_cast(next_node); - assert(leaf); - leaves.push_back(std::move(leaf)); + leaves.push_back(std::move(next_node)); return true; } @@ -132,22 +117,28 @@ public: return findImpl(path, true); } - const Leaf * findLeaf(const PathInData & path) const + const Node * findLeaf(const PathInData & path) const { - return typeid_cast(findExact(path)); + const auto * candidate = findExact(path); + if (!candidate || !candidate->isScalar()) + return nullptr; + return candidate; } - using LeafPredicate = std::function; + using NodePredicate = std::function; - const Leaf * findLeaf(const LeafPredicate & predicate) + const Node * findLeaf(const NodePredicate & predicate) { return findLeaf(root.get(), predicate); } - static const Leaf * findLeaf(const Node * node, const LeafPredicate & predicate) + static const Node * findLeaf(const Node * node, const NodePredicate & predicate) { - if (const auto * leaf = typeid_cast(node)) - return predicate(*leaf) ? leaf : nullptr; + if (!node) + return nullptr; + + if (node->isScalar()) + return predicate(*node) ? node : nullptr; for (const auto & [_, child] : node->children) if (const auto * leaf = findLeaf(child.get(), predicate)) @@ -156,8 +147,6 @@ public: return nullptr; } - using NodePredicate = std::function; - static const Node * findParent(const Node * node, const NodePredicate & predicate) { while (node && !predicate(*node)) @@ -168,12 +157,13 @@ public: bool empty() const { return root == nullptr; } size_t size() const { return leaves.size(); } - using Leaves = std::vector; - const Leaves & getLeaves() const { return leaves; } + using Nodes = std::vector; + + const Nodes & getLeaves() const { return leaves; } const Node * getRoot() const { return root.get(); } - using iterator = typename Leaves::iterator; - using const_iterator = typename Leaves::const_iterator; + using iterator = typename Nodes::iterator; + using const_iterator = typename Nodes::const_iterator; iterator begin() { return leaves.begin(); } iterator end() { return leaves.end(); } @@ -200,11 +190,10 @@ private: } return current_node; - } NodePtr root; - Leaves leaves; + Nodes leaves; }; } diff --git a/src/DataTypes/getLeastSupertype.h b/src/DataTypes/getLeastSupertype.h index 366fa885a66..5444bb34d06 100644 --- a/src/DataTypes/getLeastSupertype.h +++ b/src/DataTypes/getLeastSupertype.h @@ -14,7 +14,6 @@ namespace DB * Examples: there is no least common supertype for Array(UInt8), Int8. */ DataTypePtr getLeastSupertype(const DataTypes & types, bool allow_conversion_to_string = false); -DataTypePtr getLeastSupertype(const DataTypePtr & lhs, const DataTypePtr & rhs, bool allow_conversion_to_string = false); using TypeIndexSet = std::unordered_set; DataTypePtr getLeastSupertype(const TypeIndexSet & types, bool allow_conversion_to_string = false); diff --git a/src/Storages/IStorage.cpp b/src/Storages/IStorage.cpp index 66f9513c7f7..89403a773b3 100644 --- a/src/Storages/IStorage.cpp +++ b/src/Storages/IStorage.cpp @@ -13,7 +13,6 @@ #include #include #include -#include namespace DB From 8e1941599259f0d78736c783fe5002f7c9d9a7e5 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Mon, 21 Feb 2022 11:32:02 -0800 Subject: [PATCH 085/132] generalize implementation for h3PointDist{M,Km,Rads} --- .../{h3PointDistRads.cpp => h3PointDist.cpp} | 35 +++-- src/Functions/h3PointDistKm.cpp | 129 ------------------ src/Functions/h3PointDistM.cpp | 129 ------------------ .../0_stateless/02212_h3_point_dist.reference | 39 ++++++ ..._dist_rads.sql => 02212_h3_point_dist.sql} | 5 + .../02212_h3_point_dist_km.reference | 12 -- .../0_stateless/02212_h3_point_dist_km.sql | 22 --- .../02212_h3_point_dist_m.reference | 12 -- .../0_stateless/02212_h3_point_dist_m.sql | 22 --- .../02212_h3_point_dist_rads.reference | 12 -- 10 files changed, 70 insertions(+), 347 deletions(-) rename src/Functions/{h3PointDistRads.cpp => h3PointDist.cpp} (79%) delete mode 100644 src/Functions/h3PointDistKm.cpp delete mode 100644 src/Functions/h3PointDistM.cpp create mode 100644 tests/queries/0_stateless/02212_h3_point_dist.reference rename tests/queries/0_stateless/{02212_h3_point_dist_rads.sql => 02212_h3_point_dist.sql} (65%) delete mode 100644 tests/queries/0_stateless/02212_h3_point_dist_km.reference delete mode 100644 tests/queries/0_stateless/02212_h3_point_dist_km.sql delete mode 100644 tests/queries/0_stateless/02212_h3_point_dist_m.reference delete mode 100644 tests/queries/0_stateless/02212_h3_point_dist_m.sql delete mode 100644 tests/queries/0_stateless/02212_h3_point_dist_rads.reference diff --git a/src/Functions/h3PointDistRads.cpp b/src/Functions/h3PointDist.cpp similarity index 79% rename from src/Functions/h3PointDistRads.cpp rename to src/Functions/h3PointDist.cpp index 8b2cee2ed06..38d22ced055 100644 --- a/src/Functions/h3PointDistRads.cpp +++ b/src/Functions/h3PointDist.cpp @@ -25,13 +25,14 @@ extern const int ILLEGAL_COLUMN; namespace { - -class FunctionH3PointDistRads final : public IFunction +template +class FunctionH3PointDist final : public IFunction { public: - static constexpr auto name = "h3PointDistRads"; + static constexpr auto name = Impl::name; + static constexpr auto function = Impl::function; - static FunctionPtr create(ContextPtr) { return std::make_shared(); } + static FunctionPtr create(ContextPtr) { return std::make_shared(); } std::string getName() const override { return name; } @@ -109,7 +110,8 @@ public: LatLng point1 = {degsToRads(lat1), degsToRads(lon1)}; LatLng point2 = {degsToRads(lat2), degsToRads(lon2)}; - Float64 res = distanceRads(&point1, &point2); + // function will be equivalent to distanceM or distanceKm or distanceRads + Float64 res = function(&point1, &point2); dst_data[row] = res; } @@ -119,10 +121,25 @@ public: } -void registerFunctionH3PointDistRads(FunctionFactory & factory) -{ - factory.registerFunction(); -} +struct H3PointDistM { + static constexpr auto name = "h3PointDistM"; + static constexpr auto function = distanceM; +}; + +struct H3PointDistKm { + static constexpr auto name = "h3PointDistKm"; + static constexpr auto function = distanceKm; +}; + +struct H3PointDistRads { + static constexpr auto name = "h3PointDistRads"; + static constexpr auto function = distanceRads; +}; + + +void registerFunctionH3PointDistM(FunctionFactory & factory) { factory.registerFunction>(); } +void registerFunctionH3PointDistKm(FunctionFactory & factory) { factory.registerFunction>(); } +void registerFunctionH3PointDistRads(FunctionFactory & factory) { factory.registerFunction>(); } } diff --git a/src/Functions/h3PointDistKm.cpp b/src/Functions/h3PointDistKm.cpp deleted file mode 100644 index ef4f9196ac0..00000000000 --- a/src/Functions/h3PointDistKm.cpp +++ /dev/null @@ -1,129 +0,0 @@ -#include "config_functions.h" - -#if USE_H3 - -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - - -namespace DB -{ -namespace ErrorCodes -{ -extern const int ILLEGAL_TYPE_OF_ARGUMENT; -extern const int ILLEGAL_COLUMN; -} - -namespace -{ - -class FunctionH3PointDistKm final : public IFunction -{ -public: - static constexpr auto name = "h3PointDistKm"; - - static FunctionPtr create(ContextPtr) { return std::make_shared(); } - - std::string getName() const override { return name; } - - size_t getNumberOfArguments() const override { return 4; } - bool useDefaultImplementationForConstants() const override { return true; } - bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } - - DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override - { - for (size_t i = 0; i < getNumberOfArguments(); ++i) - { - const auto * arg = arguments[i].get(); - if (!WhichDataType(arg).isFloat64()) - throw Exception( - ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, - "Illegal type {} of argument {} of function {}. Must be Float64", - arg->getName(), i, getName()); - } - return std::make_shared(); - } - - ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override - { - const auto * col_lat1 = checkAndGetColumn(arguments[0].column.get()); - if (!col_lat1) - throw Exception( - ErrorCodes::ILLEGAL_COLUMN, - "Illegal type {} of argument {} of function {}. Must be Float64", - arguments[0].type->getName(), - 1, - getName()); - const auto & data_lat1 = col_lat1->getData(); - - const auto * col_lon1 = checkAndGetColumn(arguments[1].column.get()); - if (!col_lon1) - throw Exception( - ErrorCodes::ILLEGAL_COLUMN, - "Illegal type {} of argument {} of function {}. Must be Float64", - arguments[1].type->getName(), - 2, - getName()); - const auto & data_lon1 = col_lon1->getData(); - - const auto * col_lat2 = checkAndGetColumn(arguments[2].column.get()); - if (!col_lat2) - throw Exception( - ErrorCodes::ILLEGAL_COLUMN, - "Illegal type {} of argument {} of function {}. Must be Float64", - arguments[2].type->getName(), - 3, - getName()); - const auto & data_lat2 = col_lat2->getData(); - - const auto * col_lon2 = checkAndGetColumn(arguments[3].column.get()); - if (!col_lon2) - throw Exception( - ErrorCodes::ILLEGAL_COLUMN, - "Illegal type {} of argument {} of function {}. Must be Float64", - arguments[3].type->getName(), - 4, - getName()); - const auto & data_lon2 = col_lon2->getData(); - - auto dst = ColumnVector::create(); - auto & dst_data = dst->getData(); - dst_data.resize(input_rows_count); - - for (size_t row = 0; row < input_rows_count; ++row) - { - const double lat1 = data_lat1[row]; - const double lon1 = data_lon1[row]; - const auto lat2 = data_lat2[row]; - const auto lon2 = data_lon2[row]; - - LatLng point1 = {degsToRads(lat1), degsToRads(lon1)}; - LatLng point2 = {degsToRads(lat2), degsToRads(lon2)}; - - Float64 res = distanceKm(&point1, &point2); - dst_data[row] = res; - } - - return dst; - } -}; - -} - -void registerFunctionH3PointDistKm(FunctionFactory & factory) -{ - factory.registerFunction(); -} - -} - -#endif diff --git a/src/Functions/h3PointDistM.cpp b/src/Functions/h3PointDistM.cpp deleted file mode 100644 index 8aff1d7adec..00000000000 --- a/src/Functions/h3PointDistM.cpp +++ /dev/null @@ -1,129 +0,0 @@ -#include "config_functions.h" - -#if USE_H3 - -#include -#include -#include -#include -#include -#include -#include -#include - -#include -#include - - -namespace DB -{ -namespace ErrorCodes -{ -extern const int ILLEGAL_TYPE_OF_ARGUMENT; -extern const int ILLEGAL_COLUMN; -} - -namespace -{ - -class FunctionH3PointDistM final : public IFunction -{ -public: - static constexpr auto name = "h3PointDistM"; - - static FunctionPtr create(ContextPtr) { return std::make_shared(); } - - std::string getName() const override { return name; } - - size_t getNumberOfArguments() const override { return 4; } - bool useDefaultImplementationForConstants() const override { return true; } - bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } - - DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override - { - for (size_t i = 0; i < getNumberOfArguments(); ++i) - { - const auto * arg = arguments[i].get(); - if (!WhichDataType(arg).isFloat64()) - throw Exception( - ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, - "Illegal type {} of argument {} of function {}. Must be Float64", - arg->getName(), i, getName()); - } - return std::make_shared(); - } - - ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override - { - const auto * col_lat1 = checkAndGetColumn(arguments[0].column.get()); - if (!col_lat1) - throw Exception( - ErrorCodes::ILLEGAL_COLUMN, - "Illegal type {} of argument {} of function {}. Must be Float64", - arguments[0].type->getName(), - 1, - getName()); - const auto & data_lat1 = col_lat1->getData(); - - const auto * col_lon1 = checkAndGetColumn(arguments[1].column.get()); - if (!col_lon1) - throw Exception( - ErrorCodes::ILLEGAL_COLUMN, - "Illegal type {} of argument {} of function {}. Must be Float64", - arguments[1].type->getName(), - 2, - getName()); - const auto & data_lon1 = col_lon1->getData(); - - const auto * col_lat2 = checkAndGetColumn(arguments[2].column.get()); - if (!col_lat2) - throw Exception( - ErrorCodes::ILLEGAL_COLUMN, - "Illegal type {} of argument {} of function {}. Must be Float64", - arguments[2].type->getName(), - 3, - getName()); - const auto & data_lat2 = col_lat2->getData(); - - const auto * col_lon2 = checkAndGetColumn(arguments[3].column.get()); - if (!col_lon2) - throw Exception( - ErrorCodes::ILLEGAL_COLUMN, - "Illegal type {} of argument {} of function {}. Must be Float64", - arguments[3].type->getName(), - 4, - getName()); - const auto & data_lon2 = col_lon2->getData(); - - auto dst = ColumnVector::create(); - auto & dst_data = dst->getData(); - dst_data.resize(input_rows_count); - - for (size_t row = 0; row < input_rows_count; ++row) - { - const double lat1 = data_lat1[row]; - const double lon1 = data_lon1[row]; - const auto lat2 = data_lat2[row]; - const auto lon2 = data_lon2[row]; - - LatLng point1 = {degsToRads(lat1), degsToRads(lon1)}; - LatLng point2 = {degsToRads(lat2), degsToRads(lon2)}; - - Float64 res = distanceM(&point1, &point2); - dst_data[row] = res; - } - - return dst; - } -}; - -} - -void registerFunctionH3PointDistM(FunctionFactory & factory) -{ - factory.registerFunction(); -} - -} - -#endif diff --git a/tests/queries/0_stateless/02212_h3_point_dist.reference b/tests/queries/0_stateless/02212_h3_point_dist.reference new file mode 100644 index 00000000000..171b2024095 --- /dev/null +++ b/tests/queries/0_stateless/02212_h3_point_dist.reference @@ -0,0 +1,39 @@ +-- select h3PointDistM(lat1, lon1,lat2, lon2) AS k from table1 order by k; +111195.05197522961 +111228.91103262542 +111901.0753744776 +111901.07537447763 +111901.07537447763 +157225.60925091387 +157249.55851177874 +222457.78082261496 +223528.36944466401 +223528.36944466401 +400900.66882205213 +2223901.039504589 +-- select h3PointDistKm(lat1, lon1,lat2, lon2) AS k from table1 order by k; +111.1950519752296 +111.22891103262542 +111.9010753744776 +111.90107537447763 +111.90107537447763 +157.22560925091386 +157.24955851177873 +222.45778082261498 +223.528369444664 +223.528369444664 +400.9006688220521 +2223.901039504589 +-- select h3PointDistRads(lat1, lon1,lat2, lon2) AS k from table1 order by k; +0.01745329251994332 +0.017458607073268143 +0.017564110696598745 +0.01756411069659875 +0.01756411069659875 +0.024678297290546682 +0.02468205639176644 +0.034917207673048706 +0.03508524839120321 +0.03508524839120321 +0.06292579139178688 +0.3490658503988659 diff --git a/tests/queries/0_stateless/02212_h3_point_dist_rads.sql b/tests/queries/0_stateless/02212_h3_point_dist.sql similarity index 65% rename from tests/queries/0_stateless/02212_h3_point_dist_rads.sql rename to tests/queries/0_stateless/02212_h3_point_dist.sql index ba841174f7d..ccbbfe4d0a8 100644 --- a/tests/queries/0_stateless/02212_h3_point_dist_rads.sql +++ b/tests/queries/0_stateless/02212_h3_point_dist.sql @@ -17,6 +17,11 @@ INSERT INTO table1 VALUES(-90, 181, -89, 182); INSERT INTO table1 VALUES(-84, 181, -83, 182); INSERT INTO table1 VALUES(-87, 0, -85, 3); +select '-- select h3PointDistM(lat1, lon1,lat2, lon2) AS k from table1 order by k;'; +select h3PointDistM(lat1, lon1,lat2, lon2) AS k from table1 order by k; +select '-- select h3PointDistKm(lat1, lon1,lat2, lon2) AS k from table1 order by k;'; +select h3PointDistKm(lat1, lon1,lat2, lon2) AS k from table1 order by k; +select '-- select h3PointDistRads(lat1, lon1,lat2, lon2) AS k from table1 order by k;'; select h3PointDistRads(lat1, lon1,lat2, lon2) AS k from table1 order by k; DROP TABLE table1 diff --git a/tests/queries/0_stateless/02212_h3_point_dist_km.reference b/tests/queries/0_stateless/02212_h3_point_dist_km.reference deleted file mode 100644 index 2d0cc817236..00000000000 --- a/tests/queries/0_stateless/02212_h3_point_dist_km.reference +++ /dev/null @@ -1,12 +0,0 @@ -111.1950519752296 -111.22891103262542 -111.9010753744776 -111.90107537447763 -111.90107537447763 -157.22560925091386 -157.24955851177873 -222.45778082261498 -223.528369444664 -223.528369444664 -400.9006688220521 -2223.901039504589 diff --git a/tests/queries/0_stateless/02212_h3_point_dist_km.sql b/tests/queries/0_stateless/02212_h3_point_dist_km.sql deleted file mode 100644 index 5f684349d62..00000000000 --- a/tests/queries/0_stateless/02212_h3_point_dist_km.sql +++ /dev/null @@ -1,22 +0,0 @@ --- Tags: no-fasttest - -DROP TABLE IF EXISTS table1; - -CREATE TABLE table1 (lat1 Float64, lon1 Float64, lat2 Float64, lon2 Float64) ENGINE = Memory; - -INSERT INTO table1 VALUES(-10.0 ,0.0, 10.0, 0.0); -INSERT INTO table1 VALUES(-1, -1, 2, 1); -INSERT INTO table1 VALUES(0, 2, 1, 3); -INSERT INTO table1 VALUES(-2, -3, -1, -2); -INSERT INTO table1 VALUES(-87, 0, -85, 3); -INSERT INTO table1 VALUES(-89, 1, -88, 2); -INSERT INTO table1 VALUES(-84, 1, -83, 2); -INSERT INTO table1 VALUES(-88, 90, -86, 91); -INSERT INTO table1 VALUES(-84, -91, -83, -90); -INSERT INTO table1 VALUES(-90, 181, -89, 182); -INSERT INTO table1 VALUES(-84, 181, -83, 182); -INSERT INTO table1 VALUES(-87, 0, -85, 3); - -select h3PointDistKm(lat1, lon1,lat2, lon2) AS k from table1 order by k; - -DROP TABLE table1 diff --git a/tests/queries/0_stateless/02212_h3_point_dist_m.reference b/tests/queries/0_stateless/02212_h3_point_dist_m.reference deleted file mode 100644 index c52f38d0394..00000000000 --- a/tests/queries/0_stateless/02212_h3_point_dist_m.reference +++ /dev/null @@ -1,12 +0,0 @@ -111195.05197522961 -111228.91103262542 -111901.0753744776 -111901.07537447763 -111901.07537447763 -157225.60925091387 -157249.55851177874 -222457.78082261496 -223528.36944466401 -223528.36944466401 -400900.66882205213 -2223901.039504589 diff --git a/tests/queries/0_stateless/02212_h3_point_dist_m.sql b/tests/queries/0_stateless/02212_h3_point_dist_m.sql deleted file mode 100644 index 7011c50bca0..00000000000 --- a/tests/queries/0_stateless/02212_h3_point_dist_m.sql +++ /dev/null @@ -1,22 +0,0 @@ --- Tags: no-fasttest - -DROP TABLE IF EXISTS table1; - -CREATE TABLE table1 (lat1 Float64, lon1 Float64, lat2 Float64, lon2 Float64) ENGINE = Memory; - -INSERT INTO table1 VALUES(-10.0 ,0.0, 10.0, 0.0); -INSERT INTO table1 VALUES(-1, -1, 2, 1); -INSERT INTO table1 VALUES(0, 2, 1, 3); -INSERT INTO table1 VALUES(-2, -3, -1, -2); -INSERT INTO table1 VALUES(-87, 0, -85, 3); -INSERT INTO table1 VALUES(-89, 1, -88, 2); -INSERT INTO table1 VALUES(-84, 1, -83, 2); -INSERT INTO table1 VALUES(-88, 90, -86, 91); -INSERT INTO table1 VALUES(-84, -91, -83, -90); -INSERT INTO table1 VALUES(-90, 181, -89, 182); -INSERT INTO table1 VALUES(-84, 181, -83, 182); -INSERT INTO table1 VALUES(-87, 0, -85, 3); - -select h3PointDistM(lat1, lon1,lat2, lon2) AS k from table1 order by k; - -DROP TABLE table1 diff --git a/tests/queries/0_stateless/02212_h3_point_dist_rads.reference b/tests/queries/0_stateless/02212_h3_point_dist_rads.reference deleted file mode 100644 index f5f934e5cd6..00000000000 --- a/tests/queries/0_stateless/02212_h3_point_dist_rads.reference +++ /dev/null @@ -1,12 +0,0 @@ -0.01745329251994332 -0.017458607073268143 -0.017564110696598745 -0.01756411069659875 -0.01756411069659875 -0.024678297290546682 -0.02468205639176644 -0.034917207673048706 -0.03508524839120321 -0.03508524839120321 -0.06292579139178688 -0.3490658503988659 From 57e17c607a935b91fd3590f0bb4753e70f40f515 Mon Sep 17 00:00:00 2001 From: bharatnc Date: Mon, 21 Feb 2022 12:15:14 -0800 Subject: [PATCH 086/132] fix - convert const cols to full cols --- src/Functions/h3GetPentagonIndexes.cpp | 7 +++++-- src/Functions/h3PointDist.cpp | 12 ++++++++---- .../02212_h3_get_pentagon_indexes.reference | 12 ++++++++++++ .../0_stateless/02212_h3_get_pentagon_indexes.sql | 8 ++++++-- .../0_stateless/02212_h3_point_dist.reference | 3 +++ tests/queries/0_stateless/02212_h3_point_dist.sql | 7 ++++++- 6 files changed, 40 insertions(+), 9 deletions(-) diff --git a/src/Functions/h3GetPentagonIndexes.cpp b/src/Functions/h3GetPentagonIndexes.cpp index bd084e3b41c..bc90187bb3a 100644 --- a/src/Functions/h3GetPentagonIndexes.cpp +++ b/src/Functions/h3GetPentagonIndexes.cpp @@ -53,7 +53,11 @@ public: ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override { - const auto * column = checkAndGetColumn(arguments[0].column.get()); + auto non_const_arguments = arguments; + for (auto & argument : non_const_arguments) + argument.column = argument.column->convertToFullColumnIfConst(); + + const auto * column = checkAndGetColumn(non_const_arguments[0].column.get()); if (!column) throw Exception( ErrorCodes::ILLEGAL_COLUMN, @@ -74,7 +78,6 @@ public: std::vector hindex_vec; result_data.reserve(input_rows_count); - for (size_t row = 0; row < input_rows_count; ++row) { if (data[row] > MAX_H3_RES) diff --git a/src/Functions/h3PointDist.cpp b/src/Functions/h3PointDist.cpp index 38d22ced055..6312929e995 100644 --- a/src/Functions/h3PointDist.cpp +++ b/src/Functions/h3PointDist.cpp @@ -56,7 +56,11 @@ public: ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t input_rows_count) const override { - const auto * col_lat1 = checkAndGetColumn(arguments[0].column.get()); + auto non_const_arguments = arguments; + for (auto & argument : non_const_arguments) + argument.column = argument.column->convertToFullColumnIfConst(); + + const auto * col_lat1 = checkAndGetColumn(non_const_arguments[0].column.get()); if (!col_lat1) throw Exception( ErrorCodes::ILLEGAL_COLUMN, @@ -66,7 +70,7 @@ public: getName()); const auto & data_lat1 = col_lat1->getData(); - const auto * col_lon1 = checkAndGetColumn(arguments[1].column.get()); + const auto * col_lon1 = checkAndGetColumn(non_const_arguments[1].column.get()); if (!col_lon1) throw Exception( ErrorCodes::ILLEGAL_COLUMN, @@ -76,7 +80,7 @@ public: getName()); const auto & data_lon1 = col_lon1->getData(); - const auto * col_lat2 = checkAndGetColumn(arguments[2].column.get()); + const auto * col_lat2 = checkAndGetColumn(non_const_arguments[2].column.get()); if (!col_lat2) throw Exception( ErrorCodes::ILLEGAL_COLUMN, @@ -86,7 +90,7 @@ public: getName()); const auto & data_lat2 = col_lat2->getData(); - const auto * col_lon2 = checkAndGetColumn(arguments[3].column.get()); + const auto * col_lon2 = checkAndGetColumn(non_const_arguments[3].column.get()); if (!col_lon2) throw Exception( ErrorCodes::ILLEGAL_COLUMN, diff --git a/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.reference b/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.reference index c73c2a34e42..843c488e8e1 100644 --- a/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.reference +++ b/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.reference @@ -14,3 +14,15 @@ [635148284947595327,635500128668483647,635851972389371967,636344553598615615,636731581691592767,637048241040392255,637224162900836415,637540822249635903,637927850342613055,638420431551856703,638772275272745023,639124118993633343] [639651884574965767,640003728295854087,640355572016742407,640848153225986055,641235181318963207,641551840667762695,641727762528206855,642044421877006343,642431449969983495,642924031179227143,643275874900115463,643627718621003783] [644155484202336256,644507327923224576,644859171644112896,645351752853356544,645738780946333696,646055440295133184,646231362155577344,646548021504376832,646935049597353984,647427630806597632,647779474527485952,648131318248374272] +-- test for const cols +[576636674163867647,576988517884755967,577340361605644287,577832942814887935,578219970907865087,578536630256664575,578712552117108735,579029211465908223,579416239558885375,579908820768129023,580260664489017343,580612508209905663] +[581109487465660415,581461331186548735,581813174907437055,582305756116680703,582692784209657855,583009443558457343,583185365418901503,583502024767700991,583889052860678143,584381634069921791,584733477790810111,585085321511698431] +[585609238802333695,585961082523222015,586312926244110335,586805507453353983,587192535546331135,587509194895130623,587685116755574783,588001776104374271,588388804197351423,588881385406595071,589233229127483391,589585072848371711] +[590112357393367039,590464201114255359,590816044835143679,591308626044387327,591695654137364479,592012313486163967,592188235346608127,592504894695407615,592891922788384767,593384503997628415,593736347718516735,594088191439405055] +[594615896891195391,594967740612083711,595319584332972031,595812165542215679,596199193635192831,596515852983992319,596691774844436479,597008434193235967,597395462286213119,597888043495456767,598239887216345087,598591730937233407] +[599119489002373119,599471332723261439,599823176444149759,600315757653393407,600702785746370559,601019445095170047,601195366955614207,601512026304413695,601899054397390847,602391635606634495,602743479327522815,603095323048411135] +[603623087690219519,603974931411107839,604326775131996159,604819356341239807,605206384434216959,605523043783016447,605698965643460607,606015624992260095,606402653085237247,606895234294480895,607247078015369215,607598921736257535] +[608126687200149503,608478530921037823,608830374641926143,609322955851169791,609709983944146943,610026643292946431,610202565153390591,610519224502190079,610906252595167231,611398833804410879,611750677525299199,612102521246187519] +[612630286812839935,612982130533728255,613333974254616575,613826555463860223,614213583556837375,614530242905636863,614706164766081023,615022824114880511,615409852207857663,615902433417101311,616254277137989631,616606120858877951] +[617133886438375423,617485730159263743,617837573880152063,618330155089395711,618717183182372863,619033842531172351,619209764391616511,619526423740415999,619913451833393151,620406033042636799,620757876763525119,621109720484413439] +[621637486065516543,621989329786404863,622341173507293183,622833754716536831,623220782809513983,623537442158313471,623713364018757631,624030023367557119,624417051460534271,624909632669777919,625261476390666239,625613320111554559] diff --git a/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.sql b/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.sql index 65a6dfb11bf..c7a72fed6bc 100644 --- a/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.sql +++ b/tests/queries/0_stateless/02212_h3_get_pentagon_indexes.sql @@ -22,7 +22,11 @@ INSERT INTO table1 VALUES(14); INSERT INTO table1 VALUES(15); -select h3GetPentagonIndexes(resolution) AS indexes from table1 order by indexes; +SELECT h3GetPentagonIndexes(resolution) AS indexes from table1 order by indexes; SELECT h3GetPentagonIndexes(20) AS indexes; -- { serverError 69 } -DROP TABLE table1 +DROP TABLE table1; + +-- tests for const cols +SELECT '-- test for const cols'; +SELECT h3GetPentagonIndexes(arrayJoin([0,1,2,3,4,5,6,7,8,9,10])); diff --git a/tests/queries/0_stateless/02212_h3_point_dist.reference b/tests/queries/0_stateless/02212_h3_point_dist.reference index 171b2024095..00d316ab508 100644 --- a/tests/queries/0_stateless/02212_h3_point_dist.reference +++ b/tests/queries/0_stateless/02212_h3_point_dist.reference @@ -37,3 +37,6 @@ 0.03508524839120321 0.06292579139178688 0.3490658503988659 +-- test for non const cols +0.3490658503988659 +0.3490658503988659 diff --git a/tests/queries/0_stateless/02212_h3_point_dist.sql b/tests/queries/0_stateless/02212_h3_point_dist.sql index ccbbfe4d0a8..84218197ff4 100644 --- a/tests/queries/0_stateless/02212_h3_point_dist.sql +++ b/tests/queries/0_stateless/02212_h3_point_dist.sql @@ -24,4 +24,9 @@ select h3PointDistKm(lat1, lon1,lat2, lon2) AS k from table1 order by k; select '-- select h3PointDistRads(lat1, lon1,lat2, lon2) AS k from table1 order by k;'; select h3PointDistRads(lat1, lon1,lat2, lon2) AS k from table1 order by k; -DROP TABLE table1 +DROP TABLE table1; + +-- tests for const columns +select '-- test for non const cols'; +select h3PointDistRads(-10.0 ,0.0, 10.0, arrayJoin([0.0])) as h3PointDistRads; +select h3PointDistRads(-10.0 ,0.0, 10.0, toFloat64(0)) as h3PointDistRads; \ No newline at end of file From cf3d9f893c7e8f59c49b4c29049352b44a22e70b Mon Sep 17 00:00:00 2001 From: bharatnc Date: Mon, 21 Feb 2022 21:37:10 -0800 Subject: [PATCH 087/132] fix style --- src/Functions/h3PointDist.cpp | 9 ++++++--- 1 file changed, 6 insertions(+), 3 deletions(-) diff --git a/src/Functions/h3PointDist.cpp b/src/Functions/h3PointDist.cpp index 6312929e995..463050c9b81 100644 --- a/src/Functions/h3PointDist.cpp +++ b/src/Functions/h3PointDist.cpp @@ -125,17 +125,20 @@ public: } -struct H3PointDistM { +struct H3PointDistM +{ static constexpr auto name = "h3PointDistM"; static constexpr auto function = distanceM; }; -struct H3PointDistKm { +struct H3PointDistKm +{ static constexpr auto name = "h3PointDistKm"; static constexpr auto function = distanceKm; }; -struct H3PointDistRads { +struct H3PointDistRads +{ static constexpr auto name = "h3PointDistRads"; static constexpr auto function = distanceRads; }; From 9b5e702f6c0d4e1aab28a2bed6de830d18a53622 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 23 Feb 2022 04:28:11 +0300 Subject: [PATCH 088/132] fix deducing Array(Nested(...)) and Nested(Array(...)) --- src/DataTypes/ObjectUtils.cpp | 135 ++++++++++-------- src/DataTypes/Serializations/JSONDataParser.h | 4 +- src/DataTypes/Serializations/PathInData.cpp | 58 +++++--- src/DataTypes/Serializations/PathInData.h | 17 ++- .../Serializations/SerializationObject.cpp | 2 +- .../tests/gtest_json_parser.cpp | 76 +++++----- .../queries/0_stateless/01825_type_json_1.sql | 1 - .../0_stateless/01825_type_json_8.reference | 2 + .../queries/0_stateless/01825_type_json_8.sh | 36 +++++ .../01825_type_json_nbagames.reference | 4 +- .../0_stateless/01825_type_json_nbagames.sh | 2 +- 11 files changed, 205 insertions(+), 132 deletions(-) create mode 100644 tests/queries/0_stateless/01825_type_json_8.reference create mode 100644 tests/queries/0_stateless/01825_type_json_8.sh diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 0f09729d009..55ecd073eb6 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -327,14 +327,9 @@ namespace void flattenTupleImpl( PathInDataBuilder & builder, DataTypePtr type, - size_t array_level, - PathsInData & new_paths, + std::vector & new_paths, DataTypes & new_types) { - bool is_nested = isNested(type); - if (is_nested) - type = assert_cast(*type).getNestedType(); - if (const auto * type_tuple = typeid_cast(type.get())) { const auto & tuple_names = type_tuple->getElementNames(); @@ -342,19 +337,32 @@ void flattenTupleImpl( for (size_t i = 0; i < tuple_names.size(); ++i) { - builder.append(tuple_names[i], is_nested); - flattenTupleImpl(builder, tuple_types[i], array_level + is_nested, new_paths, new_types); + builder.append(tuple_names[i], false); + flattenTupleImpl(builder, tuple_types[i], new_paths, new_types); builder.popBack(); } } else if (const auto * type_array = typeid_cast(type.get())) { - flattenTupleImpl(builder, type_array->getNestedType(), array_level + 1, new_paths, new_types); + PathInDataBuilder element_builder; + std::vector element_paths; + DataTypes element_types; + + flattenTupleImpl(element_builder, type_array->getNestedType(), element_paths, element_types); + assert(element_paths.size() == element_types.size()); + + for (size_t i = 0; i < element_paths.size(); ++i) + { + builder.append(element_paths[i], true); + new_paths.emplace_back(builder.getParts()); + new_types.emplace_back(std::make_shared(element_types[i])); + builder.popBack(element_paths[i].size()); + } } else { new_paths.emplace_back(builder.getParts()); - new_types.push_back(createArrayOfType(type, array_level)); + new_types.emplace_back(type); } } @@ -428,16 +436,16 @@ struct ColumnWithTypeAndDimensions using SubcolumnsTreeWithTypes = SubcolumnsTree; using Node = SubcolumnsTreeWithTypes::Node; -std::pair createTypeFromNode(const Node * node) +ColumnWithTypeAndDimensions createTypeFromNode(const Node * node) { auto collect_tuple_elemets = [](const auto & children) { - std::vector> tuple_elements; + std::vector> tuple_elements; tuple_elements.reserve(children.size()); for (const auto & [name, child] : children) { - auto [column, type] = createTypeFromNode(child.get()); - tuple_elements.emplace_back(name, std::move(column), std::move(type)); + auto column = createTypeFromNode(child.get()); + tuple_elements.emplace_back(name, std::move(column)); } /// Sort to always create the same type for the same set of subcolumns. @@ -446,35 +454,44 @@ std::pair createTypeFromNode(const Node * node) auto tuple_names = extractVector<0>(tuple_elements); auto tuple_columns = extractVector<1>(tuple_elements); - auto tuple_types = extractVector<2>(tuple_elements); - return std::make_tuple(tuple_names, tuple_columns, tuple_types); + return std::make_tuple(std::move(tuple_names), std::move(tuple_columns)); }; if (node->kind == Node::SCALAR) { - return {node->data.column, node->data.type}; + return node->data; } else if (node->kind == Node::NESTED) { + auto [tuple_names, tuple_columns] = collect_tuple_elemets(node->children); + Columns offsets_columns; - ColumnPtr current_column = node->data.column; + offsets_columns.reserve(tuple_columns[0].array_dimensions + 1); - assert(node->data.array_dimensions > 0); - offsets_columns.reserve(node->data.array_dimensions); + const auto & current_array = assert_cast(*node->data.column); + offsets_columns.push_back(current_array.getOffsetsPtr()); - for (size_t i = 0; i < node->data.array_dimensions; ++i) + for (size_t i = 0; i < tuple_columns[0].array_dimensions; ++i) { - const auto & column_array = assert_cast(*current_column); - + const auto & column_array = assert_cast(*tuple_columns[0].column); offsets_columns.push_back(column_array.getOffsetsPtr()); - current_column = column_array.getDataPtr(); + tuple_columns[0].column = column_array.getDataPtr(); } - auto [tuple_names, tuple_columns, tuple_types] = collect_tuple_elemets(node->children); + size_t num_elements = tuple_columns.size(); + Columns tuple_elements_columns(num_elements); + DataTypes tuple_elements_types(num_elements); - auto result_column = ColumnArray::create(ColumnTuple::create(tuple_columns), offsets_columns.back()); - auto result_type = createNested(tuple_types, tuple_names); + for (size_t i = 0; i < num_elements; ++i) + { + assert(tuple_columns[i].array_dimensions == tuple_columns[0].array_dimensions); + tuple_elements_columns[i] = reduceNumberOfDimensions(tuple_columns[i].column, tuple_columns[i].array_dimensions); + tuple_elements_types[i] = reduceNumberOfDimensions(tuple_columns[i].type, tuple_columns[i].array_dimensions); + } + + auto result_column = ColumnArray::create(ColumnTuple::create(tuple_elements_columns), offsets_columns.back()); + auto result_type = createNested(tuple_elements_types, tuple_names); for (auto it = offsets_columns.rbegin() + 1; it != offsets_columns.rend(); ++it) { @@ -482,16 +499,27 @@ std::pair createTypeFromNode(const Node * node) result_type = std::make_shared(result_type); } - return {result_column, result_type}; + return {result_column, result_type, tuple_columns[0].array_dimensions}; } else { - auto [tuple_names, tuple_columns, tuple_types] = collect_tuple_elemets(node->children); + auto [tuple_names, tuple_columns] = collect_tuple_elemets(node->children); - auto result_column = ColumnTuple::create(tuple_columns); - auto result_type = std::make_shared(tuple_types, tuple_names); + size_t num_elements = tuple_columns.size(); + Columns tuple_elements_columns(num_elements); + DataTypes tuple_elements_types(num_elements); - return {result_column, result_type}; + for (size_t i = 0; i < tuple_columns.size(); ++i) + { + assert(tuple_columns[i].array_dimensions == tuple_columns[0].array_dimensions); + tuple_elements_columns[i] = tuple_columns[i].column; + tuple_elements_types[i] = tuple_columns[i].type; + } + + auto result_column = ColumnTuple::create(tuple_elements_columns); + auto result_type = std::make_shared(tuple_elements_types, tuple_names); + + return {result_column, result_type, tuple_columns[0].array_dimensions}; } } @@ -499,11 +527,13 @@ std::pair createTypeFromNode(const Node * node) std::pair flattenTuple(const DataTypePtr & type) { - PathsInData new_paths; + std::vector new_path_parts; DataTypes new_types; PathInDataBuilder builder; - flattenTupleImpl(builder, type, 0, new_paths, new_types); + flattenTupleImpl(builder, type, new_path_parts, new_types); + + PathsInData new_paths(new_path_parts.begin(), new_path_parts.end()); return {new_paths, new_types}; } @@ -546,15 +576,7 @@ std::pair unflattenTuple( auto type = tuple_types[i]; const auto & parts = paths[i].getParts(); - size_t num_parts = parts.size(); - size_t nested_level = std::count_if(parts.begin(), parts.end(), [](const auto & part) { return part.is_nested; }); - size_t array_level = getNumberOfDimensions(*type); - - if (array_level < nested_level) - throw Exception(ErrorCodes::LOGICAL_ERROR, - "Number of dimensions ({}) is less than number Nested types ({}) for path {}", - array_level, nested_level, paths[i].getPath()); size_t pos = 0; tree.add(paths[i], [&](Node::Kind kind, bool exists) -> std::shared_ptr @@ -564,27 +586,13 @@ std::pair unflattenTuple( "Not enough name parts for path {}. Expected at least {}, got {}", paths[i].getPath(), pos + 1, num_parts); - ColumnWithTypeAndDimensions current_column; - if (kind == Node::NESTED) + size_t array_dimensions = kind == Node::NESTED ? 1 : parts[pos].anonymous_array_level; + ColumnWithTypeAndDimensions current_column{column, type, array_dimensions}; + + if (array_dimensions) { - assert(parts[pos].is_nested); - - size_t dimensions_to_reduce = array_level - nested_level + 1; - --nested_level; - - current_column = ColumnWithTypeAndDimensions{column, type, dimensions_to_reduce}; - - if (dimensions_to_reduce) - { - type = reduceNumberOfDimensions(type, dimensions_to_reduce); - column = reduceNumberOfDimensions(column, dimensions_to_reduce); - } - - array_level -= dimensions_to_reduce; - } - else - { - current_column = ColumnWithTypeAndDimensions{column, type, 0}; + type = reduceNumberOfDimensions(type, array_dimensions); + column = reduceNumberOfDimensions(column, array_dimensions); } ++pos; @@ -597,7 +605,8 @@ std::pair unflattenTuple( }); } - return createTypeFromNode(tree.getRoot()); + const auto & [column, type, _] = createTypeFromNode(tree.getRoot()); + return std::make_pair(std::move(column), std::move(type)); } static void addConstantToWithClause(const ASTPtr & query, const String & column_name, const DataTypePtr & data_type) diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index 5e45533b225..4a5077f2825 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -153,13 +153,11 @@ private: paths.reserve(paths.size() + arrays_by_path.size()); values.reserve(values.size() + arrays_by_path.size()); - bool is_nested = arrays_by_path.size() > 1 || !arrays_by_path.begin()->getMapped().first.empty(); - for (auto && [_, value] : arrays_by_path) { auto && [path, path_array] = value; - paths.push_back(builder.append(path, is_nested).getParts()); + paths.push_back(builder.append(path, true).getParts()); values.push_back(std::move(path_array)); builder.popBack(path.size()); diff --git a/src/DataTypes/Serializations/PathInData.cpp b/src/DataTypes/Serializations/PathInData.cpp index 86e8fb9d8a2..cd467b2eefb 100644 --- a/src/DataTypes/Serializations/PathInData.cpp +++ b/src/DataTypes/Serializations/PathInData.cpp @@ -26,13 +26,13 @@ PathInData::PathInData(std::string_view path_) if (*it == '.') { size_t size = static_cast(it - begin); - parts.emplace_back(std::string_view{begin, size}, false); + parts.emplace_back(std::string_view{begin, size}, false, 0); begin = it + 1; } } size_t size = static_cast(end - begin); - parts.emplace_back(std::string_view{begin, size}, false); + parts.emplace_back(std::string_view{begin, size}, false, 0.); } PathInData::PathInData(const Parts & parts_) @@ -65,6 +65,7 @@ UInt128 PathInData::getPartsHash(const Parts & parts_) { hash.update(part.key.data(), part.key.length()); hash.update(part.is_nested); + hash.update(part.anonymous_array_level); } UInt128 res; @@ -78,7 +79,8 @@ void PathInData::writeBinary(WriteBuffer & out) const for (const auto & part : parts) { writeStringBinary(part.key, out); - writeVarUInt(static_cast(part.is_nested) , out); + writeVarUInt(part.is_nested, out); + writeVarUInt(part.anonymous_array_level, out); } } @@ -93,11 +95,14 @@ void PathInData::readBinary(ReadBuffer & in) for (size_t i = 0; i < num_parts; ++i) { - UInt8 is_nested; + bool is_nested; + UInt8 anonymous_array_level; + auto ref = readStringBinaryInto(arena, in); readVarUInt(is_nested, in); + readVarUInt(anonymous_array_level, in); - temp_parts.emplace_back(static_cast(ref), is_nested); + temp_parts.emplace_back(static_cast(ref), is_nested, anonymous_array_level); } path = buildPath(temp_parts); @@ -122,16 +127,16 @@ String PathInData::buildPath(const Parts & other_parts) return res; } -PathInData::Parts PathInData::buildParts(const String & path, const Parts & other_parts) +PathInData::Parts PathInData::buildParts(const String & other_path, const Parts & other_parts) { if (other_parts.empty()) return {}; Parts res; - const char * begin = path.data(); + const char * begin = other_path.data(); for (const auto & part : other_parts) { - res.emplace_back(std::string_view{begin, part.key.length()}, part.is_nested); + res.emplace_back(std::string_view{begin, part.key.length()}, part.is_nested, part.anonymous_array_level); begin += part.key.length() + 1; } return res; @@ -139,24 +144,43 @@ PathInData::Parts PathInData::buildParts(const String & path, const Parts & othe size_t PathInData::Hash::operator()(const PathInData & value) const { - return std::hash{}(value.path); + auto hash = getPartsHash(value.parts); + return hash.items[0] ^ hash.items[1]; } -PathInDataBuilder & PathInDataBuilder::append(std::string_view key, bool is_nested) +PathInDataBuilder & PathInDataBuilder::append(std::string_view key, bool is_array) { - if (!parts.empty()) - parts.back().is_nested = is_nested; + if (parts.empty()) + current_anonymous_array_level += is_array; + + if (!key.empty()) + { + if (!parts.empty()) + parts.back().is_nested = is_array; + + parts.emplace_back(key, false, current_anonymous_array_level); + current_anonymous_array_level = 0; + } - parts.emplace_back(key, false); return *this; } -PathInDataBuilder & PathInDataBuilder::append(const PathInData::Parts & path, bool is_nested) +PathInDataBuilder & PathInDataBuilder::append(const PathInData::Parts & path, bool is_array) { - if (!parts.empty()) - parts.back().is_nested = is_nested; + if (parts.empty()) + current_anonymous_array_level += is_array; + + if (!path.empty()) + { + if (!parts.empty()) + parts.back().is_nested = is_array; + + auto it = parts.insert(parts.end(), path.begin(), path.end()); + for (; it != parts.end(); ++it) + it->anonymous_array_level += current_anonymous_array_level; + current_anonymous_array_level = 0; + } - parts.insert(parts.end(), path.begin(), path.end()); return *this; } diff --git a/src/DataTypes/Serializations/PathInData.h b/src/DataTypes/Serializations/PathInData.h index 04cfff922d0..d4d36e346dc 100644 --- a/src/DataTypes/Serializations/PathInData.h +++ b/src/DataTypes/Serializations/PathInData.h @@ -16,13 +16,16 @@ public: struct Part { Part() = default; - Part(std::string_view key_, bool is_nested_) - : key(key_), is_nested(is_nested_) + Part(std::string_view key_, bool is_nested_, UInt8 anonymous_array_level_) + : key(key_), is_nested(is_nested_), anonymous_array_level(anonymous_array_level_) { } std::string_view key; bool is_nested = false; + UInt8 anonymous_array_level = 0; + + bool operator==(const Part & other) const = default; }; using Parts = std::vector; @@ -47,13 +50,12 @@ public: void writeBinary(WriteBuffer & out) const; void readBinary(ReadBuffer & in); - bool operator==(const PathInData & other) const { return path == other.path; } - bool operator!=(const PathInData & other) const { return !(*this == other); } + bool operator==(const PathInData & other) const { return parts == other.parts; } struct Hash { size_t operator()(const PathInData & value) const; }; private: static String buildPath(const Parts & other_parts); - static Parts buildParts(const String & path, const Parts & other_parts); + static Parts buildParts(const String & other_path, const Parts & other_parts); String path; Parts parts; @@ -64,14 +66,15 @@ class PathInDataBuilder public: const PathInData::Parts & getParts() const { return parts; } - PathInDataBuilder & append(std::string_view key, bool is_nested); - PathInDataBuilder & append(const PathInData::Parts & path, bool is_nested); + PathInDataBuilder & append(std::string_view key, bool is_array); + PathInDataBuilder & append(const PathInData::Parts & path, bool is_array); void popBack(); void popBack(size_t n); private: PathInData::Parts parts; + size_t current_anonymous_array_level = 0; }; using PathsInData = std::vector; diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index b306a3f6cbd..b6b4812af57 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -260,7 +260,7 @@ void SerializationObject::serializeBinaryBulkWithMultipleStreams( if (auto * stream = settings.getter(settings.path)) writeVarUInt(column_object.getSubcolumns().size(), *stream); - const auto & subcolumns = column_object.getSubcolumns().getLeaves(); + const auto & subcolumns = column_object.getSubcolumns(); for (const auto & entry : subcolumns) { settings.path.back() = Substream::ObjectStructure; diff --git a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp index b93873b22c6..4dddb3cd03d 100644 --- a/src/DataTypes/Serializations/tests/gtest_json_parser.cpp +++ b/src/DataTypes/Serializations/tests/gtest_json_parser.cpp @@ -1,9 +1,11 @@ #include #include #include -#include #include +#include +#include + #if USE_SIMDJSON using namespace DB; @@ -49,26 +51,32 @@ TEST(JSONDataParser, ReadJSON) struct JSONPathAndValue { - String path; + PathInData path; Field value; - std::vector is_nested; - - JSONPathAndValue(const String & path_, const Field & value_, const std::vector & is_nested_) - : path(path_), value(value_), is_nested(is_nested_) - { - } JSONPathAndValue(const PathInData & path_, const Field & value_) - : path(path_.getPath()), value(value_) + : path(path_), value(value_) { - for (const auto & part : path_.getParts()) - is_nested.push_back(part.is_nested); } bool operator==(const JSONPathAndValue & other) const = default; - bool operator<(const JSONPathAndValue & other) const { return path < other.path; } + bool operator<(const JSONPathAndValue & other) const { return path.getPath() < other.path.getPath(); } }; +static std::ostream & operator<<(std::ostream & ostr, const JSONPathAndValue & path_and_value) +{ + ostr << "{ PathInData{"; + bool first = true; + for (const auto & part : path_and_value.path.getParts()) + { + ostr << (first ? "{" : ", {") << part.key << ", " << part.is_nested << ", " << part.anonymous_array_level << "}"; + first = false; + } + + ostr << "}, Field{" << applyVisitor(FieldVisitorToString(), path_and_value.value) << "} }"; + return ostr; +} + using JSONValues = std::vector; static void check( @@ -100,17 +108,17 @@ TEST(JSONDataParser, Parse) { check(json1, "json1", { - {"k1", 1, {false}}, - {"k2.k3", "aa", {false, false}}, - {"k2.k4", 2, {false, false}}, + { PathInData{{{"k1", false, 0}}}, 1 }, + { PathInData{{{"k2", false, 0}, {"k3", false, 0}}}, "aa" }, + { PathInData{{{"k2", false, 0}, {"k4", false, 0}}}, 2 }, }); } { check(json2, "json2", { - {"k1.k2", Array{"aaa", "ddd"}, {true, false}}, - {"k1.k3.k4", Array{Array{"bbb", "ccc"}, Array{"eee", "fff"}}, {true, true, false}}, + { PathInData{{{"k1", true, 0}, {"k2", false, 0}}}, Array{"aaa", "ddd"} }, + { PathInData{{{"k1", true, 0}, {"k3", true, 0}, {"k4", false, 0}}}, Array{Array{"bbb", "ccc"}, Array{"eee", "fff"}} }, }); } @@ -134,15 +142,11 @@ TEST(JSONDataParser, Parse) } ]})"; - Strings paths = {"k1.k2.k4", "k1.k5", "k1.k2.k3"}; - - auto k1k2k4 = Array{Array{3, 4}, Array{7, 8}}; - check(json3, "json3", { - {"k1.k5", Array{"foo", "bar"}, {true, false}}, - {"k1.k2.k3", Array{Array{1, 2}, Array{5, 6}}, {true, false, false}}, - {"k1.k2.k4", Array{Array{3, 4}, Array{7, 8}}, {true, false, false}}, + { PathInData{{{"k1", true, 0}, {"k5", false, 0}}}, Array{"foo", "bar"} }, + { PathInData{{{"k1", true, 0}, {"k2", false, 0}, {"k3", false, 0}}}, Array{Array{1, 2}, Array{5, 6}} }, + { PathInData{{{"k1", true, 0}, {"k2", false, 0}, {"k4", false, 0}}}, Array{Array{3, 4}, Array{7, 8}} }, }); } @@ -162,15 +166,18 @@ TEST(JSONDataParser, Parse) check(json4, "json4", { - {"k1.k5", Array{"foo", "bar"}, {true, false}}, - {"k1.k2.k3", Array{Array{1, 2}, Array{5, 6}}, {true, true, false}}, - {"k1.k2.k4", Array{Array{3, 4}, Array{7, 8}}, {true, true, false}}, + { PathInData{{{"k1", true, 0}, {"k5", false, 0}}}, Array{"foo", "bar"} }, + { PathInData{{{"k1", true, 0}, {"k2", true, 0}, {"k3", false, 0}}}, Array{Array{1, 2}, Array{5, 6}} }, + { PathInData{{{"k1", true, 0}, {"k2", true, 0}, {"k4", false, 0}}}, Array{Array{3, 4}, Array{7, 8}} }, }); } { const String json5 = R"({"k1": [[1, 2, 3], [4, 5], [6]]})"; - check(json5, "json5", {{"k1", Array{Array{1, 2, 3}, Array{4, 5}, Array{6}}, {false}}}); + check(json5, "json5", + { + { PathInData{{{"k1", false, 0}}}, Array{Array{1, 2, 3}, Array{4, 5}, Array{6}} } + }); } { @@ -182,15 +189,10 @@ TEST(JSONDataParser, Parse) ] })"; - Strings paths = {"k1.k2", "k1.k3"}; - - auto k1k2 = Array{Array{1, 3}, Array{5}}; - auto k1k3 = Array{Array{2, 4}, Array{6}}; - check(json6, "json6", { - {"k1.k2", Array{Array{1, 3}, Array{5}}, {true, false}}, - {"k1.k3", Array{Array{2, 4}, Array{6}}, {true, false}}, + { PathInData{{{"k1", true, 0}, {"k2", false, 1}}}, Array{Array{1, 3}, Array{5}} }, + { PathInData{{{"k1", true, 0}, {"k3", false, 1}}}, Array{Array{2, 4}, Array{6}} }, }); } @@ -205,8 +207,8 @@ TEST(JSONDataParser, Parse) check(json7, "json7", { - {"k1.k2", Array{Array{1, 3}, Array{5}}, {true, false}}, - {"k1.k3", Array{Array{2, 4}, Array{6}}, {true, false}}, + { PathInData{{{"k1", true, 0}, {"k2", false, 0}}}, Array{Array{1, 3}, Array{5}} }, + { PathInData{{{"k1", true, 0}, {"k3", false, 0}}}, Array{Array{2, 4}, Array{6}} }, }); } } diff --git a/tests/queries/0_stateless/01825_type_json_1.sql b/tests/queries/0_stateless/01825_type_json_1.sql index 233d0fae1e8..c2110f35c33 100644 --- a/tests/queries/0_stateless/01825_type_json_1.sql +++ b/tests/queries/0_stateless/01825_type_json_1.sql @@ -26,7 +26,6 @@ FROM system.parts_columns WHERE table = 't_json' AND database = currentDatabase() AND active AND column = 'data' ORDER BY name; - SELECT '============'; TRUNCATE TABLE t_json; diff --git a/tests/queries/0_stateless/01825_type_json_8.reference b/tests/queries/0_stateless/01825_type_json_8.reference new file mode 100644 index 00000000000..b64e6d0c9b9 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_8.reference @@ -0,0 +1,2 @@ +([[(1,2),(3,4)],[(5,6)]]) Tuple(k1 Array(Nested(k2 Int8, k3 Int8))) +([([1,3,4,5],[6,7]),([8],[9,10,11])]) Tuple(k1 Nested(k2 Array(Int8), k3 Array(Int8))) diff --git a/tests/queries/0_stateless/01825_type_json_8.sh b/tests/queries/0_stateless/01825_type_json_8.sh new file mode 100644 index 00000000000..e3ae8f23d36 --- /dev/null +++ b/tests/queries/0_stateless/01825_type_json_8.sh @@ -0,0 +1,36 @@ +#!/usr/bin/env bash +# Tags: no-fasttest + +CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) +# shellcheck source=../shell_config.sh +. "$CURDIR"/../shell_config.sh + +$CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_8" + +$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_8 (data JSON) ENGINE = MergeTree ORDER BY tuple()" + +cat < Date: Mon, 21 Feb 2022 22:08:15 -0800 Subject: [PATCH 089/132] improve h3GetRes0Indexes implementation --- src/Functions/h3GetRes0Indexes.cpp | 35 +++++++++++------------------- 1 file changed, 13 insertions(+), 22 deletions(-) diff --git a/src/Functions/h3GetRes0Indexes.cpp b/src/Functions/h3GetRes0Indexes.cpp index f9bbf7f9175..2514dcbdd0b 100644 --- a/src/Functions/h3GetRes0Indexes.cpp +++ b/src/Functions/h3GetRes0Indexes.cpp @@ -39,32 +39,23 @@ public: return std::make_shared(std::make_shared()); } - ColumnPtr executeImpl(const ColumnsWithTypeAndName & /*arguments*/, const DataTypePtr &, size_t input_rows_count) const override + ColumnPtr executeImpl(const ColumnsWithTypeAndName &, const DataTypePtr & result_type, size_t input_rows_count) const override { - auto dst = ColumnArray::create(ColumnUInt64::create()); - auto & dst_data = dst->getData(); - auto & dst_offsets = dst->getOffsets(); - dst_offsets.resize(input_rows_count); - auto current_offset = 0; + if (input_rows_count == 0) + return result_type->createColumn(); - const auto vec_size = res0CellCount(); - std::vector hindex_vec; + std::vector res0_indexes; + const auto cell_count = res0CellCount(); + res0_indexes.resize(cell_count); + getRes0Cells(res0_indexes.data()); - for (size_t row = 0; row < input_rows_count; ++row) - { - hindex_vec.resize(vec_size); - getRes0Cells(hindex_vec.data()); - dst_data.reserve(input_rows_count); + auto res = ColumnArray::create(ColumnUInt64::create()); - for (auto & hindex : hindex_vec) - { - ++current_offset; - dst_data.insert(hindex); - } - hindex_vec.clear(); - dst_offsets[row] = current_offset; - } - return dst; + Array res_indexes; + res_indexes.insert(res_indexes.end(), res0_indexes.begin(), res0_indexes.end()); + res->insert(res_indexes); + + return res; } }; From 7df8b38f6aa0df8d600cc306b8fa20e9be97fd50 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Fri, 25 Feb 2022 18:07:30 +0300 Subject: [PATCH 090/132] fix deducing of nested types --- src/DataTypes/DataTypeObject.cpp | 51 ++++++++----------- src/DataTypes/ObjectUtils.cpp | 24 +++++++-- .../queries/0_stateless/01825_type_json_8.sh | 0 .../0_stateless/01825_type_json_nullable.sql | 2 +- 4 files changed, 42 insertions(+), 35 deletions(-) mode change 100644 => 100755 tests/queries/0_stateless/01825_type_json_8.sh diff --git a/src/DataTypes/DataTypeObject.cpp b/src/DataTypes/DataTypeObject.cpp index e05add0b91b..47964ff0049 100644 --- a/src/DataTypes/DataTypeObject.cpp +++ b/src/DataTypes/DataTypeObject.cpp @@ -4,6 +4,7 @@ #include #include +#include #include namespace DB @@ -35,49 +36,41 @@ SerializationPtr DataTypeObject::doGetDefaultSerialization() const return default_serialization; } -static constexpr auto NAME_DEFAULT = "Default"; -static constexpr auto NAME_NULL = "Null"; - String DataTypeObject::doGetName() const { WriteBufferFromOwnString out; - out << "Object(" << quote << schema_format; if (is_nullable) - out << ", " << quote << NAME_NULL; - out << ")"; + out << "Object(Nullable(" << quote << schema_format << "))"; + else + out << "Object(" << quote << schema_format << ")"; return out.str(); } static DataTypePtr create(const ASTPtr & arguments) { - if (!arguments || arguments->children.empty() || arguments->children.size() > 2) - throw Exception("Object data type family must have one or two arguments -" - " name of schema format and type of default value", - ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH); - - const auto * literal = arguments->children[0]->as(); - if (!literal || literal->value.getType() != Field::Types::String) - throw Exception(ErrorCodes::UNEXPECTED_AST_STRUCTURE, - "Object data type family must have a const string as its first argument"); + if (!arguments || arguments->children.size() != 1) + throw Exception(ErrorCodes::NUMBER_OF_ARGUMENTS_DOESNT_MATCH, + "Object data type family must have one argument - name of schema format"); + ASTPtr schema_argument = arguments->children[0]; bool is_nullable = false; - if (arguments->children.size() == 2) - { - const auto * default_literal = arguments->children[1]->as(); - if (!default_literal || default_literal->value.getType() != Field::Types::String) - throw Exception(ErrorCodes::UNEXPECTED_AST_STRUCTURE, - "Object data type family must have a const string as its second argument"); - const auto & default_kind = default_literal->value.get(); - if (default_kind == NAME_NULL) - is_nullable = true; - else if (default_kind != NAME_DEFAULT) - throw Exception(ErrorCodes::BAD_ARGUMENTS, - "Unexpected type of default value '{}'. Should be {} or {}", - default_kind, NAME_DEFAULT, NAME_NULL); + if (const auto * func = schema_argument->as()) + { + if (func->name != "Nullable" || func->arguments->children.size() != 1) + throw Exception(ErrorCodes::UNEXPECTED_AST_STRUCTURE, + "Expected 'Nullable()' as parameter for type Object", func->name); + + schema_argument = func->arguments->children[0]; + is_nullable = true; } - return std::make_shared(literal->value.get(), is_nullable); + const auto * literal = schema_argument->as(); + if (!literal || literal->value.getType() != Field::Types::String) + throw Exception(ErrorCodes::UNEXPECTED_AST_STRUCTURE, + "Object data type family must have a const string as its schema name parameter"); + + return std::make_shared(literal->value.get(), is_nullable); } void registerDataTypeObject(DataTypeFactory & factory) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index f3272a66a5e..92bca815ec6 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -426,6 +426,9 @@ ColumnPtr reduceNumberOfDimensions(ColumnPtr column, size_t dimensions_to_reduce return column; } +/// We save intermidiate column, type and number of array +/// dimensions for each intermidiate node in path in subcolumns tree. + struct ColumnWithTypeAndDimensions { ColumnPtr column; @@ -433,8 +436,8 @@ struct ColumnWithTypeAndDimensions size_t array_dimensions; }; -using SubcolumnsTreeWithTypes = SubcolumnsTree; -using Node = SubcolumnsTreeWithTypes::Node; +using SubcolumnsTreeWithColumns = SubcolumnsTree; +using Node = SubcolumnsTreeWithColumns::Node; /// Creates data type and column from tree of subcolumns. ColumnWithTypeAndDimensions createTypeFromNode(const Node * node) @@ -479,17 +482,19 @@ ColumnWithTypeAndDimensions createTypeFromNode(const Node * node) const auto & current_array = assert_cast(*node->data.column); offsets_columns.push_back(current_array.getOffsetsPtr()); + auto first_column = tuple_columns[0].column; for (size_t i = 0; i < tuple_columns[0].array_dimensions; ++i) { - const auto & column_array = assert_cast(*tuple_columns[0].column); + const auto & column_array = assert_cast(*first_column); offsets_columns.push_back(column_array.getOffsetsPtr()); - tuple_columns[0].column = column_array.getDataPtr(); + first_column = column_array.getDataPtr(); } size_t num_elements = tuple_columns.size(); Columns tuple_elements_columns(num_elements); DataTypes tuple_elements_types(num_elements); + /// Reduce extra array dimesions to get columns and types of Nested elements. for (size_t i = 0; i < num_elements; ++i) { assert(tuple_columns[i].array_dimensions == tuple_columns[0].array_dimensions); @@ -500,6 +505,7 @@ ColumnWithTypeAndDimensions createTypeFromNode(const Node * node) auto result_column = ColumnArray::create(ColumnTuple::create(tuple_elements_columns), offsets_columns.back()); auto result_type = createNested(tuple_elements_types, tuple_names); + /// Recreate result Array type and Array column. for (auto it = offsets_columns.rbegin() + 1; it != offsets_columns.rend(); ++it) { result_column = ColumnArray::create(result_column, *it); @@ -575,7 +581,7 @@ std::pair unflattenTuple( /// We add all paths to the subcolumn tree and then create a type from it. /// The tree stores column, type and number of array dimensions /// for each intermediate node. - SubcolumnsTreeWithTypes tree; + SubcolumnsTreeWithColumns tree; for (size_t i = 0; i < paths.size(); ++i) { @@ -596,6 +602,7 @@ std::pair unflattenTuple( size_t array_dimensions = kind == Node::NESTED ? 1 : parts[pos].anonymous_array_level; ColumnWithTypeAndDimensions current_column{column, type, array_dimensions}; + /// Get type and column for next node. if (array_dimensions) { type = reduceNumberOfDimensions(type, array_dimensions); @@ -633,16 +640,21 @@ static void addConstantToWithClause(const ASTPtr & query, const String & column_ select.with()->children.push_back(std::move(node)); } +/// @expected_columns and @available_columns contain descriptions +/// of extended Object columns. void replaceMissedSubcolumnsByConstants( const ColumnsDescription & expected_columns, const ColumnsDescription & available_columns, ASTPtr query) { NamesAndTypes missed_names_types; + + /// Find all subcolumns that are in @expected_columns, but not in @available_columns. for (const auto & column : available_columns) { auto expected_column = expected_columns.getColumn(GetColumnsOptions::All, column.name); + /// Extract all paths from both descriptions to easily check existence of subcolumns. auto [available_paths, available_types] = flattenTuple(column.type); auto [expected_paths, expected_types] = flattenTuple(expected_column.type); @@ -675,6 +687,8 @@ void replaceMissedSubcolumnsByConstants( IdentifierNameSet identifiers; query->collectIdentifierNames(identifiers); + + /// Replace missed subcolumns to default literals of theirs type. for (const auto & [name, type] : missed_names_types) if (identifiers.count(name)) addConstantToWithClause(query, name, type); diff --git a/tests/queries/0_stateless/01825_type_json_8.sh b/tests/queries/0_stateless/01825_type_json_8.sh old mode 100644 new mode 100755 diff --git a/tests/queries/0_stateless/01825_type_json_nullable.sql b/tests/queries/0_stateless/01825_type_json_nullable.sql index 5c4a364b81a..3a9f893a0da 100644 --- a/tests/queries/0_stateless/01825_type_json_nullable.sql +++ b/tests/queries/0_stateless/01825_type_json_nullable.sql @@ -2,7 +2,7 @@ DROP TABLE IF EXISTS t_json_null; -CREATE TABLE t_json_null(id UInt64, data Object('JSON', 'Null')) +CREATE TABLE t_json_null(id UInt64, data Object(Nullable('JSON'))) ENGINE = MergeTree ORDER BY tuple(); INSERT INTO t_json_null FORMAT JSONEachRow {"id": 1, "data": {"k1": 1, "k2" : 2}} {"id": 2, "data": {"k2": 3, "k3" : 4}}; From 2758db5341fd3e3d4e2064315b13c02d4ac195cf Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Tue, 1 Mar 2022 19:32:55 +0300 Subject: [PATCH 091/132] add more comments --- src/DataTypes/DataTypeObject.cpp | 1 - src/DataTypes/ObjectUtils.cpp | 7 +- src/DataTypes/ObjectUtils.h | 2 +- src/DataTypes/Serializations/JSONDataParser.h | 8 +- src/DataTypes/Serializations/PathInData.cpp | 1 + src/DataTypes/Serializations/PathInData.h | 24 ++++++ .../Serializations/SerializationObject.cpp | 17 ++++- .../Serializations/SerializationObject.h | 6 +- src/DataTypes/Serializations/SubcolumnsTree.h | 10 +++ src/Functions/FunctionsConversion.h | 3 + src/IO/ReadHelpers.cpp | 2 +- src/IO/ReadHelpers.h | 3 + .../Formats/Impl/JSONAsStringRowInputFormat.h | 8 +- src/Storages/IStorage.h | 4 + src/Storages/MergeTree/MergeTreeData.h | 6 ++ .../StorageFromBasePartsOfProjection.h | 76 ------------------- src/Storages/StorageDistributed.cpp | 4 +- src/Storages/StorageDistributed.h | 2 + src/Storages/StorageMemory.h | 1 + src/Storages/StorageSnapshot.cpp | 7 -- src/Storages/StorageSnapshot.h | 22 +++--- src/Storages/getStructureOfRemoteTable.h | 1 + 22 files changed, 104 insertions(+), 111 deletions(-) delete mode 100644 src/Storages/MergeTree/StorageFromBasePartsOfProjection.h diff --git a/src/DataTypes/DataTypeObject.cpp b/src/DataTypes/DataTypeObject.cpp index 47964ff0049..9203c6764ea 100644 --- a/src/DataTypes/DataTypeObject.cpp +++ b/src/DataTypes/DataTypeObject.cpp @@ -14,7 +14,6 @@ namespace ErrorCodes { extern const int NUMBER_OF_ARGUMENTS_DOESNT_MATCH; extern const int UNEXPECTED_AST_STRUCTURE; - extern const int BAD_ARGUMENTS; } DataTypeObject::DataTypeObject(const String & schema_format_, bool is_nullable_) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index 92bca815ec6..daad3fc52ba 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -426,9 +426,8 @@ ColumnPtr reduceNumberOfDimensions(ColumnPtr column, size_t dimensions_to_reduce return column; } -/// We save intermidiate column, type and number of array -/// dimensions for each intermidiate node in path in subcolumns tree. - +/// We save intermediate column, type and number of array +/// dimensions for each intermediate node in path in subcolumns tree. struct ColumnWithTypeAndDimensions { ColumnPtr column; @@ -494,7 +493,7 @@ ColumnWithTypeAndDimensions createTypeFromNode(const Node * node) Columns tuple_elements_columns(num_elements); DataTypes tuple_elements_types(num_elements); - /// Reduce extra array dimesions to get columns and types of Nested elements. + /// Reduce extra array dimensions to get columns and types of Nested elements. for (size_t i = 0; i < num_elements; ++i) { assert(tuple_columns[i].array_dimensions == tuple_columns[0].array_dimensions); diff --git a/src/DataTypes/ObjectUtils.h b/src/DataTypes/ObjectUtils.h index f0c9a73bf80..199a048c8cd 100644 --- a/src/DataTypes/ObjectUtils.h +++ b/src/DataTypes/ObjectUtils.h @@ -132,7 +132,7 @@ ColumnsDescription getObjectColumns( } for (const auto & [name, types] : types_in_entries) - res.add({String(name), getLeastCommonTypeForObject(types)}); + res.add({name, getLeastCommonTypeForObject(types)}); return res; } diff --git a/src/DataTypes/Serializations/JSONDataParser.h b/src/DataTypes/Serializations/JSONDataParser.h index 4a5077f2825..76974b269fd 100644 --- a/src/DataTypes/Serializations/JSONDataParser.h +++ b/src/DataTypes/Serializations/JSONDataParser.h @@ -90,11 +90,13 @@ private: using PathPartsWithArray = std::pair; using PathToArray = HashMapWithStackMemory; + /// Traverse elements of array and collect an array + /// of fields by each path. + PathToArray arrays_by_path; Arena strings_pool; size_t current_size = 0; - for (auto it = array.begin(); it != array.end(); ++it) { std::vector element_paths; @@ -118,6 +120,7 @@ private: } else { + /// We found a new key. Add and empty array with current size. Array path_array; path_array.reserve(array.size()); path_array.resize(current_size); @@ -129,6 +132,8 @@ private: } } + /// If some of the keys are missed in current element, + /// add default values for them. if (keys_to_update) { for (auto & [_, value] : arrays_by_path) @@ -157,6 +162,7 @@ private: { auto && [path, path_array] = value; + /// Merge prefix path and path of array element. paths.push_back(builder.append(path, true).getParts()); values.push_back(std::move(path_array)); diff --git a/src/DataTypes/Serializations/PathInData.cpp b/src/DataTypes/Serializations/PathInData.cpp index cd467b2eefb..9631138dce9 100644 --- a/src/DataTypes/Serializations/PathInData.cpp +++ b/src/DataTypes/Serializations/PathInData.cpp @@ -105,6 +105,7 @@ void PathInData::readBinary(ReadBuffer & in) temp_parts.emplace_back(static_cast(ref), is_nested, anonymous_array_level); } + /// Recreate path and parts. path = buildPath(temp_parts); parts = buildParts(path, temp_parts); } diff --git a/src/DataTypes/Serializations/PathInData.h b/src/DataTypes/Serializations/PathInData.h index d4d36e346dc..35f6d10438d 100644 --- a/src/DataTypes/Serializations/PathInData.h +++ b/src/DataTypes/Serializations/PathInData.h @@ -10,6 +10,7 @@ namespace DB class ReadBuffer; class WriteBuffer; +/// Class that represents path in document, e.g. JSON. class PathInData { public: @@ -21,8 +22,17 @@ public: { } + /// Name of part of path. std::string_view key; + + /// If this part is Nested, i.e. element + /// related to this key is the array of objects. bool is_nested = false; + + /// Number of array levels between current key and previous key. + /// E.g. in JSON {"k1": [[[{"k2": 1, "k3": 2}]]]} + /// "k1" is nested and has anonymous_array_level = 0. + /// "k2" and "k3" are not nested and have anonymous_array_level = 2. UInt8 anonymous_array_level = 0; bool operator==(const Part & other) const = default; @@ -54,10 +64,16 @@ public: struct Hash { size_t operator()(const PathInData & value) const; }; private: + /// Creates full path from parts. static String buildPath(const Parts & other_parts); + + /// Creates new parts full from full path with correct string pointers. static Parts buildParts(const String & other_path, const Parts & other_parts); + /// The full path. Parts are separated by dots. String path; + + /// Parts of the path. All string_view-s in parts must point to the @path. Parts parts; }; @@ -74,11 +90,19 @@ public: private: PathInData::Parts parts; + + /// Number of array levels without key to which + /// next non-empty key will be nested. + /// Example: for JSON { "k1": [[{"k2": 1, "k3": 2}] } + // `k2` and `k3` has anonymous_array_level = 1 in that case. size_t current_anonymous_array_level = 0; }; using PathsInData = std::vector; +/// Result of parsing of a document. +/// Contains all paths extracted from document +/// and values which are related to them. struct ParseResult { std::vector paths; diff --git a/src/DataTypes/Serializations/SerializationObject.cpp b/src/DataTypes/Serializations/SerializationObject.cpp index b6b4812af57..f826478958c 100644 --- a/src/DataTypes/Serializations/SerializationObject.cpp +++ b/src/DataTypes/Serializations/SerializationObject.cpp @@ -30,10 +30,12 @@ namespace ErrorCodes namespace { +/// Visitor that keeps @num_dimensions_to_keep dimensions in arrays +/// and replaces all scalars or nested arrays to @replacement at that level. class FieldVisitorReplaceScalars : public StaticVisitor { public: - explicit FieldVisitorReplaceScalars(const Field & replacement_, size_t num_dimensions_to_keep_) + FieldVisitorReplaceScalars(const Field & replacement_, size_t num_dimensions_to_keep_) : replacement(replacement_), num_dimensions_to_keep(num_dimensions_to_keep_) { } @@ -49,7 +51,7 @@ public: const size_t size = x.size(); Array res(size); for (size_t i = 0; i < size; ++i) - res[i] = applyVisitor(*this, x[i]); + res[i] = applyVisitor(FieldVisitorReplaceScalars(replacement, num_dimensions_to_keep - 1), x[i]); return res; } else @@ -63,6 +65,8 @@ private: using Node = typename ColumnObject::SubcolumnsTree::Node; +/// Finds a subcolumn from the same Nested type as @entry and inserts +/// an array with default values with consistent sizes as in Nested type. bool tryInsertDefaultFromNested( std::shared_ptr entry, const ColumnObject::SubcolumnsTree & subcolumns) { @@ -75,12 +79,15 @@ bool tryInsertDefaultFromNested( while (current_node) { + /// Try to find the first Nested up to the current node. const auto * node_nested = subcolumns.findParent(current_node, [](const auto & candidate) { return candidate.isNested(); }); if (!node_nested) break; + /// If there are no leaves, skip current node and find + /// the next node up to the current. leaf = subcolumns.findLeaf(node_nested, [&](const auto & candidate) { @@ -105,6 +112,7 @@ bool tryInsertDefaultFromNested( size_t num_dimensions = getNumberOfDimensions(*least_common_type); assert(num_skipped_nested < num_dimensions); + /// Replace scalars to default values with consistent array sizes. size_t num_dimensions_to_keep = num_dimensions - num_skipped_nested; auto default_scalar = num_skipped_nested ? createEmptyArrayField(num_skipped_nested) @@ -161,6 +169,7 @@ void SerializationObject::deserializeTextImpl(IColumn & column, Reader & subcolumn.insert(std::move(values[i]), std::move(field_info)); } + /// Insert default values to missed subcolumns. const auto & subcolumns = column_object.getSubcolumns(); for (const auto & entry : subcolumns) { @@ -207,7 +216,7 @@ void SerializationObject::deserializeTextCSV(IColumn & column, ReadBuffe template template -void SerializationObject::checkSerializationIsSupported(TSettings & settings, TStatePtr & state) const +void SerializationObject::checkSerializationIsSupported(const TSettings & settings, const TStatePtr & state) const { if (settings.position_independent_encoding) throw Exception(ErrorCodes::NOT_IMPLEMENTED, @@ -333,7 +342,7 @@ void SerializationObject::deserializeBinaryBulkWithMultipleStreams( auto serialization = type->getDefaultSerialization(); ColumnPtr subcolumn_data = type->createColumn(); serialization->deserializeBinaryBulkWithMultipleStreams(subcolumn_data, limit, settings, state, cache); - column_object.addSubcolumn(PathInData(key), subcolumn_data->assumeMutable()); + column_object.addSubcolumn(key, subcolumn_data->assumeMutable()); } else { diff --git a/src/DataTypes/Serializations/SerializationObject.h b/src/DataTypes/Serializations/SerializationObject.h index 532de22a47a..c91d467d5e1 100644 --- a/src/DataTypes/Serializations/SerializationObject.h +++ b/src/DataTypes/Serializations/SerializationObject.h @@ -5,6 +5,10 @@ namespace DB { +/// Serialization for data type Object. +/// Supported only test serialization/deserialization. +/// and binary bulk serialization/deserialization without position independent +/// encoding, i.e. serialization/deserialization into Native format. template class SerializationObject : public ISerialization { @@ -54,7 +58,7 @@ public: private: template - void checkSerializationIsSupported(TSettings & settings, TStatePtr & state) const; + void checkSerializationIsSupported(const TSettings & settings, const TStatePtr & state) const; template void deserializeTextImpl(IColumn & column, Reader && reader) const; diff --git a/src/DataTypes/Serializations/SubcolumnsTree.h b/src/DataTypes/Serializations/SubcolumnsTree.h index 8722f14b4e9..64fc14ba834 100644 --- a/src/DataTypes/Serializations/SubcolumnsTree.h +++ b/src/DataTypes/Serializations/SubcolumnsTree.h @@ -8,6 +8,8 @@ namespace DB { +/// Tree that represents paths in document +/// with additional data in nodes. template class SubcolumnsTree { @@ -47,6 +49,7 @@ public: using NodeKind = typename Node::Kind; using NodePtr = std::shared_ptr; + /// Add a leaf without any data in other nodes. bool add(const PathInData & path, const NodeData & leaf_data) { return add(path, [&](NodeKind kind, bool exists) -> NodePtr @@ -61,6 +64,8 @@ public: }); } + /// Callback for creation of node. Receives kind of node and + /// flag, which is true if node already exists. using NodeCreator = std::function; bool add(const PathInData & path, const NodeCreator & node_creator) @@ -107,16 +112,19 @@ public: return true; } + /// Find node that matches the path the best. const Node * findBestMatch(const PathInData & path) const { return findImpl(path, false); } + /// Find node that matches the path exactly. const Node * findExact(const PathInData & path) const { return findImpl(path, true); } + /// Find leaf by path. const Node * findLeaf(const PathInData & path) const { const auto * candidate = findExact(path); @@ -127,6 +135,7 @@ public: using NodePredicate = std::function; + /// Finds leaf that satisfies the predicate. const Node * findLeaf(const NodePredicate & predicate) { return findLeaf(root.get(), predicate); @@ -147,6 +156,7 @@ public: return nullptr; } + /// Find first parent node that satisfies the predicate. static const Node * findParent(const Node * node, const NodePredicate & predicate) { while (node && !predicate(*node)) diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index f58864b2ed0..67c01921ccf 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -2912,6 +2912,9 @@ private: std::vector element_wrappers; std::vector> to_reverse_index; + /// For named tuples allow conversions for tuples with + /// different sets of elements. If element exists in @to_type + /// and doesn't exist in @to_type it will be filled by default values. if (from_type->haveExplicitNames() && from_type->serializeNames() && to_type->haveExplicitNames() && to_type->serializeNames()) { diff --git a/src/IO/ReadHelpers.cpp b/src/IO/ReadHelpers.cpp index 12993911312..b69ace7f7e6 100644 --- a/src/IO/ReadHelpers.cpp +++ b/src/IO/ReadHelpers.cpp @@ -836,7 +836,7 @@ ReturnType readJSONObjectPossiblyInvalid(Vector & s, ReadBuffer & buf) if (balance == 0) return ReturnType(true); - if (balance < 0) + if (balance < 0) break; } diff --git a/src/IO/ReadHelpers.h b/src/IO/ReadHelpers.h index 54ceb554a5a..a4f5e529d76 100644 --- a/src/IO/ReadHelpers.h +++ b/src/IO/ReadHelpers.h @@ -601,6 +601,9 @@ bool tryReadJSONStringInto(Vector & s, ReadBuffer & buf) return readJSONStringInto(s, buf); } +/// Reads chunk of data between {} in that way, +/// that it has balanced parentheses sequence of {}. +/// So, it may form a JSON object, but it can be incorrenct. template ReturnType readJSONObjectPossiblyInvalid(Vector & s, ReadBuffer & buf); diff --git a/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.h b/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.h index e8220fcdaa1..f7880eac867 100644 --- a/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.h +++ b/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.h @@ -12,9 +12,6 @@ namespace DB class ReadBuffer; /// This format parses a sequence of JSON objects separated by newlines, spaces and/or comma. -/// Each JSON object is parsed as a whole to string. -/// This format can only parse a table with single field of type String. - class JSONAsRowInputFormat : public IRowInputFormat { public: @@ -41,6 +38,8 @@ private: bool allow_new_rows = true; }; +/// Each JSON object is parsed as a whole to string. +/// This format can only parse a table with single field of type String. class JSONAsStringRowInputFormat final : public JSONAsRowInputFormat { public: @@ -51,6 +50,9 @@ private: void readJSONObject(IColumn & column) override; }; + +/// Each JSON object is parsed as a whole to object. +/// This format can only parse a table with single field of type Object. class JSONAsObjectRowInputFormat final : public JSONAsRowInputFormat { public: diff --git a/src/Storages/IStorage.h b/src/Storages/IStorage.h index e2d2636c717..d8558a0485b 100644 --- a/src/Storages/IStorage.h +++ b/src/Storages/IStorage.h @@ -159,6 +159,8 @@ public: /// Returns true if the storage supports reading of subcolumns of complex types. virtual bool supportsSubcolumns() const { return false; } + /// Returns true if the storage supports storing of dynamic subcolumns. + /// For now it makes sense only for data type Object. virtual bool supportsDynamicSubcolumns() const { return false; } /// Requires squashing small blocks to large for optimal storage. @@ -600,11 +602,13 @@ public: /// Does not takes underlying Storage (if any) into account. virtual std::optional lifetimeBytes() const { return {}; } + /// Creates a storage snapshot from given metadata. virtual StorageSnapshotPtr getStorageSnapshot(const StorageMetadataPtr & metadata_snapshot) const { return std::make_shared(*this, metadata_snapshot); } + /// Creates a storage snapshot from given metadata and columns, which are used in query. virtual StorageSnapshotPtr getStorageSnapshotForQuery(const StorageMetadataPtr & metadata_snapshot, const ASTPtr & /*query*/) const { return getStorageSnapshot(metadata_snapshot); diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index f6be9f35f4f..c281573520b 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -422,6 +422,7 @@ public: bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr, const StorageMetadataPtr & metadata_snapshot) const override; + /// Snapshot for MergeTree fixes the current set of data parts. struct SnapshotData : public StorageSnapshot::Data { DataPartsVector parts; @@ -709,6 +710,7 @@ public: const ColumnsDescription & getObjectColumns() const { return object_columns; } + /// Creates desciprion of columns of data type Object from the range of data parts. static ColumnsDescription getObjectColumns( const DataPartsVector & parts, const ColumnsDescription & storage_columns); @@ -1002,6 +1004,9 @@ protected: DataPartsIndexes::index::type & data_parts_by_info; DataPartsIndexes::index::type & data_parts_by_state_and_info; + /// Current descriprion of columns of data type Object. + /// It changes only when set of parts is changed and is + /// protected by @data_parts_mutex. ColumnsDescription object_columns; MergeTreePartsMover parts_mover; @@ -1040,6 +1045,7 @@ protected: return {begin, end}; } + /// Creates desciprion of columns of data type Object from the range of data parts. static ColumnsDescription getObjectColumns( boost::iterator_range range, const ColumnsDescription & storage_columns); diff --git a/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h b/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h deleted file mode 100644 index 9664af21541..00000000000 --- a/src/Storages/MergeTree/StorageFromBasePartsOfProjection.h +++ /dev/null @@ -1,76 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include -#include -#include - -#include - - -namespace DB -{ -/// A Storage that allows reading from a single MergeTree data part. -class StorageFromBasePartsOfProjection final : public shared_ptr_helper, public IStorage -{ - friend struct shared_ptr_helper; - -public: - String getName() const override { return "FromBasePartsOfProjection"; } - - Pipe read( - const Names & column_names, - const StorageSnapshotPtr & storage_snapshot, - SelectQueryInfo & query_info, - ContextPtr context, - QueryProcessingStage::Enum /*processed_stage*/, - size_t max_block_size, - unsigned num_streams) override - { - // NOTE: It's used to read normal parts only - QueryPlan query_plan = std::move(*MergeTreeDataSelectExecutor(storage).readFromParts( - {}, - column_names, - storage_snapshot, - metadata_snapshot, - metadata_snapshot, - query_info, - context, - max_block_size, - num_streams, - nullptr, - query_info.projection ? query_info.projection->merge_tree_data_select_base_cache.get() - : query_info.merge_tree_data_select_cache.get())); - - return query_plan.convertToPipe( - QueryPlanOptimizationSettings::fromContext(context), BuildQueryPipelineSettings::fromContext(context)); - } - - - bool supportsIndexForIn() const override { return true; } - - bool mayBenefitFromIndexForIn( - const ASTPtr & left_in_operand, ContextPtr query_context, const StorageMetadataPtr & metadata_snapshot) const override - { - return storage.mayBenefitFromIndexForIn(left_in_operand, query_context, metadata_snapshot); - } - - NamesAndTypesList getVirtuals() const override { return storage.getVirtuals(); } - -protected: - StorageFromBasePartsOfProjection(const MergeTreeData & storage_, const StorageMetadataPtr & metadata_snapshot) - : IStorage(storage_.getStorageID()), storage(storage_) - { - setInMemoryMetadata(*metadata_snapshot); - } - - -private: - const MergeTreeData & storage; -}; - -} diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index b1648bfdc98..3c6ed84dfb9 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -622,6 +622,8 @@ StorageSnapshotPtr StorageDistributed::getStorageSnapshot(const StorageMetadataP StorageSnapshotPtr StorageDistributed::getStorageSnapshotForQuery( const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query) const { + /// If query doesn't use columns of type Object don't deduce + /// concrete types for them, because it required extra round trip. auto snapshot_data = std::make_unique(); if (!requiresObjectColumns(metadata_snapshot->getColumns(), query)) return std::make_shared(*this, metadata_snapshot, ColumnsDescription{}, std::move(snapshot_data)); @@ -632,7 +634,7 @@ StorageSnapshotPtr StorageDistributed::getStorageSnapshotForQuery( metadata_snapshot->getColumns(), getContext()); - auto object_columns = getObjectColumns( + auto object_columns = DB::getObjectColumns( snapshot_data->objects_by_shard.begin(), snapshot_data->objects_by_shard.end(), metadata_snapshot->getColumns(), diff --git a/src/Storages/StorageDistributed.h b/src/Storages/StorageDistributed.h index 17e0d7d542d..70bc61a4d25 100644 --- a/src/Storages/StorageDistributed.h +++ b/src/Storages/StorageDistributed.h @@ -61,6 +61,8 @@ public: bool isRemote() const override { return true; } + /// Snapshot for StorageDistributed fixes current descriptions + /// of columns of type Object for each shard. struct SnapshotData : public StorageSnapshot::Data { ColumnsDescriptionByShardNum objects_by_shard; diff --git a/src/Storages/StorageMemory.h b/src/Storages/StorageMemory.h index 003d7f1e8e0..c507a3d1819 100644 --- a/src/Storages/StorageMemory.h +++ b/src/Storages/StorageMemory.h @@ -29,6 +29,7 @@ public: size_t getSize() const { return data.get()->size(); } + /// Snapshot for StorageMemory fixes current set of blocks. struct SnapshotData : public StorageSnapshot::Data { std::shared_ptr blocks; diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp index 44dd77b2ce2..b03af8fa4f7 100644 --- a/src/Storages/StorageSnapshot.cpp +++ b/src/Storages/StorageSnapshot.cpp @@ -178,11 +178,4 @@ DataTypePtr StorageSnapshot::getConcreteType(const String & column_name) const return metadata->getColumns().get(column_name).type; } -bool StorageSnapshot::isSubcolumnOfObject(const String & name) const -{ - auto split = Nested::splitName(name); - return !split.second.empty() - && object_columns.tryGetColumn(GetColumnsOptions::All, split.first); -} - } diff --git a/src/Storages/StorageSnapshot.h b/src/Storages/StorageSnapshot.h index fece121cd6f..46244827f6c 100644 --- a/src/Storages/StorageSnapshot.h +++ b/src/Storages/StorageSnapshot.h @@ -1,24 +1,22 @@ #pragma once #include -// #include namespace DB { class IStorage; -// #if !defined(ARCADIA_BUILD) -// using NamesAndTypesMap = google::dense_hash_map; -// #else -// using NamesAndTypesMap = google::sparsehash::dense_hash_map; -// #endif - +/// Snapshot of storage that fixes set columns that can be read in query. +/// There are 3 sources of columns: regular columns from metadata, +/// dynamic columns from object Types, virtual columns. struct StorageSnapshot { const IStorage & storage; const StorageMetadataPtr metadata; const ColumnsDescription object_columns; + /// Additional data, on which set of columns may depend. + /// E.g. data parts in MergeTree, list of blocks in Memory, etc. struct Data { virtual ~Data() = default; @@ -27,7 +25,7 @@ struct StorageSnapshot using DataPtr = std::unique_ptr; const DataPtr data; - /// TODO: fix + /// Projection that is used in query. mutable const ProjectionDescription * projection = nullptr; StorageSnapshot( @@ -57,7 +55,10 @@ struct StorageSnapshot init(); } + /// Get all available columns with types according to options. NamesAndTypesList getColumns(const GetColumnsOptions & options) const; + + /// Get columns with types according to options only for requested names. NamesAndTypesList getColumnsByNames(const GetColumnsOptions & options, const Names & names) const; /// Block with ordinary + materialized + aliases + virtuals + subcolumns. @@ -71,9 +72,8 @@ struct StorageSnapshot void addProjection(const ProjectionDescription * projection_) const { projection = projection_; } - StorageMetadataPtr getMetadataForQuery() const { return (projection ? projection->metadata : metadata); } - - bool isSubcolumnOfObject(const String & name) const; + /// If we have a projection then we should use its metadata. + StorageMetadataPtr getMetadataForQuery() const { return projection ? projection->metadata : metadata; } private: void init(); diff --git a/src/Storages/getStructureOfRemoteTable.h b/src/Storages/getStructureOfRemoteTable.h index 39d040c9f30..62f93dccf1a 100644 --- a/src/Storages/getStructureOfRemoteTable.h +++ b/src/Storages/getStructureOfRemoteTable.h @@ -23,6 +23,7 @@ ColumnsDescription getStructureOfRemoteTable( using ColumnsDescriptionByShardNum = std::unordered_map; +/// Returns descriptions of columns of type Object for each shard. ColumnsDescriptionByShardNum getExtendedObjectsOfRemoteTables( const Cluster & cluster, const StorageID & remote_table_id, From 04a3a10148ad1415db56b20f2d51ada1b172d11b Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Tue, 1 Mar 2022 20:20:53 +0300 Subject: [PATCH 092/132] minor fixes --- src/Columns/ColumnAggregateFunction.cpp | 2 +- src/Columns/ColumnArray.cpp | 4 ++-- src/Columns/ColumnDecimal.cpp | 2 +- src/Columns/ColumnFixedString.cpp | 2 +- src/Columns/ColumnSparse.cpp | 2 +- src/Columns/ColumnVector.cpp | 4 ++-- src/Columns/ColumnsCommon.cpp | 2 +- src/Storages/MergeTree/IMergeTreeReader.cpp | 2 +- src/Storages/MergeTree/MergeTreeData.cpp | 4 ++-- src/Storages/StorageDistributed.cpp | 2 +- src/Storages/StorageMemory.cpp | 2 +- 11 files changed, 14 insertions(+), 14 deletions(-) diff --git a/src/Columns/ColumnAggregateFunction.cpp b/src/Columns/ColumnAggregateFunction.cpp index d675d166f5f..2bc55ecf2e8 100644 --- a/src/Columns/ColumnAggregateFunction.cpp +++ b/src/Columns/ColumnAggregateFunction.cpp @@ -295,7 +295,7 @@ ColumnPtr ColumnAggregateFunction::filter(const Filter & filter, ssize_t result_ { size_t size = data.size(); if (size != filter.size()) - throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filter.size(), size); if (size == 0) return cloneEmpty(); diff --git a/src/Columns/ColumnArray.cpp b/src/Columns/ColumnArray.cpp index 78a894a83de..a2535a8cd84 100644 --- a/src/Columns/ColumnArray.cpp +++ b/src/Columns/ColumnArray.cpp @@ -592,7 +592,7 @@ ColumnPtr ColumnArray::filterString(const Filter & filt, ssize_t result_size_hin { size_t col_size = getOffsets().size(); if (col_size != filt.size()) - throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), col_size); if (0 == col_size) return ColumnArray::create(data); @@ -660,7 +660,7 @@ ColumnPtr ColumnArray::filterGeneric(const Filter & filt, ssize_t result_size_hi { size_t size = getOffsets().size(); if (size != filt.size()) - throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), size); if (size == 0) return ColumnArray::create(data); diff --git a/src/Columns/ColumnDecimal.cpp b/src/Columns/ColumnDecimal.cpp index 9898f013886..757bf64f10b 100644 --- a/src/Columns/ColumnDecimal.cpp +++ b/src/Columns/ColumnDecimal.cpp @@ -205,7 +205,7 @@ ColumnPtr ColumnDecimal::filter(const IColumn::Filter & filt, ssize_t result_ { size_t size = data.size(); if (size != filt.size()) - throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), size); auto res = this->create(0, scale); Container & res_data = res->getData(); diff --git a/src/Columns/ColumnFixedString.cpp b/src/Columns/ColumnFixedString.cpp index 81eb9615ff9..1bd2dd2a91f 100644 --- a/src/Columns/ColumnFixedString.cpp +++ b/src/Columns/ColumnFixedString.cpp @@ -226,7 +226,7 @@ ColumnPtr ColumnFixedString::filter(const IColumn::Filter & filt, ssize_t result { size_t col_size = size(); if (col_size != filt.size()) - throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), col_size); auto res = ColumnFixedString::create(n); diff --git a/src/Columns/ColumnSparse.cpp b/src/Columns/ColumnSparse.cpp index e9bdc3971c0..a00fe89c5db 100644 --- a/src/Columns/ColumnSparse.cpp +++ b/src/Columns/ColumnSparse.cpp @@ -288,7 +288,7 @@ void ColumnSparse::popBack(size_t n) ColumnPtr ColumnSparse::filter(const Filter & filt, ssize_t) const { if (_size != filt.size()) - throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), _size); if (offsets->empty()) { diff --git a/src/Columns/ColumnVector.cpp b/src/Columns/ColumnVector.cpp index eca10049a0b..444fa1063de 100644 --- a/src/Columns/ColumnVector.cpp +++ b/src/Columns/ColumnVector.cpp @@ -297,7 +297,7 @@ ColumnPtr ColumnVector::filter(const IColumn::Filter & filt, ssize_t result_s { size_t size = data.size(); if (size != filt.size()) - throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), size); auto res = this->create(); Container & res_data = res->getData(); @@ -366,7 +366,7 @@ void ColumnVector::applyZeroMap(const IColumn::Filter & filt, bool inverted) { size_t size = data.size(); if (size != filt.size()) - throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), size); const UInt8 * filt_pos = filt.data(); const UInt8 * filt_end = filt_pos + size; diff --git a/src/Columns/ColumnsCommon.cpp b/src/Columns/ColumnsCommon.cpp index 701b888fb25..0a9201f7543 100644 --- a/src/Columns/ColumnsCommon.cpp +++ b/src/Columns/ColumnsCommon.cpp @@ -192,7 +192,7 @@ namespace { const size_t size = src_offsets.size(); if (size != filt.size()) - throw Exception("Size of filter doesn't match size of column.", ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH); + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, "Size of filter ({}) doesn't match size of column ({})", filt.size(), size); ResultOffsetsBuilder result_offsets_builder(res_offsets); diff --git a/src/Storages/MergeTree/IMergeTreeReader.cpp b/src/Storages/MergeTree/IMergeTreeReader.cpp index 9fdad8d6962..3a823345dda 100644 --- a/src/Storages/MergeTree/IMergeTreeReader.cpp +++ b/src/Storages/MergeTree/IMergeTreeReader.cpp @@ -149,7 +149,7 @@ NameAndTypePair IMergeTreeReader::getColumnFromPart(const NameAndTypePair & requ auto subcolumn_type = type->tryGetSubcolumnType(subcolumn_name); if (!subcolumn_type) - return {required_column.name, required_column.type}; + return required_column; return {String(it->getKey()), subcolumn_name, type, subcolumn_type}; } diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index 448fae0cf77..f2f5144b044 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -6117,7 +6117,7 @@ ColumnsDescription MergeTreeData::getObjectColumns( { return DB::getObjectColumns( parts.begin(), parts.end(), - storage_columns, [](const auto & part) { return part->getColumns(); }); + storage_columns, [](const auto & part) -> const auto & { return part->getColumns(); }); } ColumnsDescription MergeTreeData::getObjectColumns( @@ -6125,7 +6125,7 @@ ColumnsDescription MergeTreeData::getObjectColumns( { return DB::getObjectColumns( range.begin(), range.end(), - storage_columns, [](const auto & part) { return part->getColumns(); }); + storage_columns, [](const auto & part) -> const auto & { return part->getColumns(); }); } void MergeTreeData::resetObjectColumnsFromActiveParts(const DataPartsLock & /*lock*/) diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index 3c6ed84dfb9..16b11a81c78 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -638,7 +638,7 @@ StorageSnapshotPtr StorageDistributed::getStorageSnapshotForQuery( snapshot_data->objects_by_shard.begin(), snapshot_data->objects_by_shard.end(), metadata_snapshot->getColumns(), - [](const auto & shard_num_and_columns) { return shard_num_and_columns.second; }); + [](const auto & shard_num_and_columns) -> const auto & { return shard_num_and_columns.second; }); return std::make_shared(*this, metadata_snapshot, object_columns, std::move(snapshot_data)); } diff --git a/src/Storages/StorageMemory.cpp b/src/Storages/StorageMemory.cpp index 54a6bfb55a7..c3601b33a04 100644 --- a/src/Storages/StorageMemory.cpp +++ b/src/Storages/StorageMemory.cpp @@ -202,7 +202,7 @@ StorageSnapshotPtr StorageMemory::getStorageSnapshot(const StorageMetadataPtr & snapshot_data->blocks->begin(), snapshot_data->blocks->end(), metadata_snapshot->getColumns(), - [](const auto & block) { return block.getColumnsWithTypeAndName(); }); + [](const auto & block) -> const auto & { return block.getColumnsWithTypeAndName(); }); return std::make_shared(*this, metadata_snapshot, object_columns, std::move(snapshot_data)); } From d7cd9aa69ba69d531d364496342441df8831e988 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 2 Mar 2022 03:31:40 +0300 Subject: [PATCH 093/132] fix reading of missed subcolumns --- src/Storages/MergeTree/MergeTreeReaderCompact.cpp | 9 +++++++++ 1 file changed, 9 insertions(+) diff --git a/src/Storages/MergeTree/MergeTreeReaderCompact.cpp b/src/Storages/MergeTree/MergeTreeReaderCompact.cpp index 726b2141ffb..f8bf6b94cfe 100644 --- a/src/Storages/MergeTree/MergeTreeReaderCompact.cpp +++ b/src/Storages/MergeTree/MergeTreeReaderCompact.cpp @@ -52,6 +52,15 @@ MergeTreeReaderCompact::MergeTreeReaderCompact( auto name_and_type = columns.begin(); for (size_t i = 0; i < columns_num; ++i, ++name_and_type) { + if (name_and_type->isSubcolumn()) + { + auto storage_column_from_part = getColumnFromPart( + {name_and_type->getNameInStorage(), name_and_type->getTypeInStorage()}); + + if (!storage_column_from_part.type->tryGetSubcolumnType(name_and_type->getSubcolumnName())) + continue; + } + auto column_from_part = getColumnFromPart(*name_and_type); auto position = data_part->getColumnPosition(column_from_part.getNameInStorage()); From 76e40e4f2254ef8d400d8accf8baa3079655e100 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 3 Mar 2022 21:50:36 +0000 Subject: [PATCH 094/132] fix msan --- src/Columns/ColumnObject.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index faa307e6dfb..3de6125f895 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -762,7 +762,7 @@ void ColumnObject::finalize() /// If all subcolumns were skipped add a dummy subcolumn, /// because Tuple type must have at least one element. if (new_subcolumns.empty()) - new_subcolumns.add(PathInData{COLUMN_NAME_DUMMY}, Subcolumn{ColumnUInt8::create(old_size), is_nullable}); + new_subcolumns.add(PathInData{COLUMN_NAME_DUMMY}, Subcolumn{ColumnUInt8::create(old_size, 0), is_nullable}); std::swap(subcolumns, new_subcolumns); checkObjectHasNoAmbiguosPaths(getKeys()); From 4200b56f3a29028d5f0e332d154c39687128ad34 Mon Sep 17 00:00:00 2001 From: Azat Khuzhin Date: Sun, 27 Feb 2022 12:35:51 +0300 Subject: [PATCH 095/132] Introduce IDisk::supportParallelWrite() Signed-off-by: Azat Khuzhin --- src/Disks/IDisk.h | 4 ++++ src/Disks/IDiskRemote.cpp | 1 - src/Disks/S3/DiskS3.h | 2 ++ 3 files changed, 6 insertions(+), 1 deletion(-) diff --git a/src/Disks/IDisk.h b/src/Disks/IDisk.h index 5068ac5dde9..12200e99507 100644 --- a/src/Disks/IDisk.h +++ b/src/Disks/IDisk.h @@ -248,6 +248,10 @@ public: /// Overrode in remote fs disks. virtual bool supportZeroCopyReplication() const = 0; + /// Whether this disk support parallel write + /// Overrode in remote fs disks. + virtual bool supportParallelWrite() const { return false; } + virtual bool isReadOnly() const { return false; } /// Check if disk is broken. Broken disks will have 0 space and not be used. diff --git a/src/Disks/IDiskRemote.cpp b/src/Disks/IDiskRemote.cpp index 2a9aded039b..fa529600714 100644 --- a/src/Disks/IDiskRemote.cpp +++ b/src/Disks/IDiskRemote.cpp @@ -4,7 +4,6 @@ #include #include #include -#include #include #include #include diff --git a/src/Disks/S3/DiskS3.h b/src/Disks/S3/DiskS3.h index 698fa6173c2..b52246ff4ac 100644 --- a/src/Disks/S3/DiskS3.h +++ b/src/Disks/S3/DiskS3.h @@ -103,6 +103,8 @@ public: bool supportZeroCopyReplication() const override { return true; } + bool supportParallelWrite() const override { return true; } + void shutdown() override; void startup() override; From 3a5a39a9df2200a298e1d3af8d41f58c75883f0e Mon Sep 17 00:00:00 2001 From: Azat Khuzhin Date: Mon, 21 Feb 2022 01:04:45 +0300 Subject: [PATCH 096/132] Do not delay final part writing by default For async s3 writes final part flushing was defered until all the INSERT block was processed, however in case of too many partitions/columns you may exceed max_memory_usage limit (since each stream has overhead). Introduce max_insert_delayed_streams_for_parallel_writes (with default to 1000 for S3, 0 otherwise), to avoid this. This should "Memory limit exceeded" errors in performance tests. Signed-off-by: Azat Khuzhin --- docs/en/operations/settings/settings.md | 13 +++++++ src/Core/Settings.h | 1 + src/Storages/MergeTree/MergeTreeData.h | 3 ++ src/Storages/MergeTree/MergeTreeSink.cpp | 32 +++++++++++++++-- .../MergeTree/ReplicatedMergeTreeSink.cpp | 34 ++++++++++++++++--- ...8_merge_tree_insert_memory_usage.reference | 0 .../02228_merge_tree_insert_memory_usage.sql | 15 ++++++++ 7 files changed, 92 insertions(+), 6 deletions(-) create mode 100644 tests/queries/0_stateless/02228_merge_tree_insert_memory_usage.reference create mode 100644 tests/queries/0_stateless/02228_merge_tree_insert_memory_usage.sql diff --git a/docs/en/operations/settings/settings.md b/docs/en/operations/settings/settings.md index 56f1e7fe3bb..6da20d515ff 100644 --- a/docs/en/operations/settings/settings.md +++ b/docs/en/operations/settings/settings.md @@ -3290,6 +3290,19 @@ Possible values: Default value: `16`. +## max_insert_delayed_streams_for_parallel_write {#max-insert-delayed-streams-for-parallel-write} + +The maximum number of streams (columns) to delay final part flush. + +It makes difference only if underlying storage supports parallel write (i.e. S3), otherwise it will not give any benefit. + +Possible values: + +- Positive integer. +- 0 or 1 — Disabled. + +Default value: `1000` for S3 and `0` otherwise. + ## opentelemetry_start_trace_probability {#opentelemetry-start-trace-probability} Sets the probability that the ClickHouse can start a trace for executed queries (if no parent [trace context](https://www.w3.org/TR/trace-context/) is supplied). diff --git a/src/Core/Settings.h b/src/Core/Settings.h index 5280e4b3eeb..6b27cd6bb26 100644 --- a/src/Core/Settings.h +++ b/src/Core/Settings.h @@ -44,6 +44,7 @@ class IColumn; M(UInt64, min_insert_block_size_bytes_for_materialized_views, 0, "Like min_insert_block_size_bytes, but applied only during pushing to MATERIALIZED VIEW (default: min_insert_block_size_bytes)", 0) \ M(UInt64, max_joined_block_size_rows, DEFAULT_BLOCK_SIZE, "Maximum block size for JOIN result (if join algorithm supports it). 0 means unlimited.", 0) \ M(UInt64, max_insert_threads, 0, "The maximum number of threads to execute the INSERT SELECT query. Values 0 or 1 means that INSERT SELECT is not run in parallel. Higher values will lead to higher memory usage. Parallel INSERT SELECT has effect only if the SELECT part is run on parallel, see 'max_threads' setting.", 0) \ + M(UInt64, max_insert_delayed_streams_for_parallel_write, 0, "The maximum number of streams (columns) to delay final part flush. Default - auto (1000 in case of underlying storage supports parallel write, for example S3 and disabled otherwise)", 0) \ M(UInt64, max_final_threads, 16, "The maximum number of threads to read from table with FINAL.", 0) \ M(MaxThreads, max_threads, 0, "The maximum number of threads to execute the request. By default, it is determined automatically.", 0) \ M(UInt64, max_read_buffer_size, DBMS_DEFAULT_BUFFER_SIZE, "The maximum size of the buffer to read from the filesystem.", 0) \ diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index 1e7f127c85b..264fb77b7f8 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -39,6 +39,9 @@ namespace DB { +/// Number of streams is not number parts, but number or parts*files, hence 1000. +const size_t DEFAULT_DELAYED_STREAMS_FOR_PARALLEL_WRITE = 1000; + class AlterCommands; class MergeTreePartsMover; class MergeTreeDataMergerMutator; diff --git a/src/Storages/MergeTree/MergeTreeSink.cpp b/src/Storages/MergeTree/MergeTreeSink.cpp index ea252954b7e..97bbfc17e9d 100644 --- a/src/Storages/MergeTree/MergeTreeSink.cpp +++ b/src/Storages/MergeTree/MergeTreeSink.cpp @@ -52,7 +52,14 @@ void MergeTreeSink::consume(Chunk chunk) auto block = getHeader().cloneWithColumns(chunk.detachColumns()); auto part_blocks = storage.writer.splitBlockIntoParts(block, max_parts_per_block, metadata_snapshot, context); - std::vector partitions; + + using DelayedPartitions = std::vector; + DelayedPartitions partitions; + + const Settings & settings = context->getSettingsRef(); + size_t streams = 0; + bool support_parallel_write = false; + for (auto & current_block : part_blocks) { Stopwatch watch; @@ -67,9 +74,12 @@ void MergeTreeSink::consume(Chunk chunk) if (!temp_part.part) continue; + if (!support_parallel_write && temp_part.part->volume->getDisk()->supportParallelWrite()) + support_parallel_write = true; + if (storage.getDeduplicationLog()) { - const String & dedup_token = context->getSettingsRef().insert_deduplication_token; + const String & dedup_token = settings.insert_deduplication_token; if (!dedup_token.empty()) { /// multiple blocks can be inserted within the same insert query @@ -79,6 +89,24 @@ void MergeTreeSink::consume(Chunk chunk) } } + size_t max_insert_delayed_streams_for_parallel_write = DEFAULT_DELAYED_STREAMS_FOR_PARALLEL_WRITE; + if (!support_parallel_write || settings.max_insert_delayed_streams_for_parallel_write.changed) + max_insert_delayed_streams_for_parallel_write = settings.max_insert_delayed_streams_for_parallel_write; + + /// In case of too much columns/parts in block, flush explicitly. + streams += temp_part.streams.size(); + if (streams > max_insert_delayed_streams_for_parallel_write) + { + finishDelayedChunk(); + delayed_chunk = std::make_unique(); + delayed_chunk->partitions = std::move(partitions); + finishDelayedChunk(); + + streams = 0; + support_parallel_write = false; + partitions = DelayedPartitions{}; + } + partitions.emplace_back(MergeTreeSink::DelayedChunk::Partition { .temp_part = std::move(temp_part), diff --git a/src/Storages/MergeTree/ReplicatedMergeTreeSink.cpp b/src/Storages/MergeTree/ReplicatedMergeTreeSink.cpp index 86d36aab50c..550c586f7de 100644 --- a/src/Storages/MergeTree/ReplicatedMergeTreeSink.cpp +++ b/src/Storages/MergeTree/ReplicatedMergeTreeSink.cpp @@ -150,9 +150,14 @@ void ReplicatedMergeTreeSink::consume(Chunk chunk) if (quorum) checkQuorumPrecondition(zookeeper); + const Settings & settings = context->getSettingsRef(); auto part_blocks = storage.writer.splitBlockIntoParts(block, max_parts_per_block, metadata_snapshot, context); - std::vector partitions; - String block_dedup_token; + + using DelayedPartitions = std::vector; + DelayedPartitions partitions; + + size_t streams = 0; + bool support_parallel_write = false; for (auto & current_block : part_blocks) { @@ -171,10 +176,12 @@ void ReplicatedMergeTreeSink::consume(Chunk chunk) if (deduplicate) { + String block_dedup_token; + /// We add the hash from the data and partition identifier to deduplication ID. /// That is, do not insert the same data to the same partition twice. - const String & dedup_token = context->getSettingsRef().insert_deduplication_token; + const String & dedup_token = settings.insert_deduplication_token; if (!dedup_token.empty()) { /// multiple blocks can be inserted within the same insert query @@ -182,6 +189,7 @@ void ReplicatedMergeTreeSink::consume(Chunk chunk) block_dedup_token = fmt::format("{}_{}", dedup_token, chunk_dedup_seqnum); ++chunk_dedup_seqnum; } + block_id = temp_part.part->getZeroLevelPartBlockID(block_dedup_token); LOG_DEBUG(log, "Wrote block with ID '{}', {} rows", block_id, current_block.block.rows()); } @@ -192,6 +200,24 @@ void ReplicatedMergeTreeSink::consume(Chunk chunk) UInt64 elapsed_ns = watch.elapsed(); + size_t max_insert_delayed_streams_for_parallel_write = DEFAULT_DELAYED_STREAMS_FOR_PARALLEL_WRITE; + if (!support_parallel_write || settings.max_insert_delayed_streams_for_parallel_write.changed) + max_insert_delayed_streams_for_parallel_write = settings.max_insert_delayed_streams_for_parallel_write; + + /// In case of too much columns/parts in block, flush explicitly. + streams += temp_part.streams.size(); + if (streams > max_insert_delayed_streams_for_parallel_write) + { + finishDelayedChunk(zookeeper); + delayed_chunk = std::make_unique(); + delayed_chunk->partitions = std::move(partitions); + finishDelayedChunk(zookeeper); + + streams = 0; + support_parallel_write = false; + partitions = DelayedPartitions{}; + } + partitions.emplace_back(ReplicatedMergeTreeSink::DelayedChunk::Partition{ .temp_part = std::move(temp_part), .elapsed_ns = elapsed_ns, @@ -207,7 +233,7 @@ void ReplicatedMergeTreeSink::consume(Chunk chunk) /// value for `last_block_is_duplicate`, which is possible only after the part is committed. /// Othervide we can delay commit. /// TODO: we can also delay commit if there is no MVs. - if (!context->getSettingsRef().deduplicate_blocks_in_dependent_materialized_views) + if (!settings.deduplicate_blocks_in_dependent_materialized_views) finishDelayedChunk(zookeeper); } diff --git a/tests/queries/0_stateless/02228_merge_tree_insert_memory_usage.reference b/tests/queries/0_stateless/02228_merge_tree_insert_memory_usage.reference new file mode 100644 index 00000000000..e69de29bb2d diff --git a/tests/queries/0_stateless/02228_merge_tree_insert_memory_usage.sql b/tests/queries/0_stateless/02228_merge_tree_insert_memory_usage.sql new file mode 100644 index 00000000000..7aa3be1990b --- /dev/null +++ b/tests/queries/0_stateless/02228_merge_tree_insert_memory_usage.sql @@ -0,0 +1,15 @@ +-- Tags: long, no-parallel + +-- regression for MEMORY_LIMIT_EXCEEDED error because of deferred final part flush + +drop table if exists data_02228; +create table data_02228 (key1 UInt32, sign Int8, s UInt64) engine = CollapsingMergeTree(sign) order by (key1) partition by key1 % 1024; +insert into data_02228 select number, 1, number from numbers_mt(100e3) settings max_memory_usage='300Mi', max_partitions_per_insert_block=1024; +insert into data_02228 select number, 1, number from numbers_mt(100e3) settings max_memory_usage='300Mi', max_partitions_per_insert_block=1024, max_insert_delayed_streams_for_parallel_write=10000000; -- { serverError MEMORY_LIMIT_EXCEEDED } +drop table data_02228; + +drop table if exists data_rep_02228; +create table data_rep_02228 (key1 UInt32, sign Int8, s UInt64) engine = ReplicatedCollapsingMergeTree('/clickhouse/{database}', 'r1', sign) order by (key1) partition by key1 % 1024; +insert into data_rep_02228 select number, 1, number from numbers_mt(100e3) settings max_memory_usage='300Mi', max_partitions_per_insert_block=1024; +insert into data_rep_02228 select number, 1, number from numbers_mt(100e3) settings max_memory_usage='300Mi', max_partitions_per_insert_block=1024, max_insert_delayed_streams_for_parallel_write=10000000; -- { serverError MEMORY_LIMIT_EXCEEDED } +drop table data_rep_02228; From 0615e97c5db5261fd8cecd058018da460ee710c1 Mon Sep 17 00:00:00 2001 From: Azat Khuzhin Date: Wed, 9 Mar 2022 17:55:47 +0300 Subject: [PATCH 097/132] tests: tune 02051_read_settings Signed-off-by: Azat Khuzhin --- tests/queries/0_stateless/02051_read_settings.sql.j2 | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/tests/queries/0_stateless/02051_read_settings.sql.j2 b/tests/queries/0_stateless/02051_read_settings.sql.j2 index fa19fbd3036..69dd3c264ba 100644 --- a/tests/queries/0_stateless/02051_read_settings.sql.j2 +++ b/tests/queries/0_stateless/02051_read_settings.sql.j2 @@ -1,4 +1,7 @@ --- Tags: long +-- Tags: long, no-tsan, no-parallel, no-random-settings +-- Tag: no-tsan -- too slow under TSan (~5-6min) +-- Tag: no-random-settings -- to avoid settings overlaps +-- Tag: no-parallel -- to reduce test time -- -- Test for testing various read settings. From 37efe2ddb5dcc16d640867e94567d797f4e27102 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 10 Mar 2022 22:24:19 +0100 Subject: [PATCH 098/132] Apply suggestions from code review Co-authored-by: Kseniia Sumarokova <54203879+kssenii@users.noreply.github.com> --- src/Columns/ColumnObject.cpp | 2 +- src/Storages/StorageDistributed.cpp | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 3de6125f895..3df15d8de3d 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -27,7 +27,7 @@ namespace ErrorCodes namespace { -/// Recreates scolumn with default scalar values and keeps sizes of arrays. +/// Recreates column with default scalar values and keeps sizes of arrays. ColumnPtr recreateColumnWithDefaultValues( const ColumnPtr & column, const DataTypePtr & scalar_type, size_t num_dimensions) { diff --git a/src/Storages/StorageDistributed.cpp b/src/Storages/StorageDistributed.cpp index 16b11a81c78..56cd6344acd 100644 --- a/src/Storages/StorageDistributed.cpp +++ b/src/Storages/StorageDistributed.cpp @@ -622,7 +622,7 @@ StorageSnapshotPtr StorageDistributed::getStorageSnapshot(const StorageMetadataP StorageSnapshotPtr StorageDistributed::getStorageSnapshotForQuery( const StorageMetadataPtr & metadata_snapshot, const ASTPtr & query) const { - /// If query doesn't use columns of type Object don't deduce + /// If query doesn't use columns of type Object, don't deduce /// concrete types for them, because it required extra round trip. auto snapshot_data = std::make_unique(); if (!requiresObjectColumns(metadata_snapshot->getColumns(), query)) From 3a2b3ce5033d8571f1e27f7cb983f8b2f18f5be2 Mon Sep 17 00:00:00 2001 From: Maksim Kita Date: Sat, 12 Mar 2022 17:12:05 +0000 Subject: [PATCH 099/132] Standardize behaviour of CAST into IPv4, IPv6, toIPv4, toIPv6 functions --- .../functions/ip-address-functions.md | 36 +- src/Core/Settings.h | 1 + src/Functions/CastOverloadResolver.h | 27 +- src/Functions/FunctionsCodingIP.cpp | 358 ++++++++++-------- src/Functions/FunctionsCodingIP.h | 205 ++++++++++ src/Functions/FunctionsConversion.h | 51 ++- .../02234_cast_to_ip_address.reference | 45 +++ .../0_stateless/02234_cast_to_ip_address.sql | 82 ++++ 8 files changed, 627 insertions(+), 178 deletions(-) create mode 100644 src/Functions/FunctionsCodingIP.h create mode 100644 tests/queries/0_stateless/02234_cast_to_ip_address.reference create mode 100644 tests/queries/0_stateless/02234_cast_to_ip_address.sql diff --git a/docs/en/sql-reference/functions/ip-address-functions.md b/docs/en/sql-reference/functions/ip-address-functions.md index 469a66d460f..cf3f92580aa 100644 --- a/docs/en/sql-reference/functions/ip-address-functions.md +++ b/docs/en/sql-reference/functions/ip-address-functions.md @@ -13,10 +13,18 @@ Alias: `INET_NTOA`. ## IPv4StringToNum(s) {#ipv4stringtonums} -The reverse function of IPv4NumToString. If the IPv4 address has an invalid format, it returns 0. +The reverse function of IPv4NumToString. If the IPv4 address has an invalid format, it throws exception. Alias: `INET_ATON`. +## IPv4StringToNumOrDefault(s) {#ipv4stringtonums} + +Same as `IPv4StringToNum`, but if the IPv4 address has an invalid format, it returns 0. + +## IPv4StringToNumOrNull(s) {#ipv4stringtonums} + +Same as `IPv4StringToNum`, but if the IPv4 address has an invalid format, it returns null. + ## IPv4NumToStringClassC(num) {#ipv4numtostringclasscnum} Similar to IPv4NumToString, but using xxx instead of the last octet. @@ -123,7 +131,7 @@ LIMIT 10 ## IPv6StringToNum {#ipv6stringtonums} -The reverse function of [IPv6NumToString](#ipv6numtostringx). If the IPv6 address has an invalid format, it returns a string of null bytes. +The reverse function of [IPv6NumToString](#ipv6numtostringx). If the IPv6 address has an invalid format, it throws exception. If the input string contains a valid IPv4 address, returns its IPv6 equivalent. HEX can be uppercase or lowercase. @@ -168,6 +176,14 @@ Result: - [cutIPv6](#cutipv6x-bytestocutforipv6-bytestocutforipv4). +## IPv6StringToNumOrDefault(s) {#ipv6stringtonums} + +Same as `IPv6StringToNum`, but if the IPv6 address has an invalid format, it returns 0. + +## IPv6StringToNumOrNull(s) {#ipv6stringtonums} + +Same as `IPv6StringToNum`, but if the IPv6 address has an invalid format, it returns null. + ## IPv4ToIPv6(x) {#ipv4toipv6x} Takes a `UInt32` number. Interprets it as an IPv4 address in [big endian](https://en.wikipedia.org/wiki/Endianness). Returns a `FixedString(16)` value containing the IPv6 address in binary format. Examples: @@ -261,6 +277,14 @@ SELECT └───────────────────────────────────┴──────────────────────────┘ ``` +## toIPv4OrDefault(string) {#toipv4ordefaultstring} + +Same as `toIPv4`, but if the IPv4 address has an invalid format, it returns 0. + +## toIPv4OrNull(string) {#toipv4ornullstring} + +Same as `toIPv4`, but if the IPv4 address has an invalid format, it returns null. + ## toIPv6 {#toipv6string} Converts a string form of IPv6 address to [IPv6](../../sql-reference/data-types/domains/ipv6.md) type. If the IPv6 address has an invalid format, returns an empty value. @@ -317,6 +341,14 @@ Result: └─────────────────────┘ ``` +## IPv6StringToNumOrDefault(s) {#toipv6ordefaultstring} + +Same as `toIPv6`, but if the IPv6 address has an invalid format, it returns 0. + +## IPv6StringToNumOrNull(s) {#toipv6ornullstring} + +Same as `toIPv6`, but if the IPv6 address has an invalid format, it returns null. + ## isIPv4String {#isipv4string} Determines whether the input string is an IPv4 address or not. If `string` is IPv6 address returns `0`. diff --git a/src/Core/Settings.h b/src/Core/Settings.h index 15ae646ab37..42a3f3797ff 100644 --- a/src/Core/Settings.h +++ b/src/Core/Settings.h @@ -471,6 +471,7 @@ class IColumn; M(Bool, allow_experimental_geo_types, false, "Allow geo data types such as Point, Ring, Polygon, MultiPolygon", 0) \ M(Bool, data_type_default_nullable, false, "Data types without NULL or NOT NULL will make Nullable", 0) \ M(Bool, cast_keep_nullable, false, "CAST operator keep Nullable for result data type", 0) \ + M(Bool, cast_ipv4_ipv6_default_on_conversion_error, false, "CAST operator into IPv4, CAST operator into IPV6 type, toIPv4, toIPv6 functions will return default value instead of throwing exception on conversion error.", 0) \ M(Bool, alter_partition_verbose_result, false, "Output information about affected parts. Currently works only for FREEZE and ATTACH commands.", 0) \ M(Bool, allow_experimental_database_materialized_mysql, false, "Allow to create database with Engine=MaterializedMySQL(...).", 0) \ M(Bool, allow_experimental_database_materialized_postgresql, false, "Allow to create database with Engine=MaterializedPostgreSQL(...).", 0) \ diff --git a/src/Functions/CastOverloadResolver.h b/src/Functions/CastOverloadResolver.h index ffd5dda4af3..cff17d810fe 100644 --- a/src/Functions/CastOverloadResolver.h +++ b/src/Functions/CastOverloadResolver.h @@ -33,22 +33,27 @@ public: ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1}; } - explicit CastOverloadResolverImpl(std::optional diagnostic_, bool keep_nullable_) - : diagnostic(std::move(diagnostic_)), keep_nullable(keep_nullable_) + explicit CastOverloadResolverImpl(std::optional diagnostic_, bool keep_nullable_, bool cast_ipv4_ipv6_default_on_conversion_error_) + : diagnostic(std::move(diagnostic_)) + , keep_nullable(keep_nullable_) + , cast_ipv4_ipv6_default_on_conversion_error(cast_ipv4_ipv6_default_on_conversion_error_) { } static FunctionOverloadResolverPtr create(ContextPtr context) { + const auto & settings_ref = context->getSettingsRef(); + if constexpr (internal) - return createImpl(); - return createImpl({}, context->getSettingsRef().cast_keep_nullable); + return createImpl({}, false /*keep_nullable*/, false /*cast_ipv4_ipv6_default_on_conversion_error*/); + + return createImpl({}, settings_ref.cast_keep_nullable, settings_ref.cast_ipv4_ipv6_default_on_conversion_error); } - static FunctionOverloadResolverPtr createImpl(std::optional diagnostic = {}, bool keep_nullable = false) + static FunctionOverloadResolverPtr createImpl(std::optional diagnostic = {}, bool keep_nullable = false, bool cast_ipv4_ipv6_default_on_conversion_error = false) { assert(!internal || !keep_nullable); - return std::make_unique(std::move(diagnostic), keep_nullable); + return std::make_unique(std::move(diagnostic), keep_nullable, cast_ipv4_ipv6_default_on_conversion_error); } protected: @@ -61,7 +66,7 @@ protected: data_types[i] = arguments[i].type; auto monotonicity = MonotonicityHelper::getMonotonicityInformation(arguments.front().type, return_type.get()); - return std::make_unique>(name, std::move(monotonicity), data_types, return_type, diagnostic, cast_type); + return std::make_unique>(name, std::move(monotonicity), data_types, return_type, diagnostic, cast_type, cast_ipv4_ipv6_default_on_conversion_error); } DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override @@ -98,6 +103,7 @@ protected: private: std::optional diagnostic; bool keep_nullable; + bool cast_ipv4_ipv6_default_on_conversion_error; }; @@ -115,7 +121,10 @@ struct CastInternalOverloadName static constexpr auto accurate_cast_or_null_name = "accurate_CastOrNull"; }; -template using CastOverloadResolver = CastOverloadResolverImpl; -template using CastInternalOverloadResolver = CastOverloadResolverImpl; +template +using CastOverloadResolver = CastOverloadResolverImpl; + +template +using CastInternalOverloadResolver = CastOverloadResolverImpl; } diff --git a/src/Functions/FunctionsCodingIP.cpp b/src/Functions/FunctionsCodingIP.cpp index 3e7c8bff4d5..de814529d03 100644 --- a/src/Functions/FunctionsCodingIP.cpp +++ b/src/Functions/FunctionsCodingIP.cpp @@ -2,12 +2,15 @@ #pragma clang diagnostic ignored "-Wreserved-identifier" #endif +#include + #include #include #include #include #include #include +#include #include #include #include @@ -17,7 +20,7 @@ #include #include #include -#include +#include #include #include #include @@ -239,17 +242,19 @@ private: } }; - +template class FunctionIPv6StringToNum : public IFunction { public: - static constexpr auto name = "IPv6StringToNum"; - static FunctionPtr create(ContextPtr) { return std::make_shared(); } + static constexpr auto name = exception_mode == IPStringToNumExceptionMode::Throw + ? "IPv6StringToNum" + : (exception_mode == IPStringToNumExceptionMode::Default ? "IPv6StringToNumOrDefault" : "IPv6StringToNumOrNull"); - static inline bool tryParseIPv4(const char * pos) + static FunctionPtr create(ContextPtr context) { return std::make_shared(context); } + + explicit FunctionIPv6StringToNum(ContextPtr context) + : cast_ipv4_ipv6_default_on_conversion_error(context->getSettingsRef().cast_ipv4_ipv6_default_on_conversion_error) { - UInt32 result = 0; - return DB::parseIPv4(pos, reinterpret_cast(&result)); } String getName() const override { return name; } @@ -258,62 +263,43 @@ public: bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } + bool useDefaultImplementationForConstants() const override { return true; } + DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { - if (!isString(arguments[0])) + if (!isStringOrFixedString(arguments[0])) + { throw Exception( - "Illegal type " + arguments[0]->getName() + " of argument of function " + getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); + ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument of function {}", arguments[0]->getName(), getName()); + } - return std::make_shared(IPV6_BINARY_LENGTH); + auto result_type = std::make_shared(IPV6_BINARY_LENGTH); + + if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + { + return makeNullable(result_type); + } + + return result_type; } - bool useDefaultImplementationForConstants() const override { return true; } - ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override { const ColumnPtr & column = arguments[0].column; - if (const auto * col_in = checkAndGetColumn(column.get())) + if constexpr (exception_mode == IPStringToNumExceptionMode::Throw) { - auto col_res = ColumnFixedString::create(IPV6_BINARY_LENGTH); - - auto & vec_res = col_res->getChars(); - vec_res.resize(col_in->size() * IPV6_BINARY_LENGTH); - - const ColumnString::Chars & vec_src = col_in->getChars(); - const ColumnString::Offsets & offsets_src = col_in->getOffsets(); - size_t src_offset = 0; - char src_ipv4_buf[sizeof("::ffff:") + IPV4_MAX_TEXT_LENGTH + 1] = "::ffff:"; - - for (size_t out_offset = 0, i = 0; out_offset < vec_res.size(); out_offset += IPV6_BINARY_LENGTH, ++i) + if (cast_ipv4_ipv6_default_on_conversion_error) { - /// For both cases below: In case of failure, the function parseIPv6 fills vec_res with zero bytes. - - /// If the source IP address is parsable as an IPv4 address, then transform it into a valid IPv6 address. - /// Keeping it simple by just prefixing `::ffff:` to the IPv4 address to represent it as a valid IPv6 address. - if (tryParseIPv4(reinterpret_cast(&vec_src[src_offset]))) - { - std::memcpy( - src_ipv4_buf + std::strlen("::ffff:"), - reinterpret_cast(&vec_src[src_offset]), - std::min(offsets_src[i] - src_offset, IPV4_MAX_TEXT_LENGTH + 1)); - parseIPv6(src_ipv4_buf, reinterpret_cast(&vec_res[out_offset])); - } - else - { - parseIPv6( - reinterpret_cast(&vec_src[src_offset]), reinterpret_cast(&vec_res[out_offset])); - } - src_offset = offsets_src[i]; + return convertToIPv6(column); } - - return col_res; } - else - throw Exception("Illegal column " + arguments[0].column->getName() - + " of argument of function " + getName(), - ErrorCodes::ILLEGAL_COLUMN); + + return convertToIPv6(column); } + +private: + bool cast_ipv4_ipv6_default_on_conversion_error = false; }; @@ -381,69 +367,64 @@ public: } }; - +template class FunctionIPv4StringToNum : public IFunction { public: - static constexpr auto name = "IPv4StringToNum"; - static FunctionPtr create(ContextPtr) { return std::make_shared(); } + static constexpr auto name = exception_mode == IPStringToNumExceptionMode::Throw + ? "IPv4StringToNum" + : (exception_mode == IPStringToNumExceptionMode::Default ? "IPv4StringToNumOrDefault" : "IPv4StringToNumOrNull"); - String getName() const override + static FunctionPtr create(ContextPtr context) { return std::make_shared(context); } + + explicit FunctionIPv4StringToNum(ContextPtr context) + : cast_ipv4_ipv6_default_on_conversion_error(context->getSettingsRef().cast_ipv4_ipv6_default_on_conversion_error) { - return name; } + String getName() const override { return name; } + size_t getNumberOfArguments() const override { return 1; } bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } + bool useDefaultImplementationForConstants() const override { return true; } + DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { if (!isString(arguments[0])) - throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName(), - ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); + { + throw Exception( + ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument of function {}", arguments[0]->getName(), getName()); + } - return std::make_shared(); + auto result_type = std::make_shared(); + + if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + { + return makeNullable(result_type); + } + + return result_type; } - static inline UInt32 parseIPv4(const char * pos) - { - UInt32 result = 0; - DB::parseIPv4(pos, reinterpret_cast(&result)); - - return result; - } - - bool useDefaultImplementationForConstants() const override { return true; } - ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override { const ColumnPtr & column = arguments[0].column; - if (const ColumnString * col = checkAndGetColumn(column.get())) + if constexpr (exception_mode == IPStringToNumExceptionMode::Throw) { - auto col_res = ColumnUInt32::create(); - - ColumnUInt32::Container & vec_res = col_res->getData(); - vec_res.resize(col->size()); - - const ColumnString::Chars & vec_src = col->getChars(); - const ColumnString::Offsets & offsets_src = col->getOffsets(); - size_t prev_offset = 0; - - for (size_t i = 0; i < vec_res.size(); ++i) + if (cast_ipv4_ipv6_default_on_conversion_error) { - vec_res[i] = parseIPv4(reinterpret_cast(&vec_src[prev_offset])); - prev_offset = offsets_src[i]; + return convertToIPv4(column); } - - return col_res; } - else - throw Exception("Illegal column " + arguments[0].column->getName() - + " of argument of function " + getName(), - ErrorCodes::ILLEGAL_COLUMN); + + return convertToIPv4(column); } + +private: + bool cast_ipv4_ipv6_default_on_conversion_error = false; }; @@ -503,16 +484,21 @@ private: } }; -class FunctionToIPv4 : public FunctionIPv4StringToNum +template +class FunctionToIPv4 : public FunctionIPv4StringToNum { public: - static constexpr auto name = "toIPv4"; - static FunctionPtr create(ContextPtr) { return std::make_shared(); } + using Base = FunctionIPv4StringToNum; - String getName() const override - { - return name; - } + static constexpr auto name = exception_mode == IPStringToNumExceptionMode::Throw + ? "toIPv4" + : (exception_mode == IPStringToNumExceptionMode::Default ? "toIPv4OrDefault" : "toIPv4OrNull"); + + static FunctionPtr create(ContextPtr context) { return std::make_shared(context); } + + explicit FunctionToIPv4(ContextPtr context) : Base(context) { } + + String getName() const override { return name; } bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } @@ -521,18 +507,35 @@ public: DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { if (!isString(arguments[0])) - throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName(), - ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); + { + throw Exception( + ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument of function {}", arguments[0]->getName(), getName()); + } - return DataTypeFactory::instance().get("IPv4"); + auto result_type = DataTypeFactory::instance().get("IPv4"); + + if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + { + return makeNullable(result_type); + } + + return result_type; } }; -class FunctionToIPv6 : public FunctionIPv6StringToNum +template +class FunctionToIPv6 : public FunctionIPv6StringToNum { public: - static constexpr auto name = "toIPv6"; - static FunctionPtr create(ContextPtr) { return std::make_shared(); } + using Base = FunctionIPv6StringToNum; + + static constexpr auto name = exception_mode == IPStringToNumExceptionMode::Throw + ? "toIPv6" + : (exception_mode == IPStringToNumExceptionMode::Default ? "toIPv6OrDefault" : "toIPv6OrNull"); + + static FunctionPtr create(ContextPtr context) { return std::make_shared(context); } + + explicit FunctionToIPv6(ContextPtr context) : Base(context) { } String getName() const override { return name; } @@ -540,11 +543,20 @@ public: DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { - if (!isString(arguments[0])) - throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName(), - ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); + if (!isStringOrFixedString(arguments[0])) + { + throw Exception( + ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument of function {}", arguments[0]->getName(), getName()); + } - return DataTypeFactory::instance().get("IPv6"); + auto result_type = DataTypeFactory::instance().get("IPv6"); + + if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + { + return makeNullable(result_type); + } + + return result_type; } }; @@ -971,7 +983,7 @@ public: } }; -class FunctionIsIPv4String : public FunctionIPv4StringToNum +class FunctionIsIPv4String : public IFunction { public: static constexpr auto name = "isIPv4String"; @@ -980,46 +992,51 @@ public: String getName() const override { return name; } - bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; } + size_t getNumberOfArguments() const override { return 1; } + + bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } + + bool useDefaultImplementationForConstants() const override { return true; } DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { if (!isString(arguments[0])) - throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName(), - ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); + throw Exception( + "Illegal type " + arguments[0]->getName() + " of argument of function " + getName(), ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); return std::make_shared(); } ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override { - const ColumnPtr & column = arguments[0].column; - if (const ColumnString * col = checkAndGetColumn(column.get())) + const ColumnString * input_column = checkAndGetColumn(arguments[0].column.get()); + + if (!input_column) { - auto col_res = ColumnUInt8::create(); - - ColumnUInt8::Container & vec_res = col_res->getData(); - vec_res.resize(col->size()); - - const ColumnString::Chars & vec_src = col->getChars(); - const ColumnString::Offsets & offsets_src = col->getOffsets(); - size_t prev_offset = 0; - UInt32 result = 0; - - for (size_t i = 0; i < vec_res.size(); ++i) - { - vec_res[i] = DB::parseIPv4(reinterpret_cast(&vec_src[prev_offset]), reinterpret_cast(&result)); - prev_offset = offsets_src[i]; - } - return col_res; + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of argument of function {}", arguments[0].column->getName(), getName()); } - else - throw Exception("Illegal column " + arguments[0].column->getName() - + " of argument of function " + getName(), - ErrorCodes::ILLEGAL_COLUMN); + + auto col_res = ColumnUInt8::create(); + + ColumnUInt8::Container & vec_res = col_res->getData(); + vec_res.resize(input_column->size()); + + const ColumnString::Chars & vec_src = input_column->getChars(); + const ColumnString::Offsets & offsets_src = input_column->getOffsets(); + size_t prev_offset = 0; + UInt32 result = 0; + + for (size_t i = 0; i < vec_res.size(); ++i) + { + vec_res[i] = DB::parseIPv4(reinterpret_cast(&vec_src[prev_offset]), reinterpret_cast(&result)); + prev_offset = offsets_src[i]; + } + + return col_res; } }; -class FunctionIsIPv6String : public FunctionIPv6StringToNum +class FunctionIsIPv6String : public IFunction { public: static constexpr auto name = "isIPv6String"; @@ -1028,44 +1045,49 @@ public: String getName() const override { return name; } - bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return true; } + size_t getNumberOfArguments() const override { return 1; } + + bool isSuitableForShortCircuitArgumentsExecution(const DataTypesWithConstInfo & /*arguments*/) const override { return false; } + + bool useDefaultImplementationForConstants() const override { return true; } DataTypePtr getReturnTypeImpl(const DataTypes & arguments) const override { if (!isString(arguments[0])) - throw Exception("Illegal type " + arguments[0]->getName() + " of argument of function " + getName(), - ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT); + { + throw Exception( + ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Illegal type {} of argument of function {}", arguments[0]->getName(), getName()); + } return std::make_shared(); } ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr &, size_t /*input_rows_count*/) const override { - const ColumnPtr & column = arguments[0].column; - - if (const ColumnString * col = checkAndGetColumn(column.get())) + const ColumnString * input_column = checkAndGetColumn(arguments[0].column.get()); + if (!input_column) { - auto col_res = ColumnUInt8::create(); - - ColumnUInt8::Container & vec_res = col_res->getData(); - vec_res.resize(col->size()); - - const ColumnString::Chars & vec_src = col->getChars(); - const ColumnString::Offsets & offsets_src = col->getOffsets(); - size_t prev_offset = 0; - char v[IPV6_BINARY_LENGTH]; - - for (size_t i = 0; i < vec_res.size(); ++i) - { - vec_res[i] = DB::parseIPv6(reinterpret_cast(&vec_src[prev_offset]), reinterpret_cast(v)); - prev_offset = offsets_src[i]; - } - return col_res; + throw Exception( + ErrorCodes::ILLEGAL_COLUMN, "Illegal column {} of argument of function {}", arguments[0].column->getName(), getName()); } - else - throw Exception("Illegal column " + arguments[0].column->getName() - + " of argument of function " + getName(), - ErrorCodes::ILLEGAL_COLUMN); + + auto col_res = ColumnUInt8::create(); + + ColumnUInt8::Container & vec_res = col_res->getData(); + vec_res.resize(input_column->size()); + + const ColumnString::Chars & vec_src = input_column->getChars(); + const ColumnString::Offsets & offsets_src = input_column->getOffsets(); + size_t prev_offset = 0; + char buffer[IPV6_BINARY_LENGTH]; + + for (size_t i = 0; i < vec_res.size(); ++i) + { + vec_res[i] = DB::parseIPv6(reinterpret_cast(&vec_src[prev_offset]), reinterpret_cast(buffer)); + prev_offset = offsets_src[i]; + } + + return col_res; } }; @@ -1079,8 +1101,6 @@ void registerFunctionsCoding(FunctionFactory & factory) factory.registerFunction(); factory.registerFunction>(); factory.registerFunction>(); - factory.registerFunction(); - factory.registerFunction(); factory.registerFunction(); factory.registerFunction(); factory.registerFunction(); @@ -1089,14 +1109,26 @@ void registerFunctionsCoding(FunctionFactory & factory) factory.registerFunction>(); factory.registerFunction>(); - factory.registerFunction(); - factory.registerFunction(); - factory.registerFunction(); + factory.registerFunction>(); + factory.registerFunction>(); + factory.registerFunction>(); + factory.registerFunction>(); + factory.registerFunction>(); + factory.registerFunction>(); - /// MysQL compatibility aliases: - factory.registerAlias("INET_ATON", FunctionIPv4StringToNum::name, FunctionFactory::CaseInsensitive); + factory.registerFunction(); + factory.registerFunction>(); + factory.registerFunction>(); + factory.registerFunction>(); + factory.registerFunction>(); + factory.registerFunction>(); + factory.registerFunction>(); + + + /// MySQL compatibility aliases: + factory.registerAlias("INET_ATON", FunctionIPv4StringToNum::name, FunctionFactory::CaseInsensitive); factory.registerAlias("INET6_NTOA", FunctionIPv6NumToString::name, FunctionFactory::CaseInsensitive); - factory.registerAlias("INET6_ATON", FunctionIPv6StringToNum::name, FunctionFactory::CaseInsensitive); + factory.registerAlias("INET6_ATON", FunctionIPv6StringToNum::name, FunctionFactory::CaseInsensitive); factory.registerAlias("INET_NTOA", NameFunctionIPv4NumToString::name, FunctionFactory::CaseInsensitive); } diff --git a/src/Functions/FunctionsCodingIP.h b/src/Functions/FunctionsCodingIP.h new file mode 100644 index 00000000000..6d3a64fb2d1 --- /dev/null +++ b/src/Functions/FunctionsCodingIP.h @@ -0,0 +1,205 @@ +#pragma once + +#include + +#include +#include +#include +#include + +namespace DB +{ + +namespace ErrorCodes +{ + extern const int CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING; + extern const int ILLEGAL_COLUMN; +} + +enum class IPStringToNumExceptionMode +{ + Throw, + Default, + Null +}; + +static inline bool tryParseIPv4(const char * pos, UInt32 & result_value) +{ + return parseIPv4(pos, reinterpret_cast(&result_value)); +} + +namespace detail +{ + template + ColumnPtr convertToIPv6(const StringColumnType & string_column) + { + size_t column_size = string_column.size(); + + ColumnUInt8::MutablePtr col_null_map_to; + ColumnUInt8::Container * vec_null_map_to = nullptr; + + if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + { + col_null_map_to = ColumnUInt8::create(column_size, false); + vec_null_map_to = &col_null_map_to->getData(); + } + + auto col_res = ColumnFixedString::create(IPV6_BINARY_LENGTH); + + auto & vec_res = col_res->getChars(); + vec_res.resize(column_size * IPV6_BINARY_LENGTH); + + using Chars = typename StringColumnType::Chars; + const Chars & vec_src = string_column.getChars(); + + size_t src_offset = 0; + char src_ipv4_buf[sizeof("::ffff:") + IPV4_MAX_TEXT_LENGTH + 1] = "::ffff:"; + + /// ColumnFixedString contains not null terminated strings. But functions parseIPv6, parseIPv4 expect null teminated string. + std::string fixed_string_buffer; + + if constexpr (std::is_same_v) + { + fixed_string_buffer.resize(string_column.getN()); + } + + for (size_t out_offset = 0, i = 0; out_offset < vec_res.size(); out_offset += IPV6_BINARY_LENGTH, ++i) + { + size_t src_next_offset = src_offset; + + const char * src_value = nullptr; + unsigned char * res_value = reinterpret_cast(&vec_res[out_offset]); + + if constexpr (std::is_same_v) + { + src_value = reinterpret_cast(&vec_src[src_offset]); + src_next_offset = string_column.getOffsets()[i]; + } + else if constexpr (std::is_same_v) + { + size_t fixed_string_size = string_column.getN(); + + std::memcpy(fixed_string_buffer.data(), reinterpret_cast(&vec_src[src_offset]), fixed_string_size); + src_value = fixed_string_buffer.data(); + + src_next_offset += fixed_string_size; + } + + bool parse_result = false; + UInt32 dummy_result = 0; + + /// For both cases below: In case of failure, the function parseIPv6 fills vec_res with zero bytes. + + /// If the source IP address is parsable as an IPv4 address, then transform it into a valid IPv6 address. + /// Keeping it simple by just prefixing `::ffff:` to the IPv4 address to represent it as a valid IPv6 address. + if (tryParseIPv4(src_value, dummy_result)) + { + std::memcpy( + src_ipv4_buf + std::strlen("::ffff:"), + src_value, + std::min(src_next_offset - src_offset, IPV4_MAX_TEXT_LENGTH + 1)); + parse_result = parseIPv6(src_ipv4_buf, res_value); + } + else + { + parse_result = parseIPv6(src_value, res_value); + } + + if (!parse_result) + { + if constexpr (exception_mode == IPStringToNumExceptionMode::Throw) + throw Exception("Invalid IPv6 value", ErrorCodes::CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING); + else if constexpr (exception_mode == IPStringToNumExceptionMode::Default) + vec_res[i] = 0; + else if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + (*vec_null_map_to)[i] = true; + } + + src_offset = src_next_offset; + } + + if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + return ColumnNullable::create(std::move(col_res), std::move(col_null_map_to)); + + return col_res; + } +} + +template +ColumnPtr convertToIPv6(ColumnPtr column) +{ + size_t column_size = column->size(); + + auto col_res = ColumnFixedString::create(IPV6_BINARY_LENGTH); + + auto & vec_res = col_res->getChars(); + vec_res.resize(column_size * IPV6_BINARY_LENGTH); + + if (const auto * column_input_string = checkAndGetColumn(column.get())) + { + return detail::convertToIPv6(*column_input_string); + } + else if (const auto * column_input_fixed_string = checkAndGetColumn(column.get())) + { + return detail::convertToIPv6(*column_input_fixed_string); + } + else + { + throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column type {}. Expected String or FixedString", column->getName()); + } +} + +template +ColumnPtr convertToIPv4(ColumnPtr column) +{ + const ColumnString * column_string = checkAndGetColumn(column.get()); + + if (!column_string) + { + throw Exception(ErrorCodes::ILLEGAL_COLUMN, "Illegal column type {}. Expected String.", column->getName()); + } + + size_t column_size = column_string->size(); + + ColumnUInt8::MutablePtr col_null_map_to; + ColumnUInt8::Container * vec_null_map_to = nullptr; + + if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + { + col_null_map_to = ColumnUInt8::create(column_size, false); + vec_null_map_to = &col_null_map_to->getData(); + } + + auto col_res = ColumnUInt32::create(); + + ColumnUInt32::Container & vec_res = col_res->getData(); + vec_res.resize(column_size); + + const ColumnString::Chars & vec_src = column_string->getChars(); + const ColumnString::Offsets & offsets_src = column_string->getOffsets(); + size_t prev_offset = 0; + + for (size_t i = 0; i < vec_res.size(); ++i) + { + bool parse_result = tryParseIPv4(reinterpret_cast(&vec_src[prev_offset]), vec_res[i]); + + if (!parse_result) + { + if constexpr (exception_mode == IPStringToNumExceptionMode::Throw) + throw Exception("Invalid IPv4 value", ErrorCodes::CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING); + else if constexpr (exception_mode == IPStringToNumExceptionMode::Default) + vec_res[i] = 0; + else if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + (*vec_null_map_to)[i] = true; + } + + prev_offset = offsets_src[i]; + } + + if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + return ColumnNullable::create(std::move(col_res), std::move(col_null_map_to)); + + return col_res; +} + +} diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index f75d67032f2..47e7ce615ed 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -45,6 +45,7 @@ #include #include #include +#include #include #include #include @@ -2532,10 +2533,12 @@ public: , const DataTypes & argument_types_ , const DataTypePtr & return_type_ , std::optional diagnostic_ - , CastType cast_type_) + , CastType cast_type_ + , bool cast_ipv4_ipv6_default_on_conversion_error_) : cast_name(cast_name_), monotonicity_for_range(std::move(monotonicity_for_range_)) , argument_types(argument_types_), return_type(return_type_), diagnostic(std::move(diagnostic_)) , cast_type(cast_type_) + , cast_ipv4_ipv6_default_on_conversion_error(cast_ipv4_ipv6_default_on_conversion_error_) { } @@ -2584,6 +2587,7 @@ private: std::optional diagnostic; CastType cast_type; + bool cast_ipv4_ipv6_default_on_conversion_error; static WrapperType createFunctionAdaptor(FunctionPtr function, const DataTypePtr & from_type) { @@ -3381,7 +3385,7 @@ private: /// 'requested_result_is_nullable' is true if CAST to Nullable type is requested. WrapperType prepareImpl(const DataTypePtr & from_type, const DataTypePtr & to_type, bool requested_result_is_nullable) const { - if (from_type->equals(*to_type)) + if (from_type->equals(*to_type) && to_type->getCustomName() && to_type->getCustomName()->getName() != "IPv6") { if (isUInt8(from_type)) return createUInt8ToUInt8Wrapper(from_type, to_type); @@ -3449,7 +3453,9 @@ private: return false; }; - auto make_custom_serialization_wrapper = [&](const auto & types) -> bool + bool cast_ipv4_ipv6_default_on_conversion_error_value = cast_ipv4_ipv6_default_on_conversion_error; + + auto make_custom_serialization_wrapper = [&, cast_ipv4_ipv6_default_on_conversion_error_value](const auto & types) -> bool { using Types = std::decay_t; using ToDataType = typename Types::RightType; @@ -3457,8 +3463,45 @@ private: if constexpr (WhichDataType(FromDataType::type_id).isStringOrFixedString()) { - if (to_type->getCustomSerialization()) + if (to_type->getCustomSerialization() && to_type->getCustomName()) { + if (to_type->getCustomName()->getName() == "IPv4") + { + ret = [cast_ipv4_ipv6_default_on_conversion_error_value]( + ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const ColumnNullable *, size_t) + -> ColumnPtr + { + if (!WhichDataType(result_type).isUInt32()) + throw Exception(ErrorCodes::TYPE_MISMATCH, "Wrong result type {}. Expected UInt32", result_type->getName()); + + if (cast_ipv4_ipv6_default_on_conversion_error_value) + return convertToIPv4(arguments[0].column); + else + return convertToIPv4(arguments[0].column); + }; + + return true; + } + + if (to_type->getCustomName()->getName() == "IPv6") + { + ret = [cast_ipv4_ipv6_default_on_conversion_error_value]( + ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const ColumnNullable *, size_t) + -> ColumnPtr + { + if (!WhichDataType(result_type).isFixedString()) + throw Exception( + ErrorCodes::TYPE_MISMATCH, "Wrong result type {}. Expected FixedString", result_type->getName()); + + if (cast_ipv4_ipv6_default_on_conversion_error_value) + return convertToIPv6(arguments[0].column); + else + return convertToIPv6(arguments[0].column); + }; + + return true; + } + ret = &ConvertImplGenericFromString::execute; return true; } diff --git a/tests/queries/0_stateless/02234_cast_to_ip_address.reference b/tests/queries/0_stateless/02234_cast_to_ip_address.reference new file mode 100644 index 00000000000..3a4c40a07cf --- /dev/null +++ b/tests/queries/0_stateless/02234_cast_to_ip_address.reference @@ -0,0 +1,45 @@ +IPv4 functions +0 +\N +2130706433 +2130706433 +2130706433 +-- +0.0.0.0 +\N +127.0.0.1 +127.0.0.1 +127.0.0.1 +-- +127.0.0.1 +-- +0 +0.0.0.0 +0 +0.0.0.0 +0.0.0.0 +0.0.0.0 +IPv6 functions +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 +\N +\0\0\0\0\0\0\0\0\0\0\0\0 +\0\0\0\0\0\0\0\0\0\0\0\0 +\0\0\0\0\0\0\0\0\0\0\0\0 +-- +:: +\N +::ffff:127.0.0.1 +::ffff:127.0.0.1 +::ffff:127.0.0.1 +-- +::ffff:127.0.0.1 +-- +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 +:: +\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0 +:: +:: +:: +-- +::ffff:127.0.0.1 ::ffff:127.0.0.1 ::ffff:127.0.0.1 +::1\0\0 ::1 ::1 diff --git a/tests/queries/0_stateless/02234_cast_to_ip_address.sql b/tests/queries/0_stateless/02234_cast_to_ip_address.sql new file mode 100644 index 00000000000..d436c93b9db --- /dev/null +++ b/tests/queries/0_stateless/02234_cast_to_ip_address.sql @@ -0,0 +1,82 @@ +SELECT 'IPv4 functions'; + +SELECT IPv4StringToNum('test'); --{serverError 441} +SELECT IPv4StringToNumOrDefault('test'); +SELECT IPv4StringToNumOrNull('test'); + +SELECT IPv4StringToNum('127.0.0.1'); +SELECT IPv4StringToNumOrDefault('127.0.0.1'); +SELECT IPv4StringToNumOrNull('127.0.0.1'); + +SELECT '--'; + +SELECT toIPv4('test'); --{serverError 441} +SELECT toIPv4OrDefault('test'); +SELECT toIPv4OrNull('test'); + +SELECT toIPv4('127.0.0.1'); +SELECT toIPv4OrDefault('127.0.0.1'); +SELECT toIPv4OrNull('127.0.0.1'); + +SELECT '--'; + +SELECT cast('test' , 'IPv4'); --{serverError 441} +SELECT cast('127.0.0.1' , 'IPv4'); + +SELECT '--'; + +SET cast_ipv4_ipv6_default_on_conversion_error = 1; + +SELECT IPv4StringToNum('test'); +SELECT toIPv4('test'); +SELECT IPv4StringToNum(''); +SELECT toIPv4(''); +SELECT cast('test' , 'IPv4'); +SELECT cast('' , 'IPv4'); + +SET cast_ipv4_ipv6_default_on_conversion_error = 0; + +SELECT 'IPv6 functions'; + +SELECT IPv6StringToNum('test'); --{serverError 441} +SELECT IPv6StringToNumOrDefault('test'); +SELECT IPv6StringToNumOrNull('test'); + +SELECT IPv6StringToNum('::ffff:127.0.0.1'); +SELECT IPv6StringToNumOrDefault('::ffff:127.0.0.1'); +SELECT IPv6StringToNumOrNull('::ffff:127.0.0.1'); + +SELECT '--'; + +SELECT toIPv6('test'); --{serverError 441} +SELECT toIPv6OrDefault('test'); +SELECT toIPv6OrNull('test'); + +SELECT toIPv6('::ffff:127.0.0.1'); +SELECT toIPv6OrDefault('::ffff:127.0.0.1'); +SELECT toIPv6OrNull('::ffff:127.0.0.1'); + +SELECT '--'; + +SELECT cast('test' , 'IPv6'); --{serverError 441} +SELECT cast('::ffff:127.0.0.1', 'IPv6'); + +SELECT '--'; + +SET cast_ipv4_ipv6_default_on_conversion_error = 1; + +SELECT IPv6StringToNum('test'); +SELECT toIPv6('test'); +SELECT IPv6StringToNum(''); +SELECT toIPv6(''); +SELECT cast('test' , 'IPv6'); +SELECT cast('' , 'IPv6'); + +SELECT '--'; + +SET cast_ipv4_ipv6_default_on_conversion_error = 0; + +SELECT toFixedString('::ffff:127.0.0.1', 16) as value, cast(value, 'IPv6'), toIPv6(value); +SELECT toFixedString('::1', 5) as value, cast(value, 'IPv6'), toIPv6(value); +SELECT toFixedString('', 16) as value, cast(value, 'IPv6'); --{serverError 441} +SELECT toFixedString('', 16) as value, toIPv6(value); --{serverError 441} From 36dc7f03a4c074e5caa0acfc60fc7154967b3bc2 Mon Sep 17 00:00:00 2001 From: Maksim Kita Date: Mon, 14 Mar 2022 09:14:41 +0000 Subject: [PATCH 100/132] Fixed tests --- src/Functions/FunctionsConversion.h | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/Functions/FunctionsConversion.h b/src/Functions/FunctionsConversion.h index 47e7ce615ed..f41a461a728 100644 --- a/src/Functions/FunctionsConversion.h +++ b/src/Functions/FunctionsConversion.h @@ -3385,7 +3385,9 @@ private: /// 'requested_result_is_nullable' is true if CAST to Nullable type is requested. WrapperType prepareImpl(const DataTypePtr & from_type, const DataTypePtr & to_type, bool requested_result_is_nullable) const { - if (from_type->equals(*to_type) && to_type->getCustomName() && to_type->getCustomName()->getName() != "IPv6") + bool convert_to_ipv6 = to_type->getCustomName() && to_type->getCustomName()->getName() == "IPv6"; + + if (from_type->equals(*to_type) && !convert_to_ipv6) { if (isUInt8(from_type)) return createUInt8ToUInt8Wrapper(from_type, to_type); From 063917786e846518a847306ed167ef6413efc746 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Mon, 14 Mar 2022 17:29:18 +0000 Subject: [PATCH 101/132] minor fixes --- src/Columns/ColumnObject.cpp | 8 ++++++++ src/Interpreters/getColumnFromBlock.cpp | 3 +-- src/Storages/MergeTree/MergeTreeData.h | 3 ++- src/Storages/StorageDistributed.h | 5 +++-- src/Storages/StorageMemory.h | 3 ++- src/Storages/StorageSnapshot.cpp | 6 ------ 6 files changed, 16 insertions(+), 12 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 3df15d8de3d..a61c252c545 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -676,6 +676,10 @@ void ColumnObject::addSubcolumn(const PathInData & key, MutableColumnPtr && subc if (num_rows == 0) num_rows = new_size; + else if (new_size != num_rows) + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, + "Size of subcolumn {} ({}) is inconsistent with column size ({})", + key.getPath(), new_size, num_rows); } void ColumnObject::addSubcolumn(const PathInData & key, size_t new_size) @@ -686,6 +690,10 @@ void ColumnObject::addSubcolumn(const PathInData & key, size_t new_size) if (num_rows == 0) num_rows = new_size; + else if (new_size != num_rows) + throw Exception(ErrorCodes::SIZES_OF_COLUMNS_DOESNT_MATCH, + "Requiered size of subcolumn {} ({}) is inconsistent with column size ({})", + key.getPath(), new_size, num_rows); } void ColumnObject::addNestedSubcolumn(const PathInData & key, const FieldInfo & field_info, size_t new_size) diff --git a/src/Interpreters/getColumnFromBlock.cpp b/src/Interpreters/getColumnFromBlock.cpp index 159457f45c1..ce6fa2904db 100644 --- a/src/Interpreters/getColumnFromBlock.cpp +++ b/src/Interpreters/getColumnFromBlock.cpp @@ -15,13 +15,12 @@ ColumnPtr tryGetColumnFromBlock(const Block & block, const NameAndTypePair & req if (!elem) return nullptr; - auto subcolumn_name = requested_column.getSubcolumnName(); - DataTypePtr elem_type; ColumnPtr elem_column; if (requested_column.isSubcolumn()) { + auto subcolumn_name = requested_column.getSubcolumnName(); elem_type = elem->type->tryGetSubcolumnType(subcolumn_name); elem_column = elem->type->tryGetSubcolumn(subcolumn_name, elem->column); diff --git a/src/Storages/MergeTree/MergeTreeData.h b/src/Storages/MergeTree/MergeTreeData.h index 21967ed037e..66bf51d0eff 100644 --- a/src/Storages/MergeTree/MergeTreeData.h +++ b/src/Storages/MergeTree/MergeTreeData.h @@ -423,7 +423,8 @@ public: bool mayBenefitFromIndexForIn(const ASTPtr & left_in_operand, ContextPtr, const StorageMetadataPtr & metadata_snapshot) const override; - /// Snapshot for MergeTree fixes the current set of data parts. + /// Snapshot for MergeTree contains the current set of data parts + /// at the moment of the start of query. struct SnapshotData : public StorageSnapshot::Data { DataPartsVector parts; diff --git a/src/Storages/StorageDistributed.h b/src/Storages/StorageDistributed.h index c37ebc90a4d..317463783ee 100644 --- a/src/Storages/StorageDistributed.h +++ b/src/Storages/StorageDistributed.h @@ -61,8 +61,9 @@ public: bool isRemote() const override { return true; } - /// Snapshot for StorageDistributed fixes current descriptions - /// of columns of type Object for each shard. + /// Snapshot for StorageDistributed contains descriptions + /// of columns of type Object for each shard at the moment + /// of the start of query. struct SnapshotData : public StorageSnapshot::Data { ColumnsDescriptionByShardNum objects_by_shard; diff --git a/src/Storages/StorageMemory.h b/src/Storages/StorageMemory.h index c507a3d1819..1c4421e51a6 100644 --- a/src/Storages/StorageMemory.h +++ b/src/Storages/StorageMemory.h @@ -29,7 +29,8 @@ public: size_t getSize() const { return data.get()->size(); } - /// Snapshot for StorageMemory fixes current set of blocks. + /// Snapshot for StorageMemory contains current set of blocks + /// at the moment of the start of query. struct SnapshotData : public StorageSnapshot::Data { std::shared_ptr blocks; diff --git a/src/Storages/StorageSnapshot.cpp b/src/Storages/StorageSnapshot.cpp index b03af8fa4f7..e214afc6a90 100644 --- a/src/Storages/StorageSnapshot.cpp +++ b/src/Storages/StorageSnapshot.cpp @@ -124,13 +124,7 @@ Block StorageSnapshot::getSampleBlockForColumns(const Names & column_names) cons namespace { - -#if !defined(ARCADIA_BUILD) using DenseHashSet = google::dense_hash_set; -#else - using DenseHashSet = google::sparsehash::dense_hash_set; -#endif - } void StorageSnapshot::check(const Names & column_names) const From 36b3aa92e40b33e7b6cd8f4244f0a77ef898c3ba Mon Sep 17 00:00:00 2001 From: Pxl <952130278@qq.com> Date: Tue, 15 Mar 2022 14:52:57 +0800 Subject: [PATCH 102/132] Update numbers_mt.md translate document --- docs/zh/operations/system-tables/numbers_mt.md | 9 ++------- 1 file changed, 2 insertions(+), 7 deletions(-) diff --git a/docs/zh/operations/system-tables/numbers_mt.md b/docs/zh/operations/system-tables/numbers_mt.md index 185bee95171..cf1c96acaab 100644 --- a/docs/zh/operations/system-tables/numbers_mt.md +++ b/docs/zh/operations/system-tables/numbers_mt.md @@ -1,10 +1,5 @@ ---- -machine_translated: true -machine_translated_rev: 5decc73b5dc60054f19087d3690c4eb99446a6c3 ---- +# system.numbers_mt {#system-numbers-mt} -# 系统。numbers_mt {#system-numbers-mt} - -一样的 [系统。数字](../../operations/system-tables/numbers.md) 但读取是并行的。 这些数字可以以任何顺序返回。 +与[system.numbers](../../operations/system-tables/numbers.md)相似，但读取是并行的。 这些数字可以以任何顺序返回。 用于测试。 From 4ac49571d124ba89f47b60a91666d37df38963a0 Mon Sep 17 00:00:00 2001 From: vdimir Date: Tue, 15 Mar 2022 14:37:29 +0000 Subject: [PATCH 103/132] Revert "Fix" This reverts commit 887414296beb8f8593cda08543fc26c51e254942. --- ...etting_input_format_use_lowercase_column_name.sh | 4 ++-- ...tting_input_format_use_lowercase_column_name.orc | Bin ...g_input_format_use_lowercase_column_name.parquet | Bin 3 files changed, 2 insertions(+), 2 deletions(-) rename tests/queries/0_stateless/{02233_data => data_orc}/test_setting_input_format_use_lowercase_column_name.orc (100%) rename tests/queries/0_stateless/{02233_data => data_parquet}/test_setting_input_format_use_lowercase_column_name.parquet (100%) diff --git a/tests/queries/0_stateless/02233_setting_input_format_use_lowercase_column_name.sh b/tests/queries/0_stateless/02233_setting_input_format_use_lowercase_column_name.sh index 9a4f40ca4ee..b946addd01c 100755 --- a/tests/queries/0_stateless/02233_setting_input_format_use_lowercase_column_name.sh +++ b/tests/queries/0_stateless/02233_setting_input_format_use_lowercase_column_name.sh @@ -6,7 +6,7 @@ CUR_DIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) . "$CUR_DIR"/../shell_config.sh echo "Parquet" -DATA_FILE=$CUR_DIR/02233_data/test_setting_input_format_use_lowercase_column_name.parquet +DATA_FILE=$CUR_DIR/data_parquet/test_setting_input_format_use_lowercase_column_name.parquet ${CLICKHOUSE_CLIENT} --query="DROP TABLE IF EXISTS parquet_load" ${CLICKHOUSE_CLIENT} --query="CREATE TABLE parquet_load (id String, score Int32) ENGINE = Memory" cat "$DATA_FILE" | ${CLICKHOUSE_CLIENT} -q "INSERT INTO parquet_load FORMAT Parquet SETTINGS input_format_use_lowercase_column_name=true" @@ -14,7 +14,7 @@ ${CLICKHOUSE_CLIENT} --query="SELECT * FROM parquet_load" ${CLICKHOUSE_CLIENT} --query="drop table parquet_load" echo "ORC" -DATA_FILE=$CUR_DIR/02233_data/test_setting_input_format_use_lowercase_column_name.orc +DATA_FILE=$CUR_DIR/data_orc/test_setting_input_format_use_lowercase_column_name.orc ${CLICKHOUSE_CLIENT} --query="DROP TABLE IF EXISTS orc_load" ${CLICKHOUSE_CLIENT} --query="CREATE TABLE orc_load (id String, score Int32) ENGINE = Memory" cat "$DATA_FILE" | ${CLICKHOUSE_CLIENT} -q "INSERT INTO orc_load FORMAT ORC SETTINGS input_format_use_lowercase_column_name=true" diff --git a/tests/queries/0_stateless/02233_data/test_setting_input_format_use_lowercase_column_name.orc b/tests/queries/0_stateless/data_orc/test_setting_input_format_use_lowercase_column_name.orc similarity index 100% rename from tests/queries/0_stateless/02233_data/test_setting_input_format_use_lowercase_column_name.orc rename to tests/queries/0_stateless/data_orc/test_setting_input_format_use_lowercase_column_name.orc diff --git a/tests/queries/0_stateless/02233_data/test_setting_input_format_use_lowercase_column_name.parquet b/tests/queries/0_stateless/data_parquet/test_setting_input_format_use_lowercase_column_name.parquet similarity index 100% rename from tests/queries/0_stateless/02233_data/test_setting_input_format_use_lowercase_column_name.parquet rename to tests/queries/0_stateless/data_parquet/test_setting_input_format_use_lowercase_column_name.parquet From 6d6c63a47a1c0d37613102835229360f540d1cc2 Mon Sep 17 00:00:00 2001 From: vdimir Date: Tue, 15 Mar 2022 14:05:56 +0000 Subject: [PATCH 104/132] Skip files if no .columns or parquet-reader in 00900_long_parquet_load (cherry picked from commit 120dc30bfdf980fe6017316844df0d52902ec944) --- tests/queries/0_stateless/00900_long_parquet_load.sh | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/tests/queries/0_stateless/00900_long_parquet_load.sh b/tests/queries/0_stateless/00900_long_parquet_load.sh index e47185261fb..8e6ea24edb4 100755 --- a/tests/queries/0_stateless/00900_long_parquet_load.sh +++ b/tests/queries/0_stateless/00900_long_parquet_load.sh @@ -40,11 +40,13 @@ DATA_DIR=$CUR_DIR/data_parquet # Code: 349. DB::Ex---tion: Can not insert NULL data into non-nullable column "phoneNumbers": data for INSERT was parsed from stdin for NAME in $(find "$DATA_DIR"/*.parquet -print0 | xargs -0 -n 1 basename | LC_ALL=C sort); do - echo === Try load data from "$NAME" - JSON=$DATA_DIR/$NAME.json COLUMNS_FILE=$DATA_DIR/$NAME.columns + ([ -z "$PARQUET_READER" ] || [ ! -s "$PARQUET_READER" ]) && [ ! -s "$COLUMNS_FILE" ] && continue + + echo === Try load data from "$NAME" + # If you want change or add .parquet file - rm data_parquet/*.json data_parquet/*.columns [ -n "$PARQUET_READER" ] && [ ! -s "$COLUMNS_FILE" ] && [ ! -s "$JSON" ] && "$PARQUET_READER" --json "$DATA_DIR"/"$NAME" > "$JSON" [ ! -s "$COLUMNS_FILE" ] && "$CUR_DIR"/helpers/00900_parquet_create_table_columns.py "$JSON" > "$COLUMNS_FILE" From 4eb4bc3794357a312fac3e6a9bac9be23c6e4c8d Mon Sep 17 00:00:00 2001 From: vdimir Date: Tue, 15 Mar 2022 14:18:38 +0000 Subject: [PATCH 105/132] Add test_setting_input_format_use_lowercase_column_name.parquet.columns (cherry picked from commit 346810cbe8976ca9dba34dbb3b1f6d00280ad9e2) --- tests/queries/0_stateless/00900_long_parquet_load.reference | 3 +++ ...ting_input_format_use_lowercase_column_name.parquet.columns | 1 + 2 files changed, 4 insertions(+) create mode 100644 tests/queries/0_stateless/data_parquet/test_setting_input_format_use_lowercase_column_name.parquet.columns diff --git a/tests/queries/0_stateless/00900_long_parquet_load.reference b/tests/queries/0_stateless/00900_long_parquet_load.reference index 89da3c6fa43..6ecff505b2e 100644 --- a/tests/queries/0_stateless/00900_long_parquet_load.reference +++ b/tests/queries/0_stateless/00900_long_parquet_load.reference @@ -339,6 +339,9 @@ Code: 33. DB::ParsingEx---tion: Error while reading Parquet data: IOError: Unkno (NULL) === Try load data from single_nan.parquet \N +=== Try load data from test_setting_input_format_use_lowercase_column_name.parquet +123 1 +456 2 === Try load data from userdata1.parquet 1454486129 1 Amanda Jordan ajordan0@com.com Female 1.197.201.2 6759521864920116 Indonesia 3/8/1971 49756.53 Internal Auditor 1E+02 1454519043 2 Albert Freeman afreeman1@is.gd Male 218.111.175.34 Canada 1/16/1968 150280.17 Accountant IV diff --git a/tests/queries/0_stateless/data_parquet/test_setting_input_format_use_lowercase_column_name.parquet.columns b/tests/queries/0_stateless/data_parquet/test_setting_input_format_use_lowercase_column_name.parquet.columns new file mode 100644 index 00000000000..e25da8f923d --- /dev/null +++ b/tests/queries/0_stateless/data_parquet/test_setting_input_format_use_lowercase_column_name.parquet.columns @@ -0,0 +1 @@ +`Id` Nullable(String), `Score` Nullable(Int32) From 558f3e965052a9508f7f0c72fe8807de77c27ee0 Mon Sep 17 00:00:00 2001 From: LAL2211 Date: Tue, 15 Mar 2022 11:34:49 -0400 Subject: [PATCH 106/132] Modified python packages --- docs/tools/requirements.txt | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/docs/tools/requirements.txt b/docs/tools/requirements.txt index 4e0789b5d24..cbc4947222c 100644 --- a/docs/tools/requirements.txt +++ b/docs/tools/requirements.txt @@ -1,4 +1,4 @@ -Babel==2.8.0 +Babel==2.9.1 backports-abc==0.5 backports.functools-lru-cache==1.6.1 beautifulsoup4==4.9.1 @@ -10,22 +10,22 @@ cssmin==0.2.0 future==0.18.2 htmlmin==0.1.12 idna==2.10 -Jinja2>=2.11.3 +Jinja2>=3.0.3 jinja2-highlight==0.6.1 jsmin==3.0.0 -livereload==2.6.2 +livereload==2.6.3 Markdown==3.3.2 -MarkupSafe==1.1.1 +MarkupSafe==2.1.0 mkdocs==1.1.2 mkdocs-htmlproofer-plugin==0.0.3 mkdocs-macros-plugin==0.4.20 -nltk==3.5 +nltk==3.7 nose==1.3.7 protobuf==3.14.0 numpy==1.21.2 pymdown-extensions==8.0 python-slugify==4.0.1 -PyYAML==5.4.1 +PyYAML==6.0 repackage==0.7.3 requests==2.25.1 singledispatch==3.4.0.3 @@ -34,5 +34,5 @@ soupsieve==2.0.1 termcolor==1.1.0 tornado==6.1 Unidecode==1.1.1 -urllib3>=1.26.5 -Pygments>=2.7.4 +urllib3>=1.26.8 +Pygments>=2.11.2 From fa4508bcb9358317792af874d8f646e893031cc9 Mon Sep 17 00:00:00 2001 From: Maksim Kita Date: Tue, 15 Mar 2022 15:35:25 +0000 Subject: [PATCH 107/132] Fixed tests --- src/Functions/FunctionsCodingIP.h | 2 +- tests/queries/0_stateless/00076_ip_coding_functions.sql | 2 ++ .../02007_ipv4_and_ipv6_to_and_from_string.reference | 1 + .../0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql | 4 +++- 4 files changed, 7 insertions(+), 2 deletions(-) diff --git a/src/Functions/FunctionsCodingIP.h b/src/Functions/FunctionsCodingIP.h index 6d3a64fb2d1..1bc3fea84bb 100644 --- a/src/Functions/FunctionsCodingIP.h +++ b/src/Functions/FunctionsCodingIP.h @@ -55,7 +55,7 @@ namespace detail size_t src_offset = 0; char src_ipv4_buf[sizeof("::ffff:") + IPV4_MAX_TEXT_LENGTH + 1] = "::ffff:"; - /// ColumnFixedString contains not null terminated strings. But functions parseIPv6, parseIPv4 expect null teminated string. + /// ColumnFixedString contains not null terminated strings. But functions parseIPv6, parseIPv4 expect null terminated string. std::string fixed_string_buffer; if constexpr (std::is_same_v) diff --git a/tests/queries/0_stateless/00076_ip_coding_functions.sql b/tests/queries/0_stateless/00076_ip_coding_functions.sql index 659267c61ed..f693b336e57 100644 --- a/tests/queries/0_stateless/00076_ip_coding_functions.sql +++ b/tests/queries/0_stateless/00076_ip_coding_functions.sql @@ -1,3 +1,5 @@ +SET cast_ipv4_ipv6_default_on_conversion_error = 1; + select IPv4StringToNum('') == 0; select IPv4StringToNum(materialize('')) == 0; select IPv4StringToNum('not an ip string') == 0; diff --git a/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.reference b/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.reference index 8a4df1605fb..8da82a0726f 100644 --- a/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.reference +++ b/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.reference @@ -4,3 +4,4 @@ 2001:db8:0:85a3::ac1f:8001 String 0.0.0.0 IPv4 :: IPv6 +::ffff:1.1.1.1 IPv6 diff --git a/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql b/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql index 2fcc20b9811..41c62974117 100644 --- a/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql +++ b/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql @@ -1,3 +1,5 @@ +SET cast_ipv4_ipv6_default_on_conversion_error = 1; + SELECT CAST('127.0.0.1' as IPv4) as v, toTypeName(v); SELECT CAST(toIPv4('127.0.0.1') as String) as v, toTypeName(v); @@ -10,4 +12,4 @@ SELECT toIPv6('hello') as v, toTypeName(v); SELECT CAST('hello' as IPv4) as v, toTypeName(v); -- { serverError CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING } SELECT CAST('hello' as IPv6) as v, toTypeName(v); -- { serverError CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING } -SELECT CAST('1.1.1.1' as IPv6) as v, toTypeName(v); -- { serverError CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING } +SELECT CAST('1.1.1.1' as IPv6) as v, toTypeName(v); From bad6bbf3e63b15c6fabb2a81f14b5028b74d3874 Mon Sep 17 00:00:00 2001 From: LAL2211 Date: Tue, 15 Mar 2022 11:48:49 -0400 Subject: [PATCH 108/132] Modified python packages --- docs/tools/requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/tools/requirements.txt b/docs/tools/requirements.txt index cbc4947222c..8bf1a5f477c 100644 --- a/docs/tools/requirements.txt +++ b/docs/tools/requirements.txt @@ -36,3 +36,4 @@ tornado==6.1 Unidecode==1.1.1 urllib3>=1.26.8 Pygments>=2.11.2 + From 45ce2b5354f945cd80e4b79feff2434a5e40bf6b Mon Sep 17 00:00:00 2001 From: LAL2211 Date: Tue, 15 Mar 2022 11:53:14 -0400 Subject: [PATCH 109/132] Modified python packages --- docs/tools/requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/docs/tools/requirements.txt b/docs/tools/requirements.txt index 8bf1a5f477c..cbc4947222c 100644 --- a/docs/tools/requirements.txt +++ b/docs/tools/requirements.txt @@ -36,4 +36,3 @@ tornado==6.1 Unidecode==1.1.1 urllib3>=1.26.8 Pygments>=2.11.2 - From ff90dbbb5cd8e115ea4e8c875793680ab328f05e Mon Sep 17 00:00:00 2001 From: LAL2211 Date: Tue, 15 Mar 2022 12:01:30 -0400 Subject: [PATCH 110/132] Modified python packages --- docs/tools/requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/docs/tools/requirements.txt b/docs/tools/requirements.txt index cbc4947222c..8bf1a5f477c 100644 --- a/docs/tools/requirements.txt +++ b/docs/tools/requirements.txt @@ -36,3 +36,4 @@ tornado==6.1 Unidecode==1.1.1 urllib3>=1.26.8 Pygments>=2.11.2 + From 225368aa2c94d4a532397df0ce52d5442cbbcb0e Mon Sep 17 00:00:00 2001 From: Maksim Kita Date: Tue, 15 Mar 2022 18:34:23 +0000 Subject: [PATCH 111/132] Fixed tests --- tests/queries/0_stateless/00938_ipv6_cidr_range.sql | 2 +- .../0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql | 6 ++---- 2 files changed, 3 insertions(+), 5 deletions(-) diff --git a/tests/queries/0_stateless/00938_ipv6_cidr_range.sql b/tests/queries/0_stateless/00938_ipv6_cidr_range.sql index 3fa4c7c5d3f..1ceefa8cfb3 100644 --- a/tests/queries/0_stateless/00938_ipv6_cidr_range.sql +++ b/tests/queries/0_stateless/00938_ipv6_cidr_range.sql @@ -9,7 +9,7 @@ SELECT 'tests'; DROP TABLE IF EXISTS ipv6_range; CREATE TABLE ipv6_range(ip IPv6, cidr UInt8) ENGINE = Memory; -INSERT INTO ipv6_range (ip, cidr) VALUES (IPv6StringToNum('2001:0db8:0000:85a3:0000:0000:ac1f:8001'), 0), (IPv6StringToNum('2001:0db8:0000:85a3:ffff:ffff:ffff:ffff'), 32), (IPv6StringToNum('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff'), 16), (IPv6StringToNum('2001:df8:0:85a3::ac1f:8001'), 32), (IPv6StringToNum('2001:0db8:85a3:85a3:0000:0000:ac1f:8001'), 16), (IPv6StringToNum('0000:0000:0000:0000:0000:0000:0000:0000'), 8), (IPv6StringToNum('ffff:0000:0000:0000:0000:0000:0000:0000'), 4); +INSERT INTO ipv6_range (ip, cidr) VALUES ('2001:0db8:0000:85a3:0000:0000:ac1f:8001', 0), ('2001:0db8:0000:85a3:ffff:ffff:ffff:ffff', 32), ('ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff', 16), ('2001:df8:0:85a3::ac1f:8001', 32), ('2001:0db8:85a3:85a3:0000:0000:ac1f:8001', 16), ('0000:0000:0000:0000:0000:0000:0000:0000', 8), ('ffff:0000:0000:0000:0000:0000:0000:0000', 4); WITH IPv6CIDRToRange(IPv6StringToNum('2001:0db8:0000:85a3:0000:0000:ac1f:8001'), 32) as ip_range SELECT COUNT(*) FROM ipv6_range WHERE ip BETWEEN tupleElement(ip_range, 1) AND tupleElement(ip_range, 2); diff --git a/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql b/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql index 41c62974117..b303d580e72 100644 --- a/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql +++ b/tests/queries/0_stateless/02007_ipv4_and_ipv6_to_and_from_string.sql @@ -1,13 +1,11 @@ -SET cast_ipv4_ipv6_default_on_conversion_error = 1; - SELECT CAST('127.0.0.1' as IPv4) as v, toTypeName(v); SELECT CAST(toIPv4('127.0.0.1') as String) as v, toTypeName(v); SELECT CAST('2001:0db8:0000:85a3:0000:0000:ac1f:8001' as IPv6) as v, toTypeName(v); SELECT CAST(toIPv6('2001:0db8:0000:85a3:0000:0000:ac1f:8001') as String) as v, toTypeName(v); -SELECT toIPv4('hello') as v, toTypeName(v); -SELECT toIPv6('hello') as v, toTypeName(v); +SELECT toIPv4OrDefault('hello') as v, toTypeName(v); +SELECT toIPv6OrDefault('hello') as v, toTypeName(v); SELECT CAST('hello' as IPv4) as v, toTypeName(v); -- { serverError CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING } SELECT CAST('hello' as IPv6) as v, toTypeName(v); -- { serverError CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING } From 3cba1177ee945b110330709d98e509ce21d13c7e Mon Sep 17 00:00:00 2001 From: zhangyuli1 Date: Wed, 16 Mar 2022 17:40:49 +0800 Subject: [PATCH 112/132] remove wchc from four_letter_word_white_list --- docs/en/operations/clickhouse-keeper.md | 4 ++-- src/Coordination/CoordinationSettings.cpp | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/docs/en/operations/clickhouse-keeper.md b/docs/en/operations/clickhouse-keeper.md index 35ec5d858f5..04b29b7cb30 100644 --- a/docs/en/operations/clickhouse-keeper.md +++ b/docs/en/operations/clickhouse-keeper.md @@ -55,7 +55,7 @@ Internal coordination settings are located in `..` section and contain servers description. @@ -121,7 +121,7 @@ clickhouse keeper --config /etc/your_path_to_config/config.xml ClickHouse Keeper also provides 4lw commands which are almost the same with Zookeeper. Each command is composed of four letters such as `mntr`, `stat` etc. There are some more interesting commands: `stat` gives some general information about the server and connected clients, while `srvr` and `cons` give extended details on server and connections respectively. -The 4lw commands has a white list configuration `four_letter_word_white_list` which has default value "conf,cons,crst,envi,ruok,srst,srvr,stat,wchc,wchs,dirs,mntr,isro". +The 4lw commands has a white list configuration `four_letter_word_white_list` which has default value "conf,cons,crst,envi,ruok,srst,srvr,stat,wchs,dirs,mntr,isro". You can issue the commands to ClickHouse Keeper via telnet or nc, at the client port. diff --git a/src/Coordination/CoordinationSettings.cpp b/src/Coordination/CoordinationSettings.cpp index b93420133fa..36245336de7 100644 --- a/src/Coordination/CoordinationSettings.cpp +++ b/src/Coordination/CoordinationSettings.cpp @@ -37,7 +37,7 @@ void CoordinationSettings::loadFromConfig(const String & config_elem, const Poco } -const String KeeperConfigurationAndSettings::DEFAULT_FOUR_LETTER_WORD_CMD = "conf,cons,crst,envi,ruok,srst,srvr,stat,wchc,wchs,dirs,mntr,isro"; +const String KeeperConfigurationAndSettings::DEFAULT_FOUR_LETTER_WORD_CMD = "conf,cons,crst,envi,ruok,srst,srvr,stat,wchs,dirs,mntr,isro"; KeeperConfigurationAndSettings::KeeperConfigurationAndSettings() : server_id(NOT_EXIST) From d130e51f07b0f9c8dc7d6d3c6925f8446467f3c3 Mon Sep 17 00:00:00 2001 From: Maksim Kita Date: Wed, 16 Mar 2022 12:47:17 +0000 Subject: [PATCH 113/132] Fixed tests --- tests/queries/0_stateless/01018_ip_dictionary_long.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/queries/0_stateless/01018_ip_dictionary_long.sql b/tests/queries/0_stateless/01018_ip_dictionary_long.sql index 7d9dfeb1bae..647c36429cc 100644 --- a/tests/queries/0_stateless/01018_ip_dictionary_long.sql +++ b/tests/queries/0_stateless/01018_ip_dictionary_long.sql @@ -44,7 +44,7 @@ LAYOUT(IP_TRIE()) LIFETIME(MIN 10 MAX 100); -- fuzzer -SELECT '127.0.0.0/24' = dictGetString('database_for_dict.dict_ipv4_trie', 'prefixprefixprefixprefix', tuple(IPv4StringToNum('127.0.0.0127.0.0.0'))); -- { serverError 36 } +SELECT '127.0.0.0/24' = dictGetString('database_for_dict.dict_ipv4_trie', 'prefixprefixprefixprefix', tuple(IPv4StringToNumOrDefault('127.0.0.0127.0.0.0'))); -- { serverError 36 } SELECT 0 == dictGetUInt32('database_for_dict.dict_ipv4_trie', 'asn', tuple(IPv4StringToNum('0.0.0.0'))); SELECT 1 == dictGetUInt32('database_for_dict.dict_ipv4_trie', 'asn', tuple(IPv4StringToNum('128.0.0.0'))); From 2ced42ed4166035011be6e815c99590597425f76 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 16 Mar 2022 16:51:23 +0000 Subject: [PATCH 114/132] add experimental settings for Object type --- src/Core/Settings.h | 1 + src/Formats/registerFormats.cpp | 2 -- src/Interpreters/InterpreterCreateQuery.cpp | 26 ++++++++++++++++++- .../Impl/JSONAsStringRowInputFormat.cpp | 5 ---- .../queries/0_stateless/01825_type_json_1.sql | 4 +++ .../queries/0_stateless/01825_type_json_2.sql | 2 ++ .../0_stateless/01825_type_json_3.sql.j2 | 2 ++ .../queries/0_stateless/01825_type_json_4.sh | 2 +- .../queries/0_stateless/01825_type_json_5.sql | 2 ++ .../queries/0_stateless/01825_type_json_6.sh | 2 +- .../queries/0_stateless/01825_type_json_7.sh | 2 +- .../queries/0_stateless/01825_type_json_8.sh | 2 +- .../0_stateless/01825_type_json_btc.sh | 4 +-- .../0_stateless/01825_type_json_describe.sql | 3 +++ .../01825_type_json_distributed.sql | 2 ++ .../0_stateless/01825_type_json_field.sql | 2 ++ .../0_stateless/01825_type_json_ghdata.sh | 4 +-- .../01825_type_json_insert_select.sql | 2 ++ .../0_stateless/01825_type_json_nbagames.sh | 4 +-- .../0_stateless/01825_type_json_nullable.sql | 2 ++ .../01825_type_json_schema_race_long.sh | 2 +- 21 files changed, 58 insertions(+), 19 deletions(-) diff --git a/src/Core/Settings.h b/src/Core/Settings.h index cdb54e55b10..3ff61379e39 100644 --- a/src/Core/Settings.h +++ b/src/Core/Settings.h @@ -567,6 +567,7 @@ class IColumn; /** Experimental functions */ \ M(Bool, allow_experimental_funnel_functions, false, "Enable experimental functions for funnel analysis.", 0) \ M(Bool, allow_experimental_nlp_functions, false, "Enable experimental functions for natural language processing.", 0) \ + M(Bool, allow_experimental_object_type, false, "Allow Object and JSON data types", 0) \ M(String, insert_deduplication_token, "", "If not empty, used for duplicate detection instead of data digest", 0) \ // End of COMMON_SETTINGS // Please add settings related to formats into the FORMAT_FACTORY_SETTINGS and move obsolete settings to OBSOLETE_SETTINGS. diff --git a/src/Formats/registerFormats.cpp b/src/Formats/registerFormats.cpp index 15da5355041..78851e5ebb0 100644 --- a/src/Formats/registerFormats.cpp +++ b/src/Formats/registerFormats.cpp @@ -13,7 +13,6 @@ void registerFileSegmentationEngineCSV(FormatFactory & factory); void registerFileSegmentationEngineJSONEachRow(FormatFactory & factory); void registerFileSegmentationEngineRegexp(FormatFactory & factory); void registerFileSegmentationEngineJSONAsString(FormatFactory & factory); -void registerFileSegmentationEngineJSONAsObject(FormatFactory & factory); void registerFileSegmentationEngineJSONCompactEachRow(FormatFactory & factory); /// Formats for both input/output. @@ -121,7 +120,6 @@ void registerFormats() registerFileSegmentationEngineJSONEachRow(factory); registerFileSegmentationEngineRegexp(factory); registerFileSegmentationEngineJSONAsString(factory); - registerFileSegmentationEngineJSONAsObject(factory); registerFileSegmentationEngineJSONCompactEachRow(factory); registerInputFormatNative(factory); diff --git a/src/Interpreters/InterpreterCreateQuery.cpp b/src/Interpreters/InterpreterCreateQuery.cpp index ba4063b4c38..f7dbd1c8b65 100644 --- a/src/Interpreters/InterpreterCreateQuery.cpp +++ b/src/Interpreters/InterpreterCreateQuery.cpp @@ -53,6 +53,7 @@ #include #include #include +#include #include #include @@ -733,11 +734,26 @@ void InterpreterCreateQuery::validateTableStructure(const ASTCreateQuery & creat { String message = "Cannot create table with column '" + name_and_type_pair.name + "' which type is '" + type + "' because experimental geo types are not allowed. " - + "Set setting allow_experimental_geo_types = 1 in order to allow it."; + + "Set setting allow_experimental_geo_types = 1 in order to allow it"; throw Exception(message, ErrorCodes::ILLEGAL_COLUMN); } } } + + if (!create.attach && !settings.allow_experimental_object_type) + { + for (const auto & [name, type] : properties.columns.getAllPhysical()) + { + if (isObject(type)) + { + throw Exception(ErrorCodes::ILLEGAL_COLUMN, + "Cannot create table with column '{}' which type is '{}' " + "because experimental Object type is not allowed. " + "Set setting allow_experimental_object_type = 1 in order to allow it", + name, type->getName()); + } + } + } } String InterpreterCreateQuery::getTableEngineName(DefaultTableEngine default_table_engine) @@ -1230,6 +1246,14 @@ bool InterpreterCreateQuery::doCreateTable(ASTCreateQuery & create, /// we can safely destroy the object without a call to "shutdown", because there is guarantee /// that no background threads/similar resources remain after exception from "startup". + if (!res->supportsDynamicSubcolumns() && hasObjectColumns(res->getInMemoryMetadataPtr()->getColumns())) + { + throw Exception(ErrorCodes::ILLEGAL_COLUMN, + "Cannot create table with column of type Object, " + "because storage {} doesn't support dynamic subcolumns", + res->getName()); + } + res->startup(); return true; } diff --git a/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.cpp b/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.cpp index 6602d658a72..914ec27fc46 100644 --- a/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.cpp +++ b/src/Processors/Formats/Impl/JSONAsStringRowInputFormat.cpp @@ -240,11 +240,6 @@ void registerInputFormatJSONAsObject(FormatFactory & factory) }); } -void registerFileSegmentationEngineJSONAsObject(FormatFactory & factory) -{ - factory.registerFileSegmentationEngine("JSONAsObject", &fileSegmentationEngineJSONEachRow); -} - void registerNonTrivialPrefixAndSuffixCheckerJSONAsObject(FormatFactory & factory) { factory.registerNonTrivialPrefixAndSuffixChecker("JSONAsObject", nonTrivialPrefixAndSuffixCheckerJSONEachRowImpl); diff --git a/tests/queries/0_stateless/01825_type_json_1.sql b/tests/queries/0_stateless/01825_type_json_1.sql index c2110f35c33..e74faf2d4c7 100644 --- a/tests/queries/0_stateless/01825_type_json_1.sql +++ b/tests/queries/0_stateless/01825_type_json_1.sql @@ -1,5 +1,7 @@ -- Tags: no-fasttest +SET allow_experimental_object_type = 1; + DROP TABLE IF EXISTS t_json; CREATE TABLE t_json(id UInt64, data Object('JSON')) @@ -79,3 +81,5 @@ WHERE table = 't_json' AND database = currentDatabase() AND active AND column = ORDER BY name; DROP TABLE IF EXISTS t_json; + +CREATE TABLE t_json(id UInt64, data Object('JSON')) ENGINE = Log; -- { serverError 44 } diff --git a/tests/queries/0_stateless/01825_type_json_2.sql b/tests/queries/0_stateless/01825_type_json_2.sql index cf5a74ad1e8..d2d26ce4106 100644 --- a/tests/queries/0_stateless/01825_type_json_2.sql +++ b/tests/queries/0_stateless/01825_type_json_2.sql @@ -1,5 +1,7 @@ -- Tags: no-fasttest +SET allow_experimental_object_type = 1; + DROP TABLE IF EXISTS t_json_2; CREATE TABLE t_json_2(id UInt64, data Object('JSON')) diff --git a/tests/queries/0_stateless/01825_type_json_3.sql.j2 b/tests/queries/0_stateless/01825_type_json_3.sql.j2 index 66c74bd17a0..62d86c3efd4 100644 --- a/tests/queries/0_stateless/01825_type_json_3.sql.j2 +++ b/tests/queries/0_stateless/01825_type_json_3.sql.j2 @@ -2,6 +2,8 @@ {% for engine in ["ReplicatedMergeTree('/clickhouse/tables/{database}/test_01825_3/t_json_3', 'r1') ORDER BY tuple()", "Memory"] -%} +SET allow_experimental_object_type = 1; + DROP TABLE IF EXISTS t_json_3; CREATE TABLE t_json_3(id UInt64, data JSON) diff --git a/tests/queries/0_stateless/01825_type_json_4.sh b/tests/queries/0_stateless/01825_type_json_4.sh index d25a0f3a7dd..4d81e9516c9 100755 --- a/tests/queries/0_stateless/01825_type_json_4.sh +++ b/tests/queries/0_stateless/01825_type_json_4.sh @@ -8,7 +8,7 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) $CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_4" $CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_4(id UInt64, data JSON) \ -ENGINE = MergeTree ORDER BY tuple()" +ENGINE = MergeTree ORDER BY tuple()" --allow_experimental_object_type 1 echo '{"id": 1, "data": {"k1": "v1"}}, {"id": 2, "data": {"k1": [1, 2]}}' \ | $CLICKHOUSE_CLIENT -q "INSERT INTO t_json_4 FORMAT JSONEachRow" 2>&1 | grep -o -m1 "Code: 645" diff --git a/tests/queries/0_stateless/01825_type_json_5.sql b/tests/queries/0_stateless/01825_type_json_5.sql index eeea03432b4..b939a960e32 100644 --- a/tests/queries/0_stateless/01825_type_json_5.sql +++ b/tests/queries/0_stateless/01825_type_json_5.sql @@ -1,5 +1,7 @@ -- Tags: no-fasttest +SET allow_experimental_object_type = 1; + SELECT '{"a": {"b": 1, "c": 2}}'::JSON AS s; SELECT '{"a": {"b": 1, "c": 2}}'::JSON AS s format JSONEachRow; diff --git a/tests/queries/0_stateless/01825_type_json_6.sh b/tests/queries/0_stateless/01825_type_json_6.sh index b992023fee0..8bbb1abee4a 100755 --- a/tests/queries/0_stateless/01825_type_json_6.sh +++ b/tests/queries/0_stateless/01825_type_json_6.sh @@ -7,7 +7,7 @@ CURDIR=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd) $CLICKHOUSE_CLIENT -q "DROP TABLE IF EXISTS t_json_6;" -$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_6 (data JSON) ENGINE = MergeTree ORDER BY tuple();" +$CLICKHOUSE_CLIENT -q "CREATE TABLE t_json_6 (data JSON) ENGINE = MergeTree ORDER BY tuple()" --allow_experimental_object_type 1 cat < Date: Wed, 16 Mar 2022 19:27:17 +0100 Subject: [PATCH 115/132] Generated changelog for master (temporary) --- CHANGELOG.md | 138 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 138 insertions(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 5bbadb2115d..27b680d07b2 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,3 +1,141 @@ +### ClickHouse release master FIXME as compared to v22.2.3.5-stable + +#### Backward Incompatible Change + +* Make arrayCompact behave as other higher-order functions: perform compaction not of lambda function results but on original array. If you using nontrivial lambda functions in arrayCompact you may restore old behaviour by wrapping arrayCompact arguments into arrayMap. Closes [#34010](https://github.com/ClickHouse/ClickHouse/issues/34010) [#18535](https://github.com/ClickHouse/ClickHouse/issues/18535) [#14778](https://github.com/ClickHouse/ClickHouse/issues/14778). [#34795](https://github.com/ClickHouse/ClickHouse/pull/34795) ([Alexandre Snarskii](https://github.com/snar)). +* Fix the bug that the toDatetime function overflows. When the date string is very large, it will be converted to 1970. [#32898](https://github.com/ClickHouse/ClickHouse/pull/32898) ([HaiBo Li](https://github.com/marising)). + +#### New Feature + +* Add `database_replicated_allow_only_replicated_engine` setting. When enabled, it only allowed to create `Replicated` tables in `Replicated` database. [#35214](https://github.com/ClickHouse/ClickHouse/pull/35214) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). +* ``` sql ) explain ast graph = 1 select * from system.parts;. [#35173](https://github.com/ClickHouse/ClickHouse/pull/35173) ([李扬](https://github.com/taiyang-li)). +* Changed the Play UI to select a theme by the following priority: * 'theme' GET parameter * 'theme' in localStorage * According to OS preference (didn't work before). [#35068](https://github.com/ClickHouse/ClickHouse/pull/35068) ([peledni](https://github.com/peledni)). +* Added date_time_input_format = 'best_effort_us'. Closes [#34799](https://github.com/ClickHouse/ClickHouse/issues/34799). [#34982](https://github.com/ClickHouse/ClickHouse/pull/34982) ([WenYao](https://github.com/Cai-Yao)). +* - When use clickhouse-client logining, If user and password is not specified in command line or configuration file, get them from `CLICKHOUSE_USER` and `CLICKHOUSE_PASSWORD` environment variables. Close [#34538](https://github.com/ClickHouse/ClickHouse/issues/34538). [#34947](https://github.com/ClickHouse/ClickHouse/pull/34947) ([DR](https://github.com/freedomDR)). +* Add new table function `hive`, usage as follow ``` hive('', '', '', '', '') ``` for example ``` SELECT * FROM hive('thrift://hivetest:9083', 'test', 'demo', '`id` Nullable(String), `score` Nullable(Int32), `day` Nullable(String)', 'day') ```. [#34946](https://github.com/ClickHouse/ClickHouse/pull/34946) ([lgbo](https://github.com/lgbo-ustc)). +* A new settings called is added in server configuration which on/off insecure AUTH_TYPE plaintext-password and no_password. By default the property is set to true which means authType Plaintext_password & NO_password is allowed. [#34738](https://github.com/ClickHouse/ClickHouse/pull/34738) ([Heena Bansal](https://github.com/HeenaBansal2009)). +* Support schema inference for inserting into table functions file/hdfs/s3/url. [#34732](https://github.com/ClickHouse/ClickHouse/pull/34732) ([Kruglov Pavel](https://github.com/Avogar)). +* Add cpu/mem metric for clickhouse-local. Close [#34545](https://github.com/ClickHouse/ClickHouse/issues/34545). [#34605](https://github.com/ClickHouse/ClickHouse/pull/34605) ([李扬](https://github.com/taiyang-li)). +* Implement DateTime64 transform from and to arrow column, which closes [#8280](https://github.com/ClickHouse/ClickHouse/issues/8280) and closes [#28574](https://github.com/ClickHouse/ClickHouse/issues/28574). [#34561](https://github.com/ClickHouse/ClickHouse/pull/34561) ([李扬](https://github.com/taiyang-li)). +* - Add startsWith & endsWith function for arrays, closes [#33982](https://github.com/ClickHouse/ClickHouse/issues/33982). [#34368](https://github.com/ClickHouse/ClickHouse/pull/34368) ([usurai](https://github.com/usurai)). +* Add local cache for disk s3. Closes [#28961](https://github.com/ClickHouse/ClickHouse/issues/28961). [#33717](https://github.com/ClickHouse/ClickHouse/pull/33717) ([Kseniia Sumarokova](https://github.com/kssenii)). +* related to issue: [#30715](https://github.com/ClickHouse/ClickHouse/issues/30715). Add three functions for map data type: 1. mapReplace(map1, map2) - replaces values for keys in map1 with the values of the corresponding keys in map2; adds keys from map2 that don't exist in map1. 2. mapFilter 3. mapMap mapFilter and mapMap are higher order functions , accept two arguments, first argument is a lambda function with k, v pair , the second argument is a map type column. [#33698](https://github.com/ClickHouse/ClickHouse/pull/33698) ([hexiaoting](https://github.com/hexiaoting)). +* Support authentication of users connected via SSL by their X.509 certificate. [#31484](https://github.com/ClickHouse/ClickHouse/pull/31484) ([eungenue](https://github.com/eungenue)). + +#### Performance Improvement + +* Less lock on connection using atomic stat. Notice that it is an approximate stat. [#35010](https://github.com/ClickHouse/ClickHouse/pull/35010) ([zhanglistar](https://github.com/zhanglistar)). +* Improve the performance of the `ANY` aggregation function by acting over batches. [#34760](https://github.com/ClickHouse/ClickHouse/pull/34760) ([Raúl Marín](https://github.com/Algunenano)). +* MergeTree improve insert performance replacing std::stable_sort with pdqsort. [#34750](https://github.com/ClickHouse/ClickHouse/pull/34750) ([Maksim Kita](https://github.com/kitaisreal)). +* Don't hold the latest snapshot in memory, instead, reading the snapshot if needed, sequence reading is fast to 200+MBps even on HDD using mmap system call. Writing snapshot data directly to disk using compression method without holding original data and compressed data in memory. [#34584](https://github.com/ClickHouse/ClickHouse/pull/34584) ([zhanglistar](https://github.com/zhanglistar)). +* Compaction of log store in Nuraft need acquire an inner lock which also used in normal commit process, so we delete useless logs in `compact` method of Changelog class in a background thread. See details on: https://github.com/ClickHouse-Extras/NuRaft/blob/1707a7572aa66ec5d0a2dbe2bf5effa3352e6b2d/src/handle_commit.cxx#L560. [#34534](https://github.com/ClickHouse/ClickHouse/pull/34534) ([zhanglistar](https://github.com/zhanglistar)). +* Calling std::distance on large list will decrease performance, use a version in Node to substitute with more memory 80MB/1000w Nodes. The logic is: Every node is list has a version with type size_t, setting in insert or insertOrReplace method using the class member variable current_version. The version is only increase at enableSnapshot method. When doing a snapshot, call snapshotSizeWithVersion to get snapshot size and version(snapshot_up_to_version). When traversing the list, if node version is less then or equal to snapshot_up_to_version, then protects it from deleting if node version is bigger than snapshot_up_to_version, we can do anything to it. [#34486](https://github.com/ClickHouse/ClickHouse/pull/34486) ([zhanglistar](https://github.com/zhanglistar)). + +#### Improvement + +* Reload `remote_url_allow_hosts` after config update. [#35294](https://github.com/ClickHouse/ClickHouse/pull/35294) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). +* Return const for function getMacro if not in distributed query. Close [#34727](https://github.com/ClickHouse/ClickHouse/issues/34727). [#35289](https://github.com/ClickHouse/ClickHouse/pull/35289) ([李扬](https://github.com/taiyang-li)). +* Support test mode for clickhouse-local. [#35264](https://github.com/ClickHouse/ClickHouse/pull/35264) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Sometimes it is not enough for us to distinguish queries hierachy only by is_initial_query in system.query_log and system.processes. So distributed_depth is needed. [#35207](https://github.com/ClickHouse/ClickHouse/pull/35207) ([李扬](https://github.com/taiyang-li)). +* Currently,Clickhouse validates hosts defined under for URL and Remote Table functions. This PR extends the RemoteHostFilter to Mysql and PostgreSQL table functions. [#35191](https://github.com/ClickHouse/ClickHouse/pull/35191) ([Heena Bansal](https://github.com/HeenaBansal2009)). +* Added disk_name to system.part_log. [#35178](https://github.com/ClickHouse/ClickHouse/pull/35178) ([Artyom Yurkov](https://github.com/Varinara)). +* Do not retry non-rertiable errors. Closes [#35161](https://github.com/ClickHouse/ClickHouse/issues/35161). [#35172](https://github.com/ClickHouse/ClickHouse/pull/35172) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Add setting to lower column case when reading parquet/ORC file. [#35145](https://github.com/ClickHouse/ClickHouse/pull/35145) ([shuchaome](https://github.com/shuchaome)). +* Support `view()` for `parallel_distributed_insert_select`. [#35132](https://github.com/ClickHouse/ClickHouse/pull/35132) ([Azat Khuzhin](https://github.com/azat)). +* Avoid possible `MEMORY_LIMIT_EXCEEDED` during `INSERT` into `Buffer` with `AggregateFunction`. [#35072](https://github.com/ClickHouse/ClickHouse/pull/35072) ([Azat Khuzhin](https://github.com/azat)). +* Avoid division by zero in Query Profiler if Linux kernel has a bug. Closes [#34787](https://github.com/ClickHouse/ClickHouse/issues/34787). [#35032](https://github.com/ClickHouse/ClickHouse/pull/35032) ([Alexey Milovidov](https://github.com/alexey-milovidov)). +* Functions `dictGetHierarchy`, `dictIsIn`, `dictGetChildren`, `dictGetDescendants` support implicit key cast and constant arguments. Closes [#34970](https://github.com/ClickHouse/ClickHouse/issues/34970). [#35027](https://github.com/ClickHouse/ClickHouse/pull/35027) ([Maksim Kita](https://github.com/kitaisreal)). +* Add more sanity checks for keeper configuration: now mixing of localhost and non-local servers is not allowed, also add checks for same value of internal raft port and keeper client port. [#35004](https://github.com/ClickHouse/ClickHouse/pull/35004) ([alesapin](https://github.com/alesapin)). +* For random access readbuffer in hive, the first time to read the readbuffer would use the original readbuffer instead of local file. When we read a parquet/orc format file, the readbuffer seeks to the end of the file, which will be blocked until the local file finishes download, and make the whold process slow. [#34957](https://github.com/ClickHouse/ClickHouse/pull/34957) ([lgbo](https://github.com/lgbo-ustc)). +* remove unnecessary columns for reading parquet/orc files. [#34954](https://github.com/ClickHouse/ClickHouse/pull/34954) ([lgbo](https://github.com/lgbo-ustc)). +* Currently, if the user changes the settings of the system tables there will be tons of logs and ClickHouse will rename the tables every minute. This fixes [#34929](https://github.com/ClickHouse/ClickHouse/issues/34929). [#34949](https://github.com/ClickHouse/ClickHouse/pull/34949) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)). +* Use connection pool for hive metastore client. [#34940](https://github.com/ClickHouse/ClickHouse/pull/34940) ([lgbo](https://github.com/lgbo-ustc)). +* Ignore per-column `TTL` in `CREATE TABLE AS` if new table engine does not support it (i.e. if the engine is not of `MergeTree` family). [#34938](https://github.com/ClickHouse/ClickHouse/pull/34938) ([Azat Khuzhin](https://github.com/azat)). +* Allow LowCardinality strings for ngrambf_v1/tokenbf_v1 indexes. Closes [#21865](https://github.com/ClickHouse/ClickHouse/issues/21865). [#34911](https://github.com/ClickHouse/ClickHouse/pull/34911) ([Lars Hiller Eidnes](https://github.com/larspars)). +* Allow to open empty sqlite db file if it does not exist. Closes [#33367](https://github.com/ClickHouse/ClickHouse/issues/33367). [#34907](https://github.com/ClickHouse/ClickHouse/pull/34907) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Implement MemoryStatisticsOS for FreeBSD. [#34902](https://github.com/ClickHouse/ClickHouse/pull/34902) ([Alexandre Snarskii](https://github.com/snar)). +* Fix reading only columns which user asked for. Closes [#34163](https://github.com/ClickHouse/ClickHouse/issues/34163). [#34849](https://github.com/ClickHouse/ClickHouse/pull/34849) ([Kseniia Sumarokova](https://github.com/kssenii)). +* In previous versions the progress bar in clickhouse-client can jump forward near 50% for no reason. This closes [#34324](https://github.com/ClickHouse/ClickHouse/issues/34324). [#34801](https://github.com/ClickHouse/ClickHouse/pull/34801) ([Alexey Milovidov](https://github.com/alexey-milovidov)). +* Now `ALTER TABLE DROP COLUMN columnX` queries for `MergeTree` table engines will work instantly when `columnX` is `ALIAS` column. Fixes [#34660](https://github.com/ClickHouse/ClickHouse/issues/34660). [#34786](https://github.com/ClickHouse/ClickHouse/pull/34786) ([alesapin](https://github.com/alesapin)). +* Add name hints for data skipping indices. Closes [#29698](https://github.com/ClickHouse/ClickHouse/issues/29698). [#34764](https://github.com/ClickHouse/ClickHouse/pull/34764) ([flynn](https://github.com/ucasfl)). +* Support `remote()`/`cluster()` for `parallel_distributed_insert_select=2`. [#34728](https://github.com/ClickHouse/ClickHouse/pull/34728) ([Azat Khuzhin](https://github.com/azat)). +* Do not reset logging that configured via --log-file/--errorlog-file in case of empty logger.log/logger.errorlog. [#34718](https://github.com/ClickHouse/ClickHouse/pull/34718) ([Amos Bird](https://github.com/amosbird)). +* Extract schema only once on table creation and prevent reading from local files/external sources to extract schema on each server startup. [#34684](https://github.com/ClickHouse/ClickHouse/pull/34684) ([Kruglov Pavel](https://github.com/Avogar)). +* ExecutableUserDefinedFunctions allow to specify argument names. This is necessary for formats where argument name is part of serialization, like `Native`, `JSONEachRow`. Closes [#34604](https://github.com/ClickHouse/ClickHouse/issues/34604). [#34653](https://github.com/ClickHouse/ClickHouse/pull/34653) ([Maksim Kita](https://github.com/kitaisreal)). +* Some refactoring and improvement over async and remote buffer related stuff. Separated in each commit. [#34629](https://github.com/ClickHouse/ClickHouse/pull/34629) ([Amos Bird](https://github.com/amosbird)). +* Now you can read `system.zookeeper` table without restrictions on path or using `like` expression. This reads can generate quite heavy load for zookeeper so to enable this ability you have to enable setting `allow_unrestricted_reads_from_keeper`. [#34609](https://github.com/ClickHouse/ClickHouse/pull/34609) ([Sergei Trifonov](https://github.com/serxa)). +* This PR changes restrictive row policies a bit to make them an easier alternative to permissive policies in easy cases. If for a particular table only restrictive policies exist (without permissive policies) users will be able to see some rows. Also `SHOW CREATE ROW POLICY` will always show `AS permissive` or `AS restrictive` in row policy's definition. [#34596](https://github.com/ClickHouse/ClickHouse/pull/34596) ([Vitaly Baranov](https://github.com/vitlibar)). +* MaterializedMySQL support materialized_mysql_tables_list(a comma-separated list of mysql database tables, which will be replicated by MaterializedMySQL database engine. Default value: empty list — means whole tables will be replicated) settings, mentioned at [#32977](https://github.com/ClickHouse/ClickHouse/issues/32977). [#34487](https://github.com/ClickHouse/ClickHouse/pull/34487) ([zzsmdfj](https://github.com/zzsmdfj)). +* - Improve the opentelemetry span logs for INSERT operation on distributed table. [#34480](https://github.com/ClickHouse/ClickHouse/pull/34480) ([Frank Chen](https://github.com/FrankChen021)). +* Improve schema inference with globs in FIle/S3/HDFS/URL engines. Try to use the next path for schema inference in case of error. [#34465](https://github.com/ClickHouse/ClickHouse/pull/34465) ([Kruglov Pavel](https://github.com/Avogar)). +* When large files were written with `s3` table function or table engine, the content type on the files was mistakenly set to `application/xml` due to a bug in the AWS SDK. This closes [#33964](https://github.com/ClickHouse/ClickHouse/issues/33964). [#34433](https://github.com/ClickHouse/ClickHouse/pull/34433) ([Alexey Milovidov](https://github.com/alexey-milovidov)). +* Hold time lock while assigning tasks to clear old temporary directories in StorageMergeTree. [#34025](https://github.com/ClickHouse/ClickHouse/pull/34025) ([Amos Bird](https://github.com/amosbird)). +* Make the znode ctime and mtime consistent between servers. [#33441](https://github.com/ClickHouse/ClickHouse/pull/33441) ([小路](https://github.com/nicelulu)). + +#### Bug Fix + +* When the inner readbuffer's buffer size is too small, NEED_MORE_INPUT in `HadoopSnappyDecoder` will run multi times (>=3)for one compressed block. This makes the input data be copied into the wrong place in `HadoopSnappyDecoder::buffer`. [#35116](https://github.com/ClickHouse/ClickHouse/pull/35116) ([lgbo](https://github.com/lgbo-ustc)). +* Ignore obsolete grants in ATTACH GRANT statements. This PR fixes [#34815](https://github.com/ClickHouse/ClickHouse/issues/34815). [#34855](https://github.com/ClickHouse/ClickHouse/pull/34855) ([Vitaly Baranov](https://github.com/vitlibar)). + +#### Build/Testing/Packaging Improvement + +* Add an ability to build stripped binaries with cmake. [#35196](https://github.com/ClickHouse/ClickHouse/pull/35196) ([alesapin](https://github.com/alesapin)). +* Clion has the following problems "The breakpoint will not currently be hit. No executable code is associated with this line". [#35179](https://github.com/ClickHouse/ClickHouse/pull/35179) ([小路](https://github.com/nicelulu)). +* Separate smaller clickhouse-keeper build. [#35031](https://github.com/ClickHouse/ClickHouse/pull/35031) ([alesapin](https://github.com/alesapin)). +* Use @robot-clickhouse as an author and committer for PRs like https://github.com/ClickHouse/ClickHouse/pull/34685. [#34793](https://github.com/ClickHouse/ClickHouse/pull/34793) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). +* Improve CI scripts arguments. [#34792](https://github.com/ClickHouse/ClickHouse/pull/34792) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). +* Limit DWARF version for debug info by 4 max, because our internal stack symbolizer cannot parse DWARF version 5. This makes sense if you compile ClickHouse with clang-15. [#34777](https://github.com/ClickHouse/ClickHouse/pull/34777) ([Alexey Milovidov](https://github.com/alexey-milovidov)). +* Drop PVS test from CI. [#34680](https://github.com/ClickHouse/ClickHouse/pull/34680) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). +* Set timeout 40 minutes for fast tests. [#34624](https://github.com/ClickHouse/ClickHouse/pull/34624) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). +* Debian package clickhouse-test.deb removed completely. CI use tests from repository and standalone testing via deb package is no longer supported. [#34606](https://github.com/ClickHouse/ClickHouse/pull/34606) ([Ilya Yatsishin](https://github.com/qoega)). +* NA. [#34513](https://github.com/ClickHouse/ClickHouse/pull/34513) ([vzakaznikov](https://github.com/vzakaznikov)). +* Randomize some settings in functional tests. This closes [#32268](https://github.com/ClickHouse/ClickHouse/issues/32268). [#34092](https://github.com/ClickHouse/ClickHouse/pull/34092) ([Kruglov Pavel](https://github.com/Avogar)). + +#### Bug Fix (user-visible misbehaviour in official stable or prestable release) + +* Fix segfault in Postgres database when getting create table query if database was created using named collections. Closes [#35312](https://github.com/ClickHouse/ClickHouse/issues/35312). [#35313](https://github.com/ClickHouse/ClickHouse/pull/35313) ([Kseniia Sumarokova](https://github.com/kssenii)). +* - Fix partial merge join duplicate rows bug, close [#31009](https://github.com/ClickHouse/ClickHouse/issues/31009). [#35311](https://github.com/ClickHouse/ClickHouse/pull/35311) ([Vladimir C](https://github.com/vdimir)). +* Fix possible `Assertion 'position() != working_buffer.end()' failed` while using bzip2 compression with small `max_read_buffer_size` setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35300](https://github.com/ClickHouse/ClickHouse/pull/35300) ([Kruglov Pavel](https://github.com/Avogar)). +* Fix possible segfault while using lz4 compression with a small max_read_buffer_size setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35296](https://github.com/ClickHouse/ClickHouse/pull/35296) ([Kruglov Pavel](https://github.com/Avogar)). +* Fix possible `Assertion 'position() != working_buffer.end()' failed` while using lzma compression with small `max_read_buffer_size` setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35295](https://github.com/ClickHouse/ClickHouse/pull/35295) ([Kruglov Pavel](https://github.com/Avogar)). +* Fix possible segfault in JSONEachRow schema inference. [#35291](https://github.com/ClickHouse/ClickHouse/pull/35291) ([Kruglov Pavel](https://github.com/Avogar)). +* Fix possible Abort while using Brotli compression with a small `max_read_buffer_size` setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35281](https://github.com/ClickHouse/ClickHouse/pull/35281) ([Kruglov Pavel](https://github.com/Avogar)). +* Fix `CHECK TABLE` query in case when sparse columns are enabled in table. [#35274](https://github.com/ClickHouse/ClickHouse/pull/35274) ([Anton Popov](https://github.com/CurtizJ)). +* Wait for IDiskRemote thread pool properly. [#35257](https://github.com/ClickHouse/ClickHouse/pull/35257) ([Azat Khuzhin](https://github.com/azat)). +* * Fix reading port from config, close [#34776](https://github.com/ClickHouse/ClickHouse/issues/34776). [#35193](https://github.com/ClickHouse/ClickHouse/pull/35193) ([Vladimir C](https://github.com/vdimir)). +* Fix error in query with `WITH TOTALS` in case if `HAVING` returned empty result. This fixes [#33711](https://github.com/ClickHouse/ClickHouse/issues/33711). [#35186](https://github.com/ClickHouse/ClickHouse/pull/35186) ([Amos Bird](https://github.com/amosbird)). +* - Fix `replaceRegexpAll`, close [#35117](https://github.com/ClickHouse/ClickHouse/issues/35117). [#35182](https://github.com/ClickHouse/ClickHouse/pull/35182) ([Vladimir C](https://github.com/vdimir)). +* Schema inference didn't work properly on case of `INSERT INTO FUNCTION s3(...) FROM ...`, it tried to read schema from s3 file instead of from select query. [#35176](https://github.com/ClickHouse/ClickHouse/pull/35176) ([Kruglov Pavel](https://github.com/Avogar)). +* Fix materialised postgres `table overrides` for partition by, etc. Closes [#35048](https://github.com/ClickHouse/ClickHouse/issues/35048). [#35162](https://github.com/ClickHouse/ClickHouse/pull/35162) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix materialised postrgesql adding new table to replication (ATTACH TABLE) after manually removing (DETACH TABLE). Closes [#33800](https://github.com/ClickHouse/ClickHouse/issues/33800). Closes [#34922](https://github.com/ClickHouse/ClickHouse/issues/34922). Closes [#34315](https://github.com/ClickHouse/ClickHouse/issues/34315). [#35158](https://github.com/ClickHouse/ClickHouse/pull/35158) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix partition pruning error when non-monotonic function is used with IN operator. This fixes [#35136](https://github.com/ClickHouse/ClickHouse/issues/35136). [#35146](https://github.com/ClickHouse/ClickHouse/pull/35146) ([Amos Bird](https://github.com/amosbird)). +* Fixed the incorrect translation YAML config to XML. [#35135](https://github.com/ClickHouse/ClickHouse/pull/35135) ([Miel Donkers](https://github.com/mdonkers)). +* Fix `optimize_skip_unused_shards_rewrite_in` for signed columns and negative values. [#35134](https://github.com/ClickHouse/ClickHouse/pull/35134) ([Azat Khuzhin](https://github.com/azat)). +* Fixed the "update_lag" external dictionary configuration option being unusable with the error message ``Unexpected key `update_lag` in dictionary source configuration``. [#35089](https://github.com/ClickHouse/ClickHouse/pull/35089) ([Jason Chu](https://github.com/1lann)). +* Avoid possible deadlock on server shutdown. [#35081](https://github.com/ClickHouse/ClickHouse/pull/35081) ([Azat Khuzhin](https://github.com/azat)). +* Fix missing alias after function is optimized to subcolumn when setting `optimize_functions_to_subcolumns` is enabled. Closes [#33798](https://github.com/ClickHouse/ClickHouse/issues/33798). [#35079](https://github.com/ClickHouse/ClickHouse/pull/35079) ([qieqieplus](https://github.com/qieqieplus)). +* Fix reading from `system.asynchronous_inserts` table if there exists asynchronous insert into table function. [#35050](https://github.com/ClickHouse/ClickHouse/pull/35050) ([Anton Popov](https://github.com/CurtizJ)). +* Fix possible exception `Reading for MergeTree family tables must be done with last position boundary`. Closes [#34979](https://github.com/ClickHouse/ClickHouse/issues/34979). [#35001](https://github.com/ClickHouse/ClickHouse/pull/35001) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix unexpected result when use -state type aggregate function in window frame. [#34999](https://github.com/ClickHouse/ClickHouse/pull/34999) ([metahys](https://github.com/metahys)). +* Fix possible segfault in filelog. Closes [#30749](https://github.com/ClickHouse/ClickHouse/issues/30749). [#34996](https://github.com/ClickHouse/ClickHouse/pull/34996) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix possible rare error `Cannot push block to port which already has data`. Avoid pushing to port with data inside `DelayedSource`. [#34993](https://github.com/ClickHouse/ClickHouse/pull/34993) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). +* Fix wrong schema inference for unquoted dates in CSV. Closes [#34768](https://github.com/ClickHouse/ClickHouse/issues/34768). [#34961](https://github.com/ClickHouse/ClickHouse/pull/34961) ([Kruglov Pavel](https://github.com/Avogar)). +* Unexpected result when use `in` in `where` in hive query. [#34945](https://github.com/ClickHouse/ClickHouse/pull/34945) ([lgbo](https://github.com/lgbo-ustc)). +* Avoid busy polling in keeper while searching for changelog files to delete. [#34931](https://github.com/ClickHouse/ClickHouse/pull/34931) ([Azat Khuzhin](https://github.com/azat)). +* Fix postgres datetime64 conversion. Closes [#33364](https://github.com/ClickHouse/ClickHouse/issues/33364). [#34910](https://github.com/ClickHouse/ClickHouse/pull/34910) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix possible "Part directory doesn't exist" during `INSERT`. [#34876](https://github.com/ClickHouse/ClickHouse/pull/34876) ([Azat Khuzhin](https://github.com/azat)). +* Fix asynchronous inserts to table functions. Fixes [#34864](https://github.com/ClickHouse/ClickHouse/issues/34864). [#34866](https://github.com/ClickHouse/ClickHouse/pull/34866) ([Anton Popov](https://github.com/CurtizJ)). +* Support DDLs like CREATE USER to be executed on cross replicated cluster. [#34860](https://github.com/ClickHouse/ClickHouse/pull/34860) ([Jianmei Zhang](https://github.com/zhangjmruc)). +* Fix bugs for multiple columns group by in WindowView. [#34859](https://github.com/ClickHouse/ClickHouse/pull/34859) ([vxider](https://github.com/Vxider)). +* Fix possible failures in S2 functions when queries contain const columns. [#34745](https://github.com/ClickHouse/ClickHouse/pull/34745) ([Bharat Nallan](https://github.com/bharatnc)). +* Fix bug for h3 funcs containing const columns which cause queries to fail. [#34743](https://github.com/ClickHouse/ClickHouse/pull/34743) ([Bharat Nallan](https://github.com/bharatnc)). +* Fix ENOENT with fsync_part_directory and Vertical merge. [#34739](https://github.com/ClickHouse/ClickHouse/pull/34739) ([Azat Khuzhin](https://github.com/azat)). +* Fix serialization/printing for system queries `RELOAD MODEL`, `RELOAD FUNCTION`, `RESTART DISK` when used `ON CLUSTER`. Closes [#34514](https://github.com/ClickHouse/ClickHouse/issues/34514). [#34696](https://github.com/ClickHouse/ClickHouse/pull/34696) ([Maksim Kita](https://github.com/kitaisreal)). +* Fix `allow_experimental_projection_optimization` with `enable_global_with_statement` (before it may lead to `Stack size too large` error in case of multiple expressions in `WITH` clause, and also it executes scalar subqueries again and again, so not it will be more optimal). [#34650](https://github.com/ClickHouse/ClickHouse/pull/34650) ([Azat Khuzhin](https://github.com/azat)). +* Stop to select part for mutate when the other replica has already updated the /log for ReplatedMergeTree engine. [#34633](https://github.com/ClickHouse/ClickHouse/pull/34633) ([Jianmei Zhang](https://github.com/zhangjmruc)). +* Fix incorrect trivial count result when part movement feature is used [#34089](https://github.com/ClickHouse/ClickHouse/issues/34089). [#34385](https://github.com/ClickHouse/ClickHouse/pull/34385) ([nvartolomei](https://github.com/nvartolomei)). +* Fix distributed subquery max_query_size limitation inconsistency. [#34078](https://github.com/ClickHouse/ClickHouse/pull/34078) ([Chao Ma](https://github.com/godliness)). + ### ClickHouse release v22.2, 2022-02-17 #### Upgrade Notes From 05f4fbe21723b99222809ecaaca9cc86cf564b81 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Wed, 16 Mar 2022 19:27:39 +0100 Subject: [PATCH 116/132] Started editing it --- CHANGELOG.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 27b680d07b2..8b99dca2434 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,8 +2,8 @@ #### Backward Incompatible Change -* Make arrayCompact behave as other higher-order functions: perform compaction not of lambda function results but on original array. If you using nontrivial lambda functions in arrayCompact you may restore old behaviour by wrapping arrayCompact arguments into arrayMap. Closes [#34010](https://github.com/ClickHouse/ClickHouse/issues/34010) [#18535](https://github.com/ClickHouse/ClickHouse/issues/18535) [#14778](https://github.com/ClickHouse/ClickHouse/issues/14778). [#34795](https://github.com/ClickHouse/ClickHouse/pull/34795) ([Alexandre Snarskii](https://github.com/snar)). -* Fix the bug that the toDatetime function overflows. When the date string is very large, it will be converted to 1970. [#32898](https://github.com/ClickHouse/ClickHouse/pull/32898) ([HaiBo Li](https://github.com/marising)). +* Make `arrayCompact` function behave as other higher-order functions: perform compaction not of lambda function results but on the original array. If you're using nontrivial lambda functions in arrayCompact you may restore old behaviour by wrapping `arrayCompact` arguments into `arrayMap`. Closes [#34010](https://github.com/ClickHouse/ClickHouse/issues/34010) [#18535](https://github.com/ClickHouse/ClickHouse/issues/18535) [#14778](https://github.com/ClickHouse/ClickHouse/issues/14778). [#34795](https://github.com/ClickHouse/ClickHouse/pull/34795) ([Alexandre Snarskii](https://github.com/snar)). +* Change implementation specific behavior on overflow of function `toDatetime`. It will be saturated to the min/max supported instant of datetime instead of wraparound. This change is highlighted as "backward incompatible" because someone may unintentionally rely on the old behavior. [#32898](https://github.com/ClickHouse/ClickHouse/pull/32898) ([HaiBo Li](https://github.com/marising)). #### New Feature From b56c28d8411d534d358a09d792ee7107bf65fab9 Mon Sep 17 00:00:00 2001 From: Robert Schulze Date: Tue, 15 Mar 2022 20:37:28 +0100 Subject: [PATCH 117/132] Replace a few uses of enable_if for SFINAE by concepts - enable_if is usually regarded as fragile and unreadable - C++20 concepts are much easier to read and produce more expressive error messages --- .../AggregateFunctionFactory.h | 3 +- src/Common/DateLUTImpl.h | 36 +++++----- src/Common/Exception.h | 3 +- src/Common/FieldVisitorConvertToNumber.h | 3 +- src/Common/FieldVisitorSum.h | 3 +- src/Common/IntervalTree.h | 1 + src/Common/JSONBuilder.h | 6 +- src/Common/StringSearcher.h | 72 ++++++++++++------- src/Common/UTF8Helpers.h | 6 +- src/Common/typeid_cast.h | 9 ++- src/Core/DecimalComparison.h | 12 ++-- src/Core/MultiEnum.h | 12 ++-- src/Core/iostream_debug_helpers.h | 3 +- src/Functions/roundToExp2.cpp | 20 +++--- src/IO/ReadHelpers.h | 23 +++--- src/IO/VarInt.h | 4 +- 16 files changed, 127 insertions(+), 89 deletions(-) diff --git a/src/AggregateFunctions/AggregateFunctionFactory.h b/src/AggregateFunctions/AggregateFunctionFactory.h index ef5740733df..e5263a54d79 100644 --- a/src/AggregateFunctions/AggregateFunctionFactory.h +++ b/src/AggregateFunctions/AggregateFunctionFactory.h @@ -38,7 +38,8 @@ struct AggregateFunctionWithProperties AggregateFunctionWithProperties(const AggregateFunctionWithProperties &) = default; AggregateFunctionWithProperties & operator = (const AggregateFunctionWithProperties &) = default; - template > * = nullptr> + template + requires (!std::is_same_v) AggregateFunctionWithProperties(Creator creator_, AggregateFunctionProperties properties_ = {}) /// NOLINT : creator(std::forward(creator_)), properties(std::move(properties_)) { diff --git a/src/Common/DateLUTImpl.h b/src/Common/DateLUTImpl.h index a5b2bbedc8a..50afc90f481 100644 --- a/src/Common/DateLUTImpl.h +++ b/src/Common/DateLUTImpl.h @@ -883,8 +883,8 @@ public: return toDayNum(years_lut[year - DATE_LUT_MIN_YEAR]); } - template || std::is_same_v>> + template + requires std::is_same_v || std::is_same_v inline auto toStartOfQuarterInterval(Date d, UInt64 quarters) const { if (quarters == 1) @@ -892,8 +892,8 @@ public: return toStartOfMonthInterval(d, quarters * 3); } - template || std::is_same_v>> + template + requires std::is_same_v || std::is_same_v inline auto toStartOfMonthInterval(Date d, UInt64 months) const { if (months == 1) @@ -906,8 +906,8 @@ public: return toDayNum(years_months_lut[month_total_index / months * months]); } - template || std::is_same_v>> + template + requires std::is_same_v || std::is_same_v inline auto toStartOfWeekInterval(Date d, UInt64 weeks) const { if (weeks == 1) @@ -920,8 +920,8 @@ public: return ExtendedDayNum(4 + (d - 4) / days * days); } - template || std::is_same_v>> + template + requires std::is_same_v || std::is_same_v inline Time toStartOfDayInterval(Date d, UInt64 days) const { if (days == 1) @@ -1219,10 +1219,8 @@ public: /// If resulting month has less deys than source month, then saturation can happen. /// Example: 31 Aug + 1 month = 30 Sep. - template < - typename DateTime, - typename - = std::enable_if_t || std::is_same_v || std::is_same_v>> + template + requires std::is_same_v || std::is_same_v || std::is_same_v inline Time NO_SANITIZE_UNDEFINED addMonths(DateTime t, Int64 delta) const { const auto result_day = addMonthsIndex(t, delta); @@ -1247,8 +1245,8 @@ public: return res; } - template || std::is_same_v>> + template + requires std::is_same_v || std::is_same_v inline auto NO_SANITIZE_UNDEFINED addMonths(Date d, Int64 delta) const { if constexpr (std::is_same_v) @@ -1280,10 +1278,8 @@ public: } /// Saturation can occur if 29 Feb is mapped to non-leap year. - template < - typename DateTime, - typename - = std::enable_if_t || std::is_same_v || std::is_same_v>> + template + requires std::is_same_v || std::is_same_v || std::is_same_v inline Time addYears(DateTime t, Int64 delta) const { auto result_day = addYearsIndex(t, delta); @@ -1308,8 +1304,8 @@ public: return res; } - template || std::is_same_v>> + template + requires std::is_same_v || std::is_same_v inline auto addYears(Date d, Int64 delta) const { if constexpr (std::is_same_v) diff --git a/src/Common/Exception.h b/src/Common/Exception.h index fc4f6d1295d..0bf89e7a447 100644 --- a/src/Common/Exception.h +++ b/src/Common/Exception.h @@ -205,7 +205,8 @@ void rethrowFirstException(const Exceptions & exceptions); template -std::enable_if_t, T> exception_cast(std::exception_ptr e) +requires std::is_pointer_v +T exception_cast(std::exception_ptr e) { try { diff --git a/src/Common/FieldVisitorConvertToNumber.h b/src/Common/FieldVisitorConvertToNumber.h index 7bbb7f0708a..ab6043738d0 100644 --- a/src/Common/FieldVisitorConvertToNumber.h +++ b/src/Common/FieldVisitorConvertToNumber.h @@ -113,7 +113,8 @@ public: throw Exception("Cannot convert AggregateFunctionStateData to " + demangle(typeid(T).name()), ErrorCodes::CANNOT_CONVERT_TYPE); } - template > > + template + requires is_big_int_v T operator() (const U & x) const { if constexpr (is_decimal) diff --git a/src/Common/FieldVisitorSum.h b/src/Common/FieldVisitorSum.h index 3e868e46f71..8ab82a2db49 100644 --- a/src/Common/FieldVisitorSum.h +++ b/src/Common/FieldVisitorSum.h @@ -36,7 +36,8 @@ public: return x.getValue() != T(0); } - template > > + template + requires is_big_int_v bool operator() (T & x) const { x += rhs.reinterpret(); diff --git a/src/Common/IntervalTree.h b/src/Common/IntervalTree.h index b8334653754..e11edde53a9 100644 --- a/src/Common/IntervalTree.h +++ b/src/Common/IntervalTree.h @@ -130,6 +130,7 @@ public: IntervalTree() { nodes.resize(1); } template , bool> = true> + requires std::is_same_v ALWAYS_INLINE bool emplace(Interval interval) { assert(!tree_is_built); diff --git a/src/Common/JSONBuilder.h b/src/Common/JSONBuilder.h index fd4c66b4a9e..9a218fcf08b 100644 --- a/src/Common/JSONBuilder.h +++ b/src/Common/JSONBuilder.h @@ -76,7 +76,8 @@ public: void add(const char * value) { add(std::make_unique(value)); } void add(bool value) { add(std::make_unique(std::move(value))); } - template , bool> = true> + template + requires std::is_arithmetic_v void add(T value) { add(std::make_unique>(value)); } void format(const FormatSettings & settings, FormatContext & context) override; @@ -100,7 +101,8 @@ public: void add(std::string key, std::string_view value) { add(std::move(key), std::make_unique(value)); } void add(std::string key, bool value) { add(std::move(key), std::make_unique(std::move(value))); } - template , bool> = true> + template + requires std::is_arithmetic_v void add(std::string key, T value) { add(std::move(key), std::make_unique>(value)); } void format(const FormatSettings & settings, FormatContext & context) override; diff --git a/src/Common/StringSearcher.h b/src/Common/StringSearcher.h index 5cdbbc22e12..b556ace75a7 100644 --- a/src/Common/StringSearcher.h +++ b/src/Common/StringSearcher.h @@ -82,7 +82,8 @@ private: #endif public: - template > + template + requires (sizeof(CharT) == 1) StringSearcher(const CharT * needle_, const size_t needle_size_) : needle{reinterpret_cast(needle_)}, needle_size{needle_size_} { @@ -191,7 +192,8 @@ public: #endif } - template > + template + requires (sizeof(CharT) == 1) ALWAYS_INLINE bool compareTrivial(const CharT * haystack_pos, const CharT * const haystack_end, const uint8_t * needle_pos) const { while (haystack_pos < haystack_end && needle_pos < needle_end) @@ -217,7 +219,8 @@ public: return needle_pos == needle_end; } - template > + template + requires (sizeof(CharT) == 1) ALWAYS_INLINE bool compare(const CharT * /*haystack*/, const CharT * haystack_end, const CharT * pos) const { @@ -262,7 +265,8 @@ public: /** Returns haystack_end if not found. */ - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const CharT * const haystack_end) const { if (0 == needle_size) @@ -338,7 +342,8 @@ public: return haystack_end; } - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const size_t haystack_size) const { return search(haystack, haystack + haystack_size); @@ -367,7 +372,8 @@ private: #endif public: - template > + template + requires (sizeof(CharT) == 1) StringSearcher(const CharT * needle_, const size_t needle_size) : needle{reinterpret_cast(needle_)}, needle_end{needle + needle_size} { @@ -399,7 +405,8 @@ public: #endif } - template > + template + requires (sizeof(CharT) == 1) ALWAYS_INLINE bool compare(const CharT * /*haystack*/, const CharT * /*haystack_end*/, const CharT * pos) const { #ifdef __SSE4_1__ @@ -453,7 +460,8 @@ public: return false; } - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const CharT * const haystack_end) const { if (needle == needle_end) @@ -540,7 +548,8 @@ public: return haystack_end; } - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const size_t haystack_size) const { return search(haystack, haystack + haystack_size); @@ -568,7 +577,8 @@ private: #endif public: - template > + template + requires (sizeof(CharT) == 1) StringSearcher(const CharT * needle_, const size_t needle_size) : needle{reinterpret_cast(needle_)}, needle_end{needle + needle_size} { @@ -596,7 +606,8 @@ public: #endif } - template > + template + requires (sizeof(CharT) == 1) ALWAYS_INLINE bool compare(const CharT * /*haystack*/, const CharT * /*haystack_end*/, const CharT * pos) const { #ifdef __SSE4_1__ @@ -642,7 +653,8 @@ public: return false; } - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const CharT * const haystack_end) const { if (needle == needle_end) @@ -722,7 +734,8 @@ public: return haystack_end; } - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const size_t haystack_size) const { return search(haystack, haystack + haystack_size); @@ -740,7 +753,8 @@ class TokenSearcher : public StringSearcherBase size_t needle_size; public: - template > + template + requires (sizeof(CharT) == 1) TokenSearcher(const CharT * needle_, const size_t needle_size_) : searcher{needle_, needle_size_}, needle_size(needle_size_) @@ -752,7 +766,8 @@ public: } - template > + template + requires (sizeof(CharT) == 1) ALWAYS_INLINE bool compare(const CharT * haystack, const CharT * haystack_end, const CharT * pos) const { // use searcher only if pos is in the beginning of token and pos + searcher.needle_size is end of token. @@ -762,7 +777,8 @@ public: return false; } - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const CharT * const haystack_end) const { // use searcher.search(), then verify that returned value is a token @@ -781,13 +797,15 @@ public: return haystack_end; } - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const size_t haystack_size) const { return search(haystack, haystack + haystack_size); } - template > + template + requires (sizeof(CharT) == 1) ALWAYS_INLINE bool isToken(const CharT * haystack, const CharT * const haystack_end, const CharT* p) const { return (p == haystack || isTokenSeparator(*(p - 1))) @@ -819,11 +837,13 @@ struct LibCASCIICaseSensitiveStringSearcher : public StringSearcherBase { const char * const needle; - template > + template + requires (sizeof(CharT) == 1) LibCASCIICaseSensitiveStringSearcher(const CharT * const needle_, const size_t /* needle_size */) : needle(reinterpret_cast(needle_)) {} - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const CharT * const haystack_end) const { const auto * res = strstr(reinterpret_cast(haystack), reinterpret_cast(needle)); @@ -832,7 +852,8 @@ struct LibCASCIICaseSensitiveStringSearcher : public StringSearcherBase return reinterpret_cast(res); } - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const size_t haystack_size) const { return search(haystack, haystack + haystack_size); @@ -843,11 +864,13 @@ struct LibCASCIICaseInsensitiveStringSearcher : public StringSearcherBase { const char * const needle; - template > + template + requires (sizeof(CharT) == 1) LibCASCIICaseInsensitiveStringSearcher(const CharT * const needle_, const size_t /* needle_size */) : needle(reinterpret_cast(needle_)) {} - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const CharT * const haystack_end) const { const auto * res = strcasestr(reinterpret_cast(haystack), reinterpret_cast(needle)); @@ -856,7 +879,8 @@ struct LibCASCIICaseInsensitiveStringSearcher : public StringSearcherBase return reinterpret_cast(res); } - template > + template + requires (sizeof(CharT) == 1) const CharT * search(const CharT * haystack, const size_t haystack_size) const { return search(haystack, haystack + haystack_size); diff --git a/src/Common/UTF8Helpers.h b/src/Common/UTF8Helpers.h index 75cfd8fe070..a940ddc0234 100644 --- a/src/Common/UTF8Helpers.h +++ b/src/Common/UTF8Helpers.h @@ -75,7 +75,8 @@ inline size_t countCodePoints(const UInt8 * data, size_t size) } -template > +template +requires (sizeof(CharT) == 1) size_t convertCodePointToUTF8(int code_point, CharT * out_bytes, size_t out_length) { static const Poco::UTF8Encoding utf8; @@ -84,7 +85,8 @@ size_t convertCodePointToUTF8(int code_point, CharT * out_bytes, size_t out_leng return res; } -template > +template +requires (sizeof(CharT) == 1) std::optional convertUTF8ToCodePoint(const CharT * in_bytes, size_t in_length) { static const Poco::UTF8Encoding utf8; diff --git a/src/Common/typeid_cast.h b/src/Common/typeid_cast.h index b656c6548ea..465de425532 100644 --- a/src/Common/typeid_cast.h +++ b/src/Common/typeid_cast.h @@ -25,7 +25,8 @@ namespace DB * In the rest, behaves like a dynamic_cast. */ template -std::enable_if_t, To> typeid_cast(From & from) +requires std::is_reference_v +To typeid_cast(From & from) { try { @@ -43,7 +44,8 @@ std::enable_if_t, To> typeid_cast(From & from) template -std::enable_if_t, To> typeid_cast(From * from) +requires std::is_pointer_v +To typeid_cast(From * from) { try { @@ -60,7 +62,8 @@ std::enable_if_t, To> typeid_cast(From * from) template -std::enable_if_t, To> typeid_cast(const std::shared_ptr & from) +requires is_shared_ptr_v +To typeid_cast(const std::shared_ptr & from) { try { diff --git a/src/Core/DecimalComparison.h b/src/Core/DecimalComparison.h index b8498b6c84b..530722a2519 100644 --- a/src/Core/DecimalComparison.h +++ b/src/Core/DecimalComparison.h @@ -115,8 +115,8 @@ private: } template - static std::enable_if_t && is_decimal, Shift> - getScales(const DataTypePtr & left_type, const DataTypePtr & right_type) + requires is_decimal && is_decimal + static Shift getScales(const DataTypePtr & left_type, const DataTypePtr & right_type) { const DataTypeDecimalBase * decimal0 = checkDecimalBase(*left_type); const DataTypeDecimalBase * decimal1 = checkDecimalBase(*right_type); @@ -137,8 +137,8 @@ private: } template - static std::enable_if_t && !is_decimal, Shift> - getScales(const DataTypePtr & left_type, const DataTypePtr &) + requires is_decimal && (!is_decimal) + static Shift getScales(const DataTypePtr & left_type, const DataTypePtr &) { Shift shift; const DataTypeDecimalBase * decimal0 = checkDecimalBase(*left_type); @@ -148,8 +148,8 @@ private: } template - static std::enable_if_t && is_decimal, Shift> - getScales(const DataTypePtr &, const DataTypePtr & right_type) + requires (!is_decimal) && is_decimal + static Shift getScales(const DataTypePtr &, const DataTypePtr & right_type) { Shift shift; const DataTypeDecimalBase * decimal1 = checkDecimalBase(*right_type); diff --git a/src/Core/MultiEnum.h b/src/Core/MultiEnum.h index 40cf166ccf7..1c013cc0dc1 100644 --- a/src/Core/MultiEnum.h +++ b/src/Core/MultiEnum.h @@ -53,7 +53,8 @@ struct MultiEnum return bitset; } - template >> + template + requires std::is_convertible_v void setValue(ValueType new_value) { // Can't set value from any enum avoid confusion @@ -66,7 +67,8 @@ struct MultiEnum return bitset == other.bitset; } - template >> + template + requires std::is_convertible_v bool operator==(ValueType other) const { // Shouldn't be comparable with any enum to avoid confusion @@ -80,13 +82,15 @@ struct MultiEnum return !(*this == other); } - template >> + template + requires std::is_convertible_v friend bool operator==(ValueType left, MultiEnum right) { return right.operator==(left); } - template >::type> + template + requires (!std::is_same_v) friend bool operator!=(L left, MultiEnum right) { return !(right.operator==(left)); diff --git a/src/Core/iostream_debug_helpers.h b/src/Core/iostream_debug_helpers.h index 8aafe0b6c9c..e40bf74583e 100644 --- a/src/Core/iostream_debug_helpers.h +++ b/src/Core/iostream_debug_helpers.h @@ -7,7 +7,8 @@ namespace DB // Use template to disable implicit casting for certain overloaded types such as Field, which leads // to overload resolution ambiguity. class Field; -template >> +template +requires std::is_same_v std::ostream & operator<<(std::ostream & stream, const T & what); struct NameAndTypePair; diff --git a/src/Functions/roundToExp2.cpp b/src/Functions/roundToExp2.cpp index 37f0637c79a..846890bc5c8 100644 --- a/src/Functions/roundToExp2.cpp +++ b/src/Functions/roundToExp2.cpp @@ -14,36 +14,36 @@ namespace { template -inline std::enable_if_t && (sizeof(T) <= sizeof(UInt32)), T> -roundDownToPowerOfTwo(T x) +requires std::is_integral_v && (sizeof(T) <= sizeof(UInt32)) +inline T roundDownToPowerOfTwo(T x) { return x <= 0 ? 0 : (T(1) << (31 - __builtin_clz(x))); } template -inline std::enable_if_t && (sizeof(T) == sizeof(UInt64)), T> -roundDownToPowerOfTwo(T x) +requires std::is_integral_v && (sizeof(T) == sizeof(UInt64)) +inline T roundDownToPowerOfTwo(T x) { return x <= 0 ? 0 : (T(1) << (63 - __builtin_clzll(x))); } template -inline std::enable_if_t, T> -roundDownToPowerOfTwo(T x) +requires std::is_same_v +inline T roundDownToPowerOfTwo(T x) { return bit_cast(bit_cast(x) & ~((1ULL << 23) - 1)); } template -inline std::enable_if_t, T> -roundDownToPowerOfTwo(T x) +requires std::is_same_v +inline T roundDownToPowerOfTwo(T x) { return bit_cast(bit_cast(x) & ~((1ULL << 52) - 1)); } template -inline std::enable_if_t, T> -roundDownToPowerOfTwo(T) +requires is_big_int_v +inline T roundDownToPowerOfTwo(T) { throw Exception("roundToExp2() for big integers is not implemented", ErrorCodes::NOT_IMPLEMENTED); } diff --git a/src/IO/ReadHelpers.h b/src/IO/ReadHelpers.h index fd2c4218aef..af18f286846 100644 --- a/src/IO/ReadHelpers.h +++ b/src/IO/ReadHelpers.h @@ -966,8 +966,8 @@ inline void readDateTimeText(LocalDateTime & datetime, ReadBuffer & buf) /// Generic methods to read value in native binary format. template -inline std::enable_if_t, void> -readBinary(T & x, ReadBuffer & buf) { readPODBinary(x, buf); } +requires is_arithmetic_v +inline void readBinary(T & x, ReadBuffer & buf) { readPODBinary(x, buf); } inline void readBinary(String & x, ReadBuffer & buf) { readStringBinary(x, buf); } inline void readBinary(Int128 & x, ReadBuffer & buf) { readPODBinary(x, buf); } @@ -982,8 +982,8 @@ inline void readBinary(LocalDate & x, ReadBuffer & buf) { readPODBinary(x, buf); template -inline std::enable_if_t && (sizeof(T) <= 8), void> -readBinaryBigEndian(T & x, ReadBuffer & buf) /// Assuming little endian architecture. +requires is_arithmetic_v && (sizeof(T) <= 8) +inline void readBinaryBigEndian(T & x, ReadBuffer & buf) /// Assuming little endian architecture. { readPODBinary(x, buf); @@ -998,8 +998,8 @@ readBinaryBigEndian(T & x, ReadBuffer & buf) /// Assuming little endian archi } template -inline std::enable_if_t, void> -readBinaryBigEndian(T & x, ReadBuffer & buf) /// Assuming little endian architecture. +requires is_big_int_v +inline void readBinaryBigEndian(T & x, ReadBuffer & buf) /// Assuming little endian architecture. { for (size_t i = 0; i != std::size(x.items); ++i) { @@ -1034,8 +1034,8 @@ inline void readText(UUID & x, ReadBuffer & buf) { readUUIDText(x, buf); } /// Generic methods to read value in text format, /// possibly in single quotes (only for data types that use quotes in VALUES format of INSERT statement in SQL). template -inline std::enable_if_t, void> -readQuoted(T & x, ReadBuffer & buf) { readText(x, buf); } +requires is_arithmetic_v +inline void readQuoted(T & x, ReadBuffer & buf) { readText(x, buf); } inline void readQuoted(String & x, ReadBuffer & buf) { readQuotedString(x, buf); } @@ -1063,8 +1063,8 @@ inline void readQuoted(UUID & x, ReadBuffer & buf) /// Same as above, but in double quotes. template -inline std::enable_if_t, void> -readDoubleQuoted(T & x, ReadBuffer & buf) { readText(x, buf); } +requires is_arithmetic_v +inline void readDoubleQuoted(T & x, ReadBuffer & buf) { readText(x, buf); } inline void readDoubleQuoted(String & x, ReadBuffer & buf) { readDoubleQuotedString(x, buf); } @@ -1101,7 +1101,8 @@ inline void readCSVSimple(T & x, ReadBuffer & buf) } template -inline std::enable_if_t, void> readCSV(T & x, ReadBuffer & buf) +requires is_arithmetic_v +inline void readCSV(T & x, ReadBuffer & buf) { readCSVSimple(x, buf); } diff --git a/src/IO/VarInt.h b/src/IO/VarInt.h index 29c8a60c935..3161ca6d8a8 100644 --- a/src/IO/VarInt.h +++ b/src/IO/VarInt.h @@ -108,8 +108,8 @@ inline void readVarInt(Int16 & x, ReadBuffer & istr) } template -inline std::enable_if_t, void> -readVarUInt(T & x, ReadBuffer & istr) +requires (!std::is_same_v) +inline void readVarUInt(T & x, ReadBuffer & istr) { UInt64 tmp; readVarUInt(tmp, istr); From b1243ccd4fcdb085beb175ccd9d5db2be50d754c Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Wed, 16 Mar 2022 19:53:14 +0100 Subject: [PATCH 118/132] Started editing it --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 8b99dca2434..af8b2ca21fe 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -3,7 +3,7 @@ #### Backward Incompatible Change * Make `arrayCompact` function behave as other higher-order functions: perform compaction not of lambda function results but on the original array. If you're using nontrivial lambda functions in arrayCompact you may restore old behaviour by wrapping `arrayCompact` arguments into `arrayMap`. Closes [#34010](https://github.com/ClickHouse/ClickHouse/issues/34010) [#18535](https://github.com/ClickHouse/ClickHouse/issues/18535) [#14778](https://github.com/ClickHouse/ClickHouse/issues/14778). [#34795](https://github.com/ClickHouse/ClickHouse/pull/34795) ([Alexandre Snarskii](https://github.com/snar)). -* Change implementation specific behavior on overflow of function `toDatetime`. It will be saturated to the min/max supported instant of datetime instead of wraparound. This change is highlighted as "backward incompatible" because someone may unintentionally rely on the old behavior. [#32898](https://github.com/ClickHouse/ClickHouse/pull/32898) ([HaiBo Li](https://github.com/marising)). +* Change implementation specific behavior on overflow of function `toDatetime`. It will be saturated to the nearest min/max supported instant of datetime instead of wraparound. This change is highlighted as "backward incompatible" because someone may unintentionally rely on the old behavior. [#32898](https://github.com/ClickHouse/ClickHouse/pull/32898) ([HaiBo Li](https://github.com/marising)). #### New Feature From 346c6b9d79623c85d38dbdb7e66e86dcd5888d0b Mon Sep 17 00:00:00 2001 From: Maksim Kita Date: Wed, 16 Mar 2022 19:59:31 +0000 Subject: [PATCH 119/132] Fixed tests --- src/Functions/FunctionsCodingIP.h | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/Functions/FunctionsCodingIP.h b/src/Functions/FunctionsCodingIP.h index 1bc3fea84bb..246e62d965c 100644 --- a/src/Functions/FunctionsCodingIP.h +++ b/src/Functions/FunctionsCodingIP.h @@ -16,7 +16,7 @@ namespace ErrorCodes extern const int ILLEGAL_COLUMN; } -enum class IPStringToNumExceptionMode +enum class IPStringToNumExceptionMode : uint8_t { Throw, Default, @@ -186,11 +186,18 @@ ColumnPtr convertToIPv4(ColumnPtr column) if (!parse_result) { if constexpr (exception_mode == IPStringToNumExceptionMode::Throw) + { throw Exception("Invalid IPv4 value", ErrorCodes::CANNOT_PARSE_DOMAIN_VALUE_FROM_STRING); + } else if constexpr (exception_mode == IPStringToNumExceptionMode::Default) + { vec_res[i] = 0; + } else if constexpr (exception_mode == IPStringToNumExceptionMode::Null) + { (*vec_null_map_to)[i] = true; + vec_res[i] = 0; + } } prev_offset = offsets_src[i]; From de2cc23e155d69a124bb560f1a8d9b845d95a1f7 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Wed, 16 Mar 2022 20:16:59 +0000 Subject: [PATCH 120/132] fix race --- src/Columns/ColumnObject.cpp | 6 +++--- src/Storages/MergeTree/MergeTreeData.cpp | 6 ++++-- tests/integration/test_distributed_type_object/test.py | 4 ++-- 3 files changed, 9 insertions(+), 7 deletions(-) diff --git a/src/Columns/ColumnObject.cpp b/src/Columns/ColumnObject.cpp index 596aa83d42f..bfa8ffe6358 100644 --- a/src/Columns/ColumnObject.cpp +++ b/src/Columns/ColumnObject.cpp @@ -303,9 +303,9 @@ void ColumnObject::Subcolumn::insert(Field field, FieldInfo info) } if (type_changed || info.need_convert) - field = convertFieldToTypeOrThrow(std::move(field), *value_type); + field = convertFieldToTypeOrThrow(field, *value_type); - data.back()->insert(std::move(field)); + data.back()->insert(field); } void ColumnObject::Subcolumn::insertRangeFrom(const Subcolumn & src, size_t start, size_t length) @@ -765,7 +765,7 @@ void ColumnObject::finalize() continue; entry->data.finalize(); - new_subcolumns.add(entry->path, std::move(entry->data)); + new_subcolumns.add(entry->path, entry->data); } /// If all subcolumns were skipped add a dummy subcolumn, diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index 5c9ca396e24..b789cefc40a 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -6131,7 +6131,8 @@ ColumnsDescription MergeTreeData::getObjectColumns( void MergeTreeData::resetObjectColumnsFromActiveParts(const DataPartsLock & /*lock*/) { - const auto & columns = getInMemoryMetadataPtr()->getColumns(); + auto metadata_snapshot = getInMemoryMetadataPtr(); + const auto & columns = metadata_snapshot->getColumns(); if (!hasObjectColumns(columns)) return; @@ -6141,7 +6142,8 @@ void MergeTreeData::resetObjectColumnsFromActiveParts(const DataPartsLock & /*lo void MergeTreeData::updateObjectColumns(const DataPartPtr & part, const DataPartsLock & /*lock*/) { - const auto & columns = getInMemoryMetadataPtr()->getColumns(); + auto metadata_snapshot = getInMemoryMetadataPtr(); + const auto & columns = metadata_snapshot->getColumns(); if (!hasObjectColumns(columns)) return; diff --git a/tests/integration/test_distributed_type_object/test.py b/tests/integration/test_distributed_type_object/test.py index 5bf5899388d..faf509c46cd 100644 --- a/tests/integration/test_distributed_type_object/test.py +++ b/tests/integration/test_distributed_type_object/test.py @@ -14,8 +14,8 @@ def started_cluster(): cluster.start() for node in (node1, node2): - node.query("CREATE TABLE local_table(id UInt32, data JSON) ENGINE = MergeTree ORDER BY id") - node.query("CREATE TABLE dist_table AS local_table ENGINE = Distributed(test_cluster, default, local_table)") + node.query("CREATE TABLE local_table(id UInt32, data JSON) ENGINE = MergeTree ORDER BY id", settings={"allow_experimental_object_type": 1}) + node.query("CREATE TABLE dist_table AS local_table ENGINE = Distributed(test_cluster, default, local_table)", settings={"allow_experimental_object_type": 1}) yield cluster From 03ff6d52f62f77b31a82b5984c28a1ceba210c6e Mon Sep 17 00:00:00 2001 From: alesapin Date: Wed, 16 Mar 2022 21:51:33 +0100 Subject: [PATCH 121/132] Fix race in zero copy replication --- src/Storages/StorageReplicatedMergeTree.cpp | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/Storages/StorageReplicatedMergeTree.cpp b/src/Storages/StorageReplicatedMergeTree.cpp index 9a5e1cfbabd..4b917c4ac47 100644 --- a/src/Storages/StorageReplicatedMergeTree.cpp +++ b/src/Storages/StorageReplicatedMergeTree.cpp @@ -7715,7 +7715,12 @@ void StorageReplicatedMergeTree::createZeroCopyLockNode(const zkutil::ZooKeeperP { try { - zookeeper->createAncestors(zookeeper_node); + /// Ephemeral locks can be created only when we fetch shared data. + /// So it never require to create ancestors. If we create them + /// race condition with source replica drop is possible. + if (mode == zkutil::CreateMode::Persistent) + zookeeper->createAncestors(zookeeper_node); + if (replace_existing_lock && zookeeper->exists(zookeeper_node)) { Coordination::Requests ops; From 6fe26d24e7f2aaf140e040be7b97dc7ce86a82e1 Mon Sep 17 00:00:00 2001 From: Pablo Alegre Date: Wed, 9 Mar 2022 17:27:38 +0100 Subject: [PATCH 122/132] Add test for #26965 * Add a test for 'WITH'+CTE performance if enable_global_with_statement is enabled --- ...t_enable_with_statement_cte_perf.reference | 4 +++ ...233_set_enable_with_statement_cte_perf.sql | 27 +++++++++++++++++++ 2 files changed, 31 insertions(+) create mode 100644 tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.reference create mode 100644 tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql diff --git a/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.reference b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.reference new file mode 100644 index 00000000000..d97ba04b8c3 --- /dev/null +++ b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.reference @@ -0,0 +1,4 @@ +1000 +1000 +1000 +3 diff --git a/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql new file mode 100644 index 00000000000..bae7e562d6c --- /dev/null +++ b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql @@ -0,0 +1,27 @@ +DROP TABLE IF EXISTS ev; +DROP TABLE IF EXISTS idx; + +CREATE TABLE ev (a Int32, b Int32) Engine=MergeTree() ORDER BY a; +CREATE TABLE idx (a Int32) Engine=MergeTree() ORDER BY a; +INSERT INTO ev SELECT number, number FROM numbers(100000000); +INSERT INTO idx SELECT number*5 FROM numbers(1000); + +SET enable_global_with_statement = 1; + +-- test_enable_global_with_statement_performance_1 +WITH 'test' AS u SELECT count()FROM ev WHERE a IN (SELECT a FROM idx); + +-- test_enable_global_with_statement_performance_2 +SELECT count() FROM ev WHERE a IN (SELECT a FROM idx); + +SET enable_global_with_statement = 0; + +-- test_enable_global_with_statement_performance_3 +WITH 'test' AS u SELECT count() FROM ev WHERE a IN (SELECT a FROM idx); + +SYSTEM FLUSH LOGS; + +SELECT count(read_rows) FROM (SELECT read_rows FROM system.query_log WHERE current_database=currentDatabase() AND type='QueryFinish' AND query LIKE '%test_enable_global_with_statement_performance%' ORDER BY event_date, event_time DESC LIMIT 3) GROUP BY read_rows; + +DROP TABLE IF EXISTS ev; +DROP TABLE IF EXISTS idx; \ No newline at end of file From 289070a55c36ad0a2915c4aeb8394dc15983b883 Mon Sep 17 00:00:00 2001 From: Pablo Alegre Date: Thu, 10 Mar 2022 11:11:46 +0100 Subject: [PATCH 123/132] fixup! Add test for #26965 * Add a test for 'WITH'+CTE performance if enable_global_with_statement is enabled --- .../0_stateless/02233_set_enable_with_statement_cte_perf.sql | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql index bae7e562d6c..f0d14e041dc 100644 --- a/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql +++ b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql @@ -21,7 +21,7 @@ WITH 'test' AS u SELECT count() FROM ev WHERE a IN (SELECT a FROM idx); SYSTEM FLUSH LOGS; -SELECT count(read_rows) FROM (SELECT read_rows FROM system.query_log WHERE current_database=currentDatabase() AND type='QueryFinish' AND query LIKE '%test_enable_global_with_statement_performance%' ORDER BY event_date, event_time DESC LIMIT 3) GROUP BY read_rows; +SELECT count(read_rows) FROM (SELECT read_rows FROM system.query_log WHERE current_database=currentDatabase() AND type='QueryFinish' AND query LIKE '-- test_enable_global_with_statement_performance%' ORDER BY initial_query_start_time_microseconds DESC LIMIT 3) GROUP BY read_rows; DROP TABLE IF EXISTS ev; DROP TABLE IF EXISTS idx; \ No newline at end of file From d2bc179d3de0c4562488501c89a199675b7b2e31 Mon Sep 17 00:00:00 2001 From: Pablo Alegre Date: Wed, 16 Mar 2022 23:01:24 +0100 Subject: [PATCH 124/132] fixup! Add test for #26965 * Add a test for 'WITH'+CTE performance if enable_global_with_statement is enabled --- .../02233_set_enable_with_statement_cte_perf.sql | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql index f0d14e041dc..42e8aa63ea7 100644 --- a/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql +++ b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql @@ -3,21 +3,17 @@ DROP TABLE IF EXISTS idx; CREATE TABLE ev (a Int32, b Int32) Engine=MergeTree() ORDER BY a; CREATE TABLE idx (a Int32) Engine=MergeTree() ORDER BY a; -INSERT INTO ev SELECT number, number FROM numbers(100000000); +INSERT INTO ev SELECT number, number FROM numbers(10000000); INSERT INTO idx SELECT number*5 FROM numbers(1000); -SET enable_global_with_statement = 1; - -- test_enable_global_with_statement_performance_1 -WITH 'test' AS u SELECT count()FROM ev WHERE a IN (SELECT a FROM idx); +WITH 'test' AS u SELECT count()FROM ev WHERE a IN (SELECT a FROM idx) SETTINGS enable_global_with_statement = 1; -- test_enable_global_with_statement_performance_2 -SELECT count() FROM ev WHERE a IN (SELECT a FROM idx); - -SET enable_global_with_statement = 0; +SELECT count() FROM ev WHERE a IN (SELECT a FROM idx) SETTINGS enable_global_with_statement = 1; -- test_enable_global_with_statement_performance_3 -WITH 'test' AS u SELECT count() FROM ev WHERE a IN (SELECT a FROM idx); +WITH 'test' AS u SELECT count() FROM ev WHERE a IN (SELECT a FROM idx) SETTINGS enable_global_with_statement = 0; SYSTEM FLUSH LOGS; From 35ee584c8714c542418f763e79d32c334408ad55 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Thu, 17 Mar 2022 00:28:53 +0100 Subject: [PATCH 125/132] Editing it, mostly done --- CHANGELOG.md | 128 +++++++++++++++++++++++---------------------------- 1 file changed, 58 insertions(+), 70 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index af8b2ca21fe..16ee2c79942 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -7,92 +7,80 @@ #### New Feature -* Add `database_replicated_allow_only_replicated_engine` setting. When enabled, it only allowed to create `Replicated` tables in `Replicated` database. [#35214](https://github.com/ClickHouse/ClickHouse/pull/35214) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). -* ``` sql ) explain ast graph = 1 select * from system.parts;. [#35173](https://github.com/ClickHouse/ClickHouse/pull/35173) ([李扬](https://github.com/taiyang-li)). -* Changed the Play UI to select a theme by the following priority: * 'theme' GET parameter * 'theme' in localStorage * According to OS preference (didn't work before). [#35068](https://github.com/ClickHouse/ClickHouse/pull/35068) ([peledni](https://github.com/peledni)). -* Added date_time_input_format = 'best_effort_us'. Closes [#34799](https://github.com/ClickHouse/ClickHouse/issues/34799). [#34982](https://github.com/ClickHouse/ClickHouse/pull/34982) ([WenYao](https://github.com/Cai-Yao)). -* - When use clickhouse-client logining, If user and password is not specified in command line or configuration file, get them from `CLICKHOUSE_USER` and `CLICKHOUSE_PASSWORD` environment variables. Close [#34538](https://github.com/ClickHouse/ClickHouse/issues/34538). [#34947](https://github.com/ClickHouse/ClickHouse/pull/34947) ([DR](https://github.com/freedomDR)). -* Add new table function `hive`, usage as follow ``` hive('', '', '', '', '') ``` for example ``` SELECT * FROM hive('thrift://hivetest:9083', 'test', 'demo', '`id` Nullable(String), `score` Nullable(Int32), `day` Nullable(String)', 'day') ```. [#34946](https://github.com/ClickHouse/ClickHouse/pull/34946) ([lgbo](https://github.com/lgbo-ustc)). -* A new settings called is added in server configuration which on/off insecure AUTH_TYPE plaintext-password and no_password. By default the property is set to true which means authType Plaintext_password & NO_password is allowed. [#34738](https://github.com/ClickHouse/ClickHouse/pull/34738) ([Heena Bansal](https://github.com/HeenaBansal2009)). -* Support schema inference for inserting into table functions file/hdfs/s3/url. [#34732](https://github.com/ClickHouse/ClickHouse/pull/34732) ([Kruglov Pavel](https://github.com/Avogar)). -* Add cpu/mem metric for clickhouse-local. Close [#34545](https://github.com/ClickHouse/ClickHouse/issues/34545). [#34605](https://github.com/ClickHouse/ClickHouse/pull/34605) ([李扬](https://github.com/taiyang-li)). -* Implement DateTime64 transform from and to arrow column, which closes [#8280](https://github.com/ClickHouse/ClickHouse/issues/8280) and closes [#28574](https://github.com/ClickHouse/ClickHouse/issues/28574). [#34561](https://github.com/ClickHouse/ClickHouse/pull/34561) ([李扬](https://github.com/taiyang-li)). -* - Add startsWith & endsWith function for arrays, closes [#33982](https://github.com/ClickHouse/ClickHouse/issues/33982). [#34368](https://github.com/ClickHouse/ClickHouse/pull/34368) ([usurai](https://github.com/usurai)). -* Add local cache for disk s3. Closes [#28961](https://github.com/ClickHouse/ClickHouse/issues/28961). [#33717](https://github.com/ClickHouse/ClickHouse/pull/33717) ([Kseniia Sumarokova](https://github.com/kssenii)). -* related to issue: [#30715](https://github.com/ClickHouse/ClickHouse/issues/30715). Add three functions for map data type: 1. mapReplace(map1, map2) - replaces values for keys in map1 with the values of the corresponding keys in map2; adds keys from map2 that don't exist in map1. 2. mapFilter 3. mapMap mapFilter and mapMap are higher order functions , accept two arguments, first argument is a lambda function with k, v pair , the second argument is a map type column. [#33698](https://github.com/ClickHouse/ClickHouse/pull/33698) ([hexiaoting](https://github.com/hexiaoting)). +* Support for caching data locally for remote filesystems. It can be enabled for `s3` disks. Closes [#28961](https://github.com/ClickHouse/ClickHouse/issues/28961). [#33717](https://github.com/ClickHouse/ClickHouse/pull/33717) ([Kseniia Sumarokova](https://github.com/kssenii)). In the meantime, we enabled the test suite on s3 filesystem and no more known issues exist, so it is started to be production ready. +* Add new table function `hive`. It can be used as follows `hive('', '', '', '', '')` for example `SELECT * FROM hive('thrift://hivetest:9083', 'test', 'demo', 'id Nullable(String), score Nullable(Int32), day Nullable(String)', 'day')`. [#34946](https://github.com/ClickHouse/ClickHouse/pull/34946) ([lgbo](https://github.com/lgbo-ustc)). * Support authentication of users connected via SSL by their X.509 certificate. [#31484](https://github.com/ClickHouse/ClickHouse/pull/31484) ([eungenue](https://github.com/eungenue)). +* Support schema inference for inserting into table functions `file`/`hdfs`/`s3`/`url`. [#34732](https://github.com/ClickHouse/ClickHouse/pull/34732) ([Kruglov Pavel](https://github.com/Avogar)). +* Now you can read `system.zookeeper` table without restrictions on path or using `like` expression. This reads can generate quite heavy load for zookeeper so to enable this ability you have to enable setting `allow_unrestricted_reads_from_keeper`. [#34609](https://github.com/ClickHouse/ClickHouse/pull/34609) ([Sergei Trifonov](https://github.com/serxa)). +* Display CPU and memory metrics in clickhouse-local. Close [#34545](https://github.com/ClickHouse/ClickHouse/issues/34545). [#34605](https://github.com/ClickHouse/ClickHouse/pull/34605) ([李扬](https://github.com/taiyang-li)). +* Implement `startsWith` and `endsWith` function for arrays, closes [#33982](https://github.com/ClickHouse/ClickHouse/issues/33982). [#34368](https://github.com/ClickHouse/ClickHouse/pull/34368) ([usurai](https://github.com/usurai)). +* Add three functions for Map data type: 1. `mapReplace(map1, map2)` - replaces values for keys in map1 with the values of the corresponding keys in map2; adds keys from map2 that don't exist in map1. 2. `mapFilter` 3. `mapMap`. mapFilter and mapMap are higher order functions, accepting two arguments, the first argument is a lambda function with k, v pair as arguments, the second argument is a column of type Map. [#33698](https://github.com/ClickHouse/ClickHouse/pull/33698) ([hexiaoting](https://github.com/hexiaoting)). +* Allow getting default user and password for clickhouse-client from the `CLICKHOUSE_USER` and `CLICKHOUSE_PASSWORD` environment variables. Close [#34538](https://github.com/ClickHouse/ClickHouse/issues/34538). [#34947](https://github.com/ClickHouse/ClickHouse/pull/34947) ([DR](https://github.com/freedomDR)). + +#### Experimental Feature + +* Add `database_replicated_allow_only_replicated_engine` setting. When enabled, it only allowed to only create `Replicated` tables or tables with stateless engines in `Replicated` databases. [#35214](https://github.com/ClickHouse/ClickHouse/pull/35214) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). Note that `Replicated` database is still an experimental feature. #### Performance Improvement -* Less lock on connection using atomic stat. Notice that it is an approximate stat. [#35010](https://github.com/ClickHouse/ClickHouse/pull/35010) ([zhanglistar](https://github.com/zhanglistar)). -* Improve the performance of the `ANY` aggregation function by acting over batches. [#34760](https://github.com/ClickHouse/ClickHouse/pull/34760) ([Raúl Marín](https://github.com/Algunenano)). -* MergeTree improve insert performance replacing std::stable_sort with pdqsort. [#34750](https://github.com/ClickHouse/ClickHouse/pull/34750) ([Maksim Kita](https://github.com/kitaisreal)). -* Don't hold the latest snapshot in memory, instead, reading the snapshot if needed, sequence reading is fast to 200+MBps even on HDD using mmap system call. Writing snapshot data directly to disk using compression method without holding original data and compressed data in memory. [#34584](https://github.com/ClickHouse/ClickHouse/pull/34584) ([zhanglistar](https://github.com/zhanglistar)). -* Compaction of log store in Nuraft need acquire an inner lock which also used in normal commit process, so we delete useless logs in `compact` method of Changelog class in a background thread. See details on: https://github.com/ClickHouse-Extras/NuRaft/blob/1707a7572aa66ec5d0a2dbe2bf5effa3352e6b2d/src/handle_commit.cxx#L560. [#34534](https://github.com/ClickHouse/ClickHouse/pull/34534) ([zhanglistar](https://github.com/zhanglistar)). -* Calling std::distance on large list will decrease performance, use a version in Node to substitute with more memory 80MB/1000w Nodes. The logic is: Every node is list has a version with type size_t, setting in insert or insertOrReplace method using the class member variable current_version. The version is only increase at enableSnapshot method. When doing a snapshot, call snapshotSizeWithVersion to get snapshot size and version(snapshot_up_to_version). When traversing the list, if node version is less then or equal to snapshot_up_to_version, then protects it from deleting if node version is bigger than snapshot_up_to_version, we can do anything to it. [#34486](https://github.com/ClickHouse/ClickHouse/pull/34486) ([zhanglistar](https://github.com/zhanglistar)). +* Improve performance of insertion into `MergeTree` tables by optimizing sorting. Up to 2x improvement is observed on realistic benchmarks. [#34750](https://github.com/ClickHouse/ClickHouse/pull/34750) ([Maksim Kita](https://github.com/kitaisreal)). +* Columns pruning when reading Parquet, ORC and Arrow files from URL and S3. Closes [#34163](https://github.com/ClickHouse/ClickHouse/issues/34163). [#34849](https://github.com/ClickHouse/ClickHouse/pull/34849) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Columns pruning when reading Parquet, ORC and Arrow files from Hive. [#34954](https://github.com/ClickHouse/ClickHouse/pull/34954) ([lgbo](https://github.com/lgbo-ustc)). +* Improve performance of `any` aggregate function by using more batching. [#34760](https://github.com/ClickHouse/ClickHouse/pull/34760) ([Raúl Marín](https://github.com/Algunenano)). +* Multiple improvements for performance of `clickhouse-keeper`: less locking [#35010](https://github.com/ClickHouse/ClickHouse/pull/35010) ([zhanglistar](https://github.com/zhanglistar)), lower memory usage by streaming reading and writing of snapshot instead of full copy. [#34584](https://github.com/ClickHouse/ClickHouse/pull/34584) ([zhanglistar](https://github.com/zhanglistar)), optimizing compaction of log store in the RAFT implementation. [#34534](https://github.com/ClickHouse/ClickHouse/pull/34534) ([zhanglistar](https://github.com/zhanglistar)), versioning of the internal data structure [#34486](https://github.com/ClickHouse/ClickHouse/pull/34486) ([zhanglistar](https://github.com/zhanglistar)). #### Improvement -* Reload `remote_url_allow_hosts` after config update. [#35294](https://github.com/ClickHouse/ClickHouse/pull/35294) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). -* Return const for function getMacro if not in distributed query. Close [#34727](https://github.com/ClickHouse/ClickHouse/issues/34727). [#35289](https://github.com/ClickHouse/ClickHouse/pull/35289) ([李扬](https://github.com/taiyang-li)). -* Support test mode for clickhouse-local. [#35264](https://github.com/ClickHouse/ClickHouse/pull/35264) ([Kseniia Sumarokova](https://github.com/kssenii)). -* Sometimes it is not enough for us to distinguish queries hierachy only by is_initial_query in system.query_log and system.processes. So distributed_depth is needed. [#35207](https://github.com/ClickHouse/ClickHouse/pull/35207) ([李扬](https://github.com/taiyang-li)). -* Currently,Clickhouse validates hosts defined under for URL and Remote Table functions. This PR extends the RemoteHostFilter to Mysql and PostgreSQL table functions. [#35191](https://github.com/ClickHouse/ClickHouse/pull/35191) ([Heena Bansal](https://github.com/HeenaBansal2009)). -* Added disk_name to system.part_log. [#35178](https://github.com/ClickHouse/ClickHouse/pull/35178) ([Artyom Yurkov](https://github.com/Varinara)). -* Do not retry non-rertiable errors. Closes [#35161](https://github.com/ClickHouse/ClickHouse/issues/35161). [#35172](https://github.com/ClickHouse/ClickHouse/pull/35172) ([Kseniia Sumarokova](https://github.com/kssenii)). -* Add setting to lower column case when reading parquet/ORC file. [#35145](https://github.com/ClickHouse/ClickHouse/pull/35145) ([shuchaome](https://github.com/shuchaome)). -* Support `view()` for `parallel_distributed_insert_select`. [#35132](https://github.com/ClickHouse/ClickHouse/pull/35132) ([Azat Khuzhin](https://github.com/azat)). -* Avoid possible `MEMORY_LIMIT_EXCEEDED` during `INSERT` into `Buffer` with `AggregateFunction`. [#35072](https://github.com/ClickHouse/ClickHouse/pull/35072) ([Azat Khuzhin](https://github.com/azat)). -* Avoid division by zero in Query Profiler if Linux kernel has a bug. Closes [#34787](https://github.com/ClickHouse/ClickHouse/issues/34787). [#35032](https://github.com/ClickHouse/ClickHouse/pull/35032) ([Alexey Milovidov](https://github.com/alexey-milovidov)). -* Functions `dictGetHierarchy`, `dictIsIn`, `dictGetChildren`, `dictGetDescendants` support implicit key cast and constant arguments. Closes [#34970](https://github.com/ClickHouse/ClickHouse/issues/34970). [#35027](https://github.com/ClickHouse/ClickHouse/pull/35027) ([Maksim Kita](https://github.com/kitaisreal)). -* Add more sanity checks for keeper configuration: now mixing of localhost and non-local servers is not allowed, also add checks for same value of internal raft port and keeper client port. [#35004](https://github.com/ClickHouse/ClickHouse/pull/35004) ([alesapin](https://github.com/alesapin)). -* For random access readbuffer in hive, the first time to read the readbuffer would use the original readbuffer instead of local file. When we read a parquet/orc format file, the readbuffer seeks to the end of the file, which will be blocked until the local file finishes download, and make the whold process slow. [#34957](https://github.com/ClickHouse/ClickHouse/pull/34957) ([lgbo](https://github.com/lgbo-ustc)). -* remove unnecessary columns for reading parquet/orc files. [#34954](https://github.com/ClickHouse/ClickHouse/pull/34954) ([lgbo](https://github.com/lgbo-ustc)). -* Currently, if the user changes the settings of the system tables there will be tons of logs and ClickHouse will rename the tables every minute. This fixes [#34929](https://github.com/ClickHouse/ClickHouse/issues/34929). [#34949](https://github.com/ClickHouse/ClickHouse/pull/34949) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)). -* Use connection pool for hive metastore client. [#34940](https://github.com/ClickHouse/ClickHouse/pull/34940) ([lgbo](https://github.com/lgbo-ustc)). -* Ignore per-column `TTL` in `CREATE TABLE AS` if new table engine does not support it (i.e. if the engine is not of `MergeTree` family). [#34938](https://github.com/ClickHouse/ClickHouse/pull/34938) ([Azat Khuzhin](https://github.com/azat)). -* Allow LowCardinality strings for ngrambf_v1/tokenbf_v1 indexes. Closes [#21865](https://github.com/ClickHouse/ClickHouse/issues/21865). [#34911](https://github.com/ClickHouse/ClickHouse/pull/34911) ([Lars Hiller Eidnes](https://github.com/larspars)). -* Allow to open empty sqlite db file if it does not exist. Closes [#33367](https://github.com/ClickHouse/ClickHouse/issues/33367). [#34907](https://github.com/ClickHouse/ClickHouse/pull/34907) ([Kseniia Sumarokova](https://github.com/kssenii)). -* Implement MemoryStatisticsOS for FreeBSD. [#34902](https://github.com/ClickHouse/ClickHouse/pull/34902) ([Alexandre Snarskii](https://github.com/snar)). -* Fix reading only columns which user asked for. Closes [#34163](https://github.com/ClickHouse/ClickHouse/issues/34163). [#34849](https://github.com/ClickHouse/ClickHouse/pull/34849) ([Kseniia Sumarokova](https://github.com/kssenii)). -* In previous versions the progress bar in clickhouse-client can jump forward near 50% for no reason. This closes [#34324](https://github.com/ClickHouse/ClickHouse/issues/34324). [#34801](https://github.com/ClickHouse/ClickHouse/pull/34801) ([Alexey Milovidov](https://github.com/alexey-milovidov)). -* Now `ALTER TABLE DROP COLUMN columnX` queries for `MergeTree` table engines will work instantly when `columnX` is `ALIAS` column. Fixes [#34660](https://github.com/ClickHouse/ClickHouse/issues/34660). [#34786](https://github.com/ClickHouse/ClickHouse/pull/34786) ([alesapin](https://github.com/alesapin)). -* Add name hints for data skipping indices. Closes [#29698](https://github.com/ClickHouse/ClickHouse/issues/29698). [#34764](https://github.com/ClickHouse/ClickHouse/pull/34764) ([flynn](https://github.com/ucasfl)). -* Support `remote()`/`cluster()` for `parallel_distributed_insert_select=2`. [#34728](https://github.com/ClickHouse/ClickHouse/pull/34728) ([Azat Khuzhin](https://github.com/azat)). -* Do not reset logging that configured via --log-file/--errorlog-file in case of empty logger.log/logger.errorlog. [#34718](https://github.com/ClickHouse/ClickHouse/pull/34718) ([Amos Bird](https://github.com/amosbird)). -* Extract schema only once on table creation and prevent reading from local files/external sources to extract schema on each server startup. [#34684](https://github.com/ClickHouse/ClickHouse/pull/34684) ([Kruglov Pavel](https://github.com/Avogar)). -* ExecutableUserDefinedFunctions allow to specify argument names. This is necessary for formats where argument name is part of serialization, like `Native`, `JSONEachRow`. Closes [#34604](https://github.com/ClickHouse/ClickHouse/issues/34604). [#34653](https://github.com/ClickHouse/ClickHouse/pull/34653) ([Maksim Kita](https://github.com/kitaisreal)). -* Some refactoring and improvement over async and remote buffer related stuff. Separated in each commit. [#34629](https://github.com/ClickHouse/ClickHouse/pull/34629) ([Amos Bird](https://github.com/amosbird)). -* Now you can read `system.zookeeper` table without restrictions on path or using `like` expression. This reads can generate quite heavy load for zookeeper so to enable this ability you have to enable setting `allow_unrestricted_reads_from_keeper`. [#34609](https://github.com/ClickHouse/ClickHouse/pull/34609) ([Sergei Trifonov](https://github.com/serxa)). -* This PR changes restrictive row policies a bit to make them an easier alternative to permissive policies in easy cases. If for a particular table only restrictive policies exist (without permissive policies) users will be able to see some rows. Also `SHOW CREATE ROW POLICY` will always show `AS permissive` or `AS restrictive` in row policy's definition. [#34596](https://github.com/ClickHouse/ClickHouse/pull/34596) ([Vitaly Baranov](https://github.com/vitlibar)). -* MaterializedMySQL support materialized_mysql_tables_list(a comma-separated list of mysql database tables, which will be replicated by MaterializedMySQL database engine. Default value: empty list — means whole tables will be replicated) settings, mentioned at [#32977](https://github.com/ClickHouse/ClickHouse/issues/32977). [#34487](https://github.com/ClickHouse/ClickHouse/pull/34487) ([zzsmdfj](https://github.com/zzsmdfj)). -* - Improve the opentelemetry span logs for INSERT operation on distributed table. [#34480](https://github.com/ClickHouse/ClickHouse/pull/34480) ([Frank Chen](https://github.com/FrankChen021)). -* Improve schema inference with globs in FIle/S3/HDFS/URL engines. Try to use the next path for schema inference in case of error. [#34465](https://github.com/ClickHouse/ClickHouse/pull/34465) ([Kruglov Pavel](https://github.com/Avogar)). +* Implicit type casting of the key argument for functions `dictGetHierarchy`, `dictIsIn`, `dictGetChildren`, `dictGetDescendants`. Closes [#34970](https://github.com/ClickHouse/ClickHouse/issues/34970). [#35027](https://github.com/ClickHouse/ClickHouse/pull/35027) ([Maksim Kita](https://github.com/kitaisreal)). +* `EXPLAIN AST` query can output AST in form of a graph in Graphviz format: `EXPLAIN AST graph = 1 SELECT * FROM system.parts`. [#35173](https://github.com/ClickHouse/ClickHouse/pull/35173) ([李扬](https://github.com/taiyang-li)). * When large files were written with `s3` table function or table engine, the content type on the files was mistakenly set to `application/xml` due to a bug in the AWS SDK. This closes [#33964](https://github.com/ClickHouse/ClickHouse/issues/33964). [#34433](https://github.com/ClickHouse/ClickHouse/pull/34433) ([Alexey Milovidov](https://github.com/alexey-milovidov)). -* Hold time lock while assigning tasks to clear old temporary directories in StorageMergeTree. [#34025](https://github.com/ClickHouse/ClickHouse/pull/34025) ([Amos Bird](https://github.com/amosbird)). -* Make the znode ctime and mtime consistent between servers. [#33441](https://github.com/ClickHouse/ClickHouse/pull/33441) ([小路](https://github.com/nicelulu)). - -#### Bug Fix - -* When the inner readbuffer's buffer size is too small, NEED_MORE_INPUT in `HadoopSnappyDecoder` will run multi times (>=3)for one compressed block. This makes the input data be copied into the wrong place in `HadoopSnappyDecoder::buffer`. [#35116](https://github.com/ClickHouse/ClickHouse/pull/35116) ([lgbo](https://github.com/lgbo-ustc)). -* Ignore obsolete grants in ATTACH GRANT statements. This PR fixes [#34815](https://github.com/ClickHouse/ClickHouse/issues/34815). [#34855](https://github.com/ClickHouse/ClickHouse/pull/34855) ([Vitaly Baranov](https://github.com/vitlibar)). +* Change restrictive row policies a bit to make them an easier alternative to permissive policies in easy cases. If for a particular table only restrictive policies exist (without permissive policies) users will be able to see some rows. Also `SHOW CREATE ROW POLICY` will always show `AS permissive` or `AS restrictive` in row policy's definition. [#34596](https://github.com/ClickHouse/ClickHouse/pull/34596) ([Vitaly Baranov](https://github.com/vitlibar)). +* Improve schema inference with globs in File/S3/HDFS/URL engines. Try to use the next path for schema inference in case of error. [#34465](https://github.com/ClickHouse/ClickHouse/pull/34465) ([Kruglov Pavel](https://github.com/Avogar)). +* Play UI now correctly detects the preferred light/dark theme from the OS. [#35068](https://github.com/ClickHouse/ClickHouse/pull/35068) ([peledni](https://github.com/peledni)). +* Added `date_time_input_format = 'best_effort_us'`. Closes [#34799](https://github.com/ClickHouse/ClickHouse/issues/34799). [#34982](https://github.com/ClickHouse/ClickHouse/pull/34982) ([WenYao](https://github.com/Cai-Yao)). +* A new settings called `allow_plaintext_password` and `allow_no_password` are added in server configuration which turn on/off authentication types that can be potentially insecure in some environments. They are allowed by default. [#34738](https://github.com/ClickHouse/ClickHouse/pull/34738) ([Heena Bansal](https://github.com/HeenaBansal2009)). +* Support for `DateTime64` data type in `Arrow` format, closes [#8280](https://github.com/ClickHouse/ClickHouse/issues/8280) and closes [#28574](https://github.com/ClickHouse/ClickHouse/issues/28574). [#34561](https://github.com/ClickHouse/ClickHouse/pull/34561) ([李扬](https://github.com/taiyang-li)). +* Reload `remote_url_allow_hosts` (filtering of outgoing connections) on config update. [#35294](https://github.com/ClickHouse/ClickHouse/pull/35294) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). +* Support `--testmode` parameter for `clickhouse-local`. This parameter enables interpretation of test hints that we use in functional tests. [#35264](https://github.com/ClickHouse/ClickHouse/pull/35264) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Add `distributed_depth` to query log. It is like a more detailed variant of `is_initial_query` [#35207](https://github.com/ClickHouse/ClickHouse/pull/35207) ([李扬](https://github.com/taiyang-li)). +* Respect `remote_url_allow_hosts` for `MySQL` and `PostgreSQL` table functions. [#35191](https://github.com/ClickHouse/ClickHouse/pull/35191) ([Heena Bansal](https://github.com/HeenaBansal2009)). +* Added `disk_name` field to `system.part_log`. [#35178](https://github.com/ClickHouse/ClickHouse/pull/35178) ([Artyom Yurkov](https://github.com/Varinara)). +* Do not retry non-rertiable errors when querying remote URLs. Closes [#35161](https://github.com/ClickHouse/ClickHouse/issues/35161). [#35172](https://github.com/ClickHouse/ClickHouse/pull/35172) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Support distributed INSERT SELECT queries (the setting `parallel_distributed_insert_select`) table function `view()`. [#35132](https://github.com/ClickHouse/ClickHouse/pull/35132) ([Azat Khuzhin](https://github.com/azat)). +* More precise memory tracking during `INSERT` into `Buffer` with `AggregateFunction`. [#35072](https://github.com/ClickHouse/ClickHouse/pull/35072) ([Azat Khuzhin](https://github.com/azat)). +* Avoid division by zero in Query Profiler if Linux kernel has a bug. Closes [#34787](https://github.com/ClickHouse/ClickHouse/issues/34787). [#35032](https://github.com/ClickHouse/ClickHouse/pull/35032) ([Alexey Milovidov](https://github.com/alexey-milovidov)). +* Add more sanity checks for keeper configuration: now mixing of localhost and non-local servers is not allowed, also add checks for same value of internal raft port and keeper client port. [#35004](https://github.com/ClickHouse/ClickHouse/pull/35004) ([alesapin](https://github.com/alesapin)). +* Currently, if the user changes the settings of the system tables there will be tons of logs and ClickHouse will rename the tables every minute. This fixes [#34929](https://github.com/ClickHouse/ClickHouse/issues/34929). [#34949](https://github.com/ClickHouse/ClickHouse/pull/34949) ([Nikita Mikhaylov](https://github.com/nikitamikhaylov)). +* Use connection pool for Hive metastore client. [#34940](https://github.com/ClickHouse/ClickHouse/pull/34940) ([lgbo](https://github.com/lgbo-ustc)). +* Ignore per-column `TTL` in `CREATE TABLE AS` if new table engine does not support it (i.e. if the engine is not of `MergeTree` family). [#34938](https://github.com/ClickHouse/ClickHouse/pull/34938) ([Azat Khuzhin](https://github.com/azat)). +* Allow `LowCardinality` strings for `ngrambf_v1`/`tokenbf_v1` indexes. Closes [#21865](https://github.com/ClickHouse/ClickHouse/issues/21865). [#34911](https://github.com/ClickHouse/ClickHouse/pull/34911) ([Lars Hiller Eidnes](https://github.com/larspars)). +* Allow opening empty sqlite db if the file doesn't exist. Closes [#33367](https://github.com/ClickHouse/ClickHouse/issues/33367). [#34907](https://github.com/ClickHouse/ClickHouse/pull/34907) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Implement memory statistics for FreeBSD - this is required for `max_server_memory_usage` to work correctly. [#34902](https://github.com/ClickHouse/ClickHouse/pull/34902) ([Alexandre Snarskii](https://github.com/snar)). +* In previous versions the progress bar in clickhouse-client can jump forward near 50% for no reason. This closes [#34324](https://github.com/ClickHouse/ClickHouse/issues/34324). [#34801](https://github.com/ClickHouse/ClickHouse/pull/34801) ([Alexey Milovidov](https://github.com/alexey-milovidov)). +* Now `ALTER TABLE DROP COLUMN columnX` queries for `MergeTree` table engines will work instantly when `columnX` is an `ALIAS` column. Fixes [#34660](https://github.com/ClickHouse/ClickHouse/issues/34660). [#34786](https://github.com/ClickHouse/ClickHouse/pull/34786) ([alesapin](https://github.com/alesapin)). +* Show hints when user mistyped the name of a data skipping index. Closes [#29698](https://github.com/ClickHouse/ClickHouse/issues/29698). [#34764](https://github.com/ClickHouse/ClickHouse/pull/34764) ([flynn](https://github.com/ucasfl)). +* Support `remote()`/`cluster()` table functions for `parallel_distributed_insert_select`. [#34728](https://github.com/ClickHouse/ClickHouse/pull/34728) ([Azat Khuzhin](https://github.com/azat)). +* Do not reset logging that configured via `--log-file`/`--errorlog-file` command line options in case of empty configuration in the config file. [#34718](https://github.com/ClickHouse/ClickHouse/pull/34718) ([Amos Bird](https://github.com/amosbird)). +* Extract schema only once on table creation and prevent reading from local files/external sources to extract schema on each server startup. [#34684](https://github.com/ClickHouse/ClickHouse/pull/34684) ([Kruglov Pavel](https://github.com/Avogar)). +* Allow specifying argument names for executable UDFs. This is necessary for formats where argument name is part of serialization, like `Native`, `JSONEachRow`. Closes [#34604](https://github.com/ClickHouse/ClickHouse/issues/34604). [#34653](https://github.com/ClickHouse/ClickHouse/pull/34653) ([Maksim Kita](https://github.com/kitaisreal)). +* `MaterializedMySQL` (experimental feature) now supports `materialized_mysql_tables_list` (a comma-separated list of MySQL database tables, which will be replicated by the MaterializedMySQL database engine. Default value: empty list — means all the tables will be replicated), mentioned at [#32977](https://github.com/ClickHouse/ClickHouse/issues/32977). [#34487](https://github.com/ClickHouse/ClickHouse/pull/34487) ([zzsmdfj](https://github.com/zzsmdfj)). +* Improve OpenTelemetry span logs for INSERT operation on distributed table. [#34480](https://github.com/ClickHouse/ClickHouse/pull/34480) ([Frank Chen](https://github.com/FrankChen021)). +* Make the znode `ctime` and `mtime` consistent between servers in ClickHouse Keeper. [#33441](https://github.com/ClickHouse/ClickHouse/pull/33441) ([小路](https://github.com/nicelulu)). #### Build/Testing/Packaging Improvement -* Add an ability to build stripped binaries with cmake. [#35196](https://github.com/ClickHouse/ClickHouse/pull/35196) ([alesapin](https://github.com/alesapin)). -* Clion has the following problems "The breakpoint will not currently be hit. No executable code is associated with this line". [#35179](https://github.com/ClickHouse/ClickHouse/pull/35179) ([小路](https://github.com/nicelulu)). -* Separate smaller clickhouse-keeper build. [#35031](https://github.com/ClickHouse/ClickHouse/pull/35031) ([alesapin](https://github.com/alesapin)). +* Randomize some settings in functional tests, so more possible combinations of settings will be tested. This is yet another fuzzing method to ensure better test coverage. This closes [#32268](https://github.com/ClickHouse/ClickHouse/issues/32268). [#34092](https://github.com/ClickHouse/ClickHouse/pull/34092) ([Kruglov Pavel](https://github.com/Avogar)). +* Drop PVS-Studio from our CI. [#34680](https://github.com/ClickHouse/ClickHouse/pull/34680) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). +* Add an ability to build stripped binaries with CMake. In previous versions it was performed by dh-tools. [#35196](https://github.com/ClickHouse/ClickHouse/pull/35196) ([alesapin](https://github.com/alesapin)). +* Smaller "fat-free" `clickhouse-keeper` build. [#35031](https://github.com/ClickHouse/ClickHouse/pull/35031) ([alesapin](https://github.com/alesapin)). * Use @robot-clickhouse as an author and committer for PRs like https://github.com/ClickHouse/ClickHouse/pull/34685. [#34793](https://github.com/ClickHouse/ClickHouse/pull/34793) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). -* Improve CI scripts arguments. [#34792](https://github.com/ClickHouse/ClickHouse/pull/34792) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). * Limit DWARF version for debug info by 4 max, because our internal stack symbolizer cannot parse DWARF version 5. This makes sense if you compile ClickHouse with clang-15. [#34777](https://github.com/ClickHouse/ClickHouse/pull/34777) ([Alexey Milovidov](https://github.com/alexey-milovidov)). -* Drop PVS test from CI. [#34680](https://github.com/ClickHouse/ClickHouse/pull/34680) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). -* Set timeout 40 minutes for fast tests. [#34624](https://github.com/ClickHouse/ClickHouse/pull/34624) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). -* Debian package clickhouse-test.deb removed completely. CI use tests from repository and standalone testing via deb package is no longer supported. [#34606](https://github.com/ClickHouse/ClickHouse/pull/34606) ([Ilya Yatsishin](https://github.com/qoega)). -* NA. [#34513](https://github.com/ClickHouse/ClickHouse/pull/34513) ([vzakaznikov](https://github.com/vzakaznikov)). -* Randomize some settings in functional tests. This closes [#32268](https://github.com/ClickHouse/ClickHouse/issues/32268). [#34092](https://github.com/ClickHouse/ClickHouse/pull/34092) ([Kruglov Pavel](https://github.com/Avogar)). +* Remove `clickhouse-test` debian package as unneeded complication. CI use tests from repository and standalone testing via deb package is no longer supported. [#34606](https://github.com/ClickHouse/ClickHouse/pull/34606) ([Ilya Yatsishin](https://github.com/qoega)). #### Bug Fix (user-visible misbehaviour in official stable or prestable release) +* When the inner readbuffer's buffer size is too small, NEED_MORE_INPUT in `HadoopSnappyDecoder` will run multi times (>=3) for one compressed block. This makes the input data be copied into the wrong place in `HadoopSnappyDecoder::buffer`. [#35116](https://github.com/ClickHouse/ClickHouse/pull/35116) ([lgbo](https://github.com/lgbo-ustc)). +* Ignore obsolete grants in ATTACH GRANT statements. This PR fixes [#34815](https://github.com/ClickHouse/ClickHouse/issues/34815). [#34855](https://github.com/ClickHouse/ClickHouse/pull/34855) ([Vitaly Baranov](https://github.com/vitlibar)). * Fix segfault in Postgres database when getting create table query if database was created using named collections. Closes [#35312](https://github.com/ClickHouse/ClickHouse/issues/35312). [#35313](https://github.com/ClickHouse/ClickHouse/pull/35313) ([Kseniia Sumarokova](https://github.com/kssenii)). * - Fix partial merge join duplicate rows bug, close [#31009](https://github.com/ClickHouse/ClickHouse/issues/31009). [#35311](https://github.com/ClickHouse/ClickHouse/pull/35311) ([Vladimir C](https://github.com/vdimir)). * Fix possible `Assertion 'position() != working_buffer.end()' failed` while using bzip2 compression with small `max_read_buffer_size` setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35300](https://github.com/ClickHouse/ClickHouse/pull/35300) ([Kruglov Pavel](https://github.com/Avogar)). From a19e2d34492ca053accceec2aa9406060c54d6c2 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Thu, 17 Mar 2022 00:41:20 +0100 Subject: [PATCH 126/132] Mostly done --- CHANGELOG.md | 58 +++++++++++++++++++++++++--------------------------- 1 file changed, 28 insertions(+), 30 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 16ee2c79942..3ed779b6a45 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -31,6 +31,7 @@ #### Improvement +* Allow asynchronous inserts to table functions. Fixes [#34864](https://github.com/ClickHouse/ClickHouse/issues/34864). [#34866](https://github.com/ClickHouse/ClickHouse/pull/34866) ([Anton Popov](https://github.com/CurtizJ)). * Implicit type casting of the key argument for functions `dictGetHierarchy`, `dictIsIn`, `dictGetChildren`, `dictGetDescendants`. Closes [#34970](https://github.com/ClickHouse/ClickHouse/issues/34970). [#35027](https://github.com/ClickHouse/ClickHouse/pull/35027) ([Maksim Kita](https://github.com/kitaisreal)). * `EXPLAIN AST` query can output AST in form of a graph in Graphviz format: `EXPLAIN AST graph = 1 SELECT * FROM system.parts`. [#35173](https://github.com/ClickHouse/ClickHouse/pull/35173) ([李扬](https://github.com/taiyang-li)). * When large files were written with `s3` table function or table engine, the content type on the files was mistakenly set to `application/xml` due to a bug in the AWS SDK. This closes [#33964](https://github.com/ClickHouse/ClickHouse/issues/33964). [#34433](https://github.com/ClickHouse/ClickHouse/pull/34433) ([Alexey Milovidov](https://github.com/alexey-milovidov)). @@ -79,50 +80,47 @@ #### Bug Fix (user-visible misbehaviour in official stable or prestable release) -* When the inner readbuffer's buffer size is too small, NEED_MORE_INPUT in `HadoopSnappyDecoder` will run multi times (>=3) for one compressed block. This makes the input data be copied into the wrong place in `HadoopSnappyDecoder::buffer`. [#35116](https://github.com/ClickHouse/ClickHouse/pull/35116) ([lgbo](https://github.com/lgbo-ustc)). +* A fix for HDFS integration: When the inner buffer size is too small, NEED_MORE_INPUT in `HadoopSnappyDecoder` will run multi times (>=3) for one compressed block. This makes the input data be copied into the wrong place in `HadoopSnappyDecoder::buffer`. [#35116](https://github.com/ClickHouse/ClickHouse/pull/35116) ([lgbo](https://github.com/lgbo-ustc)). * Ignore obsolete grants in ATTACH GRANT statements. This PR fixes [#34815](https://github.com/ClickHouse/ClickHouse/issues/34815). [#34855](https://github.com/ClickHouse/ClickHouse/pull/34855) ([Vitaly Baranov](https://github.com/vitlibar)). * Fix segfault in Postgres database when getting create table query if database was created using named collections. Closes [#35312](https://github.com/ClickHouse/ClickHouse/issues/35312). [#35313](https://github.com/ClickHouse/ClickHouse/pull/35313) ([Kseniia Sumarokova](https://github.com/kssenii)). -* - Fix partial merge join duplicate rows bug, close [#31009](https://github.com/ClickHouse/ClickHouse/issues/31009). [#35311](https://github.com/ClickHouse/ClickHouse/pull/35311) ([Vladimir C](https://github.com/vdimir)). -* Fix possible `Assertion 'position() != working_buffer.end()' failed` while using bzip2 compression with small `max_read_buffer_size` setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35300](https://github.com/ClickHouse/ClickHouse/pull/35300) ([Kruglov Pavel](https://github.com/Avogar)). -* Fix possible segfault while using lz4 compression with a small max_read_buffer_size setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35296](https://github.com/ClickHouse/ClickHouse/pull/35296) ([Kruglov Pavel](https://github.com/Avogar)). -* Fix possible `Assertion 'position() != working_buffer.end()' failed` while using lzma compression with small `max_read_buffer_size` setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35295](https://github.com/ClickHouse/ClickHouse/pull/35295) ([Kruglov Pavel](https://github.com/Avogar)). -* Fix possible segfault in JSONEachRow schema inference. [#35291](https://github.com/ClickHouse/ClickHouse/pull/35291) ([Kruglov Pavel](https://github.com/Avogar)). -* Fix possible Abort while using Brotli compression with a small `max_read_buffer_size` setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35281](https://github.com/ClickHouse/ClickHouse/pull/35281) ([Kruglov Pavel](https://github.com/Avogar)). +* Fix partial merge join duplicate rows bug, close [#31009](https://github.com/ClickHouse/ClickHouse/issues/31009). [#35311](https://github.com/ClickHouse/ClickHouse/pull/35311) ([Vladimir C](https://github.com/vdimir)). +* Fix possible `Assertion 'position() != working_buffer.end()' failed` while using bzip2 compression with small `max_read_buffer_size` setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35300](https://github.com/ClickHouse/ClickHouse/pull/35300) ([Kruglov Pavel](https://github.com/Avogar)). While using lz4 compression with a small max_read_buffer_size setting value. [#35296](https://github.com/ClickHouse/ClickHouse/pull/35296) ([Kruglov Pavel](https://github.com/Avogar)). While using lzma compression with small `max_read_buffer_size` setting value. [#35295](https://github.com/ClickHouse/ClickHouse/pull/35295) ([Kruglov Pavel](https://github.com/Avogar)). While using `brotli` compression with a small `max_read_buffer_size` setting value. The bug was found in https://github.com/ClickHouse/ClickHouse/pull/35047. [#35281](https://github.com/ClickHouse/ClickHouse/pull/35281) ([Kruglov Pavel](https://github.com/Avogar)). +* Fix possible segfault in `JSONEachRow` schema inference. [#35291](https://github.com/ClickHouse/ClickHouse/pull/35291) ([Kruglov Pavel](https://github.com/Avogar)). * Fix `CHECK TABLE` query in case when sparse columns are enabled in table. [#35274](https://github.com/ClickHouse/ClickHouse/pull/35274) ([Anton Popov](https://github.com/CurtizJ)). -* Wait for IDiskRemote thread pool properly. [#35257](https://github.com/ClickHouse/ClickHouse/pull/35257) ([Azat Khuzhin](https://github.com/azat)). -* * Fix reading port from config, close [#34776](https://github.com/ClickHouse/ClickHouse/issues/34776). [#35193](https://github.com/ClickHouse/ClickHouse/pull/35193) ([Vladimir C](https://github.com/vdimir)). +* Avoid std::terminate in case of exception in reading from remote VFS. [#35257](https://github.com/ClickHouse/ClickHouse/pull/35257) ([Azat Khuzhin](https://github.com/azat)). +* Fix reading port from config, close [#34776](https://github.com/ClickHouse/ClickHouse/issues/34776). [#35193](https://github.com/ClickHouse/ClickHouse/pull/35193) ([Vladimir C](https://github.com/vdimir)). * Fix error in query with `WITH TOTALS` in case if `HAVING` returned empty result. This fixes [#33711](https://github.com/ClickHouse/ClickHouse/issues/33711). [#35186](https://github.com/ClickHouse/ClickHouse/pull/35186) ([Amos Bird](https://github.com/amosbird)). -* - Fix `replaceRegexpAll`, close [#35117](https://github.com/ClickHouse/ClickHouse/issues/35117). [#35182](https://github.com/ClickHouse/ClickHouse/pull/35182) ([Vladimir C](https://github.com/vdimir)). +* Fix a corner case of `replaceRegexpAll`, close [#35117](https://github.com/ClickHouse/ClickHouse/issues/35117). [#35182](https://github.com/ClickHouse/ClickHouse/pull/35182) ([Vladimir C](https://github.com/vdimir)). * Schema inference didn't work properly on case of `INSERT INTO FUNCTION s3(...) FROM ...`, it tried to read schema from s3 file instead of from select query. [#35176](https://github.com/ClickHouse/ClickHouse/pull/35176) ([Kruglov Pavel](https://github.com/Avogar)). -* Fix materialised postgres `table overrides` for partition by, etc. Closes [#35048](https://github.com/ClickHouse/ClickHouse/issues/35048). [#35162](https://github.com/ClickHouse/ClickHouse/pull/35162) ([Kseniia Sumarokova](https://github.com/kssenii)). -* Fix materialised postrgesql adding new table to replication (ATTACH TABLE) after manually removing (DETACH TABLE). Closes [#33800](https://github.com/ClickHouse/ClickHouse/issues/33800). Closes [#34922](https://github.com/ClickHouse/ClickHouse/issues/34922). Closes [#34315](https://github.com/ClickHouse/ClickHouse/issues/34315). [#35158](https://github.com/ClickHouse/ClickHouse/pull/35158) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix MaterializedPostgreSQL (experimental feature) `table overrides` for partition by, etc. Closes [#35048](https://github.com/ClickHouse/ClickHouse/issues/35048). [#35162](https://github.com/ClickHouse/ClickHouse/pull/35162) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix MaterializedPostgreSQL (experimental feature) adding new table to replication (ATTACH TABLE) after manually removing (DETACH TABLE). Closes [#33800](https://github.com/ClickHouse/ClickHouse/issues/33800). Closes [#34922](https://github.com/ClickHouse/ClickHouse/issues/34922). Closes [#34315](https://github.com/ClickHouse/ClickHouse/issues/34315). [#35158](https://github.com/ClickHouse/ClickHouse/pull/35158) ([Kseniia Sumarokova](https://github.com/kssenii)). * Fix partition pruning error when non-monotonic function is used with IN operator. This fixes [#35136](https://github.com/ClickHouse/ClickHouse/issues/35136). [#35146](https://github.com/ClickHouse/ClickHouse/pull/35146) ([Amos Bird](https://github.com/amosbird)). -* Fixed the incorrect translation YAML config to XML. [#35135](https://github.com/ClickHouse/ClickHouse/pull/35135) ([Miel Donkers](https://github.com/mdonkers)). +* Fixed slightly incorrect translation of YAML configs to XML. [#35135](https://github.com/ClickHouse/ClickHouse/pull/35135) ([Miel Donkers](https://github.com/mdonkers)). * Fix `optimize_skip_unused_shards_rewrite_in` for signed columns and negative values. [#35134](https://github.com/ClickHouse/ClickHouse/pull/35134) ([Azat Khuzhin](https://github.com/azat)). -* Fixed the "update_lag" external dictionary configuration option being unusable with the error message ``Unexpected key `update_lag` in dictionary source configuration``. [#35089](https://github.com/ClickHouse/ClickHouse/pull/35089) ([Jason Chu](https://github.com/1lann)). +* The `update_lag` external dictionary configuration option was unusable showing the error message ``Unexpected key `update_lag` in dictionary source configuration``. [#35089](https://github.com/ClickHouse/ClickHouse/pull/35089) ([Jason Chu](https://github.com/1lann)). * Avoid possible deadlock on server shutdown. [#35081](https://github.com/ClickHouse/ClickHouse/pull/35081) ([Azat Khuzhin](https://github.com/azat)). -* Fix missing alias after function is optimized to subcolumn when setting `optimize_functions_to_subcolumns` is enabled. Closes [#33798](https://github.com/ClickHouse/ClickHouse/issues/33798). [#35079](https://github.com/ClickHouse/ClickHouse/pull/35079) ([qieqieplus](https://github.com/qieqieplus)). +* Fix missing alias after function is optimized to a subcolumn when setting `optimize_functions_to_subcolumns` is enabled. Closes [#33798](https://github.com/ClickHouse/ClickHouse/issues/33798). [#35079](https://github.com/ClickHouse/ClickHouse/pull/35079) ([qieqieplus](https://github.com/qieqieplus)). * Fix reading from `system.asynchronous_inserts` table if there exists asynchronous insert into table function. [#35050](https://github.com/ClickHouse/ClickHouse/pull/35050) ([Anton Popov](https://github.com/CurtizJ)). -* Fix possible exception `Reading for MergeTree family tables must be done with last position boundary`. Closes [#34979](https://github.com/ClickHouse/ClickHouse/issues/34979). [#35001](https://github.com/ClickHouse/ClickHouse/pull/35001) ([Kseniia Sumarokova](https://github.com/kssenii)). -* Fix unexpected result when use -state type aggregate function in window frame. [#34999](https://github.com/ClickHouse/ClickHouse/pull/34999) ([metahys](https://github.com/metahys)). -* Fix possible segfault in filelog. Closes [#30749](https://github.com/ClickHouse/ClickHouse/issues/30749). [#34996](https://github.com/ClickHouse/ClickHouse/pull/34996) ([Kseniia Sumarokova](https://github.com/kssenii)). -* Fix possible rare error `Cannot push block to port which already has data`. Avoid pushing to port with data inside `DelayedSource`. [#34993](https://github.com/ClickHouse/ClickHouse/pull/34993) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). +* Fix possible exception `Reading for MergeTree family tables must be done with last position boundary` (relevant to operation on remote VFS). Closes [#34979](https://github.com/ClickHouse/ClickHouse/issues/34979). [#35001](https://github.com/ClickHouse/ClickHouse/pull/35001) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix unexpected result when use -State type aggregate function in window frame. [#34999](https://github.com/ClickHouse/ClickHouse/pull/34999) ([metahys](https://github.com/metahys)). +* Fix possible segfault in FileLog (experimental feature). Closes [#30749](https://github.com/ClickHouse/ClickHouse/issues/30749). [#34996](https://github.com/ClickHouse/ClickHouse/pull/34996) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix possible rare error `Cannot push block to port which already has data`. [#34993](https://github.com/ClickHouse/ClickHouse/pull/34993) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). * Fix wrong schema inference for unquoted dates in CSV. Closes [#34768](https://github.com/ClickHouse/ClickHouse/issues/34768). [#34961](https://github.com/ClickHouse/ClickHouse/pull/34961) ([Kruglov Pavel](https://github.com/Avogar)). -* Unexpected result when use `in` in `where` in hive query. [#34945](https://github.com/ClickHouse/ClickHouse/pull/34945) ([lgbo](https://github.com/lgbo-ustc)). -* Avoid busy polling in keeper while searching for changelog files to delete. [#34931](https://github.com/ClickHouse/ClickHouse/pull/34931) ([Azat Khuzhin](https://github.com/azat)). -* Fix postgres datetime64 conversion. Closes [#33364](https://github.com/ClickHouse/ClickHouse/issues/33364). [#34910](https://github.com/ClickHouse/ClickHouse/pull/34910) ([Kseniia Sumarokova](https://github.com/kssenii)). -* Fix possible "Part directory doesn't exist" during `INSERT`. [#34876](https://github.com/ClickHouse/ClickHouse/pull/34876) ([Azat Khuzhin](https://github.com/azat)). -* Fix asynchronous inserts to table functions. Fixes [#34864](https://github.com/ClickHouse/ClickHouse/issues/34864). [#34866](https://github.com/ClickHouse/ClickHouse/pull/34866) ([Anton Popov](https://github.com/CurtizJ)). +* Integration with Hive: Fix unexpected result when use `in` in `where` in hive query. [#34945](https://github.com/ClickHouse/ClickHouse/pull/34945) ([lgbo](https://github.com/lgbo-ustc)). +* Avoid busy polling in ClickHouse Keeper while searching for changelog files to delete. [#34931](https://github.com/ClickHouse/ClickHouse/pull/34931) ([Azat Khuzhin](https://github.com/azat)). +* Fix DateTime64 conversion from PostgreSQL. Closes [#33364](https://github.com/ClickHouse/ClickHouse/issues/33364). [#34910](https://github.com/ClickHouse/ClickHouse/pull/34910) ([Kseniia Sumarokova](https://github.com/kssenii)). +* Fix possible "Part directory doesn't exist" during `INSERT` into MergeTree table backed by VFS over s3. [#34876](https://github.com/ClickHouse/ClickHouse/pull/34876) ([Azat Khuzhin](https://github.com/azat)). * Support DDLs like CREATE USER to be executed on cross replicated cluster. [#34860](https://github.com/ClickHouse/ClickHouse/pull/34860) ([Jianmei Zhang](https://github.com/zhangjmruc)). -* Fix bugs for multiple columns group by in WindowView. [#34859](https://github.com/ClickHouse/ClickHouse/pull/34859) ([vxider](https://github.com/Vxider)). +* Fix bugs for multiple columns group by in `WindowView` (experimental feature). [#34859](https://github.com/ClickHouse/ClickHouse/pull/34859) ([vxider](https://github.com/Vxider)). * Fix possible failures in S2 functions when queries contain const columns. [#34745](https://github.com/ClickHouse/ClickHouse/pull/34745) ([Bharat Nallan](https://github.com/bharatnc)). -* Fix bug for h3 funcs containing const columns which cause queries to fail. [#34743](https://github.com/ClickHouse/ClickHouse/pull/34743) ([Bharat Nallan](https://github.com/bharatnc)). -* Fix ENOENT with fsync_part_directory and Vertical merge. [#34739](https://github.com/ClickHouse/ClickHouse/pull/34739) ([Azat Khuzhin](https://github.com/azat)). +* Fix bug for H3 funcs containing const columns which cause queries to fail. [#34743](https://github.com/ClickHouse/ClickHouse/pull/34743) ([Bharat Nallan](https://github.com/bharatnc)). +* Fix `No such file or directory` with enabled `fsync_part_directory` and vertical merge. [#34739](https://github.com/ClickHouse/ClickHouse/pull/34739) ([Azat Khuzhin](https://github.com/azat)). * Fix serialization/printing for system queries `RELOAD MODEL`, `RELOAD FUNCTION`, `RESTART DISK` when used `ON CLUSTER`. Closes [#34514](https://github.com/ClickHouse/ClickHouse/issues/34514). [#34696](https://github.com/ClickHouse/ClickHouse/pull/34696) ([Maksim Kita](https://github.com/kitaisreal)). * Fix `allow_experimental_projection_optimization` with `enable_global_with_statement` (before it may lead to `Stack size too large` error in case of multiple expressions in `WITH` clause, and also it executes scalar subqueries again and again, so not it will be more optimal). [#34650](https://github.com/ClickHouse/ClickHouse/pull/34650) ([Azat Khuzhin](https://github.com/azat)). -* Stop to select part for mutate when the other replica has already updated the /log for ReplatedMergeTree engine. [#34633](https://github.com/ClickHouse/ClickHouse/pull/34633) ([Jianmei Zhang](https://github.com/zhangjmruc)). -* Fix incorrect trivial count result when part movement feature is used [#34089](https://github.com/ClickHouse/ClickHouse/issues/34089). [#34385](https://github.com/ClickHouse/ClickHouse/pull/34385) ([nvartolomei](https://github.com/nvartolomei)). -* Fix distributed subquery max_query_size limitation inconsistency. [#34078](https://github.com/ClickHouse/ClickHouse/pull/34078) ([Chao Ma](https://github.com/godliness)). +* Stop to select part for mutate when the other replica has already updated the transaction log for `ReplatedMergeTree` engine. [#34633](https://github.com/ClickHouse/ClickHouse/pull/34633) ([Jianmei Zhang](https://github.com/zhangjmruc)). +* Fix incorrect result of trivial count query when part movement feature is used [#34089](https://github.com/ClickHouse/ClickHouse/issues/34089). [#34385](https://github.com/ClickHouse/ClickHouse/pull/34385) ([nvartolomei](https://github.com/nvartolomei)). +* Fix inconsistency of `max_query_size` limitation in distributed subqueries. [#34078](https://github.com/ClickHouse/ClickHouse/pull/34078) ([Chao Ma](https://github.com/godliness)). + ### ClickHouse release v22.2, 2022-02-17 From 72b2619c7c7f95ac018a4d3781025788bca6b38a Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Thu, 17 Mar 2022 01:05:15 +0100 Subject: [PATCH 127/132] Nice addition --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index 3ed779b6a45..703ea858189 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -26,6 +26,7 @@ * Improve performance of insertion into `MergeTree` tables by optimizing sorting. Up to 2x improvement is observed on realistic benchmarks. [#34750](https://github.com/ClickHouse/ClickHouse/pull/34750) ([Maksim Kita](https://github.com/kitaisreal)). * Columns pruning when reading Parquet, ORC and Arrow files from URL and S3. Closes [#34163](https://github.com/ClickHouse/ClickHouse/issues/34163). [#34849](https://github.com/ClickHouse/ClickHouse/pull/34849) ([Kseniia Sumarokova](https://github.com/kssenii)). * Columns pruning when reading Parquet, ORC and Arrow files from Hive. [#34954](https://github.com/ClickHouse/ClickHouse/pull/34954) ([lgbo](https://github.com/lgbo-ustc)). +* A bunch of performance optimizations from a performance superhero. Improve performance of processing queries with large `IN` section. Improve performance of `DirectDictionary` if dictionary source is `ClickHouse`. Improve performance of `detectCharset `, `detectLanguageUnknown ` functions. [#34888](https://github.com/ClickHouse/ClickHouse/pull/34888) ([Maksim Kita](https://github.com/kitaisreal)). * Improve performance of `any` aggregate function by using more batching. [#34760](https://github.com/ClickHouse/ClickHouse/pull/34760) ([Raúl Marín](https://github.com/Algunenano)). * Multiple improvements for performance of `clickhouse-keeper`: less locking [#35010](https://github.com/ClickHouse/ClickHouse/pull/35010) ([zhanglistar](https://github.com/zhanglistar)), lower memory usage by streaming reading and writing of snapshot instead of full copy. [#34584](https://github.com/ClickHouse/ClickHouse/pull/34584) ([zhanglistar](https://github.com/zhanglistar)), optimizing compaction of log store in the RAFT implementation. [#34534](https://github.com/ClickHouse/ClickHouse/pull/34534) ([zhanglistar](https://github.com/zhanglistar)), versioning of the internal data structure [#34486](https://github.com/ClickHouse/ClickHouse/pull/34486) ([zhanglistar](https://github.com/zhanglistar)). From b70dd1fc3667d94f53ca006e9dbbb0067bb14c25 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Thu, 17 Mar 2022 02:33:29 +0100 Subject: [PATCH 128/132] More features --- CHANGELOG.md | 4 +++- src/Core/Settings.h | 4 ++-- 2 files changed, 5 insertions(+), 3 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 703ea858189..d01421fd606 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -19,6 +19,7 @@ #### Experimental Feature +* New data type `Object()`, which supports storing of semi-structured data (for now JSON only). Data is written to such types as string. Then all paths are extracted according to format of semi-structured data and written as separate columns in most optimal types, that can store all their values. Those columns can be queried by names that match paths in source data. E.g `data.key1.key2` or with cast operator `data.key1.key2::Int64`. * Add `database_replicated_allow_only_replicated_engine` setting. When enabled, it only allowed to only create `Replicated` tables or tables with stateless engines in `Replicated` databases. [#35214](https://github.com/ClickHouse/ClickHouse/pull/35214) ([Nikolai Kochetov](https://github.com/KochetovNicolai)). Note that `Replicated` database is still an experimental feature. #### Performance Improvement @@ -26,7 +27,7 @@ * Improve performance of insertion into `MergeTree` tables by optimizing sorting. Up to 2x improvement is observed on realistic benchmarks. [#34750](https://github.com/ClickHouse/ClickHouse/pull/34750) ([Maksim Kita](https://github.com/kitaisreal)). * Columns pruning when reading Parquet, ORC and Arrow files from URL and S3. Closes [#34163](https://github.com/ClickHouse/ClickHouse/issues/34163). [#34849](https://github.com/ClickHouse/ClickHouse/pull/34849) ([Kseniia Sumarokova](https://github.com/kssenii)). * Columns pruning when reading Parquet, ORC and Arrow files from Hive. [#34954](https://github.com/ClickHouse/ClickHouse/pull/34954) ([lgbo](https://github.com/lgbo-ustc)). -* A bunch of performance optimizations from a performance superhero. Improve performance of processing queries with large `IN` section. Improve performance of `DirectDictionary` if dictionary source is `ClickHouse`. Improve performance of `detectCharset `, `detectLanguageUnknown ` functions. [#34888](https://github.com/ClickHouse/ClickHouse/pull/34888) ([Maksim Kita](https://github.com/kitaisreal)). +* A bunch of performance optimizations from a performance superhero. Improve performance of processing queries with large `IN` section. Improve performance of `direct` dictionary if its source is `ClickHouse`. Improve performance of `detectCharset `, `detectLanguageUnknown ` functions. [#34888](https://github.com/ClickHouse/ClickHouse/pull/34888) ([Maksim Kita](https://github.com/kitaisreal)). * Improve performance of `any` aggregate function by using more batching. [#34760](https://github.com/ClickHouse/ClickHouse/pull/34760) ([Raúl Marín](https://github.com/Algunenano)). * Multiple improvements for performance of `clickhouse-keeper`: less locking [#35010](https://github.com/ClickHouse/ClickHouse/pull/35010) ([zhanglistar](https://github.com/zhanglistar)), lower memory usage by streaming reading and writing of snapshot instead of full copy. [#34584](https://github.com/ClickHouse/ClickHouse/pull/34584) ([zhanglistar](https://github.com/zhanglistar)), optimizing compaction of log store in the RAFT implementation. [#34534](https://github.com/ClickHouse/ClickHouse/pull/34534) ([zhanglistar](https://github.com/zhanglistar)), versioning of the internal data structure [#34486](https://github.com/ClickHouse/ClickHouse/pull/34486) ([zhanglistar](https://github.com/zhanglistar)). @@ -71,6 +72,7 @@ #### Build/Testing/Packaging Improvement +* Package repository is migrated to JFrog Artifactory (**Mikhail f. Shiryaev**). * Randomize some settings in functional tests, so more possible combinations of settings will be tested. This is yet another fuzzing method to ensure better test coverage. This closes [#32268](https://github.com/ClickHouse/ClickHouse/issues/32268). [#34092](https://github.com/ClickHouse/ClickHouse/pull/34092) ([Kruglov Pavel](https://github.com/Avogar)). * Drop PVS-Studio from our CI. [#34680](https://github.com/ClickHouse/ClickHouse/pull/34680) ([Mikhail f. Shiryaev](https://github.com/Felixoid)). * Add an ability to build stripped binaries with CMake. In previous versions it was performed by dh-tools. [#35196](https://github.com/ClickHouse/ClickHouse/pull/35196) ([alesapin](https://github.com/alesapin)). diff --git a/src/Core/Settings.h b/src/Core/Settings.h index 513effabffa..59a03dfa5f8 100644 --- a/src/Core/Settings.h +++ b/src/Core/Settings.h @@ -136,7 +136,7 @@ class IColumn; \ M(Bool, skip_unavailable_shards, false, "If true, ClickHouse silently skips unavailable shards and nodes unresolvable through DNS. Shard is marked as unavailable when none of the replicas can be reached.", 0) \ \ - M(UInt64, parallel_distributed_insert_select, 0, "Process distributed INSERT SELECT query in the same cluster on local tables on every shard, if 1 SELECT is executed on each shard, if 2 SELECT and INSERT is executed on each shard", 0) \ + M(UInt64, parallel_distributed_insert_select, 0, "Process distributed INSERT SELECT query in the same cluster on local tables on every shard; if set to 1 - SELECT is executed on each shard; if set to 2 - SELECT and INSERT are executed on each shard", 0) \ M(UInt64, distributed_group_by_no_merge, 0, "If 1, Do not merge aggregation states from different servers for distributed queries (shards will process query up to the Complete stage, initiator just proxies the data from the shards). If 2 the initiator will apply ORDER BY and LIMIT stages (it is not in case when shard process query up to the Complete stage)", 0) \ M(UInt64, distributed_push_down_limit, 1, "If 1, LIMIT will be applied on each shard separatelly. Usually you don't need to use it, since this will be done automatically if it is possible, i.e. for simple query SELECT FROM LIMIT.", 0) \ M(Bool, optimize_distributed_group_by_sharding_key, true, "Optimize GROUP BY sharding_key queries (by avoiding costly aggregation on the initiator server).", 0) \ @@ -551,7 +551,7 @@ class IColumn; M(UInt64, remote_fs_read_max_backoff_ms, 10000, "Max wait time when trying to read data for remote disk", 0) \ M(UInt64, remote_fs_read_backoff_max_tries, 5, "Max attempts to read with backoff", 0) \ M(Bool, remote_fs_enable_cache, true, "Use cache for remote filesystem. This setting does not turn on/off cache for disks (must me done via disk config), but allows to bypass cache for some queries if intended", 0) \ - M(UInt64, remote_fs_cache_max_wait_sec, 5, "Allow to wait a most this number of seconds for download of current remote_fs_buffer_size bytes, and skip cache if exceeded", 0) \ + M(UInt64, remote_fs_cache_max_wait_sec, 5, "Allow to wait at most this number of seconds for download of current remote_fs_buffer_size bytes, and skip cache if exceeded", 0) \ \ M(UInt64, http_max_tries, 10, "Max attempts to read via http.", 0) \ M(UInt64, http_retry_initial_backoff_ms, 100, "Min milliseconds for backoff, when retrying read via http", 0) \ From 416c7f2820beba1e6c70aecb1b741a0e09950128 Mon Sep 17 00:00:00 2001 From: Anton Popov Date: Thu, 17 Mar 2022 01:37:54 +0000 Subject: [PATCH 129/132] fix clang-tidy --- src/DataTypes/ObjectUtils.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/DataTypes/ObjectUtils.cpp b/src/DataTypes/ObjectUtils.cpp index daad3fc52ba..9004a5296e0 100644 --- a/src/DataTypes/ObjectUtils.cpp +++ b/src/DataTypes/ObjectUtils.cpp @@ -618,7 +618,7 @@ std::pair unflattenTuple( }); } - const auto & [column, type, _] = createTypeFromNode(tree.getRoot()); + auto [column, type, _] = createTypeFromNode(tree.getRoot()); return std::make_pair(std::move(column), std::move(type)); } From 68ef49ea51bb5cf837e5214c89d99ceb1b0f393b Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Thu, 17 Mar 2022 05:57:13 +0100 Subject: [PATCH 130/132] Fix something stupid --- src/Storages/MergeTree/MergeTreeData.cpp | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/Storages/MergeTree/MergeTreeData.cpp b/src/Storages/MergeTree/MergeTreeData.cpp index 7f407199e81..03a215e1aef 100644 --- a/src/Storages/MergeTree/MergeTreeData.cpp +++ b/src/Storages/MergeTree/MergeTreeData.cpp @@ -283,10 +283,7 @@ MergeTreeData::MergeTreeData( if (disk->exists(current_version_file_path)) { if (!version_file.first.empty()) - { - LOG_ERROR(log, "Duplication of version file {} and {}", fullPath(version_file.second, version_file.first), current_version_file_path); - throw Exception("Multiple format_version.txt file", ErrorCodes::CORRUPTED_DATA); - } + throw Exception(ErrorCodes::CORRUPTED_DATA, "Duplication of version file {} and {}", fullPath(version_file.second, version_file.first), current_version_file_path); version_file = {current_version_file_path, disk}; } } From caea3dd8478ee02ab645f6f69ffade434f017c45 Mon Sep 17 00:00:00 2001 From: Alexey Milovidov Date: Thu, 17 Mar 2022 05:58:14 +0100 Subject: [PATCH 131/132] Finalize changelog --- CHANGELOG.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d01421fd606..02e15584d2e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,4 +1,4 @@ -### ClickHouse release master FIXME as compared to v22.2.3.5-stable +### ClickHouse release v22.3-lts, 2022-03-17 #### Backward Incompatible Change From d277614eea33f436bf52275ceb478cad8df7a4a5 Mon Sep 17 00:00:00 2001 From: Maksim Kita Date: Thu, 17 Mar 2022 12:33:56 +0100 Subject: [PATCH 132/132] Update 02233_set_enable_with_statement_cte_perf.sql --- .../02233_set_enable_with_statement_cte_perf.sql | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql index 42e8aa63ea7..71321b4dfe4 100644 --- a/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql +++ b/tests/queries/0_stateless/02233_set_enable_with_statement_cte_perf.sql @@ -4,10 +4,10 @@ DROP TABLE IF EXISTS idx; CREATE TABLE ev (a Int32, b Int32) Engine=MergeTree() ORDER BY a; CREATE TABLE idx (a Int32) Engine=MergeTree() ORDER BY a; INSERT INTO ev SELECT number, number FROM numbers(10000000); -INSERT INTO idx SELECT number*5 FROM numbers(1000); +INSERT INTO idx SELECT number * 5 FROM numbers(1000); -- test_enable_global_with_statement_performance_1 -WITH 'test' AS u SELECT count()FROM ev WHERE a IN (SELECT a FROM idx) SETTINGS enable_global_with_statement = 1; +WITH 'test' AS u SELECT count() FROM ev WHERE a IN (SELECT a FROM idx) SETTINGS enable_global_with_statement = 1; -- test_enable_global_with_statement_performance_2 SELECT count() FROM ev WHERE a IN (SELECT a FROM idx) SETTINGS enable_global_with_statement = 1; @@ -20,4 +20,4 @@ SYSTEM FLUSH LOGS; SELECT count(read_rows) FROM (SELECT read_rows FROM system.query_log WHERE current_database=currentDatabase() AND type='QueryFinish' AND query LIKE '-- test_enable_global_with_statement_performance%' ORDER BY initial_query_start_time_microseconds DESC LIMIT 3) GROUP BY read_rows; DROP TABLE IF EXISTS ev; -DROP TABLE IF EXISTS idx; \ No newline at end of file +DROP TABLE IF EXISTS idx;

y*C@?%Dh0DL3pWx%2ee!u`YEpmnHjf!}O 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 z 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

y*C@?%Dh0DL3pWx%2ee!u`YEpmnHjf!}O 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ෳ+#v4E0_{x$@9%` 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