From ca2db69ed7349508fa6340b68c4ca86d3864b89a Mon Sep 17 00:00:00 2001 From: LiShuai-tp Date: Sat, 22 Mar 2025 01:38:11 +0800 Subject: [PATCH 1/2] Define thread_local variable to compatible with clickhouse. (#8161) --- .../thread_local_is_clickhouse_compatible.cpp | 3 + .../thread_local_is_clickhouse_compatible.h | 3 + src/Core/Block.cpp | 12 +- src/Core/Block.h | 5 +- src/Core/Settings.h | 1 + src/DataTypes/convertTypeToClickhouse.cpp | 111 ++ src/DataTypes/convertTypeToClickhouse.h | 15 + .../gtest_function_convertTypeToUpper.cpp | 279 +++ src/Formats/FormatFactory.cpp | 4 + src/Formats/FormatSettings.h | 4 + src/Functions/CastOverloadResolver.cpp | 146 ++ src/Interpreters/InterpreterCreateQuery.cpp | 7 +- src/Interpreters/executeQuery.cpp | 12 +- src/Parsers/ExpressionElementParsers.cpp | 1330 +++++++++++++ src/Parsers/ExpressionElementParsers.h | 10 +- src/Parsers/ParserDataType.cpp | 16 + src/Parsers/ParserInsertQuery.cpp | 2 +- src/Parsers/ParserTablesInSelectQuery.cpp | 8 +- ...ompatible_clickhouse_datatype_function.cpp | 1666 +++++++++++++++++ .../Impl/TabSeparatedRowOutputFormat.cpp | 7 +- src/Server/HTTPHandler.cpp | 11 +- src/Server/HTTPHandler.h | 3 +- src/Server/HTTPHandlerFactory.cpp | 18 +- ...ckhouse_datatype_and_functonname.reference | 97 + ...th_clickhouse_datatype_and_functonname.sql | 105 ++ 25 files changed, 3851 insertions(+), 24 deletions(-) create mode 100644 src/Common/thread_local_is_clickhouse_compatible.cpp create mode 100644 src/Common/thread_local_is_clickhouse_compatible.h create mode 100644 src/DataTypes/convertTypeToClickhouse.cpp create mode 100644 src/DataTypes/convertTypeToClickhouse.h create mode 100644 src/DataTypes/tests/gtest_function_convertTypeToUpper.cpp create mode 100644 src/Parsers/tests/gtest_compatible_clickhouse_datatype_function.cpp create mode 100644 tests/queries_ported/0_stateless/99039_compatible_with_clickhouse_datatype_and_functonname.reference create mode 100644 tests/queries_ported/0_stateless/99039_compatible_with_clickhouse_datatype_and_functonname.sql diff --git a/src/Common/thread_local_is_clickhouse_compatible.cpp b/src/Common/thread_local_is_clickhouse_compatible.cpp new file mode 100644 index 00000000000..3e87a34cf8e --- /dev/null +++ b/src/Common/thread_local_is_clickhouse_compatible.cpp @@ -0,0 +1,3 @@ +#include + +thread_local bool thread_local_is_clickhouse_compatible = false; diff --git a/src/Common/thread_local_is_clickhouse_compatible.h b/src/Common/thread_local_is_clickhouse_compatible.h new file mode 100644 index 00000000000..efd3e529404 --- /dev/null +++ b/src/Common/thread_local_is_clickhouse_compatible.h @@ -0,0 +1,3 @@ +#include + +extern thread_local bool thread_local_is_clickhouse_compatible; diff --git a/src/Core/Block.cpp b/src/Core/Block.cpp index d2b1e785d0f..f5a19841ff0 100644 --- a/src/Core/Block.cpp +++ b/src/Core/Block.cpp @@ -11,6 +11,9 @@ #include #include #include +/// proton: starts +#include "DataTypes/convertTypeToClickhouse.h" +/// proton: ends #include #include @@ -658,13 +661,20 @@ DataTypes Block::getDataTypes() const return res; } -Names Block::getDataTypeNames() const +/// proton: starts. +Names Block::getDataTypeNames(bool is_clickhouse_compatible) const +/// proton: ends. { Names res; res.reserve(columns()); for (const auto & elem : data) res.push_back(elem.type->getName()); + + /// proton: starts. + if(is_clickhouse_compatible) + std::transform(res.begin(), res.end(), res.begin(), convertTypeToUpper); + /// proton: ends. return res; } diff --git a/src/Core/Block.h b/src/Core/Block.h index 837ed74e32f..d41f86e5e3b 100644 --- a/src/Core/Block.h +++ b/src/Core/Block.h @@ -95,7 +95,10 @@ class Block NamesAndTypes getNamesAndTypes() const; Names getNames() const; DataTypes getDataTypes() const; - Names getDataTypeNames() const; + /// proton: starts. + Names getDataTypeNames(bool is_clickhouse_compatible = false) const; + /// proton: starts. + std::unordered_map getNamesToIndexesMap() const; /// Returns number of rows from first column in block, not equal to nullptr. If no columns, returns 0. size_t rows() const; diff --git a/src/Core/Settings.h b/src/Core/Settings.h index 9aaabfeb793..6ae5d97af20 100644 --- a/src/Core/Settings.h +++ b/src/Core/Settings.h @@ -634,6 +634,7 @@ static constexpr UInt64 operator""_GiB(unsigned long long value) \ /** proton: starts */ \ M(String, shards, "", "If not empty, only the specified shard IDs (or partition IDs if the target stream is a Kafka external stream) will be selected to be read data from. IDs are separated by comma. Example: shards='0,2'", 0) \ + M(Bool, is_clickhouse_compatible, false, "When this parameter is set, timeplusd works in compatible mode with ClickHouse (especially compatible with data types and function names).", 0) \ \ /** proton: ends */ \ diff --git a/src/DataTypes/convertTypeToClickhouse.cpp b/src/DataTypes/convertTypeToClickhouse.cpp new file mode 100644 index 00000000000..07c83da1029 --- /dev/null +++ b/src/DataTypes/convertTypeToClickhouse.cpp @@ -0,0 +1,111 @@ +#include "DataTypes/convertTypeToClickhouse.h" +#include + +namespace DB +{ + +std::unordered_map typeMap + = {{"void", "Void"}, + {"bool", "Bool"}, + {"int8", "Int8"}, + {"int16", "Int16"}, + {"int32", "Int32"}, + {"int64", "Int64"}, + {"uint8", "UInt8"}, + {"uint16", "UInt16"}, + {"uint32", "UInt32"}, + {"uint64", "UInt64"}, + {"int128", "Int128"}, + {"uint128", "UInt128"}, + {"int256", "Int256"}, + {"uint256", "UInt256"}, + {"float32", "Float32"}, + {"float64", "Float64"}, + {"string", "String"}, + {"json", "JSON"}, + {"fixed_string", "FixedString"}, + {"datetime", "DateTime"}, + {"date", "Date"}, + {"date32", "Date32"}, + {"datetime64", "DateTime64"}, + {"array", "Array"}, + {"nullable", "Nullable"}, + {"tuple", "Tuple"}, + {"enum", "Enum"}, + {"enum8", "Enum8"}, + {"enum16", "Enum16"}, + {"uuid", "UUID"}, + {"ipv4", "IPv4"}, + {"ipv6", "IPv6"}, + {"decimal", "Decimal"}, + {"decimal32", "Decimal32"}, + {"decimal64", "Decimal64"}, + {"decimal128", "Decimal128"}, + {"decimal256", "Decimal256"}, + {"map", "Map"}, + {"low_cardinality", "LowCardinality"}, + {"point", "Point"}, + {"ring", "Ring"}, + {"polygon", "Polygon"}, + {"multipolygon", "MultiPolygon"}}; + +/// This function converts the type name to uppercase +std::string convertTypeToUpper(const std::string & input) +{ + std::string result; + size_t i = 0; + + while (i < input.size()) + { + size_t start = i; + + while (i < input.size() && (std::isalnum(input[i]) || input[i] == '_')) + i++; + + std::string type_name = input.substr(start, i - start); + + auto it = typeMap.find(type_name); + if (it != typeMap.end()) + { + result += it->second; + } + else + { + /// If the type is not found in typeMap, log a warning and keep the original value. Unknown data type or not a data type keyword. + result += type_name; + } + + /// Processing parameter part: If there are brackets, continue splicing and parsing the content + if (i < input.size() && input[i] == '(') + { + result += '('; + i++; /// Skip '(' + int bracket_cnt = 1; + size_t param_start = i; + while (i < input.size() && bracket_cnt > 0) + { + if (input[i] == '(') + bracket_cnt++; + else if (input[i] == ')') + bracket_cnt--; + i++; + } + + /// Recursively process the parameters in parentheses + std::string params = input.substr(param_start, i - param_start - 1); + result += convertTypeToUpper(params); + result += ')'; + } + + /// Skip other non-alphanumeric characters + while (i < input.size() && !std::isalnum(input[i]) && input[i] != '_') + { + result += input[i]; + i++; + } + } + + return result; +} + +} diff --git a/src/DataTypes/convertTypeToClickhouse.h b/src/DataTypes/convertTypeToClickhouse.h new file mode 100644 index 00000000000..2a88b34f4c9 --- /dev/null +++ b/src/DataTypes/convertTypeToClickhouse.h @@ -0,0 +1,15 @@ +#pragma once + +#include +#include +#include +#include +#include + +namespace DB +{ +extern std::unordered_map typeMap; + +std::string convertTypeToUpper(const std::string & input); + +} diff --git a/src/DataTypes/tests/gtest_function_convertTypeToUpper.cpp b/src/DataTypes/tests/gtest_function_convertTypeToUpper.cpp new file mode 100644 index 00000000000..6a08051c92b --- /dev/null +++ b/src/DataTypes/tests/gtest_function_convertTypeToUpper.cpp @@ -0,0 +1,279 @@ +#include +#include + +#include + +using namespace DB; + +/// test function: convertTypeToUpper +TEST(convertTypeToUpperTest, TestInputIs_int8) +{ + std::string input = "int8"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Int8"); +} +TEST(convertTypeToUpperTest, TestInputIs_uint8) +{ + std::string input = "uint8"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "UInt8"); +} +TEST(convertTypeToUpperTest, TestInputIs_int16) +{ + std::string input = "int16"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Int16"); +} +TEST(convertTypeToUpperTest, TestInputIs_uint16) +{ + std::string input = "uint16"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "UInt16"); +} +TEST(convertTypeToUpperTest, TestInputIs_int32) +{ + std::string input = "int32"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Int32"); +} +TEST(convertTypeToUpperTest, TestInputIs_uint32) +{ + std::string input = "uint32"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "UInt32"); +} +TEST(convertTypeToUpperTest, TestInputIs_int64) +{ + std::string input = "int64"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Int64"); +} +TEST(convertTypeToUpperTest, TestInputIs_uint64) +{ + std::string input = "uint64"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "UInt64"); +} +TEST(convertTypeToUpperTest, TestInputIs_int128) +{ + std::string input = "int128"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Int128"); +} +TEST(convertTypeToUpperTest, TestInputIs_uint128) +{ + std::string input = "uint128"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "UInt128"); +} +TEST(convertTypeToUpperTest, TestInputIs_int256) +{ + std::string input = "int256"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Int256"); +} +TEST(convertTypeToUpperTest, TestInputIs_uint256) +{ + std::string input = "uint256"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "UInt256"); +} +TEST(convertTypeToUpperTest, TestInputIs_float32) +{ + std::string input = "float32"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Float32"); +} +TEST(convertTypeToUpperTest, TestInputIsfloat64) +{ + std::string input = "float64"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Float64"); +} +TEST(convertTypeToUpperTest, TestInputIs_string) +{ + std::string input = "string"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "String"); +} +TEST(convertTypeToUpperTest, TestInputIs_date) +{ + std::string input = "date"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Date"); +} +TEST(convertTypeToUpperTest, TestInputIs_date32) +{ + std::string input = "date32"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Date32"); +} +TEST(convertTypeToUpperTest, TestInputIs_datetime) +{ + std::string input = "datetime"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "DateTime"); +} +TEST(convertTypeToUpperTest, TestInputIs_bool) +{ + std::string input = "bool"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Bool"); +} +TEST(convertTypeToUpperTest, TestInputIs_uuid) +{ + std::string input = "uuid"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "UUID"); +} +TEST(convertTypeToUpperTest, TestInputIs_ipv4) +{ + std::string input = "ipv4"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "IPv4"); +} +TEST(convertTypeToUpperTest, TestInputIs_ipv6) +{ + std::string input = "ipv6"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "IPv6"); +} +TEST(convertTypeToUpperTest, TestInputIs_json) +{ + std::string input = "json"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "JSON"); +} + +TEST(convertTypeToUpperTest, TestInputIs_nullable) +{ + std::string input = "nullable(string)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Nullable(String)"); +} +TEST(convertTypeToUpperTest, TestInputIs_decimal) +{ + std::string input = "decimal(10, 3)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Decimal(10, 3)"); +} +TEST(convertTypeToUpperTest, TestInputIs_decimal32) +{ + std::string input = "decimal32(3)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Decimal32(3)"); +} +TEST(convertTypeToUpperTest, TestInputIs_decimal64) +{ + std::string input = "decimal64(3)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Decimal64(3)"); +} +TEST(convertTypeToUpperTest, TestInputIs_decimal128) +{ + std::string input = "decimal128(3)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Decimal128(3)"); +} +TEST(convertTypeToUpperTest, TestInputIs_decimal256) +{ + std::string input = "decimal256(3)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Decimal256(3)"); +} +TEST(convertTypeToUpperTest, TestInputIs_fixed_string) +{ + std::string input = "fixed_string(10)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "FixedString(10)"); +} +TEST(convertTypeToUpperTest, TestInputIs_datetime64) +{ + std::string input = "datetime64(3)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "DateTime64(3)"); +} +TEST(convertTypeToUpperTest, TestInputIs_enum) +{ + std::string input = "enum('One' = 1, 'Two' = 2, 'Three' = 3)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Enum('One' = 1, 'Two' = 2, 'Three' = 3)"); +} +TEST(convertTypeToUpperTest, TestInputIs_enum8) +{ + std::string input = "enum8('One' = 1, 'Two' = 2, 'Three' = 3)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Enum8('One' = 1, 'Two' = 2, 'Three' = 3)"); +} +TEST(convertTypeToUpperTest, TestInputIs_enum16) +{ + std::string input = "enum16('One' = 1, 'Two' = 2, 'Three' = 3)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Enum16('One' = 1, 'Two' = 2, 'Three' = 3)"); +} +TEST(convertTypeToUpperTest, TestInputIs_array) +{ + std::string input = "array(int32)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Array(Int32)"); +} +TEST(convertTypeToUpperTest, TestInputIs_map) +{ + std::string input = "map(string, int32)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Map(String, Int32)"); +} +TEST(convertTypeToUpperTest, TestInputIs_tuple) +{ + std::string input = "tuple(string, int32, string)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Tuple(String, Int32, String)"); +} +TEST(convertTypeToUpperTest, TestInputIs_low_cardinality) +{ + std::string input = "low_cardinality(string)"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "LowCardinality(String)"); +} + +TEST(convertTypeToUpperTest, TestInputIs_datetime_timezone) +{ + std::string input = "datetime('UTC')"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "DateTime('UTC')"); +} + +TEST(convertTypeToUpperTest, TestInputIs_datetime64_precision_timezone) +{ + std::string input = "datetime64(3, 'UTC')"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "DateTime64(3, 'UTC')"); +} + +TEST(convertTypeToUpperTest, TestInputIs_nested1) +{ + std::string input = "nullable(map(string, tuple(array(nullable(string), nullable(int32), nullable(fixed_string(10)), nullable(datetime64(3, 'UTC')), low_cardinality(nullable(float32))))))"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Nullable(Map(String, Tuple(Array(Nullable(String), Nullable(Int32), Nullable(FixedString(10)), Nullable(DateTime64(3, 'UTC')), LowCardinality(Nullable(Float32))))))"); +} + +TEST(convertTypeToUpperTest, TestInputIs_nested2) +{ + std::string input = "nullable(array(tuple(nullable(int32), nullable(string))))"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Nullable(Array(Tuple(Nullable(Int32), Nullable(String))))"); +} + +TEST(convertTypeToUpperTest, TestInputIs_nested3) +{ + std::string input = "tuple(nullable(string), nullable(int32), nullable(datetime64(3, 'UTC')))"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Tuple(Nullable(String), Nullable(Int32), Nullable(DateTime64(3, 'UTC')))"); +} + +TEST(convertTypeToUpperTest, TestInputIs_nested4) +{ + std::string input = "map(string, tuple(nullable(int32), nullable(string)))"; + std::string output = convertTypeToUpper(input); + EXPECT_EQ(output, "Map(String, Tuple(Nullable(Int32), Nullable(String)))"); +} diff --git a/src/Formats/FormatFactory.cpp b/src/Formats/FormatFactory.cpp index 2f95a40030f..9cc753f1f4d 100644 --- a/src/Formats/FormatFactory.cpp +++ b/src/Formats/FormatFactory.cpp @@ -308,6 +308,10 @@ OutputFormatPtr FormatFactory::getOutputFormatParallelIfPossible( auto format_settings = _format_settings ? *_format_settings : getFormatSettings(context); + /// proton: starts. + format_settings.is_clickhouse_compatible = context->getSettingsRef().is_clickhouse_compatible; + /// proton: ends. + const Settings & settings = context->getSettingsRef(); if (settings.output_format_parallel_formatting && getCreators(name).supports_parallel_formatting diff --git a/src/Formats/FormatSettings.h b/src/Formats/FormatSettings.h index 01bc5176ca2..d07bdd7cc2a 100644 --- a/src/Formats/FormatSettings.h +++ b/src/Formats/FormatSettings.h @@ -41,6 +41,10 @@ struct FormatSettings bool try_infer_dates = false; bool try_infer_datetimes = false; + /// proton: starts. + bool is_clickhouse_compatible = false; + /// proton: ends. + enum class DateTimeInputFormat { Basic, /// Default format for fast parsing: YYYY-MM-DD hh:mm:ss (ISO-8601 without fractional part and timezone) or NNNNNNNNNN unix timestamp. diff --git a/src/Functions/CastOverloadResolver.cpp b/src/Functions/CastOverloadResolver.cpp index 20a08e3b60b..2dd75116ef7 100644 --- a/src/Functions/CastOverloadResolver.cpp +++ b/src/Functions/CastOverloadResolver.cpp @@ -5,6 +5,152 @@ namespace DB { +namespace ErrorCodes +{ + extern const int ILLEGAL_TYPE_OF_ARGUMENT; +} + +/** CastInternal does not preserve nullability of the data type, + * i.e. CastInternal(toNullable(toInt8(1)) as Int32) will be Int32(1). + * + * Cast preserves nullability according to setting `cast_keep_nullable`, + * i.e. Cast(toNullable(toInt8(1)) as Int32) will be Nullable(Int32(1)) if `cast_keep_nullable` == 1. + */ +template +class CastOverloadResolverImpl : public IFunctionOverloadResolver +{ +public: + using MonotonicityForRange = FunctionCastBase::MonotonicityForRange; + + static constexpr auto name = cast_type == CastType::accurate + ? CastName::accurate_cast_name + : (cast_type == CastType::accurateOrNull ? CastName::accurate_cast_or_null_name : CastName::cast_name); + + String getName() const override { return name; } + + size_t getNumberOfArguments() const override { return 2; } + + ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1}; } + + explicit CastOverloadResolverImpl(ContextPtr context_, std::optional diagnostic_, bool keep_nullable_) + : context(context_) + , diagnostic(std::move(diagnostic_)) + , keep_nullable(keep_nullable_) + { + } + + static FunctionOverloadResolverPtr create(ContextPtr context) + { + const auto & settings_ref = context->getSettingsRef(); + + if constexpr (internal) + return createImpl(context, {}, false /*keep_nullable*/); + + return createImpl(context, {}, settings_ref.cast_keep_nullable); + } + + static FunctionOverloadResolverPtr createImpl(ContextPtr context, std::optional diagnostic = {}, bool keep_nullable = false) + { + assert(!internal || !keep_nullable); + return std::make_unique(context, std::move(diagnostic), keep_nullable); + } + + static FunctionOverloadResolverPtr createImpl(std::optional diagnostic = {}, bool keep_nullable = false) + { + assert(!internal || !keep_nullable); + return std::make_unique(ContextPtr(), std::move(diagnostic), keep_nullable); + } + +protected: + + FunctionBasePtr buildImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & return_type) const override + { + DataTypes data_types(arguments.size()); + + for (size_t i = 0; i < arguments.size(); ++i) + data_types[i] = arguments[i].type; + + auto monotonicity = MonotonicityHelper::getMonotonicityInformation(arguments.front().type, return_type.get()); + return std::make_unique>(context, name, std::move(monotonicity), data_types, return_type, diagnostic, cast_type); + } + + DataTypePtr getReturnTypeImpl(const ColumnsWithTypeAndName & arguments) const override + { + const auto & column = arguments.back().column; + if (!column) + throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Second argument to {} must be a constant string describing type. " + "Instead there is non-constant column of type {}", getName(), arguments.back().type->getName()); + + const auto * type_col = checkAndGetColumnConst(column.get()); + if (!type_col) + throw Exception(ErrorCodes::ILLEGAL_TYPE_OF_ARGUMENT, "Second argument to {} must be a constant string describing type. " + "Instead there is a column with the following structure: {}", getName(), column->dumpStructure()); + + /// proton: starts + bool is_clickhouse_compatible = false; + if (context) + is_clickhouse_compatible = context->getSettingsRef().is_clickhouse_compatible; + DataTypePtr type = DataTypeFactory::instance().get(type_col->getValue(), is_clickhouse_compatible); + /// proton: ends + + if constexpr (cast_type == CastType::accurateOrNull) + return makeNullable(type); + + if constexpr (internal) + return type; + + if (keep_nullable && arguments.front().type->isNullable() && type->canBeInsideNullable()) + return makeNullable(type); + + return type; + } + + bool useDefaultImplementationForNulls() const override { return false; } + bool useDefaultImplementationForNothing() const override { return false; } + bool useDefaultImplementationForLowCardinalityColumns() const override { return false; } + +private: + ContextPtr context; + std::optional diagnostic; + bool keep_nullable; +}; + + +struct CastOverloadName +{ + static constexpr auto cast_name = "cast"; + static constexpr auto accurate_cast_name = "accurate_cast"; + static constexpr auto accurate_cast_or_null_name = "accurate_cast_or_null"; +}; + +struct CastInternalOverloadName +{ + static constexpr auto cast_name = "_cast"; + static constexpr auto accurate_cast_name = "_accurate_cast"; + static constexpr auto accurate_cast_or_null_name = "_accurate_cast_or_null"; +}; + +template +using CastOverloadResolver = CastOverloadResolverImpl; + +template +using CastInternalOverloadResolver = CastOverloadResolverImpl; + + +FunctionOverloadResolverPtr createInternalCastOverloadResolver(CastType type, std::optional diagnostic) +{ + switch (type) + { + case CastType::nonAccurate: + return CastInternalOverloadResolver::createImpl(diagnostic); + case CastType::accurate: + return CastInternalOverloadResolver::createImpl(diagnostic); + case CastType::accurateOrNull: + return CastInternalOverloadResolver::createImpl(diagnostic); + } +} + + REGISTER_FUNCTION(CastOverloadResolvers) { factory.registerFunction>({}, FunctionFactory::CaseInsensitive); diff --git a/src/Interpreters/InterpreterCreateQuery.cpp b/src/Interpreters/InterpreterCreateQuery.cpp index 98ae4f48279..24b9088d0f4 100644 --- a/src/Interpreters/InterpreterCreateQuery.cpp +++ b/src/Interpreters/InterpreterCreateQuery.cpp @@ -458,7 +458,12 @@ ColumnsDescription InterpreterCreateQuery::getColumnsDescription( if (col_decl.type) { - column_type = DataTypeFactory::instance().get(col_decl.type); + /// proton: starts + bool is_clickhouse_compatible_ = false; + if (context_) + is_clickhouse_compatible_ = context_->getSettingsRef().is_clickhouse_compatible; + column_type = DataTypeFactory::instance().get(col_decl.type, is_clickhouse_compatible_); + /// proton: ends const auto * aggregate_function_type = typeid_cast(column_type.get()); if (attach && aggregate_function_type && aggregate_function_type->isVersioned()) diff --git a/src/Interpreters/executeQuery.cpp b/src/Interpreters/executeQuery.cpp index be2633c3fbc..32a9fcaab71 100644 --- a/src/Interpreters/executeQuery.cpp +++ b/src/Interpreters/executeQuery.cpp @@ -76,6 +76,8 @@ #include #include #include +#include /// proton: update +#include /// proton: update /// proton: ends namespace ProfileEvents @@ -474,7 +476,9 @@ static std::tuple executeQueryImpl( try { ParserQuery parser(end, settings.allow_settings_after_format_in_insert); - + /// proton: starts + thread_local_is_clickhouse_compatible = context->getSettingsRef().is_clickhouse_compatible; + /// proton: ends /// TODO: parser should fail early when max_query_size limit is reached. /// proton: starts if (settings.enable_query_pipe) @@ -482,6 +486,12 @@ static std::tuple executeQueryImpl( else ast = parseQuery(parser, begin, end, "", max_query_size, settings.max_parser_depth); + /// proton: starts + { + SCOPE_EXIT({ thread_local_is_clickhouse_compatible = false; }); + } + /// proton: ends + if (const auto * recover_query = ast->as()) { std::tie(recovered_query, ast) = handleRecoverQuery(recover_query, context); diff --git a/src/Parsers/ExpressionElementParsers.cpp b/src/Parsers/ExpressionElementParsers.cpp index 4b201142b10..f2afdb82bac 100644 --- a/src/Parsers/ExpressionElementParsers.cpp +++ b/src/Parsers/ExpressionElementParsers.cpp @@ -47,8 +47,15 @@ #include /// proton: ends. +/// proton: starts +#include +/// proton: ends + namespace DB { +/// proton: starts +class Context; +/// proton: ends namespace ErrorCodes { @@ -749,6 +756,1259 @@ namespace } } +/// proton: starts +/// When timeplus registers a new function, the new function needs to be added to one of the following two maps. +static std::unordered_map function_map + = {{"cast", "cast"}, + {"encodeURLComponent", "encode_url_component"}, + {"decodeURLComponent", "decode_url_component"}, + {"URLHierarchy", "url_hierarchy"}, + {"URLPathHierarchy", "url_path_hierarchy"}, + {"extractURLParameterNames", "extract_url_parameter_names"}, + {"extractURLParameters", "extract_url_parameters"}, + {"generateUUIDv4", "generate_uuidv4"}, + {"toYYYYMMDDhhmmss", "to_YYYYMMDDhhmmss"}, + {"toYYYYMM", "to_YYYYMM"}, + {"to_YYYYMM", "to_YYYYMM"}, + {"BLAKE3", "blake3"}, + {"connectionId", "connection_id"}, + {"countMatches", "count_matches"}, + {"countMatchesCaseInsensitive", "count_matches_case_insensitive"}, + {"dateName", "date_name"}, + {"displayName", "display_name"}, + {"formatReadableDecimalSize", "format_readable_decimal_size"}, + {"FQDN", "fqdn"}, + {"hasToken", "has_token"}, + {"leftUTF8", "left_utf8"}, + {"position", "position"}, + {"rightUTF8", "right_utf8"}, + {"roundBankers", "round_bankers"}, + {"starts", "starts"}, + {"structureToCapnProtoSchema", "structure_to_capn_proto_schema"}, + {"structureToProtobufSchema", "structure_to_protobuf_schema"}, + {"xxh3", "xxh3"}}; + +static std::unordered_map case_insensitive_function_map + /// case_insensitive_functions + = {{"bithammingdistance", "bit_hamming_distance"}, + {"polygonsdistancespherical", "polygons_distance_spherical"}, + {"polygonsdistancecartesian", "polygons_distance_cartesian"}, + {"fuzzbits", "fuzz_bits"}, + {"initializeaggregation", "initialize_aggregation"}, + {"extractgroups", "extract_groups"}, + {"tostartofsecond", "to_start_of_second"}, + {"randomintype", "random_in_type"}, + {"jsonvalues", "json_values"}, + {"jsonexists", "json_exists"}, + {"rand", "rand"}, + {"tointervalmonth", "to_interval_month"}, + {"tointervalminute", "to_interval_minute"}, + {"tointervalsecond", "to_interval_second"}, + {"tointervalmillisecond", "to_interval_millisecond"}, + {"tointervalmicrosecond", "to_interval_microsecond"}, + {"parsedatetime64besteffortusornull", "parse_datetime64_best_effort_us_or_null"}, + {"parsedatetime64besteffortorzero", "parse_datetime64_best_effort_or_zero"}, + {"parsedatetime64besteffort", "parse_datetime64_best_effort"}, + {"parsedatetime32besteffortornull", "parse_datetime32_best_effort_or_null"}, + {"parsedatetimebesteffortusorzero", "parse_datetime_best_effort_us_or_zero"}, + {"parsedatetimebesteffortus", "parse_datetime_best_effort_us"}, + {"toipv6ornull", "to_ipv6_or_null"}, + {"toipv4ornull", "to_ipv4_or_null"}, + {"touuidornull", "to_uuid_or_null"}, + {"todecimal32ornull", "to_decimal32_or_null"}, + {"todate32ornull", "to_date32_or_null"}, + {"tofloat64ornull", "to_float64_or_null"}, + {"tofloat32ornull", "to_float32_or_null"}, + {"toint256ornull", "to_int256_or_null"}, + {"toint128ornull", "to_int128_or_null"}, + {"toint64ornull", "to_int64_or_null"}, + {"toint16ornull", "to_int16_or_null"}, + {"touint256ornull", "to_uint256_or_null"}, + {"touint32ornull", "to_uint32_or_null"}, + {"touint16ornull", "to_uint16_or_null"}, + {"touint8ornull", "to_uint8_or_null"}, + {"toipv6orzero", "to_ipv6_or_zero"}, + {"toipv4orzero", "to_ipv4_or_zero"}, + {"touuidorzero", "to_uuid_or_zero"}, + {"todecimal128orzero", "to_decimal128_or_zero"}, + {"todecimal64orzero", "to_decimal64_or_zero"}, + {"todecimal32orzero", "to_decimal32_or_zero"}, + {"todatetimeorzero", "to_datetime_or_zero"}, + {"todate32orzero", "to_date32_or_zero"}, + {"tofloat64orzero", "to_float64_or_zero"}, + {"toint64orzero", "to_int64_or_zero"}, + {"toint8orzero", "to_int8_or_zero"}, + {"parsedatetimebesteffortorzero", "parse_datetime_best_effort_or_zero"}, + {"touint128orzero", "to_uint128_or_zero"}, + {"touint64orzero", "to_uint64_or_zero"}, + {"touint32orzero", "to_uint32_or_zero"}, + {"touint8orzero", "to_uint8_or_zero"}, + {"toipv4", "to_ipv4"}, + {"todatetime64", "to_datetime64"}, + {"todate", "to_date"}, + {"todate16", "to_date16"}, + {"todecimal128", "to_decimal128"}, + {"todecimal64", "to_decimal64"}, + {"todecimal32", "to_decimal32"}, + {"toint256", "to_int256"}, + {"toint128", "to_int128"}, + {"toint64", "to_int64"}, + {"toint32", "to_int32"}, + {"touint256", "to_uint256"}, + {"touint128", "to_uint128"}, + {"touint64", "to_uint64"}, + {"touint32", "to_uint32"}, + {"touint16", "to_uint16"}, + {"touint8", "to_uint8"}, + {"blocksize", "block_size"}, + {"isnotnull", "is_not_null"}, + {"rounddown", "round_down"}, + {"trunc", "trunc"}, + {"floor", "floor"}, + {"round", "round"}, + {"weakhash32", "weak_hash32"}, + {"wyhash64", "wy_hash64"}, + {"xxhash64", "xx_hash64"}, + {"xxhash32", "xx_hash32"}, + {"gccmurmurhash", "gcc_murmur_hash"}, + {"murmurhash3128", "murmur_hash3_128"}, + {"murmurhash364", "murmur_hash3_64"}, + {"todecimal256orzero", "to_decimal256_or_zero"}, + {"murmurhash332", "murmur_hash3_32"}, + {"hivehash", "hive_hash"}, + {"javahashutf16le", "java_hash_utf16_le"}, + {"javahash", "java_hash"}, + {"urlhash", "url_hash"}, + {"inthash64", "int_hash64"}, + {"inthash32", "int_hash32"}, + {"metrohash64", "metro_hash64"}, + {"farmfingerprint64", "farm_fingerprint64"}, + {"siphash128", "sip_hash128"}, + {"sha512", "sha512"}, + {"sha384", "sha384"}, + {"uuidstringtonum", "uuid_string_to_num"}, + {"sha224", "sha224"}, + {"sha1", "sha1"}, + {"todecimal", "to_decimal"}, + {"md5", "md5"}, + {"halfmd5", "half_md5"}, + {"lowcardinalityindices", "low_cardinality_indices"}, + {"logtrace", "log_trace"}, + {"edition", "edition"}, + {"stringtoh3", "string_to_h3"}, + {"toint16", "to_int16"}, + {"jsonextractkeysandvaluesraw", "json_extract_keys_and_values_raw"}, + {"jsonextractarrayraw", "json_extract_array_raw"}, + {"jsonextractraw", "json_extract_raw"}, + {"jsonextractkeysandvalues", "json_extract_keys_and_values"}, + {"jsonextract", "json_extract"}, + {"jsonextractstring", "json_extract_string"}, + {"jsonextractbool", "json_extract_bool"}, + {"jsonextractint", "json_extract_int"}, + {"jsontype", "json_type"}, + {"jsonlength", "json_length"}, + {"isvalidjson", "is_valid_json"}, + {"char", "char"}, + {"cbrt", "cbrt"}, + {"s2togeo", "s2_to_geo"}, + {"sleepeachrow", "sleep_each_row"}, + {"regiontoname", "region_to_name"}, + {"regionin", "region_in"}, + {"regiontocountry", "region_to_country"}, + {"regiontodistrict", "region_to_district"}, + {"adddays", "add_days"}, + {"countsubstringscaseinsensitiveutf8", "count_substrings_case_insensitive_utf8"}, + {"makedatetime64", "make_datetime64"}, + {"date", "date"}, + {"makedate", "make_date"}, + {"subtractnanoseconds", "subtract_nanoseconds"}, + {"ipv6stringtonumornull", "ipv6_string_to_num_or_null"}, + {"ipv6stringtonumordefault", "ipv6_string_to_num_or_default"}, + {"ipv6stringtonum", "ipv6_string_to_num"}, + {"ipv6numtostring", "ipv6_num_to_string"}, + {"ipv4stringtonumordefault", "ipv4_string_to_num_or_default"}, + {"ipv4stringtonum", "ipv4_string_to_num"}, + {"ipv4numtostringclassc", "ipv4_num_to_string_class_c"}, + {"isipv4string", "is_ipv4_string"}, + {"ipv4cidrtorange", "ipv4_cidr_to_range"}, + {"ipv6cidrtorange", "ipv6_cidr_to_range"}, + {"macstringtooui", "mac_string_to_oui"}, + {"macnumtostring", "mac_num_to_string"}, + {"ipv4toipv6", "ipv4_to_ipv6"}, + {"cutipv6", "cut_ipv6"}, + {"snowflaketodatetime64", "snowflake_to_datetime64"}, + {"subtractmilliseconds", "subtract_milliseconds"}, + {"getserverport", "get_server_port"}, + {"regiontocity", "region_to_city"}, + {"multisearchany", "multi_search_any"}, + {"bitmaphasany", "bitmap_has_any"}, + {"bitmapandnot", "bitmap_andnot"}, + {"parsedatetime64besteffortus", "parse_datetime64_best_effort_us"}, + {"bitmapand", "bitmap_and"}, + {"detectcharset", "detect_charset"}, + {"bitmapxorcardinality", "bitmap_xor_cardinality"}, + {"h3getpentagonindexes", "h3_get_pentagon_indexes"}, + {"arraylastindex", "array_last_index"}, + {"bitmaporcardinality", "bitmap_or_cardinality"}, + {"subbitmap", "sub_bitmap"}, + {"runningconcurrency", "running_concurrency"}, + {"bitmapsubsetlimit", "bitmap_subset_limit"}, + {"bitmapsubsetinrange", "bitmap_subset_in_range"}, + {"bitmapbuild", "bitmap_build"}, + {"extracttextfromhtml", "extract_text_from_html"}, + {"monthname", "month_name"}, + {"splitbyregexp", "split_by_regexp"}, + {"isnan", "is_nan"}, + {"geohashencode", "geohash_encode"}, + {"torelativequarternum", "to_relative_quarter_num"}, + {"or", "or"}, + {"dictgetchildren", "dict_get_children"}, + {"dictisin", "dict_is_in"}, + {"todecimal128ornull", "to_decimal128_or_null"}, + {"dictgetstringordefault", "dict_get_string_or_default"}, + {"dictgetipv6ordefault", "dict_get_ipv6_or_default"}, + {"dictgetdatetimeordefault", "dict_get_datetime_or_default"}, + {"datetimetosnowflake", "datetime_to_snowflake"}, + {"todateordefault", "to_date_or_default"}, + {"dictgetdateordefault", "dict_get_date_or_default"}, + {"dictgetfloat64ordefault", "dict_get_float64_or_default"}, + {"h3getresolution", "h3_get_resolution"}, + {"exp", "exp"}, + {"dictgetfloat32ordefault", "dict_get_float32_or_default"}, + {"addseconds", "add_seconds"}, + {"dictgetint64ordefault", "dict_get_int64_or_default"}, + {"toint", "to_int"}, + {"dictgetint16ordefault", "dict_get_int16_or_default"}, + {"dictgetuint64ordefault", "dict_get_uint64_or_default"}, + {"emptyarraystring", "empty_array_string"}, + {"dictgetuint32ordefault", "dict_get_uint32_or_default"}, + {"h3cellaream2", "h3_cell_area_m2"}, + {"date_diff", "date_diff"}, + {"dictgetstring", "dict_get_string"}, + {"dictgetuuid", "dict_get_uuid"}, + {"dictgetfloat64", "dict_get_float64"}, + {"tuplemultiplybynumber", "tuple_multiply_by_number"}, + {"tomonth", "to_month"}, + {"dictgetint16", "dict_get_int16"}, + {"dictgetint8", "dict_get_int8"}, + {"dictgetuint32", "dict_get_uint32"}, + {"multisearchanycaseinsensitiveutf8", "multi_search_any_case_insensitive_utf8"}, + {"cosh", "cosh"}, + {"dictgetuint16", "dict_get_uint16"}, + {"sleep", "sleep"}, + {"dictget", "dict_get"}, + {"replicate", "replicate"}, + {"tomodifiedjulianday", "to_modified_julian_day"}, + {"h3getunidirectionaledge", "h3_get_unidirectional_edge"}, + {"regiontocontinent", "region_to_continent"}, + {"hascolumnintable", "has_column_in_table"}, + {"detectlanguageunknown", "detect_language_unknown"}, + {"arrayslice", "array_slice"}, + {"todecimal128ordefault", "to_decimal128_or_default"}, + {"partitionid", "partition_id"}, + {"formatdatetimeinjodasyntax", "format_datetime_in_joda_syntax"}, + {"dictgetornull", "dict_get_or_null"}, + {"tostartofquarter", "to_start_of_quarter"}, + {"multisearchfirstindex", "multi_search_first_index"}, + {"bytesize", "byte_size"}, + {"geohashdecode", "geohash_decode"}, + {"polygonsequalscartesian", "polygons_equals_cartesian"}, + {"jsonkey", "json_key"}, + {"bitmapmax", "bitmap_max"}, + {"tid", "tid"}, + {"bitcount", "bit_count"}, + {"tointervalyear", "to_interval_year"}, + {"not", "not"}, + {"formatrow", "format_row"}, + {"arrayreduceinranges", "array_reduce_in_ranges"}, + {"addmicroseconds", "add_microseconds"}, + {"geotoh3", "geo_to_h3"}, + {"bitmapmin", "bitmap_min"}, + {"normalizequery", "normalize_query"}, + {"if", "if"}, + {"defaultprofiles", "default_profiles"}, + {"countsubstrings", "count_substrings"}, + {"ngramdistancecaseinsensitiveutf8", "ngram_distance_case_insensitive_utf8"}, + {"acosh", "acosh"}, + {"accuratecastornull", "accurate_cast_or_null"}, + {"h3indexesareneighbors", "h3_indexes_are_neighbors"}, + {"accuratecast", "accurate_cast"}, + {"cast", "cast"}, + {"notlike", "not_like"}, + {"aesdecryptmysql", "aes_decrypt_mysql"}, + {"toint8", "to_int8"}, + {"dictgetfloat32", "dict_get_float32"}, + {"arraycompact", "array_compact"}, + {"dictgetint32", "dict_get_int32"}, + {"bitslice", "bit_slice"}, + {"bitrotateright", "bit_rotate_right"}, + {"toweek", "to_week"}, + {"hashid", "hashid"}, + {"h3edgelengthm", "h3_edge_length_m"}, + {"bitshiftright", "bit_shift_right"}, + {"tan", "tan"}, + {"substring", "substring"}, + {"tostartofday", "to_start_of_day"}, + {"addhours", "add_hours"}, + {"ipv4numtostring", "ipv4_num_to_string"}, + {"randcanonical", "rand_canonical"}, + {"h3togeoboundary", "h3_to_geo_boundary"}, + {"blocknumber", "block_number"}, + {"l2normalize", "l2_normalize"}, + {"reverse", "reverse"}, + {"multisearchfirstindexutf8", "multi_search_first_index_utf8"}, + {"torelativesecondnum", "to_relative_second_num"}, + {"greatcircleangle", "great_circle_angle"}, + {"subtractyears", "subtract_years"}, + {"isvalidutf8", "is_valid_utf8"}, + {"arrayfold", "array_fold"}, + {"casewithexpression", "case_with_expression"}, + {"addyears", "add_years"}, + {"tointervalquarter", "to_interval_quarter"}, + {"tonullable", "to_nullable"}, + {"intexp2", "int_exp2"}, + {"wordshingleminhashargutf8", "word_shingle_min_hash_arg_utf8"}, + {"fromunixtimestamp", "from_unix_timestamp"}, + {"dictgetint32ordefault", "dict_get_int32_or_default"}, + {"wordshingleminhashcaseinsensitive", "word_shingle_min_hash_case_insensitive"}, + {"rownumberinblock", "row_number_in_block"}, + {"splitbywhitespace", "split_by_whitespace"}, + {"wordshingleminhasharg", "word_shingle_min_hash_arg"}, + {"s2capcontains", "s2_cap_contains"}, + {"ngramminhashargcaseinsensitiveutf8", "ngram_min_hash_arg_case_insensitive_utf8"}, + {"extractallgroupsvertical", "extract_all_groups_vertical"}, + {"globalnotnullin", "global_not_null_in"}, + {"ngramminhashargutf8", "ngram_min_hash_arg_utf8"}, + {"ngramminhashargcaseinsensitive", "ngram_min_hash_arg_case_insensitive"}, + {"ngramminhashutf8", "ngram_min_hash_utf8"}, + {"ngramminhash", "ngram_min_hash"}, + {"wordshinglesimhashutf8", "word_shingle_sim_hash_utf8"}, + {"jsonvalue", "json_value"}, + {"wordshinglesimhashcaseinsensitive", "word_shingle_sim_hash_case_insensitive"}, + {"getmacro", "get_macro"}, + {"wordshinglesimhash", "word_shingle_sim_hash"}, + {"ngramsimhashcaseinsensitiveutf8", "ngram_sim_hash_case_insensitive_utf8"}, + {"ngramsimhashutf8", "ngram_sim_hash_utf8"}, + {"wordshingleminhashargcaseinsensitiveutf8", "word_shingle_min_hash_arg_case_insensitive_utf8"}, + {"h3pointdistrads", "h3_point_dist_rads"}, + {"runningdifferencestartingwithfirstvalue", "running_difference_starting_with_first_value"}, + {"ngramsimhashcaseinsensitive", "ngram_sim_hash_case_insensitive"}, + {"base58decode", "base58_decode"}, + {"moduloorzero", "modulo_or_zero"}, + {"normalizeutf8nfd", "normalize_utf8_nfd"}, + {"currentdatabase", "current_database"}, + {"streamingnow64", "__streaming_now64"}, + {"identity", "identity"}, + {"ascii", "ascii"}, + {"currentprofiles", "current_profiles"}, + {"lowerutf8", "lower_utf8"}, + {"polygonperimetercartesian", "polygon_perimeter_cartesian"}, + {"positivemodulo", "positive_modulo"}, + {"bitpositionstoarray", "bit_positions_to_array"}, + {"dictgetipv4ordefault", "dict_get_ipv4_or_default"}, + {"jsonhas", "json_has"}, + {"currentuser", "current_user"}, + {"tofloat64", "to_float64"}, + {"age", "age"}, + {"regionhierarchy", "region_hierarchy"}, + {"reinterpret", "reinterpret"}, + {"todayofweek", "to_day_of_week"}, + {"unbin", "unbin"}, + {"h3edgeangle", "h3_edge_angle"}, + {"modulo", "modulo"}, + {"toipv6ordefault", "to_ipv6_or_default"}, + {"cos", "cos"}, + {"unhex", "unhex"}, + {"hex", "hex"}, + {"gcd", "gcd"}, + {"jumpconsistenthash", "jump_consistent_hash"}, + {"defaultvalueofargumenttype", "default_value_of_argument_type"}, + {"subtractminutes", "subtract_minutes"}, + {"frommodifiedjulianday", "from_modified_julian_day"}, + {"concat", "concat"}, + {"demangle", "demangle"}, + {"log", "log"}, + {"alphatokens", "alpha_tokens"}, + {"l1norm", "l1_norm"}, + {"dividedecimal", "divide_decimal"}, + {"h3tochildren", "h3_to_children"}, + {"fullhostname", "full_host_name"}, + {"getsetting", "get_setting"}, + {"bitboolmaskand", "__bit_bool_mask_and"}, + {"tupleplus", "tuple_plus"}, + {"minus", "minus"}, + {"sqrt", "sqrt"}, + {"casewithoutexpr", "case_without_expr"}, + {"bitrotateleft", "bit_rotate_left"}, + {"getsizeofenumtype", "get_size_of_enum_type"}, + {"endswith", "ends_with"}, + {"wordshinglesimhashcaseinsensitiveutf8", "word_shingle_sim_hash_case_insensitive_utf8"}, + {"streamingrownumber", "__streaming_row_number"}, + {"formatreadablesize", "format_readable_size"}, + {"countdigits", "count_digits"}, + {"subtractquarters", "subtract_quarters"}, + {"polygonareacartesian", "polygon_area_cartesian"}, + {"trybase58decode", "try_base58_decode"}, + {"exp10", "exp10"}, + {"bitswaplasttwo", "__bit_swap_last_two"}, + {"lowcardinalitykeys", "low_cardinality_keys"}, + {"subtractinterval", "subtract_interval"}, + {"finalizeaggregation", "finalize_aggregation"}, + {"trybase64decode", "try_base64_decode"}, + {"tokens", "tokens"}, + {"ngrams", "ngrams"}, + {"geohashesinbox", "geohashes_in_box"}, + {"runningdifference", "running_difference"}, + {"arrayenumeratedenseranked", "array_enumerate_dense_ranked"}, + {"flattentuple", "flatten_tuple"}, + {"bitmapor", "bitmap_or"}, + {"concatassumeinjective", "concat_assume_injective"}, + {"lcm", "lcm"}, + {"mapextractkeylike", "map_extract_key_like"}, + {"formatreadablequantity", "format_readable_quantity"}, + {"formatrownonewline", "format_row_no_newline"}, + {"casewithoutexpression", "case_without_expression"}, + {"multiif", "multi_if"}, + {"fromunixtimestamp64milli", "from_unix_timestamp64_milli"}, + {"hastokencaseinsensitive", "has_token_case_insensitive"}, + {"geodistance", "geo_distance"}, + {"h3getres0indexes", "h3_get_res0_indexes"}, + {"toyear", "to_year"}, + {"decodexmlcomponent", "decode_xml_component"}, + {"now64", "now64"}, + {"multimatchany", "multi_match_any"}, + {"h3exactedgelengthkm", "h3_exact_edge_length_km"}, + {"arraysum", "array_sum"}, + {"toisoyear", "to_iso_year"}, + {"enabledroles", "enabled_roles"}, + {"parsedatetimebesteffortusornull", "parse_datetime_best_effort_us_or_null"}, + {"tostartoftenminutes", "to_start_of_ten_minutes"}, + {"lower", "lower"}, + {"h3exactedgelengthm", "h3_exact_edge_length_m"}, + {"bitmapandcardinality", "bitmap_and_cardinality"}, + {"dictgetdatetime", "dict_get_datetime"}, + {"totime", "__to_time"}, + {"h3getdestinationindexfromunidirectionaledge", "h3_get_destination_index_from_unidirectional_edge"}, + {"roundduration", "round_duration"}, + {"h3getoriginindexfromunidirectionaledge", "h3_get_origin_index_from_unidirectional_edge"}, + {"crc32", "crc32"}, + {"trimright", "trim_right"}, + {"trimleft", "trim_left"}, + {"dumpcolumnstructure", "dump_column_structure"}, + {"touuid", "to_uuid"}, + {"extractallgroupshorizontal", "extract_all_groups_horizontal"}, + {"uniqthetaunion", "uniq_theta_union"}, + {"s2cellsintersect", "s2_cells_intersect"}, + {"coalesce", "coalesce"}, + {"todateorzero", "to_date_or_zero"}, + {"initialqueryid", "initial_query_id"}, + {"toyearweek", "to_year_week"}, + {"detectlanguagemixed", "detect_language_mixed"}, + {"h3line", "h3_line"}, + {"atanh", "atanh"}, + {"wordshingleminhashutf8", "word_shingle_min_hash_utf8"}, + {"toint32ornull", "to_int32_or_null"}, + {"simplejsonextractuint", "simple_json_extract_uint"}, + {"h3hexring", "h3_hex_ring"}, + {"todecimal256", "to_decimal256"}, + {"ngramsearch", "ngram_search"}, + {"arraydifference", "array_difference"}, + {"arraypushback", "array_push_back"}, + {"h3unidirectionaledgeisvalid", "h3_unidirectional_edge_is_valid"}, + {"arraystringconcat", "array_string_concat"}, + {"repeat", "repeat"}, + {"stem", "stem"}, + {"totypename", "to_type_name"}, + {"todatetime64ornull", "to_datetime64_or_null"}, + {"reversednsquery", "reverse_dns_query"}, + {"splitbynonalpha", "split_by_non_alpha"}, + {"ignore", "ignore"}, + {"tostartofnanosecond", "to_start_of_nanosecond"}, + {"bittest", "bit_test"}, + {"tointervalhour", "to_interval_hour"}, + {"h3toparent", "h3_to_parent"}, + {"buildid", "build_id"}, + {"multisearchfirstposition", "multi_search_first_position"}, + {"dictgetuint64", "dict_get_uint64"}, + {"h3hexareakm2", "h3_hex_area_km2"}, + {"h3kring", "h3k_ring"}, + {"toint8ornull", "to_int8_or_null"}, + {"hypot", "hypot"}, + {"kostikconsistenthash", "kostik_consistent_hash"}, + {"globalnotnullinignoreset", "global_not_null_in_ignore_set"}, + {"detectlanguage", "detect_language"}, + {"tupleelement", "tuple_element"}, + {"notnullinignoreset", "not_null_in_ignore_set"}, + {"h3exactedgelengthrads", "h3_exact_edge_length_rads"}, + {"globalnotinignoreset", "global_not_in_ignore_set"}, + {"globalinignoreset", "global_in_ignore_set"}, + {"subtractmonths", "subtract_months"}, + {"inignoreset", "in_ignore_set"}, + {"bitshiftleft", "bit_shift_left"}, + {"notnullin", "not_null_in"}, + {"globalnullin", "global_null_in"}, + {"globalnotin", "global_not_in"}, + {"bitmaptransform", "bitmap_transform"}, + {"parsetimedelta", "parse_time_delta"}, + {"extractkeyvaluepairs", "extract_key_value_pairs"}, + {"in", "in"}, + {"h3getbasecell", "h3_get_base_cell"}, + {"errorcodetoname", "error_code_to_name"}, + {"randomfixedstring", "random_fixed_string"}, + {"tofloat32orzero", "to_float32_or_zero"}, + {"acos", "acos"}, + {"isconstant", "is_constant"}, + {"countsubstringscaseinsensitive", "count_substrings_case_insensitive"}, + {"emptyarraytosingle", "empty_array_to_single"}, + {"isipv6string", "is_ipv6_string"}, + {"addnanoseconds", "add_nanoseconds"}, + {"monotonic", "monotonic"}, + {"randexponential", "rand_exponential"}, + {"extractkeyvaluepairswithescaping", "extract_key_value_pairs_with_escaping"}, + {"polygonsunionspherical", "polygons_union_spherical"}, + {"polygonsunioncartesian", "polygons_union_cartesian"}, + {"isnullable", "is_nullable"}, + {"iszeroornull", "is_zero_or_null"}, + {"macstringtonum", "mac_string_to_num"}, + {"leftpadutf8", "left_pad_utf8"}, + {"lagbehind", "lag_behind"}, + {"multifuzzymatchanyindex", "multi_fuzzy_match_any_index"}, + {"lemmatize", "lemmatize"}, + {"isdecimaloverflow", "is_decimal_overflow"}, + {"multisearchallpositionscaseinsensitiveutf8", "multi_search_all_positions_case_insensitive_utf8"}, + {"lengthutf8", "length_utf8"}, + {"h3hexaream2", "h3_hex_area_m2"}, + {"tobool", "to_bool"}, + {"lessorequals", "less_or_equals"}, + {"multiplydecimal", "multiply_decimal"}, + {"wkt", "wkt"}, + {"filesystemunreserved", "filesystem_unreserved"}, + {"randnormal", "rand_normal"}, + {"abs", "abs"}, + {"and", "and"}, + {"arraymap", "array_map"}, + {"log1p", "log1p"}, + {"fromunixtimestamp64nano", "from_unix_timestamp64_nano"}, + {"todecimal32ordefault", "to_decimal32_or_default"}, + {"todatetime64ordefault", "to_datetime64_or_default"}, + {"greatcircledistance", "great_circle_distance"}, + {"reinterpretasfixedstring", "reinterpret_as_fixed_string"}, + {"dotproduct", "dot_product"}, + {"touint256orzero", "to_uint256_or_zero"}, + {"jsonextractfloat", "json_extract_float"}, + {"tofloat64ordefault", "to_float64_or_default"}, + {"toint256ordefault", "to_int256_or_default"}, + {"tuplenegate", "tuple_negate"}, + {"arrayflatten", "array_flatten"}, + {"materialize", "materialize"}, + {"toint8ordefault", "to_int8_or_default"}, + {"tostartofminute", "to_start_of_minute"}, + {"extract", "extract"}, + {"touint64ordefault", "to_uint64_or_default"}, + {"arrayenumerateuniq", "array_enumerate_uniq"}, + {"svg", "svg"}, + {"bitmaphasall", "bitmap_has_all"}, + {"h3ispentagon", "h3_is_pentagon"}, + {"mapupdate", "map_update"}, + {"proportionsztest", "proportions_ztest"}, + {"base58encode", "base58_encode"}, + {"h3isvalid", "h3_is_valid"}, + {"bitmasktolist", "bitmask_to_list"}, + {"mapvalues", "map_values"}, + {"positioncaseinsensitive", "position_case_insensitive"}, + {"mapcontains", "map_contains"}, + {"meilimatch", "meili_match"}, + {"snowflaketodatetime", "snowflake_to_datetime"}, + {"multisearchfirstpositioncaseinsensitive", "multi_search_first_position_case_insensitive"}, + {"minsamplesizeconversion", "min_sample_size_conversion"}, + {"divide", "divide"}, + {"modulolegacy", "modulo_legacy"}, + {"tojsonstring", "to_json_string"}, + {"isinfinite", "is_infinite"}, + {"mortondecode", "morton_decode"}, + {"enabledprofiles", "enabled_profiles"}, + {"grok", "grok"}, + {"mortonencode", "morton_encode"}, + {"randomprintableascii", "random_printable_ascii"}, + {"todatetimeordefault", "to_datetime_or_default"}, + {"timeslot", "time_slot"}, + {"formatreadabletimedelta", "format_readable_time_delta"}, + {"s2rectadd", "s2_rect_add"}, + {"runningaccumulate", "running_accumulate"}, + {"hasthreadfuzzer", "has_thread_fuzzer"}, + {"appendtrailingcharifabsent", "append_trailing_char_if_absent"}, + {"bitboolmaskor", "__bit_bool_mask_or"}, + {"multifuzzymatchany", "multi_fuzzy_match_any"}, + {"torelativeweeknum", "to_relative_week_num"}, + {"dictgethierarchy", "dict_get_hierarchy"}, + {"aesencryptmysql", "aes_encrypt_mysql"}, + {"intdivorzero", "int_div_or_zero"}, + {"rightpadutf8", "right_pad_utf8"}, + {"reverseutf8", "reverse_utf8"}, + {"leftpad", "left_pad"}, + {"translateutf8", "translate_utf8"}, + {"multimatchanyindex", "multi_match_any_index"}, + {"todecimal64ornull", "to_decimal64_or_null"}, + {"arrayfirstornull", "array_first_or_null"}, + {"addmonths", "add_months"}, + {"timeslots", "time_slots"}, + {"toipv4ordefault", "to_ipv4_or_default"}, + {"joinget", "join_get"}, + {"base64decode", "base64_decode"}, + {"atan2", "atan2"}, + {"toint16ordefault", "to_int16_or_default"}, + {"lpdistance", "lp_distance"}, + {"normalizeutf8nfkd", "normalize_utf8_nfkd"}, + {"multisearchallpositions", "multi_search_all_positions"}, + {"dictgetuint8", "dict_get_uint8"}, + {"accuratecastordefault", "accurate_cast_or_default"}, + {"file", "file"}, + {"normalizeutf8nfkc", "normalize_utf8_nfkc"}, + {"arraypushfront", "array_push_front"}, + {"normalizeutf8nfc", "normalize_utf8_nfc"}, + {"mapkeys", "map_keys"}, + {"todatetimeornull", "to_datetime_or_null"}, + {"encrypt", "encrypt"}, + {"arrayauc", "array_auc"}, + {"tostartofmonth", "to_start_of_month"}, + {"siphash64", "sip_hash64"}, + {"arrayelement", "array_element"}, + {"bitor", "bit_or"}, + {"formatdatetime", "format_datetime"}, + {"simplejsonextractraw", "simple_json_extract_raw"}, + {"subtractseconds", "subtract_seconds"}, + {"addresstosymbol", "address_to_symbol"}, + {"emitversion", "emit_version"}, + {"tostring", "to_string"}, + {"makedate32", "make_date32"}, + {"simplejsonextractbool", "simple_json_extract_bool"}, + {"bittestall", "bit_test_all"}, + {"reinterpretasdate", "reinterpret_as_date"}, + {"getoskernelversion", "get_os_kernel_version"}, + {"arraycount", "array_count"}, + {"evalmlmethod", "eval_ml_method"}, + {"addminutes", "add_minutes"}, + {"sin", "sin"}, + {"positioncaseinsensitiveutf8", "position_case_insensitive_utf8"}, + {"multisearchfirstindexcaseinsensitiveutf8", "multi_search_first_index_case_insensitive_utf8"}, + {"mapcast", "map_cast"}, + {"todatetime64orzero", "to_datetime64_or_zero"}, + {"timediff", "time_diff"}, + {"has", "has"}, + {"base64encode", "base64_encode"}, + {"s2rectcontains", "s2_rect_contains"}, + {"negate", "negate"}, + {"intdiv", "int_div"}, + {"lags", "lags"}, + {"replaceall", "replace_all"}, + {"farmhash64", "farm_hash64"}, + {"rightpad", "right_pad"}, + {"subtractweeks", "subtract_weeks"}, + {"totimezone", "to_timezone"}, + {"currentroles", "current_roles"}, + {"bin", "bin"}, + {"h3edgelengthkm", "h3_edge_length_km"}, + {"today", "today"}, + {"match", "match"}, + {"torelativemonthnum", "to_relative_month_num"}, + {"ngramminhashcaseinsensitiveutf8", "ngram_min_hash_case_insensitive_utf8"}, + {"arraycumsum", "array_cum_sum"}, + {"arrayfirst", "array_first"}, + {"emptyarraydatetime", "empty_array_datetime"}, + {"regiontotopcontinent", "region_to_top_continent"}, + {"globalnullinignoreset", "global_null_in_ignore_set"}, + {"emptyarraydate", "empty_array_date"}, + {"emptyarrayfloat64", "empty_array_float64"}, + {"h3getunidirectionaledgesfromhexagon", "h3_get_unidirectional_edges_from_hexagon"}, + {"emptyarrayfloat32", "empty_array_float32"}, + {"atan", "atan"}, + {"md4", "md4"}, + {"queryid", "query_id"}, + {"emptyarrayuint64", "empty_array_uint64"}, + {"now", "now"}, + {"subtractdays", "subtract_days"}, + {"json_query", "json_query"}, + {"todatetime32", "to_datetime32"}, + {"nullif", "null_if"}, + {"bitand", "bit_and"}, + {"ngramminhasharg", "ngram_min_hash_arg"}, + {"boottime", "boot_time"}, + {"torelativedaynum", "to_relative_day_num"}, + {"left", "left"}, + {"asin", "asin"}, + {"tosecond", "to_second"}, + {"roundtoexp2", "round_to_exp2"}, + {"parsedatetime", "parse_datetime"}, + {"readwktmultipolygon", "read_wkt_multi_polygon"}, + {"arrayenumerate", "array_enumerate"}, + {"plus", "plus"}, + {"dictgetint8ordefault", "dict_get_int8_or_default"}, + {"reinterpretasint128", "reinterpret_as_int128"}, + {"arrayconcat", "array_concat"}, + {"h3pointdistm", "h3_point_dist_m"}, + {"parsedatetime32besteffort", "parse_datetime32_best_effort"}, + {"randconstant", "rand_constant"}, + {"cityhash64", "city_hash64"}, + {"pointinellipses", "point_in_ellipses"}, + {"toconcretetype", "to_concrete_type"}, + {"murmurhash264", "murmur_hash2_64"}, + {"nullin", "null_in"}, + {"toint16orzero", "to_int16_or_zero"}, + {"multifuzzymatchallindices", "multi_fuzzy_match_all_indices"}, + {"polygonareaspherical", "polygon_area_spherical"}, + {"dictgetdate", "dict_get_date"}, + {"dictgetint64", "dict_get_int64"}, + {"e", "e"}, + {"bitwrapperfunc", "__bit_wrapper_func"}, + {"roundage", "round_age"}, + {"polygonperimeterspherical", "polygon_perimeter_spherical"}, + {"lgamma", "lgamma"}, + {"throwif", "throw_if"}, + {"h3pointdistkm", "h3_point_dist_km"}, + {"h3isresclassiii", "h3_is_res_class_iii"}, + {"randstudentt", "rand_student_t"}, + {"polygonsintersectionspherical", "polygons_intersection_spherical"}, + {"arraymax", "array_max"}, + {"serveruuid", "server_uuid"}, + {"polygonssymdifferencespherical", "polygons_sym_difference_spherical"}, + {"polygonssymdifferencecartesian", "polygons_sym_difference_cartesian"}, + {"polygonswithinspherical", "polygons_within_spherical"}, + {"tostartoffiveminutes", "to_start_of_five_minutes"}, + {"reinterpretasint32", "reinterpret_as_int32"}, + {"todecimal64ordefault", "to_decimal64_or_default"}, + {"arrayresize", "array_resize"}, + {"joingetornull", "join_get_or_null"}, + {"encodexmlcomponent", "encode_xml_component"}, + {"polygonsintersectioncartesian", "polygons_intersection_cartesian"}, + {"pow", "pow"}, + {"decrypt", "decrypt"}, + {"emptyarrayint64", "empty_array_int64"}, + {"addweeks", "add_weeks"}, + {"streamingneighbor", "__streaming_neighbor"}, + {"addtupleofintervals", "add_tuple_of_intervals"}, + {"toquarter", "to_quarter"}, + {"yesterday", "yesterday"}, + {"todateornull", "to_date_or_null"}, + {"positionutf8", "position_utf8"}, + {"getscalar", "__get_scalar"}, + {"ilike", "ilike"}, + {"touint256ordefault", "to_uint256_or_default"}, + {"ngramsearchcaseinsensitiveutf8", "ngram_search_case_insensitive_utf8"}, + {"subtracthours", "subtract_hours"}, + {"wordshingleminhashcaseinsensitiveutf8", "word_shingle_min_hash_case_insensitive_utf8"}, + {"pointinpolygon", "point_in_polygon"}, + {"dictgetuint8ordefault", "dict_get_uint8_or_default"}, + {"ngramsearchutf8", "ngram_search_utf8"}, + {"nullinignoreset", "null_in_ignore_set"}, + {"todayofmonth", "to_day_of_month"}, + {"mapadd", "map_add"}, + {"randpoisson", "rand_poisson"}, + {"randnegativebinomial", "rand_negative_binomial"}, + {"uuidnumtostring", "uuid_num_to_string"}, + {"convertcharset", "convert_charset"}, + {"randbinomial", "rand_binomial"}, + {"todecimal256ordefault", "to_decimal256_or_default"}, + {"randbernoulli", "rand_bernoulli"}, + {"randfisherf", "rand_fisher_f"}, + {"h3tostring", "h3_to_string"}, + {"arrayall", "array_all"}, + {"blockserializedsize", "block_serialized_size"}, + {"randchisquared", "rand_chi_squared"}, + {"arrayenumeratedense", "array_enumerate_dense"}, + {"multisearchallpositionscaseinsensitive", "multi_search_all_positions_case_insensitive"}, + {"rand64", "rand64"}, + {"tofloat32ordefault", "to_float32_or_default"}, + {"radians", "radians"}, + {"multisearchanycaseinsensitive", "multi_search_any_case_insensitive"}, + {"emptyarrayint32", "empty_array_int32"}, + {"randuniform", "rand_uniform"}, + {"tominute", "to_minute"}, + {"log2", "log2"}, + {"mapapply", "map_apply"}, + {"tuplecast", "tuple_cast"}, + {"ipv4stringtonumornull", "ipv4_string_to_num_or_null"}, + {"randomstringutf8", "random_string_utf8"}, + {"parsedatetime32besteffortorzero", "parse_datetime32_best_effort_or_zero"}, + {"mapcontainskeylike", "map_contains_key_like"}, + {"arrayreversefill", "array_reverse_fill"}, + {"reinterpretasstring", "reinterpret_as_string"}, + {"reinterpretasuuid", "reinterpret_as_uuid"}, + {"uuid", "uuid"}, + {"bitmasktoarray", "bitmask_to_array"}, + {"tostartofmicrosecond", "to_start_of_microsecond"}, + {"tostartofhour", "to_start_of_hour"}, + {"normalizedqueryhash", "normalized_query_hash"}, + {"reinterpretasdatetime", "reinterpret_as_datetime"}, + {"tuplehammingdistance", "tuple_hamming_distance"}, + {"touint8ordefault", "to_uint8_or_default"}, + {"reinterpretasfloat64", "reinterpret_as_float64"}, + {"tocolumntypename", "to_column_type_name"}, + {"reinterpretasfloat32", "reinterpret_as_float32"}, + {"nowinblock", "now_in_block"}, + {"sigmoid", "sigmoid"}, + {"format", "format"}, + {"emptyarrayint16", "empty_array_int16"}, + {"replaceregexpone", "replace_regexp_one"}, + {"reinterpretasint256", "reinterpret_as_int256"}, + {"fromunixtimestamp64micro", "from_unix_timestamp64_micro"}, + {"simplejsonextractstring", "simple_json_extract_string"}, + {"reinterpretasint64", "reinterpret_as_int64"}, + {"bitmaptoarray", "bitmap_to_array"}, + {"normalizedqueryhashkeepnames", "normalized_query_hash_keep_names"}, + {"reinterpretasint16", "reinterpret_as_int16"}, + {"xor", "xor"}, + {"addinterval", "add_interval"}, + {"reinterpretasuint128", "reinterpret_as_uint128"}, + {"intexp10", "int_exp10"}, + {"touint16ordefault", "to_uint16_or_default"}, + {"notin", "not_in"}, + {"randomstring", "random_string"}, + {"dicthas", "dict_has"}, + {"mapsubtract", "map_subtract"}, + {"linfnormalize", "linf_normalize"}, + {"hasany", "has_any"}, + {"tohour", "to_hour"}, + {"readwktpolygon", "read_wkt_polygon"}, + {"reinterpretasuint32", "reinterpret_as_uint32"}, + {"wordshingleminhashargcaseinsensitive", "word_shingle_min_hash_arg_case_insensitive"}, + {"simplejsonextractfloat", "simple_json_extract_float"}, + {"filesystemavailable", "filesystem_available"}, + {"readwktring", "read_wkt_ring"}, + {"addmilliseconds", "add_milliseconds"}, + {"cosinedistance", "cosine_distance"}, + {"minsamplesizecontinous", "min_sample_size_continous"}, + {"regexpquotemeta", "regexp_quote_meta"}, + {"emptyarrayuint32", "empty_array_uint32"}, + {"parsedatetimebesteffort", "parse_datetime_best_effort"}, + {"uptime", "uptime"}, + {"arraysort", "array_sort"}, + {"l1normalize", "l1_normalize"}, + {"arraydistinct", "array_distinct"}, + {"addquarters", "add_quarters"}, + {"ifnotfinite", "if_not_finite"}, + {"equals", "equals"}, + {"ifnull", "if_null"}, + {"regiontoarea", "region_to_area"}, + {"arrayjaccardindex", "array_jaccard_index"}, + {"right", "right"}, + {"dictgetall", "dict_get_all"}, + {"notequals", "not_equals"}, + {"s2capunion", "s2_cap_union"}, + {"factorial", "factorial"}, + {"tofloat32", "to_float32"}, + {"arraymin", "array_min"}, + {"h3getunidirectionaledgeboundary", "h3_get_unidirectional_edge_boundary"}, + {"multisearchfirstindexcaseinsensitive", "multi_search_first_index_case_insensitive"}, + {"revision", "revision"}, + {"visiblewidth", "visible_width"}, + {"synonyms", "synonyms"}, + {"randlognormal", "rand_log_normal"}, + {"multisearchfirstpositionutf8", "multi_search_first_position_utf8"}, + {"globalin", "global_in"}, + {"erf", "erf"}, + {"arraypopback", "array_pop_back"}, + {"s2rectunion", "s2_rect_union"}, + {"timezone", "timezone"}, + {"countequal", "count_equal"}, + {"isfinite", "is_finite"}, + {"emptyarrayint8", "empty_array_int8"}, + {"normalizequerykeepnames", "normalize_query_keep_names"}, + {"arrayexists", "array_exists"}, + {"shardnum", "shard_num"}, + {"hassubstr", "has_substr"}, + {"streamingnow", "__streaming_now"}, + {"touint16orzero", "to_uint16_or_zero"}, + {"multisearchfirstpositioncaseinsensitiveutf8", "multi_search_first_position_case_insensitive_utf8"}, + {"dictgetipv4", "dict_get_ipv4"}, + {"replaceregexpall", "replace_regexp_all"}, + {"like", "like"}, + {"tostartofmillisecond", "to_start_of_millisecond"}, + {"fromunixtimestampinjodasyntax", "from_unix_timestamp_in_joda_syntax"}, + {"tostartoffifteenminutes", "to_start_of_fifteen_minutes"}, + {"ngramdistanceutf8", "ngram_distance_utf8"}, + {"min2", "min2"}, + {"tostartofweek", "to_start_of_week"}, + {"toint32orzero", "to_int32_or_zero"}, + {"length", "length"}, + {"lpnorm", "lp_norm"}, + {"linfnorm", "linf_norm"}, + {"datetime64tosnowflake", "datetime64_to_snowflake"}, + {"touint128ornull", "to_uint128_or_null"}, + {"tupleminus", "tuple_minus"}, + {"validatenestedarraysizes", "validate_nested_array_sizes"}, + {"reinterpretasint8", "reinterpret_as_int8"}, + {"tolastdayofmonth", "to_last_day_of_month"}, + {"sign", "sign"}, + {"upper", "upper"}, + {"arrayintersect", "array_intersect"}, + {"notempty", "not_empty"}, + {"arraysplit", "array_split"}, + {"dictgetordefault", "dict_get_or_default"}, + {"tointervalday", "to_interval_day"}, + {"substringutf8", "substring_utf8"}, + {"parsedatetimebesteffortornull", "parse_datetime_best_effort_or_null"}, + {"toint256orzero", "to_int256_or_zero"}, + {"casewithexpr", "case_with_expr"}, + {"tanh", "tanh"}, + {"tostringcuttozero", "to_string_cut_to_zero"}, + {"arraywithconstant", "array_with_constant"}, + {"murmurhash232", "murmur_hash2_32"}, + {"erfc", "erfc"}, + {"frommodifiedjuliandayornull", "from_modified_julian_day_or_null"}, + {"replaceone", "replace_one"}, + {"multisearchallpositionsutf8", "multi_search_all_positions_utf8"}, + {"asinh", "asinh"}, + {"detecttonality", "detect_tonality"}, + {"bitxor", "bit_xor"}, + {"timezoneof", "timezone_of"}, + {"greaterorequals", "greater_or_equals"}, + {"jsonextractuint", "json_extract_uint"}, + {"h3getfaces", "h3_get_faces"}, + {"notinignoreset", "not_in_ignore_set"}, + {"jsonextractarray", "json_extract_array"}, + {"ngramminhashcaseinsensitive", "ngram_min_hash_case_insensitive"}, + {"arrayreduce", "array_reduce"}, + {"todayofyear", "to_day_of_year"}, + {"l2squarednorm", "l2_squared_norm"}, + {"h3tocenterchild", "h3_to_center_child"}, + {"tounixtimestamp", "to_unix_timestamp"}, + {"toint128ordefault", "to_int128_or_default"}, + {"degrees", "degrees"}, + {"tostartofyear", "to_start_of_year"}, + {"toisoweek", "to_iso_week"}, + {"regiontopopulation", "region_to_population"}, + {"geotos2", "geo_to_s2"}, + {"max2", "max2"}, + {"upperutf8", "upper_utf8"}, + {"torelativeminutenum", "to_relative_minute_num"}, + {"tolowcardinality", "to_low_cardinality"}, + {"parsedatetime64besteffortornull", "parse_datetime64_best_effort_or_null"}, + {"tounixtimestamp64milli", "to_unix_timestamp64_milli"}, + {"hostname", "hostname"}, + {"tomodifiedjuliandayornull", "to_modified_julian_day_or_null"}, + {"multiply", "multiply"}, + {"dictgetuint16ordefault", "dict_get_uint16_or_default"}, + {"splitbystring", "split_by_string"}, + {"pi", "pi"}, + {"version", "version"}, + {"linfdistance", "linf_distance"}, + {"torelativehournum", "to_relative_hour_num"}, + {"datediffwithin", "date_diff_within"}, + {"datediff", "date_diff"}, + {"toint64ordefault", "to_int64_or_default"}, + {"tounixtimestamp64nano", "to_unix_timestamp64_nano"}, + {"emptyarrayuint8", "empty_array_uint8"}, + {"multimatchallindices", "multi_match_all_indices"}, + {"toyyyymmddhhmmss", "to_yyyymmddhhmmss"}, + {"to_yyyymmddhhmmss", "to_yyyymmddhhmmss"}, + {"toint128orzero", "to_int128_or_zero"}, + {"tovalidutf8", "to_valid_utf8"}, + {"polygonswithincartesian", "polygons_within_cartesian"}, + {"arrayzip", "array_zip"}, + {"torelativeyearnum", "to_relative_year_num"}, + {"ngramsimhash", "ngram_sim_hash"}, + {"isipaddressinrange", "is_ip_address_in_range"}, + {"exp2", "exp2"}, + {"tcpport", "tcp_port"}, + {"arraylastornull", "array_last_or_null"}, + {"transform", "transform"}, + {"bitmapcontains", "bitmap_contains"}, + {"reinterpretasuint256", "reinterpret_as_uint256"}, + {"toipv6", "to_ipv6"}, + {"subtractmicroseconds", "subtract_microseconds"}, + {"defaultroles", "default_roles"}, + {"lag", "lag"}, + {"mapfilter", "map_filter"}, + {"bitmapcardinality", "bitmap_cardinality"}, + {"toyyyymmdd", "to_yyyymmdd"}, + {"to_yyyymmdd", "to_yyyymmdd"}, + {"lpnormalize", "lp_normalize"}, + {"l2squareddistance", "l2_squared_distance"}, + {"readwktpoint", "read_wkt_point"}, + {"trimboth", "trim_both"}, + {"s2rectintersection", "s2_rect_intersection"}, + {"greatest", "greatest"}, + {"l1distance", "l1_distance"}, + {"neighbor", "neighbor"}, + {"arrayreversesort", "array_reverse_sort"}, + {"trydecrypt", "try_decrypt"}, + {"tupledividebynumber", "tuple_divide_by_number"}, + {"touint64ornull", "to_uint64_or_null"}, + {"defaultvalueoftypename", "default_value_of_type_name"}, + {"h3distance", "h3_distance"}, + {"tgamma", "tgamma"}, + {"s2getneighbors", "s2_get_neighbors"}, + {"tupledivide", "tuple_divide"}, + {"arrayfirstindex", "array_first_index"}, + {"toint32ordefault", "to_int32_or_default"}, + {"addresstoline", "address_to_line"}, + {"assumenotnull", "assume_not_null"}, + {"simplejsonhas", "simple_json_has"}, + {"arrayjoin", "array_join"}, + {"bitmapandnotcardinality", "bitmap_andnot_cardinality"}, + {"detectprogramminglanguage", "detect_programming_language"}, + {"bitmapxor", "bitmap_xor"}, + {"gettypeserializationstreams", "get_type_serialization_streams"}, + {"reinterpretasuint8", "reinterpret_as_uint8"}, + {"timezoneoffset", "timezone_offset"}, + {"filesystemcapacity", "filesystem_capacity"}, + {"arraycast", "array_cast"}, + {"touint32ordefault", "to_uint32_or_default"}, + {"startswith", "starts_with"}, + {"tofloat", "to_float"}, + {"notilike", "not_ilike"}, + {"ngramdistance", "ngram_distance"}, + {"totime", "to_time"}, + {"multisearchanyutf8", "multi_search_any_utf8"}, + {"ngramdistancecaseinsensitive", "ngram_distance_case_insensitive"}, + {"ngramsearchcaseinsensitive", "ngram_search_case_insensitive"}, + {"arraycumsumnonnegative", "array_cum_sum_non_negative"}, + {"globalvariable", "global_variable"}, + {"tointervalweek", "to_interval_week"}, + {"indexof", "index_of"}, + {"translate", "translate"}, + {"h3numhexagons", "h3_num_hexagons"}, + {"sinh", "sinh"}, + {"parsedatetimeinjodasyntax", "parse_datetime_in_joda_syntax"}, + {"tointervalnanosecond", "to_interval_nanosecond"}, + {"extractall", "extract_all"}, + {"empty", "empty"}, + {"simplejsonextractint", "simple_json_extract_int"}, + {"todatetime", "to_datetime"}, + {"bar", "bar"}, + {"h3togeo", "h3_to_geo"}, + {"indexhint", "index_hint"}, + {"date_trunc", "date_trunc"}, + {"date_add", "date_add"}, + {"date_sub", "date_sub"}, + {"uniqthetanot", "uniq_theta_not"}, + {"ceil", "ceil"}, + {"dictgetuuidordefault", "dict_get_uuid_or_default"}, + {"utctimestamp", "utc_timestamp"}, + {"arraylast", "array_last"}, + {"l2distance", "l2_distance"}, + {"wordshingleminhash", "word_shingle_min_hash"}, + {"log10", "log10"}, + {"mappopulateseries", "map_populate_series"}, + {"todecimal256ornull", "to_decimal256_or_null"}, + {"arrayenumerateuniqranked", "array_enumerate_uniq_ranked"}, + {"makedatetime", "make_datetime"}, + {"shardcount", "shard_count"}, + {"h3cellarearads2", "h3_cell_area_rads2"}, + {"arrayfilter", "array_filter"}, + {"subtracttupleofintervals", "subtract_tuple_of_intervals"}, + {"bitnot", "bit_not"}, + {"jsonextractkeys", "json_extract_keys"}, + {"addresstolinewithinlines", "address_to_line_with_inlines"}, + {"l2norm", "l2_norm"}, + {"uniqthetaintersect", "uniq_theta_intersect"}, + {"hasall", "has_all"}, + {"reinterpretasuint64", "reinterpret_as_uint64"}, + {"tofixedstring", "to_fixed_string"}, + {"emptyarrayuint16", "empty_array_uint16"}, + {"tostartofinterval", "to_start_of_interval"}, + {"tostartofisoyear", "to_start_of_iso_year"}, + {"h3getindexesfromunidirectionaledge", "h3_get_indexes_from_unidirectional_edge"}, + {"arraypopfront", "array_pop_front"}, + {"reinterpretasuint16", "reinterpret_as_uint16"}, + {"dictgetipv6", "dict_get_ipv6"}, + {"arrayreversesplit", "array_reverse_split"}, + {"dictgetdescendants", "dict_get_descendants"}, + {"crc64", "crc64"}, + {"least", "least"}, + {"crc32ieee", "crc32_ieee"}, + {"todate32ordefault", "to_date32_or_default"}, + {"arrayavg", "array_avg"}, + {"isnull", "is_null"}, + {"tomonday", "to_monday"}, + {"range", "range"}, + {"toyyyymm", "to_yyyymm"}, + {"to_yyyymm", "to_yyyymm"}, + {"splitbychar", "split_by_char"}, + {"polygonconvexhullcartesian", "polygon_convex_hull_cartesian"}, + {"tuplemultiply", "tuple_multiply"}, + {"tupletonamevaluepairs", "tuple_to_name_value_pairs"}, + {"touuidordefault", "to_uuid_or_default"}, + {"greater", "greater"}, + {"arrayuniq", "array_uniq"}, + {"less", "less"}, + {"sha256", "sha256"}, + {"bittestany", "bit_test_any"}, + {"arrayreverse", "array_reverse"}, + {"earliesttimestamp", "earliest_timestamp"}, + {"tounixtimestamp64micro", "to_unix_timestamp64_micro"}, + {"arrayfill", "array_fill"}, + {"arrayproduct", "array_product"}, + /// case_insensitive_aggregate_functions + {"uniqueretract", "__unique_retract"}, + {"groupuniqarrayretract", "group_uniq_array_retract"}, + {"minkretract", "__min_k_retract"}, + {"maxkretract", "__max_k_retract"}, + {"minretract", "__min_retract"}, + {"maxretract", "__max_retract"}, + {"sumretract", "__sum_retract"}, + {"exponentialtimedecayedcount", "exponential_time_decayed_count"}, + {"denserank", "dense_rank"}, + {"rank", "rank"}, + {"exponentialmovingaverage", "exponential_moving_average"}, + {"intervallengthsum", "interval_length_sum"}, + {"singlevalueornull", "single_value_or_null"}, + {"nothing", "nothing"}, + {"meanztest", "mean_ztest"}, + {"rankcorr", "rank_corr"}, + {"categoricalinformationvalue", "categorical_information_value"}, + {"sumkahanretract", "__sum_kahan_retract"}, + {"grouparraymovingavg", "group_array_moving_avg"}, + {"grouparraymovingsum", "group_array_moving_sum"}, + {"simplelinearregression", "simple_linear_regression"}, + {"entropy", "entropy"}, + {"exponentialtimedecayedsum", "exponential_time_decayed_sum"}, + {"retention", "retention"}, + {"histogram", "histogram"}, + {"uniqueexactretract", "__unique_exact_retract"}, + {"stochasticlogisticregression", "stochastic_logistic_regression"}, + {"groupbitmapxor", "group_bitmap_xor"}, + {"groupbitmapor", "group_bitmap_or"}, + {"groupbitmap", "group_bitmap"}, + {"cramersvbiascorrected", "cramers_v_bias_corrected"}, + {"cramersv", "cramers_v"}, + {"grouparray", "group_array"}, + {"p99", "p99"}, + {"anyheavy", "any_heavy"}, + {"groupbitand", "group_bit_and"}, + {"sparkbar", "sparkbar"}, + {"groupbitor", "group_bit_or"}, + {"leadinframe", "lead_in_frame"}, + {"deltasumtimestamp", "delta_sum_timestamp"}, + {"covarpop", "covar_pop"}, + {"topkexact", "top_k_exact"}, + {"p95", "p95"}, + {"approxtopksum", "approx_top_k_sum"}, + {"anylast", "any_last"}, + {"uniquecombined64", "unique_combined64"}, + {"quantilesexactexclusive", "quantiles_exact_exclusive"}, + {"uniquetheta", "unique_theta"}, + {"unique", "unique"}, + {"laginframe", "lag_in_frame"}, + {"summapfilteredwithoverflow", "sum_map_filtered_with_overflow"}, + {"quantilestdigest", "quantiles_t_digest"}, + {"uniquecombined", "unique_combined"}, + {"exponentialtimedecayedmax", "exponential_time_decayed_max"}, + {"minmappedarrays", "min_mapped_arrays"}, + {"maxk", "max_k"}, + {"summappedarrays", "sum_mapped_arrays"}, + {"corr", "corr"}, + {"mannwhitneyutest", "mann_whitney_utest"}, + {"stddevpop", "stddev_pop"}, + {"stddevsamp", "stddev_samp"}, + {"corrstable", "corr_stable"}, + {"avgretract", "__avg_retract"}, + {"covarsampstable", "covar_samp_stable"}, + {"stddevpopstable", "stddev_pop_stable"}, + {"maxintersections", "max_intersections"}, + {"kurtpop", "kurt_pop"}, + {"stddevsampstable", "stddev_samp_stable"}, + {"aggthrow", "agg_throw"}, + {"varsampstable", "var_samp_stable"}, + {"lastvalue", "last_value"}, + {"xirr", "xirr"}, + {"latest", "latest"}, + {"summapfiltered", "sum_map_filtered"}, + {"any", "any"}, + {"groupuniqarray", "group_uniq_array"}, + {"skewpop", "skew_pop"}, + {"max", "max"}, + {"analysisofvariance", "analysis_of_variance"}, + {"quantilebfloat16weighted", "quantile_b_float16_weighted"}, + {"countretract", "__count_retract"}, + {"groupbitxor", "group_bit_xor"}, + {"quantilesbfloat16", "quantiles_b_float16"}, + {"boundingratio", "bounding_ratio"}, + {"skewsamp", "skew_samp"}, + {"p90", "p90"}, + {"windowfunnel", "window_funnel"}, + {"quantilestdigestweighted", "quantiles_t_digest_weighted"}, + {"quantilebfloat16", "quantile_b_float16"}, + {"topkexactweighted", "top_k_exact_weighted"}, + {"quantiletdigestweighted", "quantile_t_digest_weighted"}, + {"welchttest", "welch_ttest"}, + {"quantiletdigest", "quantile_t_digest"}, + {"quantilestimingweighted", "quantiles_timing_weighted"}, + {"contingency", "contingency"}, + {"deltasum", "delta_sum"}, + {"topkweighted", "top_k_weighted"}, + {"quantiletimingweighted", "quantile_timing_weighted"}, + {"uniqueexact", "unique_exact"}, + {"quantiletiming", "quantile_timing"}, + {"quantilesexactinclusive", "quantiles_exact_inclusive"}, + {"studentttest", "student_ttest"}, + {"groupbitmapand", "group_bitmap_and"}, + {"sequencecount", "sequence_count"}, + {"avg", "avg"}, + {"rownumber", "row_number"}, + {"theilsu", "theils_u"}, + {"quantilesexacthigh", "quantiles_exact_high"}, + {"varpopstable", "var_pop_stable"}, + {"sumwithoverflow", "sum_with_overflow"}, + {"quantileexactweighted", "quantile_exact_weighted"}, + {"sequencenextnode", "sequence_next_node"}, + {"quantileexacthigh", "quantile_exact_high"}, + {"quantilesexactlow", "quantiles_exact_low"}, + {"quantilesexactweighted", "quantiles_exact_weighted"}, + {"quantilestiming", "quantiles_timing"}, + {"grouparraysample", "group_array_sample"}, + {"uniquehll12", "unique_hll12"}, + {"summapwithoverflow", "sum_map_with_overflow"}, + {"sumcount", "sum_count"}, + {"earliest", "earliest"}, + {"quantilesdeterministic", "quantiles_deterministic"}, + {"sumwithoverflowretract", "__sum_with_overflow_retract"}, + {"min", "min"}, + {"varpop", "var_pop"}, + {"quantileexactlow", "quantile_exact_low"}, + {"quantiles", "quantiles"}, + {"sum", "sum"}, + {"kurtsamp", "kurt_samp"}, + {"grouparrayinsertat", "group_array_insert_at"}, + {"quantilesexact", "quantiles_exact"}, + {"approxtopk", "approx_top_k"}, + {"exponentialtimedecayedavg", "exponential_time_decayed_avg"}, + {"firstvalue", "first_value"}, + {"quantileexact", "quantile_exact"}, + {"covarpopstable", "covar_pop_stable"}, + {"sequencematch", "sequence_match"}, + {"quantilesbfloat16weighted", "quantiles_b_float16_weighted"}, + {"uniqueupto", "unique_up_to"}, + {"largesttrianglethreebuckets", "largest_triangle_three_buckets"}, + {"quantile", "quantile"}, + {"covarsamp", "covar_samp"}, + {"varsamp", "var_samp"}, + {"quantiledeterministic", "quantile_deterministic"}, + {"quantileexactinclusive", "quantile_exact_inclusive"}, + {"maxintersectionsposition", "max_intersections_position"}, + {"maxmappedarrays", "max_mapped_arrays"}, + {"mink", "min_k"}, + {"quantileexactexclusive", "quantile_exact_exclusive"}, + {"sumkahan", "sum_kahan"}, + {"stochasticlinearregression", "stochastic_linear_regression"}, + {"count", "count"}, + {"topk", "top_k"}, + {"avgweighted", "avg_weighted"}}; + +String ParserFunction::functionNameFromCamelToSnake(const String & name) const +{ + auto it = function_map.find(name); + if (it != function_map.end()) + return it->second; + + String lower_name = Poco::toLower(name); + it = case_insensitive_function_map.find(lower_name); + if (it != case_insensitive_function_map.end()) + return it->second; + + return name; +} +/// proton: ends bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ maybe_unused ]] bool hint) { @@ -760,6 +2020,9 @@ bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ ASTPtr identifier; ASTPtr query; ASTPtr expr_list_args; + /// proton: starts + ASTPtr expr_list_params; + /// proton: ends if (is_table_function) { @@ -804,6 +2067,16 @@ bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ String function_name = getIdentifierName(identifier); String function_name_lowercase = Poco::toLower(function_name); + /// proton: starts + if (thread_local_is_clickhouse_compatible) + { + String tmp_name = functionNameFromCamelToSnake(function_name); + function_name = tmp_name; + auto * tmpnode = dynamic_cast(identifier.get()); + tmpnode->setShortName(function_name); + } + /// proton: ends + std::optional parsed_special_function; if (function_name_lowercase == "cast") @@ -916,6 +2189,55 @@ bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ , ErrorCodes::SYNTAX_ERROR); } + /// proton: starts + /// First determine whether need to be compatible with ClickHouse. Timeplus does not allow the use of syntax such as quantile(0.9)(x). + /// The parametric aggregate function has two lists (parameters and arguments) in parentheses. Example: quantile(0.9)(x). + if (thread_local_is_clickhouse_compatible && allow_function_parameters && pos->type == TokenType::OpeningRoundBracket) + { + ++pos; + + /// Parametric aggregate functions cannot have DISTINCT in parameters list. + if (has_distinct) + return false; + + expr_list_params = expr_list_args; + expr_list_args = nullptr; + + pos_after_bracket = pos; + old_expected = expected; + + if (all.ignore(pos, expected)) + has_all = true; + + if (distinct.ignore(pos, expected)) + has_distinct = true; + + if (!has_all && all.ignore(pos, expected)) + has_all = true; + + if (has_all && has_distinct) + return false; + + if (has_all || has_distinct) + { + /// case f(ALL), f(ALL, x), f(DISTINCT), f(DISTINCT, x), ALL and DISTINCT should be treat as identifier + if (pos->type == TokenType::Comma || pos->type == TokenType::ClosingRoundBracket) + { + pos = pos_after_bracket; + expected = old_expected; + has_distinct = false; + } + } + + if (!contents.parse(pos, expr_list_args, expected)) + return false; + + if (pos->type != TokenType::ClosingRoundBracket) + return false; + ++pos; + } + /// proton: ends + /// proton: starts. /// proton: don't support parametric aggregation function any more. /// proton: ends. @@ -930,6 +2252,14 @@ bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ function_node->arguments = expr_list_args; function_node->children.push_back(function_node->arguments); + /// proton: starts + if (expr_list_params) + { + function_node->parameters = expr_list_params; + function_node->children.push_back(function_node->parameters); + } + /// proton: ends + ParserKeyword filter("FILTER"); ParserKeyword over("OVER"); diff --git a/src/Parsers/ExpressionElementParsers.h b/src/Parsers/ExpressionElementParsers.h index 80c309729d0..13d80c6f2fc 100644 --- a/src/Parsers/ExpressionElementParsers.h +++ b/src/Parsers/ExpressionElementParsers.h @@ -151,14 +151,20 @@ class ParserColumnsMatcher : public IParserBase class ParserFunction : public IParserBase { public: - explicit ParserFunction(bool is_table_function_ = false) - : is_table_function(is_table_function_) + /// proton: starts + explicit ParserFunction(bool allow_function_parameters_ = true, bool is_table_function_ = false) + : allow_function_parameters(allow_function_parameters_), is_table_function(is_table_function_) + /// proton: ends { } protected: const char * getName() const override { return "function"; } bool parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ maybe_unused ]] bool hint) override; + /// proton: starts + String functionNameFromCamelToSnake(const String & name) const; + bool allow_function_parameters; + /// proton: ends bool is_table_function; }; /// proton: ends. diff --git a/src/Parsers/ParserDataType.cpp b/src/Parsers/ParserDataType.cpp index 18c8d5864b3..bec373239ef 100644 --- a/src/Parsers/ParserDataType.cpp +++ b/src/Parsers/ParserDataType.cpp @@ -5,6 +5,9 @@ #include #include #include +///proton: starts +#include +///proton: ends namespace DB @@ -57,6 +60,19 @@ bool ParserDataType::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ return false; tryGetIdentifierNameInto(identifier, type_name); + /// proton: starts + if (thread_local_is_clickhouse_compatible) + { + String type_name_lower = Poco::toLower(type_name); + /// There are special type that cannot be directly changed to lowercase and need handle specially. + if (type_name_lower == "lowcardinality") + type_name_lower = "low_cardinality"; + else if (type_name_lower == "fixedstring") + type_name_lower = "fixed_string"; + type_name = type_name_lower; + } + /// proton: ends + String type_name_upper = Poco::toUpper(type_name); String type_name_suffix; diff --git a/src/Parsers/ParserInsertQuery.cpp b/src/Parsers/ParserInsertQuery.cpp index 629cce65069..a8e6652bb32 100644 --- a/src/Parsers/ParserInsertQuery.cpp +++ b/src/Parsers/ParserInsertQuery.cpp @@ -45,7 +45,7 @@ bool ParserInsertQuery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, ParserIdentifier name_p(true); ParserList columns_p(std::make_unique(), std::make_unique(TokenType::Comma), false); /// proton: starts. - ParserFunction table_function_p; + ParserFunction table_function_p{false}; /// proton: ends. ParserStringLiteral infile_name_p; ParserExpressionWithOptionalAlias exp_elem_p(false); diff --git a/src/Parsers/ParserTablesInSelectQuery.cpp b/src/Parsers/ParserTablesInSelectQuery.cpp index 3e04540bdf4..99d8df6e860 100644 --- a/src/Parsers/ParserTablesInSelectQuery.cpp +++ b/src/Parsers/ParserTablesInSelectQuery.cpp @@ -18,10 +18,10 @@ bool ParserTableExpression::parseImpl(Pos & pos, ASTPtr & node, Expected & expec { auto res = std::make_shared(); - /// proton: starts. don't allows aliases without AS keyword. - if (!ParserWithOptionalAlias(std::make_unique(), false).parse(pos, res->subquery, expected) - && !ParserWithOptionalAlias(std::make_unique(true), false).parse(pos, res->table_function, expected) - && !ParserWithOptionalAlias(std::make_unique(true, true), false) + /// proton: starts. allows aliases without AS keyword. + if (!ParserWithOptionalAlias(std::make_unique(), true).parse(pos, res->subquery, expected) + && !ParserWithOptionalAlias(std::make_unique(true, true), true).parse(pos, res->table_function, expected) /// proton: update + && !ParserWithOptionalAlias(std::make_unique(true, true), true) .parse(pos, res->database_and_table_name, expected)) /// proton: ends. return false; diff --git a/src/Parsers/tests/gtest_compatible_clickhouse_datatype_function.cpp b/src/Parsers/tests/gtest_compatible_clickhouse_datatype_function.cpp new file mode 100644 index 00000000000..5bbbe1c604b --- /dev/null +++ b/src/Parsers/tests/gtest_compatible_clickhouse_datatype_function.cpp @@ -0,0 +1,1666 @@ +#include +#include +#include +#include +#include +#include + +#include +#include + +#include + +using namespace DB; + +/// clickhouse datatype +TEST(ParserDataTypeNameTest, TestDatatypeInt8) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Int8);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int8"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeUInt8) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS UInt8);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint8"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeInt16) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Int16);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int16"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeUInt16) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS UInt16);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint16"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeInt32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Int32);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int32"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeUInt32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS UInt32);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint32"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeInt64) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Int64);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int64"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeUInt64) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS UInt64);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint64"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeInt128) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Int128);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int128"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeUInt128) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS UInt128);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint128"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeInt256) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Int256);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int256"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeUInt256) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS UInt256);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint256"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeFloat32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Float32);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "float32"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeFloat64) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Float64);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "float64"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeString) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS String);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "string"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeDate) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Date);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "date"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeDate32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Date32);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "date32"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeDateTime) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS DateTime);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "datetime"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeBool) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Bool);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "bool"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeUUID) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS UUID);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uuid"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeIPv4) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS IPv4);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "ipv4"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatypeIPv6) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS IPv6);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "ipv6"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeJSON) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS JSON);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "json"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeNullable) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Nullable(String));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "nullable(string)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeDecimal) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Decimal(10, 3));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal(10, 3)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeDecimal32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Decimal32(3));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal32(3)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeDecimal64) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Decimal64(8));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal64(8)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeDecimal128) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Decimal128(8));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal128(8)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeDecimal256) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Decimal256(8));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal256(8)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeFixedString) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS FixedString(8));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "fixed_string(8)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeDateTime_TimeZone) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS DateTime('Asia/Istanbul'));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "datetime('Asia/Istanbul')"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeDateTime64_Precision) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS DateTime64(3));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "datetime64(3)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeDateTime64_Precision_TimeZone) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS DateTime64(3, 'Asia/Istanbul'));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "datetime64(3, 'Asia/Istanbul')"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeEnum) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Enum('One' = 1, 'Two' = 2, 'Three' = 3));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "enum('One' = 1, 'Two' = 2, 'Three' = 3)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeArray) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Array(Int32));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "array(int32)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeMap) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Map(String, Int32));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "map(string, int32)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeTuple) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Tuple(String, Int32, String));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "tuple(string, int32, string)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeLowCardinality) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS LowCardinality(String));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "low_cardinality(string)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeNested1) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Nullable(Map(String, Tuple(Array(Nullable(String), Nullable(Int32), Nullable(FixedString(10)), Nullable(DateTime64(3, 'UTC')), LowCardinality(Nullable(Float32)))))));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "nullable(map(string, tuple(array(nullable(string), nullable(int32), nullable(fixed_string(10)), nullable(datetime64(3, 'UTC')), low_cardinality(nullable(float32))))))"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeNested2) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Nullable(Array(Tuple(Nullable(Int32), Nullable(String)))));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "nullable(array(tuple(nullable(int32), nullable(string))))"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeNested3) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Tuple(Nullable(String), Nullable(Int32), Nullable(DateTime64(3, 'UTC'))));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "tuple(nullable(string), nullable(int32), nullable(datetime64(3, 'UTC')))"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatypeNested4) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Map(String, Tuple(Nullable(Int32), Nullable(String))))"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "map(string, tuple(nullable(int32), nullable(string)))"); + thread_local_is_clickhouse_compatible = false; +} + +/// timeplus datatype +TEST(ParserDataTypeNameTest, TestDatatype_int8) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS int8);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int8"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_uint8) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS uint8);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint8"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_int16) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS int16);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int16"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_uint16) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS uint16);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint16"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_int32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS Int32);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int32"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_uint32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS uint32);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint32"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_int64) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS int64);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int64"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_uint64) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS uint64);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint64"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_int128) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS int128);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int128"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_uint128) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS uint128);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint128"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_int256) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS int256);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "int256"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_uint256) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS uint256);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uint256"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_float32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS float32);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "float32"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_float64) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS float64);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "float64"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_string) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS string);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "string"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_date) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS date);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "date"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_date32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS date32);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "date32"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_dateTime) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS datetime);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "datetime"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_bool) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS bool);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "bool"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_uuid) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS uuid);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "uuid"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_ipv4) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS ipv4);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "ipv4"); + thread_local_is_clickhouse_compatible = false; +} +TEST(ParserDataTypeNameTest, TestDatatype_ipv6) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS ipv6);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "ipv6"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_json) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS json);"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "json"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_nullable) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS nullable(string));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "nullable(string)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_decimal) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS decimal(10, 3));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal(10, 3)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_decimal32) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS decimal32(3));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal32(3)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_decimal64) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS decimal64(8));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal64(8)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_decimal128) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS decimal128(8));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal128(8)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_decimal256) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS decimal256(8));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "decimal256(8)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_fixed_string) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS fixed_string(8));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "fixed_string(8)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_datetime_timezone) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS datetime('Asia/Istanbul'));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "datetime('Asia/Istanbul')"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_datetime64_precision) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS datetime64(3));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "datetime64(3)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_datetime64_precision_timezone) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS datetime64(3, 'Asia/Istanbul'));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "datetime64(3, 'Asia/Istanbul')"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_enum) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS enum('One' = 1, 'Two' = 2, 'Three' = 3));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "enum('One' = 1, 'Two' = 2, 'Three' = 3)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_array) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS array(Int32));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "array(int32)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_map) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS map(string, int32));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "map(string, int32)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_tuple) +{ + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS tuple(string, int32, string));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "tuple(string, int32, string)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_low_cardinality) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS low_cardinality(string));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "low_cardinality(string)"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_nested1) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS nullable(map(string, tuple(array(nullable(string), nullable(int32), nullable(fixed_string(10)), nullable(datetime64(3, 'UTC')), low_cardinality(nullable(float32)))))));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "nullable(map(string, tuple(array(nullable(string), nullable(int32), nullable(fixed_string(10)), nullable(datetime64(3, 'UTC')), low_cardinality(nullable(float32))))))"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_nested2) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS nullable(array(tuple(nullable(int32), nullable(string)))));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "nullable(array(tuple(nullable(int32), nullable(string))))"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_nested3) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS tuple(nullable(string), nullable(int32), nullable(datetime64(3, 'UTC'))));"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "tuple(nullable(string), nullable(int32), nullable(datetime64(3, 'UTC')))"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserDataTypeNameTest, TestDatatype_nested4) +{ + + thread_local_is_clickhouse_compatible = true; + String input = "CAST(id AS map(string, tuple(nullable(int32), nullable(string))))"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction *function = ast->as(); + + EXPECT_EQ(function->name, "cast"); + + ASTIdentifier * arg1 = function->arguments->children[0]->as(); + EXPECT_EQ(arg1->name(), "id"); + ASTLiteral * arg2 = function->arguments->children[1]->as(); + EXPECT_EQ(arg2->value, "map(string, tuple(nullable(int32), nullable(string)))"); + thread_local_is_clickhouse_compatible = false; +} + + +/// clickhouse function name +TEST(ParserFunctionNameTest, TestFunction_toUInt16) +{ + thread_local_is_clickhouse_compatible = true; + String input = "toUInt16('123')"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "to_uint16"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_encodeURLComponent) +{ + thread_local_is_clickhouse_compatible = true; + String input = "encodeURLComponent('Hello world! How are you?')"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "encode_url_component"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_todAte) +{ + thread_local_is_clickhouse_compatible = true; + String input = "todAte(now())"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "to_date"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_generateUUIDv4) +{ + thread_local_is_clickhouse_compatible = true; + String input = "generateUUIDv4(1)"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "generate_uuidv4"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_stddevSamp) +{ + thread_local_is_clickhouse_compatible = true; + String input = "stddevSamp(v)"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "stddev_samp"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_ifNull) +{ + thread_local_is_clickhouse_compatible = true; + String input = "ifNull(value, 0)"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "if_null"); + thread_local_is_clickhouse_compatible = false; +} + +/// timeplus function name +TEST(ParserFunctionNameTest, TestFunction_to_uint16) +{ + thread_local_is_clickhouse_compatible = true; + String input = "to_uint16('123')"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "to_uint16"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_encode_url_component) +{ + thread_local_is_clickhouse_compatible = true; + String input = "encode_url_component('Hello world! How are you?')"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "encode_url_component"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_to_date) +{ + thread_local_is_clickhouse_compatible = true; + String input = "to_date(now())"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "to_date"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_generate_uuidv4) +{ + thread_local_is_clickhouse_compatible = true; + String input = "generate_uuidv4(1)"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "generate_uuidv4"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_stddev_samp) +{ + thread_local_is_clickhouse_compatible = true; + String input = "stddev_samp(v)"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "stddev_samp"); + thread_local_is_clickhouse_compatible = false; +} + +TEST(ParserFunctionNameTest, TestFunction_if_null) +{ + thread_local_is_clickhouse_compatible = true; + String input = "if_null(value, 0)"; + + ParserFunction parser; + ASTPtr ast = parseQuery(parser, input.data(), input.data() + input.size(), "", 0, 0); + ASTFunction * function = ast->as(); + + EXPECT_EQ(function->name, "if_null"); + thread_local_is_clickhouse_compatible = false; +} diff --git a/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp b/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp index ad73d43e9c4..f8da63e24ad 100644 --- a/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp +++ b/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp @@ -42,7 +42,12 @@ void TabSeparatedRowOutputFormat::writePrefix() writeLine(header.getNames()); if (with_types) - writeLine(header.getDataTypeNames()); + { + /// proton: starts. + writeLine(header.getDataTypeNames(format_settings.is_clickhouse_compatible)); + /// proton: ends. + writeRowBetweenDelimiter(); + } } diff --git a/src/Server/HTTPHandler.cpp b/src/Server/HTTPHandler.cpp index 3ff26886cf4..5803c338027 100644 --- a/src/Server/HTTPHandler.cpp +++ b/src/Server/HTTPHandler.cpp @@ -950,8 +950,12 @@ void HTTPHandler::handleRequest(HTTPServerRequest & request, HTTPServerResponse } /// proton: starts -DynamicQueryHandler::DynamicQueryHandler(IServer & server_, const std::string & param_name_, bool snapshot_mode_) - : HTTPHandler(server_, "DynamicQueryHandler"), param_name(param_name_), snapshot_mode(snapshot_mode_) +DynamicQueryHandler::DynamicQueryHandler( + IServer & server_, const std::string & param_name_, bool snapshot_mode_, bool is_clickhouse_compatible_) + : HTTPHandler(server_, "DynamicQueryHandler") + , param_name(param_name_) + , snapshot_mode(snapshot_mode_) + , is_clickhouse_compatible(is_clickhouse_compatible_) { } /// proton: ends @@ -993,6 +997,9 @@ std::string DynamicQueryHandler::getQuery(HTTPServerRequest & request, HTMLForm /// set query_mode to 'snapshot' if snapshot_mode is on if (snapshot_mode) context->setSetting("query_mode", Field("snapshot")); + + if(is_clickhouse_compatible) + context->setSetting("is_clickhouse_compatible", Field(true)); /// proton: ends if (likely(!startsWith(request.getContentType(), "multipart/form-data"))) diff --git a/src/Server/HTTPHandler.h b/src/Server/HTTPHandler.h index 1aab0c5fc55..935074a9b42 100644 --- a/src/Server/HTTPHandler.h +++ b/src/Server/HTTPHandler.h @@ -141,10 +141,11 @@ class DynamicQueryHandler : public HTTPHandler std::string param_name; /// proton: starts bool snapshot_mode = false; + bool is_clickhouse_compatible = false; /// proton: ends public: /// proton: starts - explicit DynamicQueryHandler(IServer & server_, const std::string & param_name_ = "query", bool snapshot_mode_ = false); + explicit DynamicQueryHandler(IServer & server_, const std::string & param_name_ = "query", bool snapshot_mode_ = false, bool is_clickhouse_compatible_ = false); /// proton: ends std::string getQuery(HTTPServerRequest & request, HTMLForm & params, ContextMutablePtr context) override; diff --git a/src/Server/HTTPHandlerFactory.cpp b/src/Server/HTTPHandlerFactory.cpp index 44a0b7afbda..6baa136558f 100644 --- a/src/Server/HTTPHandlerFactory.cpp +++ b/src/Server/HTTPHandlerFactory.cpp @@ -28,7 +28,7 @@ namespace ErrorCodes static void addCommonDefaultHandlersFactory(HTTPRequestHandlerFactoryMain & factory, IServer & server); /// proton: starts -static void addDefaultHandlersFactory(HTTPRequestHandlerFactoryMain & factory, IServer & server, AsynchronousMetrics & async_metrics, bool snapshot_mode_ = false); +static void addDefaultHandlersFactory(HTTPRequestHandlerFactoryMain & factory, IServer & server, AsynchronousMetrics & async_metrics, bool snapshot_mode_ = false, bool is_clickhouse_compatible_ = false); /// proton: ends HTTPRequestHandlerFactoryMain::HTTPRequestHandlerFactoryMain(const std::string & name_) @@ -62,7 +62,7 @@ std::unique_ptr HTTPRequestHandlerFactoryMain::createRequest /// proton: starts static inline auto createHandlersFactoryFromConfig( - IServer & server, const std::string & name, const String & prefix, AsynchronousMetrics & async_metrics, bool snapshot_mode_ = false) + IServer & server, const std::string & name, const String & prefix, AsynchronousMetrics & async_metrics, bool snapshot_mode_ = false, bool is_clickhouse_compatible_ = false) /// proton: ends { auto main_handler_factory = std::make_shared(name); @@ -75,7 +75,7 @@ static inline auto createHandlersFactoryFromConfig( if (key == "defaults") { /// proton: starts - addDefaultHandlersFactory(*main_handler_factory, server, async_metrics, snapshot_mode_); + addDefaultHandlersFactory(*main_handler_factory, server, async_metrics, snapshot_mode_, is_clickhouse_compatible_); /// proton: ends } else if (startsWith(key, "rule")) @@ -108,20 +108,20 @@ static inline auto createHandlersFactoryFromConfig( static inline HTTPRequestHandlerFactoryPtr /// proton: starts -createHTTPHandlerFactory(IServer & server, const std::string & name, AsynchronousMetrics & async_metrics, bool snapshot_mode_ = false) +createHTTPHandlerFactory(IServer & server, const std::string & name, AsynchronousMetrics & async_metrics, bool snapshot_mode_ = false, bool is_clickhouse_compatible_ = false) /// proton: ends { if (server.config().has("http_handlers")) { /// proton: starts - return createHandlersFactoryFromConfig(server, name, "http_handlers", async_metrics, snapshot_mode_); + return createHandlersFactoryFromConfig(server, name, "http_handlers", async_metrics, snapshot_mode_, is_clickhouse_compatible_); /// proton: ends } else { auto factory = std::make_shared(name); /// proton: starts - addDefaultHandlersFactory(*factory, server, async_metrics, snapshot_mode_); + addDefaultHandlersFactory(*factory, server, async_metrics, snapshot_mode_, is_clickhouse_compatible_); /// proton: ends return factory; } @@ -161,7 +161,7 @@ HTTPRequestHandlerFactoryPtr createHandlerFactory(IServer & server, Asynchronous return createHTTPHandlerFactory(server, name, async_metrics); /// proton: starts. turn on snapshot_mode else if (name == "SnapshotHTTPHandler-factory") - return createHTTPHandlerFactory(server, name, async_metrics, true); + return createHTTPHandlerFactory(server, name, async_metrics, true, true); /// proton: ends else if (name == "InterserverIOHTTPHandler-factory" || name == "InterserverIOHTTPSHandler-factory") return createInterserverHTTPHandlerFactory(server, name); @@ -206,7 +206,7 @@ void addCommonDefaultHandlersFactory(HTTPRequestHandlerFactoryMain & factory, IS } /// proton: starts -void addDefaultHandlersFactory(HTTPRequestHandlerFactoryMain & factory, IServer & server, AsynchronousMetrics & async_metrics, bool snapshot_mode_) +void addDefaultHandlersFactory(HTTPRequestHandlerFactoryMain & factory, IServer & server, AsynchronousMetrics & async_metrics, bool snapshot_mode_, bool is_clickhouse_compatible_) /// proton: ends { addCommonDefaultHandlersFactory(factory, server); @@ -226,7 +226,7 @@ void addDefaultHandlersFactory(HTTPRequestHandlerFactoryMain & factory, IServer /// proton: end. /// proton: starts - auto query_handler = std::make_shared>(server, "query", std::move(snapshot_mode_)); + auto query_handler = std::make_shared>(server, "query", std::move(snapshot_mode_), std::move(is_clickhouse_compatible_)); /// proton: ends query_handler->allowPostAndGetParamsAndOptionsRequest(); factory.addHandler(query_handler); diff --git a/tests/queries_ported/0_stateless/99039_compatible_with_clickhouse_datatype_and_functonname.reference b/tests/queries_ported/0_stateless/99039_compatible_with_clickhouse_datatype_and_functonname.reference new file mode 100644 index 00000000000..98ad98999dc --- /dev/null +++ b/tests/queries_ported/0_stateless/99039_compatible_with_clickhouse_datatype_and_functonname.reference @@ -0,0 +1,97 @@ +id name created_at is_active value tags metadata options addresses preferences +UInt32 String DateTime Bool Float64 Array(String) Map(String, String) Enum8(\'small\' = 1, \'medium\' = 2, \'large\' = 3) Array(Tuple(String, String)) Map(String, Array(Int32)) +1 Alice 2025-03-10 14:43:21 true 99.5 ['tag1','tag2'] {'key1':'value1','key2':'value2'} medium [('New York','5th Ave'),('Los Angeles','Sunset Blvd')] {'movies':[1,2,3],'books':[4,5]} +2 Bob 2025-03-10 14:43:21 false 45.3 ['tag3'] {'key3':'value3'} small [('Chicago','State St')] {'movies':[6,7],'books':[8,9]} +3 Charlie 2025-03-10 14:43:21 true 78.2 ['tag4','tag5','tag6'] {'key4':'value4','key5':'value5'} large [('Miami','Ocean Dr')] {'movies':[10],'books':[11,12]} +id lower(name) +UInt32 String +1 alice +2 bob +3 charlie +1 Alice 1 99 [\'tag1\',\'tag2\'] +2 Bob 0 45 [\'tag3\'] +3 Charlie 1 78 [\'tag4\',\'tag5\',\'tag6\'] +1 Alice 2025-03-10 2025-03-01 170379 +2 Bob 2025-03-10 2025-03-01 170379 +3 Charlie 2025-03-10 2025-03-01 170379 +2025-03-10 3 74.33333333333333 +1 [('tag1',4),('tag2',4)] +2 [('tag3',4)] +3 [('tag4',4),('tag5',4),('tag6',4)] +1 (2,'Alice') +2 (2,'Bob') +3 (2,'Charlie') +1 1_Alice +2 2_Bob +3 3_Charlie +1 Alice [('tag1',0),('tag2',0)] +2 Bob [('tag3',0)] +3 Charlie [('tag4',0),('tag5',0),('tag6',0)] +1 Alice 99.5 +3 Charlie 78.2 +1 Alice 6 +3 Charlie 10 +medium Admin 1 99.5 tag1 1 2025-03-10 14:43:21 +medium Admin 1 99.5 tag2 1 2025-03-10 14:43:21 +large Member 1 78.2 tag4 1 2025-03-10 14:43:21 +large Member 1 78.2 tag5 1 2025-03-10 14:43:21 +large Member 1 78.2 tag6 1 2025-03-10 14:43:21 +1 Alice medium 99.5 2025-03-10 14:43:21.000 true Admin +2 Bob small 45.3 2025-03-10 14:43:21.000 false Guest +3 Charlie large 78.2 2025-03-10 14:43:21.000 true Member +3 Charlie 78.2 2025-03-10 +3 Charlie 78.2 large 14 +1 Alice 99.5 medium 14 +3 Charlie 78.2 2025-03-10 2025-03-17 +1 Alice 99.5 2025-03-10 2025-03-17 +id lower(name) +UInt32 String +1 alice +2 bob +3 charlie +1 Alice 1 99 [\'tag1\',\'tag2\'] +2 Bob 0 45 [\'tag3\'] +3 Charlie 1 78 [\'tag4\',\'tag5\',\'tag6\'] +1 Alice 2025-03-10 2025-03-01 170379 +2 Bob 2025-03-10 2025-03-01 170379 +3 Charlie 2025-03-10 2025-03-01 170379 +2025-03-10 3 74.33333333333333 +1 [('tag1',4),('tag2',4)] +2 [('tag3',4)] +3 [('tag4',4),('tag5',4),('tag6',4)] +1 (2,'Alice') +2 (2,'Bob') +3 (2,'Charlie') +1 1_Alice +2 2_Bob +3 3_Charlie +1 Alice [('tag1',0),('tag2',0)] +2 Bob [('tag3',0)] +3 Charlie [('tag4',0),('tag5',0),('tag6',0)] +1 Alice 99.5 +3 Charlie 78.2 +medium Admin 1 99.5 tag1 1 2025-03-10 14:43:21 +medium Admin 1 99.5 tag2 1 2025-03-10 14:43:21 +large Member 1 78.2 tag4 1 2025-03-10 14:43:21 +large Member 1 78.2 tag5 1 2025-03-10 14:43:21 +large Member 1 78.2 tag6 1 2025-03-10 14:43:21 +1 Alice medium 99.5 2025-03-10 14:43:21.000 true Admin +2 Bob small 45.3 2025-03-10 14:43:21.000 false Guest +3 Charlie large 78.2 2025-03-10 14:43:21.000 true Member +3 Charlie 78.2 2025-03-10 +3 Charlie 78.2 large 14 +1 Alice 99.5 medium 14 +3 Charlie 78.2 2025-03-10 2025-03-17 +1 Alice 99.5 2025-03-10 2025-03-17 +127.0.0.1 127.0.0.1 +192.168.1.1 192.168.1.1 +::1 ::1 +2001:db8:85a3::8a2e:370:7334 2001:db8:85a3::8a2e:370:7334 +::1 1 +2001:db8:85a3::8a2e:370:7334 1 +127.0.0.1 127.0.0.1 +192.168.1.1 192.168.1.1 +::1 ::1 +2001:db8:85a3::8a2e:370:7334 2001:db8:85a3::8a2e:370:7334 +::1 1 +2001:db8:85a3::8a2e:370:7334 1 diff --git a/tests/queries_ported/0_stateless/99039_compatible_with_clickhouse_datatype_and_functonname.sql b/tests/queries_ported/0_stateless/99039_compatible_with_clickhouse_datatype_and_functonname.sql new file mode 100644 index 00000000000..8b4e7cd43ce --- /dev/null +++ b/tests/queries_ported/0_stateless/99039_compatible_with_clickhouse_datatype_and_functonname.sql @@ -0,0 +1,105 @@ +SET is_clickhouse_compatible = 1; + +DROP STREAM IF EXISTS test_stream_1 ; +DROP STREAM IF EXISTS user_profiles ; +CREATE STREAM IF NOT EXISTS test_stream_1 +( + id UInt32, + name String, + created_at DateTime DEFAULT '2025-03-10 14:43:21', + is_active Boolean, + value Float64, + tags Array(String), + metadata Map(String, String), + options Enum('small' = 1, 'medium' = 2, 'large' = 3), + addresses Array( + Tuple(String, String) + ), + preferences Map(String, Array(Int32)) +) ENGINE=MergeTree ORDER BY id; + +CREATE STREAM IF NOT EXISTS user_profiles +( + id UInt32, + profile String +) ENGINE = MergeTree() +ORDER BY id; + + +INSERT INTO test_stream_1 (id, name, is_active, value, tags, metadata, options, addresses, preferences) VALUES (1, 'Alice', true, 99.5, ['tag1', 'tag2'], {'key1': 'value1', 'key2': 'value2'}, 'medium', [('New York', '5th Ave'), ('Los Angeles', 'Sunset Blvd')], {'movies': [1, 2, 3], 'books': [4, 5]}); +INSERT INTO test_stream_1 (id, name, is_active, value, tags, metadata, options, addresses, preferences) VALUES (2, 'Bob', false, 45.3, ['tag3'], {'key3': 'value3'}, 'small', [('Chicago', 'State St')], {'movies': [6, 7], 'books': [8, 9]}); +INSERT INTO test_stream_1 (id, name, is_active, value, tags, metadata, options, addresses, preferences) VALUES (3, 'Charlie', true, 78.2, ['tag4', 'tag5', 'tag6'], {'key4': 'value4', 'key5': 'value5'}, 'large', [('Miami', 'Ocean Dr')], {'movies': [10], 'books': [11, 12]}); + +INSERT INTO user_profiles (id, profile) VALUES (1, 'Admin'), (2, 'Guest'), (3, 'Member'); + + + +-- clickhouse +-- TabSeparatedWithNamesAndTypes +SELECT * FROM test_stream_1 order by id FORMAT TabSeparatedWithNamesAndTypes; +SELECT id, lower(name) FROM test_stream_1 order by id FORMAT TabSeparatedWithNamesAndTypes; +SELECT id, name, CAST(is_active AS Int32) AS is_active_int, CAST(value AS Int32) AS value_int, CAST(tags AS String) AS tags_string FROM test_stream_1 ORDER BY id; +SELECT id, name, toDate(created_at) AS created_date, toStartOfMonth(created_at) AS month_start, toDatetime('2025-03-12 14:03:00') - created_at AS time_diff FROM test_stream_1 ORDER BY id; +SELECT toDate(created_at) AS created_date, COUNT(*) AS records_count, AVG(value) AS average_value FROM test_stream_1 GROUP BY created_date ORDER BY created_date; +SELECT id, CAST(arrayMap(tag -> (tag, length(tag)), tags) AS Array(Tuple(String, Int32))) AS tag_with_lengths FROM test_stream_1 order by id; +SELECT id, CAST((dateDiff('day', toDate(created_at), toDate(toDatetime('2025-03-12 14:03:00'))), name) AS Tuple(Int32, String)) AS date_diff_and_name FROM test_stream_1 order by id; +SELECT id, CAST(concat(CAST(id AS String), '_', name) AS String) AS combined_id_name FROM test_stream_1 order by id; +SELECT id, name, CAST(arrayMap(tag -> (tag, 0), tags) AS Array(Tuple(String, Int32))) AS tags_with_index FROM test_stream_1 order by id; +SELECT id, name, value FROM test_stream_1 WHERE value > (SELECT AVG(value) FROM test_stream_1 ) order by id; +SELECT id, name, sum(arraySum(preferences['movies'])) AS total_movies FROM test_stream_1 WHERE is_active = true GROUP BY id, name order by id; + +-- JOIN +SELECT ts.options, up.profile, COUNT(*) AS active_users_count, SUM(ts.value) AS total_value, arrayJoin(ts.tags) AS tag, COUNT(DISTINCT ts.id) AS users_in_tag, MAX(ts.created_at) AS last_activity FROM test_stream_1 ts JOIN user_profiles up ON ts.id = up.id WHERE ts.is_active = 1 GROUP BY ts.options, up.profile, tag ORDER BY ts.options, tag; +SELECT ts.id, ts.name, ts.options, ts.value, CAST(ts.created_at AS Nullable(DateTime64(3))) as new_created_at, ts.is_active, up.profile FROM test_stream_1 ts JOIN user_profiles up ON ts.id = up.id ORDER BY ts.id; + +-- subquery +SELECT id, name, value, CAST(toDate(created_at) AS Date) AS created_date FROM test_stream_1 WHERE id IN (SELECT id FROM test_stream_1 WHERE options = 'large' AND value > 50) AND is_active = true ORDER BY value DESC; +SELECT id, name, value, options, toHour(created_at) AS created_hour FROM test_stream_1 WHERE id IN (SELECT id FROM test_stream_1 WHERE toStartOfDay(created_at) = toStartOfDay(toDate('2025-03-10'))) AND is_active = true ORDER BY created_hour; +SELECT id, name, value, toDate(created_at) AS created_date, addDays(toDate(created_at), 7) AS date_plus_seven FROM test_stream_1 WHERE id IN (SELECT id FROM test_stream_1 WHERE value > 50) AND is_active = true ORDER BY created_date; + + +-- timeplus +SELECT id, lower(name) FROM test_stream_1 order by id FORMAT TabSeparatedWithNamesAndTypes; +SELECT id, name, CAST(is_active AS int32) AS is_active_int, CAST(value AS int32) AS value_int, CAST(tags AS string) AS tags_string FROM test_stream_1 ORDER BY id; +SELECT id, name, to_date(created_at) AS created_date, to_start_of_month(created_at) AS month_start, to_datetime('2025-03-12 14:03:00') - created_at AS time_diff FROM test_stream_1 ORDER BY id; +SELECT to_date(created_at) AS created_date, count(*) AS records_count, avg(value) AS average_value FROM test_stream_1 GROUP BY created_date ORDER BY created_date; +SELECT id, CAST(array_map(tag -> (tag, length(tag)), tags) AS array(tuple(string, int32))) AS tag_with_lengths FROM test_stream_1 order by id; +SELECT id, CAST((date_diff('day', to_date(created_at), to_date(to_datetime('2025-03-12 14:03:00'))), name) AS tuple(int32, string)) AS date_diff_and_name FROM test_stream_1 order by id; +SELECT id, CAST(concat(CAST(id AS string), '_', name) AS string) AS combined_id_name FROM test_stream_1 order by id; +SELECT id, name, CAST(array_map(tag -> (tag, 0), tags) AS array(tuple(string, int32))) AS tags_with_index FROM test_stream_1 order by id; +SELECT id, name, value FROM test_stream_1 WHERE value > (SELECT AVG(value) FROM test_stream_1 ) order by id; + +-- JOIN +SELECT ts.options, up.profile, COUNT(*) AS active_users_count, SUM(ts.value) AS total_value, array_join(ts.tags) AS tag, COUNT(DISTINCT ts.id) AS users_in_tag, MAX(ts.created_at) AS last_activity FROM test_stream_1 ts JOIN user_profiles up ON ts.id = up.id WHERE ts.is_active = 1 GROUP BY ts.options, up.profile, tag ORDER BY ts.options, tag; +SELECT ts.id, ts.name, ts.options, ts.value, CAST(ts.created_at AS nullable(datetime64(3))) as new_created_at, ts.is_active, up.profile FROM test_stream_1 ts JOIN user_profiles up ON ts.id = up.id ORDER BY ts.id; + +-- subquery +SELECT id, name, value, CAST(to_date(created_at) AS Date) AS created_date FROM test_stream_1 WHERE id IN (SELECT id FROM test_stream_1 WHERE options = 'large' AND value > 50) AND is_active = true ORDER BY value DESC; +SELECT id, name, value, options, to_hour(created_at) AS created_hour FROM test_stream_1 WHERE id IN (SELECT id FROM test_stream_1 WHERE to_start_of_day(created_at) = to_start_of_day(to_date('2025-03-10'))) AND is_active = true ORDER BY created_hour; +SELECT id, name, value, to_date(created_at) AS created_date, add_days(to_date(created_at), 7) AS date_plus_seven FROM test_stream_1 WHERE id IN (SELECT id FROM test_stream_1 WHERE value > 50) AND is_active = true ORDER BY created_date; + +DROP STREAM IF EXISTS test_stream_1 ; +DROP STREAM IF EXISTS user_profiles ; + + +DROP STREAM IF EXISTS test_stream_IP; +CREATE STREAM IF NOT EXISTS test_stream_IP +( + ipv4_address IPv4, + ipv6_address IPv6 +) ENGINE=MergeTree order by ipv4_address; + +INSERT INTO test_stream_IP (ipv4_address, ipv6_address) VALUES ('192.168.1.1', '2001:0db8:85a3:0000:0000:8a2e:0370:7334'); +INSERT INTO test_stream_IP (ipv4_address, ipv6_address) VALUES ('127.0.0.1', '::1'); + +-- clickhouse +SELECT ipv4_address, IPv4NumToString(ipv4_address) AS ipv4_address_str FROM test_stream_IP order by ipv4_address; +SELECT ipv6_address, IPv6NumToString(ipv6_address) AS ipv6_address_str FROM test_stream_IP order by ipv6_address; +SELECT ipv6_address, isIPv6String(toString(ipv6_address)) AS is_ipv6_valid FROM test_stream_IP order by ipv6_address; + +-- timeplus +SELECT ipv4_address, ipv4_num_to_string(ipv4_address) AS ipv4_address_str FROM test_stream_IP order by ipv4_address; +SELECT ipv6_address, ipv6_num_to_string(ipv6_address) AS ipv6_address_str FROM test_stream_IP order by ipv6_address; +SELECT ipv6_address, is_ipv6_string(to_string(ipv6_address)) AS is_ipv6_valid FROM test_stream_IP order by ipv6_address; + +DROP STREAM IF EXISTS test_stream_IP ; From f59ebe4d12e48135a79a0b84ee468d3bde16d058 Mon Sep 17 00:00:00 2001 From: Ken Chen Date: Fri, 21 Mar 2025 22:05:44 -0700 Subject: [PATCH 2/2] Refactor and refinement ClickHouse compatible mode (#8169) --- src/Common/ClickHouseCompatibleFlag.cpp | 24 + src/Common/ClickHouseCompatibleFlag.h | 7 + .../thread_local_is_clickhouse_compatible.cpp | 3 - .../thread_local_is_clickhouse_compatible.h | 3 - src/Core/Block.cpp | 29 +- src/Core/Block.h | 5 +- src/Core/Settings.h | 2 +- src/DataTypes/convertToClickHouseType.h | 10 + ...khouse.cpp => convertToClickhouseType.cpp} | 63 +- src/DataTypes/convertTypeToClickhouse.h | 15 - .../gtest_function_convertTypeToUpper.cpp | 279 ---- ...st_function_convert_to_clickhouse_type.cpp | 320 +++++ src/Functions/CastOverloadResolver.cpp | 4 +- src/Interpreters/InterpreterCreateQuery.cpp | 4 +- src/Interpreters/executeQuery.cpp | 26 +- src/Parsers/ExpressionElementParsers.cpp | 1280 +---------------- .../ExpressionElementParsers_ClickHouse.cpp | 1261 ++++++++++++++++ src/Parsers/ParserDataType.cpp | 5 +- ...ompatible_clickhouse_datatype_function.cpp | 426 +++--- .../Impl/TabSeparatedRowOutputFormat.cpp | 6 +- src/Server/HTTPHandlerFactory.cpp | 28 +- src/Server/RestHTTPRequestHandler.cpp | 15 +- src/Server/RestHTTPRequestHandler.h | 6 +- 23 files changed, 1967 insertions(+), 1854 deletions(-) create mode 100644 src/Common/ClickHouseCompatibleFlag.cpp create mode 100644 src/Common/ClickHouseCompatibleFlag.h delete mode 100644 src/Common/thread_local_is_clickhouse_compatible.cpp delete mode 100644 src/Common/thread_local_is_clickhouse_compatible.h create mode 100644 src/DataTypes/convertToClickHouseType.h rename src/DataTypes/{convertTypeToClickhouse.cpp => convertToClickhouseType.cpp} (63%) delete mode 100644 src/DataTypes/convertTypeToClickhouse.h delete mode 100644 src/DataTypes/tests/gtest_function_convertTypeToUpper.cpp create mode 100644 src/DataTypes/tests/gtest_function_convert_to_clickhouse_type.cpp create mode 100644 src/Parsers/ExpressionElementParsers_ClickHouse.cpp diff --git a/src/Common/ClickHouseCompatibleFlag.cpp b/src/Common/ClickHouseCompatibleFlag.cpp new file mode 100644 index 00000000000..dcd30e97669 --- /dev/null +++ b/src/Common/ClickHouseCompatibleFlag.cpp @@ -0,0 +1,24 @@ +#include + +#include + +namespace DB +{ + +namespace +{ +/// The SQL receiving / parsing thread can set this flag to true to enable Timeplus to run ClickHouse SQL +thread_local bool is_clickhouse_compatible_mode_ = false; +} + +bool isClickHouseCompatibleMode() +{ + return is_clickhouse_compatible_mode_; +} + +void setClickHouseCompatibleMode(bool is_clickhouse_compatible) +{ + is_clickhouse_compatible_mode_ = is_clickhouse_compatible; +} + +} diff --git a/src/Common/ClickHouseCompatibleFlag.h b/src/Common/ClickHouseCompatibleFlag.h new file mode 100644 index 00000000000..385bce8d274 --- /dev/null +++ b/src/Common/ClickHouseCompatibleFlag.h @@ -0,0 +1,7 @@ +#pragma once + +namespace DB +{ +bool isClickHouseCompatibleMode(); +void setClickHouseCompatibleMode(bool is_clickhouse_compatible); +} diff --git a/src/Common/thread_local_is_clickhouse_compatible.cpp b/src/Common/thread_local_is_clickhouse_compatible.cpp deleted file mode 100644 index 3e87a34cf8e..00000000000 --- a/src/Common/thread_local_is_clickhouse_compatible.cpp +++ /dev/null @@ -1,3 +0,0 @@ -#include - -thread_local bool thread_local_is_clickhouse_compatible = false; diff --git a/src/Common/thread_local_is_clickhouse_compatible.h b/src/Common/thread_local_is_clickhouse_compatible.h deleted file mode 100644 index efd3e529404..00000000000 --- a/src/Common/thread_local_is_clickhouse_compatible.h +++ /dev/null @@ -1,3 +0,0 @@ -#include - -extern thread_local bool thread_local_is_clickhouse_compatible; diff --git a/src/Core/Block.cpp b/src/Core/Block.cpp index f5a19841ff0..3db25e0e45f 100644 --- a/src/Core/Block.cpp +++ b/src/Core/Block.cpp @@ -11,14 +11,15 @@ #include #include #include -/// proton: starts -#include "DataTypes/convertTypeToClickhouse.h" -/// proton: ends #include #include #include +/// proton: starts +#include +/// proton: ends + namespace DB { @@ -661,20 +662,26 @@ DataTypes Block::getDataTypes() const return res; } -/// proton: starts. -Names Block::getDataTypeNames(bool is_clickhouse_compatible) const -/// proton: ends. +Names Block::getDataTypeNames() const +{ + Names res; + res.reserve(columns()); + + for (const auto & elem : data) + res.push_back(elem.type->getName()); + + return res; +} + +Names Block::getClickHouseDataTypeNames() const { Names res; res.reserve(columns()); for (const auto & elem : data) res.push_back(elem.type->getName()); - - /// proton: starts. - if(is_clickhouse_compatible) - std::transform(res.begin(), res.end(), res.begin(), convertTypeToUpper); - /// proton: ends. + + std::transform(res.begin(), res.end(), res.begin(), convertToClickHouseType); return res; } diff --git a/src/Core/Block.h b/src/Core/Block.h index d41f86e5e3b..33c6129b84d 100644 --- a/src/Core/Block.h +++ b/src/Core/Block.h @@ -95,9 +95,8 @@ class Block NamesAndTypes getNamesAndTypes() const; Names getNames() const; DataTypes getDataTypes() const; - /// proton: starts. - Names getDataTypeNames(bool is_clickhouse_compatible = false) const; - /// proton: starts. + Names getDataTypeNames() const; + Names getClickHouseDataTypeNames() const; /// Added by proton to get ClickHouse compatible data types std::unordered_map getNamesToIndexesMap() const; /// Returns number of rows from first column in block, not equal to nullptr. If no columns, returns 0. diff --git a/src/Core/Settings.h b/src/Core/Settings.h index 6ae5d97af20..368f92df030 100644 --- a/src/Core/Settings.h +++ b/src/Core/Settings.h @@ -634,7 +634,7 @@ static constexpr UInt64 operator""_GiB(unsigned long long value) \ /** proton: starts */ \ M(String, shards, "", "If not empty, only the specified shard IDs (or partition IDs if the target stream is a Kafka external stream) will be selected to be read data from. IDs are separated by comma. Example: shards='0,2'", 0) \ - M(Bool, is_clickhouse_compatible, false, "When this parameter is set, timeplusd works in compatible mode with ClickHouse (especially compatible with data types and function names).", 0) \ + M(Bool, is_clickhouse_compatible, false, "When this setting is set to true, timeplus can run ClickHouse SQL", 0) \ \ /** proton: ends */ \ diff --git a/src/DataTypes/convertToClickHouseType.h b/src/DataTypes/convertToClickHouseType.h new file mode 100644 index 00000000000..c80ff4a70ce --- /dev/null +++ b/src/DataTypes/convertToClickHouseType.h @@ -0,0 +1,10 @@ +#pragma once + +#include + +namespace DB +{ + +/// Convert Timeplus (complex / compound) type names to ClickHouse data type names (recursively) +std::string convertToClickHouseType(const std::string & type_name); +} diff --git a/src/DataTypes/convertTypeToClickhouse.cpp b/src/DataTypes/convertToClickhouseType.cpp similarity index 63% rename from src/DataTypes/convertTypeToClickhouse.cpp rename to src/DataTypes/convertToClickhouseType.cpp index 07c83da1029..71c6e046bc7 100644 --- a/src/DataTypes/convertTypeToClickhouse.cpp +++ b/src/DataTypes/convertToClickhouseType.cpp @@ -1,10 +1,13 @@ -#include "DataTypes/convertTypeToClickhouse.h" -#include +#include + +#include namespace DB { -std::unordered_map typeMap +namespace +{ +const absl::flat_hash_map type_map = {{"void", "Void"}, {"bool", "Bool"}, {"int8", "Int8"}, @@ -50,58 +53,57 @@ std::unordered_map typeMap {"multipolygon", "MultiPolygon"}}; /// This function converts the type name to uppercase -std::string convertTypeToUpper(const std::string & input) +std::string convertToClickHouseType(const std::string_view input) { std::string result; - size_t i = 0; + result.reserve(input.size() + 8); - while (i < input.size()) + const size_t input_size = input.size(); + for (size_t i = 0; i < input_size;) { size_t start = i; - while (i < input.size() && (std::isalnum(input[i]) || input[i] == '_')) - i++; - - std::string type_name = input.substr(start, i - start); + while (i < input_size && (std::isalnum(input[i]) || input[i] == '_')) + ++i; - auto it = typeMap.find(type_name); - if (it != typeMap.end()) - { + std::string_view type_name{input.data() + start, i - start}; + if (auto it = type_map.find(type_name); it != type_map.end()) result += it->second; - } else - { - /// If the type is not found in typeMap, log a warning and keep the original value. Unknown data type or not a data type keyword. result += type_name; - } /// Processing parameter part: If there are brackets, continue splicing and parsing the content - if (i < input.size() && input[i] == '(') + if (i < input_size && input[i] == '(') { result += '('; - i++; /// Skip '(' + + ++i; /// Skip '(' + int bracket_cnt = 1; size_t param_start = i; - while (i < input.size() && bracket_cnt > 0) + + while (i < input_size && bracket_cnt > 0) { if (input[i] == '(') - bracket_cnt++; + ++bracket_cnt; else if (input[i] == ')') - bracket_cnt--; - i++; + --bracket_cnt; + + ++i; } /// Recursively process the parameters in parentheses - std::string params = input.substr(param_start, i - param_start - 1); - result += convertTypeToUpper(params); + std::string_view params{input.data() + param_start, i - param_start - 1}; + result += convertToClickHouseType(params); + result += ')'; } /// Skip other non-alphanumeric characters - while (i < input.size() && !std::isalnum(input[i]) && input[i] != '_') + while (i < input_size && !std::isalnum(input[i]) && input[i] != '_') { result += input[i]; - i++; + ++i; } } @@ -109,3 +111,10 @@ std::string convertTypeToUpper(const std::string & input) } } + +std::string convertToClickHouseType(const std::string & input) +{ + return convertToClickHouseType(std::string_view{input}); +} + +} diff --git a/src/DataTypes/convertTypeToClickhouse.h b/src/DataTypes/convertTypeToClickhouse.h deleted file mode 100644 index 2a88b34f4c9..00000000000 --- a/src/DataTypes/convertTypeToClickhouse.h +++ /dev/null @@ -1,15 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include - -namespace DB -{ -extern std::unordered_map typeMap; - -std::string convertTypeToUpper(const std::string & input); - -} diff --git a/src/DataTypes/tests/gtest_function_convertTypeToUpper.cpp b/src/DataTypes/tests/gtest_function_convertTypeToUpper.cpp deleted file mode 100644 index 6a08051c92b..00000000000 --- a/src/DataTypes/tests/gtest_function_convertTypeToUpper.cpp +++ /dev/null @@ -1,279 +0,0 @@ -#include -#include - -#include - -using namespace DB; - -/// test function: convertTypeToUpper -TEST(convertTypeToUpperTest, TestInputIs_int8) -{ - std::string input = "int8"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Int8"); -} -TEST(convertTypeToUpperTest, TestInputIs_uint8) -{ - std::string input = "uint8"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "UInt8"); -} -TEST(convertTypeToUpperTest, TestInputIs_int16) -{ - std::string input = "int16"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Int16"); -} -TEST(convertTypeToUpperTest, TestInputIs_uint16) -{ - std::string input = "uint16"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "UInt16"); -} -TEST(convertTypeToUpperTest, TestInputIs_int32) -{ - std::string input = "int32"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Int32"); -} -TEST(convertTypeToUpperTest, TestInputIs_uint32) -{ - std::string input = "uint32"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "UInt32"); -} -TEST(convertTypeToUpperTest, TestInputIs_int64) -{ - std::string input = "int64"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Int64"); -} -TEST(convertTypeToUpperTest, TestInputIs_uint64) -{ - std::string input = "uint64"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "UInt64"); -} -TEST(convertTypeToUpperTest, TestInputIs_int128) -{ - std::string input = "int128"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Int128"); -} -TEST(convertTypeToUpperTest, TestInputIs_uint128) -{ - std::string input = "uint128"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "UInt128"); -} -TEST(convertTypeToUpperTest, TestInputIs_int256) -{ - std::string input = "int256"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Int256"); -} -TEST(convertTypeToUpperTest, TestInputIs_uint256) -{ - std::string input = "uint256"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "UInt256"); -} -TEST(convertTypeToUpperTest, TestInputIs_float32) -{ - std::string input = "float32"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Float32"); -} -TEST(convertTypeToUpperTest, TestInputIsfloat64) -{ - std::string input = "float64"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Float64"); -} -TEST(convertTypeToUpperTest, TestInputIs_string) -{ - std::string input = "string"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "String"); -} -TEST(convertTypeToUpperTest, TestInputIs_date) -{ - std::string input = "date"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Date"); -} -TEST(convertTypeToUpperTest, TestInputIs_date32) -{ - std::string input = "date32"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Date32"); -} -TEST(convertTypeToUpperTest, TestInputIs_datetime) -{ - std::string input = "datetime"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "DateTime"); -} -TEST(convertTypeToUpperTest, TestInputIs_bool) -{ - std::string input = "bool"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Bool"); -} -TEST(convertTypeToUpperTest, TestInputIs_uuid) -{ - std::string input = "uuid"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "UUID"); -} -TEST(convertTypeToUpperTest, TestInputIs_ipv4) -{ - std::string input = "ipv4"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "IPv4"); -} -TEST(convertTypeToUpperTest, TestInputIs_ipv6) -{ - std::string input = "ipv6"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "IPv6"); -} -TEST(convertTypeToUpperTest, TestInputIs_json) -{ - std::string input = "json"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "JSON"); -} - -TEST(convertTypeToUpperTest, TestInputIs_nullable) -{ - std::string input = "nullable(string)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Nullable(String)"); -} -TEST(convertTypeToUpperTest, TestInputIs_decimal) -{ - std::string input = "decimal(10, 3)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Decimal(10, 3)"); -} -TEST(convertTypeToUpperTest, TestInputIs_decimal32) -{ - std::string input = "decimal32(3)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Decimal32(3)"); -} -TEST(convertTypeToUpperTest, TestInputIs_decimal64) -{ - std::string input = "decimal64(3)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Decimal64(3)"); -} -TEST(convertTypeToUpperTest, TestInputIs_decimal128) -{ - std::string input = "decimal128(3)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Decimal128(3)"); -} -TEST(convertTypeToUpperTest, TestInputIs_decimal256) -{ - std::string input = "decimal256(3)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Decimal256(3)"); -} -TEST(convertTypeToUpperTest, TestInputIs_fixed_string) -{ - std::string input = "fixed_string(10)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "FixedString(10)"); -} -TEST(convertTypeToUpperTest, TestInputIs_datetime64) -{ - std::string input = "datetime64(3)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "DateTime64(3)"); -} -TEST(convertTypeToUpperTest, TestInputIs_enum) -{ - std::string input = "enum('One' = 1, 'Two' = 2, 'Three' = 3)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Enum('One' = 1, 'Two' = 2, 'Three' = 3)"); -} -TEST(convertTypeToUpperTest, TestInputIs_enum8) -{ - std::string input = "enum8('One' = 1, 'Two' = 2, 'Three' = 3)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Enum8('One' = 1, 'Two' = 2, 'Three' = 3)"); -} -TEST(convertTypeToUpperTest, TestInputIs_enum16) -{ - std::string input = "enum16('One' = 1, 'Two' = 2, 'Three' = 3)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Enum16('One' = 1, 'Two' = 2, 'Three' = 3)"); -} -TEST(convertTypeToUpperTest, TestInputIs_array) -{ - std::string input = "array(int32)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Array(Int32)"); -} -TEST(convertTypeToUpperTest, TestInputIs_map) -{ - std::string input = "map(string, int32)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Map(String, Int32)"); -} -TEST(convertTypeToUpperTest, TestInputIs_tuple) -{ - std::string input = "tuple(string, int32, string)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Tuple(String, Int32, String)"); -} -TEST(convertTypeToUpperTest, TestInputIs_low_cardinality) -{ - std::string input = "low_cardinality(string)"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "LowCardinality(String)"); -} - -TEST(convertTypeToUpperTest, TestInputIs_datetime_timezone) -{ - std::string input = "datetime('UTC')"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "DateTime('UTC')"); -} - -TEST(convertTypeToUpperTest, TestInputIs_datetime64_precision_timezone) -{ - std::string input = "datetime64(3, 'UTC')"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "DateTime64(3, 'UTC')"); -} - -TEST(convertTypeToUpperTest, TestInputIs_nested1) -{ - std::string input = "nullable(map(string, tuple(array(nullable(string), nullable(int32), nullable(fixed_string(10)), nullable(datetime64(3, 'UTC')), low_cardinality(nullable(float32))))))"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Nullable(Map(String, Tuple(Array(Nullable(String), Nullable(Int32), Nullable(FixedString(10)), Nullable(DateTime64(3, 'UTC')), LowCardinality(Nullable(Float32))))))"); -} - -TEST(convertTypeToUpperTest, TestInputIs_nested2) -{ - std::string input = "nullable(array(tuple(nullable(int32), nullable(string))))"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Nullable(Array(Tuple(Nullable(Int32), Nullable(String))))"); -} - -TEST(convertTypeToUpperTest, TestInputIs_nested3) -{ - std::string input = "tuple(nullable(string), nullable(int32), nullable(datetime64(3, 'UTC')))"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Tuple(Nullable(String), Nullable(Int32), Nullable(DateTime64(3, 'UTC')))"); -} - -TEST(convertTypeToUpperTest, TestInputIs_nested4) -{ - std::string input = "map(string, tuple(nullable(int32), nullable(string)))"; - std::string output = convertTypeToUpper(input); - EXPECT_EQ(output, "Map(String, Tuple(Nullable(Int32), Nullable(String)))"); -} diff --git a/src/DataTypes/tests/gtest_function_convert_to_clickhouse_type.cpp b/src/DataTypes/tests/gtest_function_convert_to_clickhouse_type.cpp new file mode 100644 index 00000000000..45b8586dbed --- /dev/null +++ b/src/DataTypes/tests/gtest_function_convert_to_clickhouse_type.cpp @@ -0,0 +1,320 @@ +#include + +#include + +#include + +using namespace DB; + +/// test function: convertToClickHouseType +TEST(convertToClickHouseTypeTest, TestInputIs_int8) +{ + std::string input = "int8"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Int8"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_uint8) +{ + std::string input = "uint8"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "UInt8"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_int16) +{ + std::string input = "int16"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Int16"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_uint16) +{ + std::string input = "uint16"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "UInt16"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_int32) +{ + std::string input = "int32"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Int32"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_uint32) +{ + std::string input = "uint32"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "UInt32"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_int64) +{ + std::string input = "int64"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Int64"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_uint64) +{ + std::string input = "uint64"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "UInt64"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_int128) +{ + std::string input = "int128"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Int128"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_uint128) +{ + std::string input = "uint128"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "UInt128"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_int256) +{ + std::string input = "int256"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Int256"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_uint256) +{ + std::string input = "uint256"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "UInt256"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_float32) +{ + std::string input = "float32"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Float32"); +} + +TEST(convertToClickHouseTypeTest, TestInputIsfloat64) +{ + std::string input = "float64"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Float64"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_string) +{ + std::string input = "string"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "String"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_date) +{ + std::string input = "date"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Date"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_date32) +{ + std::string input = "date32"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Date32"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_datetime) +{ + std::string input = "datetime"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "DateTime"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_bool) +{ + std::string input = "bool"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Bool"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_uuid) +{ + std::string input = "uuid"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "UUID"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_ipv4) +{ + std::string input = "ipv4"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "IPv4"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_ipv6) +{ + std::string input = "ipv6"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "IPv6"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_json) +{ + std::string input = "json"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "JSON"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_nullable) +{ + std::string input = "nullable(string)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Nullable(String)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_decimal) +{ + std::string input = "decimal(10, 3)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Decimal(10, 3)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_decimal32) +{ + std::string input = "decimal32(3)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Decimal32(3)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_decimal64) +{ + std::string input = "decimal64(3)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Decimal64(3)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_decimal128) +{ + std::string input = "decimal128(3)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Decimal128(3)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_decimal256) +{ + std::string input = "decimal256(3)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Decimal256(3)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_fixed_string) +{ + std::string input = "fixed_string(10)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "FixedString(10)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_datetime64) +{ + std::string input = "datetime64(3)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "DateTime64(3)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_enum) +{ + std::string input = "enum('One' = 1, 'Two' = 2, 'Three' = 3)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Enum('One' = 1, 'Two' = 2, 'Three' = 3)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_enum8) +{ + std::string input = "enum8('One' = 1, 'Two' = 2, 'Three' = 3)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Enum8('One' = 1, 'Two' = 2, 'Three' = 3)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_enum16) +{ + std::string input = "enum16('One' = 1, 'Two' = 2, 'Three' = 3)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Enum16('One' = 1, 'Two' = 2, 'Three' = 3)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_array) +{ + std::string input = "array(int32)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Array(Int32)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_map) +{ + std::string input = "map(string, int32)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Map(String, Int32)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_tuple) +{ + std::string input = "tuple(string, int32, string)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Tuple(String, Int32, String)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_low_cardinality) +{ + std::string input = "low_cardinality(string)"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "LowCardinality(String)"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_datetime_timezone) +{ + std::string input = "datetime('UTC')"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "DateTime('UTC')"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_datetime64_precision_timezone) +{ + std::string input = "datetime64(3, 'UTC')"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "DateTime64(3, 'UTC')"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_nested1) +{ + std::string input = "nullable(map(string, tuple(array(nullable(string), nullable(int32), nullable(fixed_string(10)), " + "nullable(datetime64(3, 'UTC')), low_cardinality(nullable(float32))))))"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ( + output, + "Nullable(Map(String, Tuple(Array(Nullable(String), Nullable(Int32), Nullable(FixedString(10)), Nullable(DateTime64(3, 'UTC')), " + "LowCardinality(Nullable(Float32))))))"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_nested2) +{ + std::string input = "nullable(array(tuple(nullable(int32), nullable(string))))"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Nullable(Array(Tuple(Nullable(Int32), Nullable(String))))"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_nested3) +{ + std::string input = "tuple(nullable(string), nullable(int32), nullable(datetime64(3, 'UTC')))"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Tuple(Nullable(String), Nullable(Int32), Nullable(DateTime64(3, 'UTC')))"); +} + +TEST(convertToClickHouseTypeTest, TestInputIs_nested4) +{ + std::string input = "map(string, tuple(nullable(int32), nullable(string)))"; + std::string output = convertToClickHouseType(input); + EXPECT_EQ(output, "Map(String, Tuple(Nullable(Int32), Nullable(String)))"); +} diff --git a/src/Functions/CastOverloadResolver.cpp b/src/Functions/CastOverloadResolver.cpp index 2dd75116ef7..638beee13e3 100644 --- a/src/Functions/CastOverloadResolver.cpp +++ b/src/Functions/CastOverloadResolver.cpp @@ -87,9 +87,7 @@ class CastOverloadResolverImpl : public IFunctionOverloadResolver "Instead there is a column with the following structure: {}", getName(), column->dumpStructure()); /// proton: starts - bool is_clickhouse_compatible = false; - if (context) - is_clickhouse_compatible = context->getSettingsRef().is_clickhouse_compatible; + bool is_clickhouse_compatible = context ? context->getSettingsRef().is_clickhouse_compatible : false; DataTypePtr type = DataTypeFactory::instance().get(type_col->getValue(), is_clickhouse_compatible); /// proton: ends diff --git a/src/Interpreters/InterpreterCreateQuery.cpp b/src/Interpreters/InterpreterCreateQuery.cpp index 24b9088d0f4..a3549fbe7d3 100644 --- a/src/Interpreters/InterpreterCreateQuery.cpp +++ b/src/Interpreters/InterpreterCreateQuery.cpp @@ -459,9 +459,7 @@ ColumnsDescription InterpreterCreateQuery::getColumnsDescription( if (col_decl.type) { /// proton: starts - bool is_clickhouse_compatible_ = false; - if (context_) - is_clickhouse_compatible_ = context_->getSettingsRef().is_clickhouse_compatible; + bool is_clickhouse_compatible_ = context_->getSettingsRef().is_clickhouse_compatible; column_type = DataTypeFactory::instance().get(col_decl.type, is_clickhouse_compatible_); /// proton: ends diff --git a/src/Interpreters/executeQuery.cpp b/src/Interpreters/executeQuery.cpp index 32a9fcaab71..813c98b765a 100644 --- a/src/Interpreters/executeQuery.cpp +++ b/src/Interpreters/executeQuery.cpp @@ -76,8 +76,8 @@ #include #include #include -#include /// proton: update -#include /// proton: update +#include +#include /// proton: ends namespace ProfileEvents @@ -475,20 +475,18 @@ static std::tuple executeQueryImpl( String query_table; try { - ParserQuery parser(end, settings.allow_settings_after_format_in_insert); - /// proton: starts - thread_local_is_clickhouse_compatible = context->getSettingsRef().is_clickhouse_compatible; - /// proton: ends - /// TODO: parser should fail early when max_query_size limit is reached. - /// proton: starts - if (settings.enable_query_pipe) - ast = parseQueryPipe(parser, begin, end, max_query_size, settings.max_parser_depth); - else - ast = parseQuery(parser, begin, end, "", max_query_size, settings.max_parser_depth); - /// proton: starts { - SCOPE_EXIT({ thread_local_is_clickhouse_compatible = false; }); + setClickHouseCompatibleMode(context->getSettingsRef().is_clickhouse_compatible); + SCOPE_EXIT_SAFE({ setClickHouseCompatibleMode(false); }); + + ParserQuery parser(end, settings.allow_settings_after_format_in_insert); + /// TODO: parser should fail early when max_query_size limit is reached. + + if (settings.enable_query_pipe) + ast = parseQueryPipe(parser, begin, end, max_query_size, settings.max_parser_depth); + else + ast = parseQuery(parser, begin, end, "", max_query_size, settings.max_parser_depth); } /// proton: ends diff --git a/src/Parsers/ExpressionElementParsers.cpp b/src/Parsers/ExpressionElementParsers.cpp index f2afdb82bac..f5643c07ad7 100644 --- a/src/Parsers/ExpressionElementParsers.cpp +++ b/src/Parsers/ExpressionElementParsers.cpp @@ -43,19 +43,12 @@ #include /// proton: starts. -#include #include +#include /// proton: ends. -/// proton: starts -#include -/// proton: ends - namespace DB { -/// proton: starts -class Context; -/// proton: ends namespace ErrorCodes { @@ -756,1260 +749,6 @@ namespace } } -/// proton: starts -/// When timeplus registers a new function, the new function needs to be added to one of the following two maps. -static std::unordered_map function_map - = {{"cast", "cast"}, - {"encodeURLComponent", "encode_url_component"}, - {"decodeURLComponent", "decode_url_component"}, - {"URLHierarchy", "url_hierarchy"}, - {"URLPathHierarchy", "url_path_hierarchy"}, - {"extractURLParameterNames", "extract_url_parameter_names"}, - {"extractURLParameters", "extract_url_parameters"}, - {"generateUUIDv4", "generate_uuidv4"}, - {"toYYYYMMDDhhmmss", "to_YYYYMMDDhhmmss"}, - {"toYYYYMM", "to_YYYYMM"}, - {"to_YYYYMM", "to_YYYYMM"}, - {"BLAKE3", "blake3"}, - {"connectionId", "connection_id"}, - {"countMatches", "count_matches"}, - {"countMatchesCaseInsensitive", "count_matches_case_insensitive"}, - {"dateName", "date_name"}, - {"displayName", "display_name"}, - {"formatReadableDecimalSize", "format_readable_decimal_size"}, - {"FQDN", "fqdn"}, - {"hasToken", "has_token"}, - {"leftUTF8", "left_utf8"}, - {"position", "position"}, - {"rightUTF8", "right_utf8"}, - {"roundBankers", "round_bankers"}, - {"starts", "starts"}, - {"structureToCapnProtoSchema", "structure_to_capn_proto_schema"}, - {"structureToProtobufSchema", "structure_to_protobuf_schema"}, - {"xxh3", "xxh3"}}; - -static std::unordered_map case_insensitive_function_map - /// case_insensitive_functions - = {{"bithammingdistance", "bit_hamming_distance"}, - {"polygonsdistancespherical", "polygons_distance_spherical"}, - {"polygonsdistancecartesian", "polygons_distance_cartesian"}, - {"fuzzbits", "fuzz_bits"}, - {"initializeaggregation", "initialize_aggregation"}, - {"extractgroups", "extract_groups"}, - {"tostartofsecond", "to_start_of_second"}, - {"randomintype", "random_in_type"}, - {"jsonvalues", "json_values"}, - {"jsonexists", "json_exists"}, - {"rand", "rand"}, - {"tointervalmonth", "to_interval_month"}, - {"tointervalminute", "to_interval_minute"}, - {"tointervalsecond", "to_interval_second"}, - {"tointervalmillisecond", "to_interval_millisecond"}, - {"tointervalmicrosecond", "to_interval_microsecond"}, - {"parsedatetime64besteffortusornull", "parse_datetime64_best_effort_us_or_null"}, - {"parsedatetime64besteffortorzero", "parse_datetime64_best_effort_or_zero"}, - {"parsedatetime64besteffort", "parse_datetime64_best_effort"}, - {"parsedatetime32besteffortornull", "parse_datetime32_best_effort_or_null"}, - {"parsedatetimebesteffortusorzero", "parse_datetime_best_effort_us_or_zero"}, - {"parsedatetimebesteffortus", "parse_datetime_best_effort_us"}, - {"toipv6ornull", "to_ipv6_or_null"}, - {"toipv4ornull", "to_ipv4_or_null"}, - {"touuidornull", "to_uuid_or_null"}, - {"todecimal32ornull", "to_decimal32_or_null"}, - {"todate32ornull", "to_date32_or_null"}, - {"tofloat64ornull", "to_float64_or_null"}, - {"tofloat32ornull", "to_float32_or_null"}, - {"toint256ornull", "to_int256_or_null"}, - {"toint128ornull", "to_int128_or_null"}, - {"toint64ornull", "to_int64_or_null"}, - {"toint16ornull", "to_int16_or_null"}, - {"touint256ornull", "to_uint256_or_null"}, - {"touint32ornull", "to_uint32_or_null"}, - {"touint16ornull", "to_uint16_or_null"}, - {"touint8ornull", "to_uint8_or_null"}, - {"toipv6orzero", "to_ipv6_or_zero"}, - {"toipv4orzero", "to_ipv4_or_zero"}, - {"touuidorzero", "to_uuid_or_zero"}, - {"todecimal128orzero", "to_decimal128_or_zero"}, - {"todecimal64orzero", "to_decimal64_or_zero"}, - {"todecimal32orzero", "to_decimal32_or_zero"}, - {"todatetimeorzero", "to_datetime_or_zero"}, - {"todate32orzero", "to_date32_or_zero"}, - {"tofloat64orzero", "to_float64_or_zero"}, - {"toint64orzero", "to_int64_or_zero"}, - {"toint8orzero", "to_int8_or_zero"}, - {"parsedatetimebesteffortorzero", "parse_datetime_best_effort_or_zero"}, - {"touint128orzero", "to_uint128_or_zero"}, - {"touint64orzero", "to_uint64_or_zero"}, - {"touint32orzero", "to_uint32_or_zero"}, - {"touint8orzero", "to_uint8_or_zero"}, - {"toipv4", "to_ipv4"}, - {"todatetime64", "to_datetime64"}, - {"todate", "to_date"}, - {"todate16", "to_date16"}, - {"todecimal128", "to_decimal128"}, - {"todecimal64", "to_decimal64"}, - {"todecimal32", "to_decimal32"}, - {"toint256", "to_int256"}, - {"toint128", "to_int128"}, - {"toint64", "to_int64"}, - {"toint32", "to_int32"}, - {"touint256", "to_uint256"}, - {"touint128", "to_uint128"}, - {"touint64", "to_uint64"}, - {"touint32", "to_uint32"}, - {"touint16", "to_uint16"}, - {"touint8", "to_uint8"}, - {"blocksize", "block_size"}, - {"isnotnull", "is_not_null"}, - {"rounddown", "round_down"}, - {"trunc", "trunc"}, - {"floor", "floor"}, - {"round", "round"}, - {"weakhash32", "weak_hash32"}, - {"wyhash64", "wy_hash64"}, - {"xxhash64", "xx_hash64"}, - {"xxhash32", "xx_hash32"}, - {"gccmurmurhash", "gcc_murmur_hash"}, - {"murmurhash3128", "murmur_hash3_128"}, - {"murmurhash364", "murmur_hash3_64"}, - {"todecimal256orzero", "to_decimal256_or_zero"}, - {"murmurhash332", "murmur_hash3_32"}, - {"hivehash", "hive_hash"}, - {"javahashutf16le", "java_hash_utf16_le"}, - {"javahash", "java_hash"}, - {"urlhash", "url_hash"}, - {"inthash64", "int_hash64"}, - {"inthash32", "int_hash32"}, - {"metrohash64", "metro_hash64"}, - {"farmfingerprint64", "farm_fingerprint64"}, - {"siphash128", "sip_hash128"}, - {"sha512", "sha512"}, - {"sha384", "sha384"}, - {"uuidstringtonum", "uuid_string_to_num"}, - {"sha224", "sha224"}, - {"sha1", "sha1"}, - {"todecimal", "to_decimal"}, - {"md5", "md5"}, - {"halfmd5", "half_md5"}, - {"lowcardinalityindices", "low_cardinality_indices"}, - {"logtrace", "log_trace"}, - {"edition", "edition"}, - {"stringtoh3", "string_to_h3"}, - {"toint16", "to_int16"}, - {"jsonextractkeysandvaluesraw", "json_extract_keys_and_values_raw"}, - {"jsonextractarrayraw", "json_extract_array_raw"}, - {"jsonextractraw", "json_extract_raw"}, - {"jsonextractkeysandvalues", "json_extract_keys_and_values"}, - {"jsonextract", "json_extract"}, - {"jsonextractstring", "json_extract_string"}, - {"jsonextractbool", "json_extract_bool"}, - {"jsonextractint", "json_extract_int"}, - {"jsontype", "json_type"}, - {"jsonlength", "json_length"}, - {"isvalidjson", "is_valid_json"}, - {"char", "char"}, - {"cbrt", "cbrt"}, - {"s2togeo", "s2_to_geo"}, - {"sleepeachrow", "sleep_each_row"}, - {"regiontoname", "region_to_name"}, - {"regionin", "region_in"}, - {"regiontocountry", "region_to_country"}, - {"regiontodistrict", "region_to_district"}, - {"adddays", "add_days"}, - {"countsubstringscaseinsensitiveutf8", "count_substrings_case_insensitive_utf8"}, - {"makedatetime64", "make_datetime64"}, - {"date", "date"}, - {"makedate", "make_date"}, - {"subtractnanoseconds", "subtract_nanoseconds"}, - {"ipv6stringtonumornull", "ipv6_string_to_num_or_null"}, - {"ipv6stringtonumordefault", "ipv6_string_to_num_or_default"}, - {"ipv6stringtonum", "ipv6_string_to_num"}, - {"ipv6numtostring", "ipv6_num_to_string"}, - {"ipv4stringtonumordefault", "ipv4_string_to_num_or_default"}, - {"ipv4stringtonum", "ipv4_string_to_num"}, - {"ipv4numtostringclassc", "ipv4_num_to_string_class_c"}, - {"isipv4string", "is_ipv4_string"}, - {"ipv4cidrtorange", "ipv4_cidr_to_range"}, - {"ipv6cidrtorange", "ipv6_cidr_to_range"}, - {"macstringtooui", "mac_string_to_oui"}, - {"macnumtostring", "mac_num_to_string"}, - {"ipv4toipv6", "ipv4_to_ipv6"}, - {"cutipv6", "cut_ipv6"}, - {"snowflaketodatetime64", "snowflake_to_datetime64"}, - {"subtractmilliseconds", "subtract_milliseconds"}, - {"getserverport", "get_server_port"}, - {"regiontocity", "region_to_city"}, - {"multisearchany", "multi_search_any"}, - {"bitmaphasany", "bitmap_has_any"}, - {"bitmapandnot", "bitmap_andnot"}, - {"parsedatetime64besteffortus", "parse_datetime64_best_effort_us"}, - {"bitmapand", "bitmap_and"}, - {"detectcharset", "detect_charset"}, - {"bitmapxorcardinality", "bitmap_xor_cardinality"}, - {"h3getpentagonindexes", "h3_get_pentagon_indexes"}, - {"arraylastindex", "array_last_index"}, - {"bitmaporcardinality", "bitmap_or_cardinality"}, - {"subbitmap", "sub_bitmap"}, - {"runningconcurrency", "running_concurrency"}, - {"bitmapsubsetlimit", "bitmap_subset_limit"}, - {"bitmapsubsetinrange", "bitmap_subset_in_range"}, - {"bitmapbuild", "bitmap_build"}, - {"extracttextfromhtml", "extract_text_from_html"}, - {"monthname", "month_name"}, - {"splitbyregexp", "split_by_regexp"}, - {"isnan", "is_nan"}, - {"geohashencode", "geohash_encode"}, - {"torelativequarternum", "to_relative_quarter_num"}, - {"or", "or"}, - {"dictgetchildren", "dict_get_children"}, - {"dictisin", "dict_is_in"}, - {"todecimal128ornull", "to_decimal128_or_null"}, - {"dictgetstringordefault", "dict_get_string_or_default"}, - {"dictgetipv6ordefault", "dict_get_ipv6_or_default"}, - {"dictgetdatetimeordefault", "dict_get_datetime_or_default"}, - {"datetimetosnowflake", "datetime_to_snowflake"}, - {"todateordefault", "to_date_or_default"}, - {"dictgetdateordefault", "dict_get_date_or_default"}, - {"dictgetfloat64ordefault", "dict_get_float64_or_default"}, - {"h3getresolution", "h3_get_resolution"}, - {"exp", "exp"}, - {"dictgetfloat32ordefault", "dict_get_float32_or_default"}, - {"addseconds", "add_seconds"}, - {"dictgetint64ordefault", "dict_get_int64_or_default"}, - {"toint", "to_int"}, - {"dictgetint16ordefault", "dict_get_int16_or_default"}, - {"dictgetuint64ordefault", "dict_get_uint64_or_default"}, - {"emptyarraystring", "empty_array_string"}, - {"dictgetuint32ordefault", "dict_get_uint32_or_default"}, - {"h3cellaream2", "h3_cell_area_m2"}, - {"date_diff", "date_diff"}, - {"dictgetstring", "dict_get_string"}, - {"dictgetuuid", "dict_get_uuid"}, - {"dictgetfloat64", "dict_get_float64"}, - {"tuplemultiplybynumber", "tuple_multiply_by_number"}, - {"tomonth", "to_month"}, - {"dictgetint16", "dict_get_int16"}, - {"dictgetint8", "dict_get_int8"}, - {"dictgetuint32", "dict_get_uint32"}, - {"multisearchanycaseinsensitiveutf8", "multi_search_any_case_insensitive_utf8"}, - {"cosh", "cosh"}, - {"dictgetuint16", "dict_get_uint16"}, - {"sleep", "sleep"}, - {"dictget", "dict_get"}, - {"replicate", "replicate"}, - {"tomodifiedjulianday", "to_modified_julian_day"}, - {"h3getunidirectionaledge", "h3_get_unidirectional_edge"}, - {"regiontocontinent", "region_to_continent"}, - {"hascolumnintable", "has_column_in_table"}, - {"detectlanguageunknown", "detect_language_unknown"}, - {"arrayslice", "array_slice"}, - {"todecimal128ordefault", "to_decimal128_or_default"}, - {"partitionid", "partition_id"}, - {"formatdatetimeinjodasyntax", "format_datetime_in_joda_syntax"}, - {"dictgetornull", "dict_get_or_null"}, - {"tostartofquarter", "to_start_of_quarter"}, - {"multisearchfirstindex", "multi_search_first_index"}, - {"bytesize", "byte_size"}, - {"geohashdecode", "geohash_decode"}, - {"polygonsequalscartesian", "polygons_equals_cartesian"}, - {"jsonkey", "json_key"}, - {"bitmapmax", "bitmap_max"}, - {"tid", "tid"}, - {"bitcount", "bit_count"}, - {"tointervalyear", "to_interval_year"}, - {"not", "not"}, - {"formatrow", "format_row"}, - {"arrayreduceinranges", "array_reduce_in_ranges"}, - {"addmicroseconds", "add_microseconds"}, - {"geotoh3", "geo_to_h3"}, - {"bitmapmin", "bitmap_min"}, - {"normalizequery", "normalize_query"}, - {"if", "if"}, - {"defaultprofiles", "default_profiles"}, - {"countsubstrings", "count_substrings"}, - {"ngramdistancecaseinsensitiveutf8", "ngram_distance_case_insensitive_utf8"}, - {"acosh", "acosh"}, - {"accuratecastornull", "accurate_cast_or_null"}, - {"h3indexesareneighbors", "h3_indexes_are_neighbors"}, - {"accuratecast", "accurate_cast"}, - {"cast", "cast"}, - {"notlike", "not_like"}, - {"aesdecryptmysql", "aes_decrypt_mysql"}, - {"toint8", "to_int8"}, - {"dictgetfloat32", "dict_get_float32"}, - {"arraycompact", "array_compact"}, - {"dictgetint32", "dict_get_int32"}, - {"bitslice", "bit_slice"}, - {"bitrotateright", "bit_rotate_right"}, - {"toweek", "to_week"}, - {"hashid", "hashid"}, - {"h3edgelengthm", "h3_edge_length_m"}, - {"bitshiftright", "bit_shift_right"}, - {"tan", "tan"}, - {"substring", "substring"}, - {"tostartofday", "to_start_of_day"}, - {"addhours", "add_hours"}, - {"ipv4numtostring", "ipv4_num_to_string"}, - {"randcanonical", "rand_canonical"}, - {"h3togeoboundary", "h3_to_geo_boundary"}, - {"blocknumber", "block_number"}, - {"l2normalize", "l2_normalize"}, - {"reverse", "reverse"}, - {"multisearchfirstindexutf8", "multi_search_first_index_utf8"}, - {"torelativesecondnum", "to_relative_second_num"}, - {"greatcircleangle", "great_circle_angle"}, - {"subtractyears", "subtract_years"}, - {"isvalidutf8", "is_valid_utf8"}, - {"arrayfold", "array_fold"}, - {"casewithexpression", "case_with_expression"}, - {"addyears", "add_years"}, - {"tointervalquarter", "to_interval_quarter"}, - {"tonullable", "to_nullable"}, - {"intexp2", "int_exp2"}, - {"wordshingleminhashargutf8", "word_shingle_min_hash_arg_utf8"}, - {"fromunixtimestamp", "from_unix_timestamp"}, - {"dictgetint32ordefault", "dict_get_int32_or_default"}, - {"wordshingleminhashcaseinsensitive", "word_shingle_min_hash_case_insensitive"}, - {"rownumberinblock", "row_number_in_block"}, - {"splitbywhitespace", "split_by_whitespace"}, - {"wordshingleminhasharg", "word_shingle_min_hash_arg"}, - {"s2capcontains", "s2_cap_contains"}, - {"ngramminhashargcaseinsensitiveutf8", "ngram_min_hash_arg_case_insensitive_utf8"}, - {"extractallgroupsvertical", "extract_all_groups_vertical"}, - {"globalnotnullin", "global_not_null_in"}, - {"ngramminhashargutf8", "ngram_min_hash_arg_utf8"}, - {"ngramminhashargcaseinsensitive", "ngram_min_hash_arg_case_insensitive"}, - {"ngramminhashutf8", "ngram_min_hash_utf8"}, - {"ngramminhash", "ngram_min_hash"}, - {"wordshinglesimhashutf8", "word_shingle_sim_hash_utf8"}, - {"jsonvalue", "json_value"}, - {"wordshinglesimhashcaseinsensitive", "word_shingle_sim_hash_case_insensitive"}, - {"getmacro", "get_macro"}, - {"wordshinglesimhash", "word_shingle_sim_hash"}, - {"ngramsimhashcaseinsensitiveutf8", "ngram_sim_hash_case_insensitive_utf8"}, - {"ngramsimhashutf8", "ngram_sim_hash_utf8"}, - {"wordshingleminhashargcaseinsensitiveutf8", "word_shingle_min_hash_arg_case_insensitive_utf8"}, - {"h3pointdistrads", "h3_point_dist_rads"}, - {"runningdifferencestartingwithfirstvalue", "running_difference_starting_with_first_value"}, - {"ngramsimhashcaseinsensitive", "ngram_sim_hash_case_insensitive"}, - {"base58decode", "base58_decode"}, - {"moduloorzero", "modulo_or_zero"}, - {"normalizeutf8nfd", "normalize_utf8_nfd"}, - {"currentdatabase", "current_database"}, - {"streamingnow64", "__streaming_now64"}, - {"identity", "identity"}, - {"ascii", "ascii"}, - {"currentprofiles", "current_profiles"}, - {"lowerutf8", "lower_utf8"}, - {"polygonperimetercartesian", "polygon_perimeter_cartesian"}, - {"positivemodulo", "positive_modulo"}, - {"bitpositionstoarray", "bit_positions_to_array"}, - {"dictgetipv4ordefault", "dict_get_ipv4_or_default"}, - {"jsonhas", "json_has"}, - {"currentuser", "current_user"}, - {"tofloat64", "to_float64"}, - {"age", "age"}, - {"regionhierarchy", "region_hierarchy"}, - {"reinterpret", "reinterpret"}, - {"todayofweek", "to_day_of_week"}, - {"unbin", "unbin"}, - {"h3edgeangle", "h3_edge_angle"}, - {"modulo", "modulo"}, - {"toipv6ordefault", "to_ipv6_or_default"}, - {"cos", "cos"}, - {"unhex", "unhex"}, - {"hex", "hex"}, - {"gcd", "gcd"}, - {"jumpconsistenthash", "jump_consistent_hash"}, - {"defaultvalueofargumenttype", "default_value_of_argument_type"}, - {"subtractminutes", "subtract_minutes"}, - {"frommodifiedjulianday", "from_modified_julian_day"}, - {"concat", "concat"}, - {"demangle", "demangle"}, - {"log", "log"}, - {"alphatokens", "alpha_tokens"}, - {"l1norm", "l1_norm"}, - {"dividedecimal", "divide_decimal"}, - {"h3tochildren", "h3_to_children"}, - {"fullhostname", "full_host_name"}, - {"getsetting", "get_setting"}, - {"bitboolmaskand", "__bit_bool_mask_and"}, - {"tupleplus", "tuple_plus"}, - {"minus", "minus"}, - {"sqrt", "sqrt"}, - {"casewithoutexpr", "case_without_expr"}, - {"bitrotateleft", "bit_rotate_left"}, - {"getsizeofenumtype", "get_size_of_enum_type"}, - {"endswith", "ends_with"}, - {"wordshinglesimhashcaseinsensitiveutf8", "word_shingle_sim_hash_case_insensitive_utf8"}, - {"streamingrownumber", "__streaming_row_number"}, - {"formatreadablesize", "format_readable_size"}, - {"countdigits", "count_digits"}, - {"subtractquarters", "subtract_quarters"}, - {"polygonareacartesian", "polygon_area_cartesian"}, - {"trybase58decode", "try_base58_decode"}, - {"exp10", "exp10"}, - {"bitswaplasttwo", "__bit_swap_last_two"}, - {"lowcardinalitykeys", "low_cardinality_keys"}, - {"subtractinterval", "subtract_interval"}, - {"finalizeaggregation", "finalize_aggregation"}, - {"trybase64decode", "try_base64_decode"}, - {"tokens", "tokens"}, - {"ngrams", "ngrams"}, - {"geohashesinbox", "geohashes_in_box"}, - {"runningdifference", "running_difference"}, - {"arrayenumeratedenseranked", "array_enumerate_dense_ranked"}, - {"flattentuple", "flatten_tuple"}, - {"bitmapor", "bitmap_or"}, - {"concatassumeinjective", "concat_assume_injective"}, - {"lcm", "lcm"}, - {"mapextractkeylike", "map_extract_key_like"}, - {"formatreadablequantity", "format_readable_quantity"}, - {"formatrownonewline", "format_row_no_newline"}, - {"casewithoutexpression", "case_without_expression"}, - {"multiif", "multi_if"}, - {"fromunixtimestamp64milli", "from_unix_timestamp64_milli"}, - {"hastokencaseinsensitive", "has_token_case_insensitive"}, - {"geodistance", "geo_distance"}, - {"h3getres0indexes", "h3_get_res0_indexes"}, - {"toyear", "to_year"}, - {"decodexmlcomponent", "decode_xml_component"}, - {"now64", "now64"}, - {"multimatchany", "multi_match_any"}, - {"h3exactedgelengthkm", "h3_exact_edge_length_km"}, - {"arraysum", "array_sum"}, - {"toisoyear", "to_iso_year"}, - {"enabledroles", "enabled_roles"}, - {"parsedatetimebesteffortusornull", "parse_datetime_best_effort_us_or_null"}, - {"tostartoftenminutes", "to_start_of_ten_minutes"}, - {"lower", "lower"}, - {"h3exactedgelengthm", "h3_exact_edge_length_m"}, - {"bitmapandcardinality", "bitmap_and_cardinality"}, - {"dictgetdatetime", "dict_get_datetime"}, - {"totime", "__to_time"}, - {"h3getdestinationindexfromunidirectionaledge", "h3_get_destination_index_from_unidirectional_edge"}, - {"roundduration", "round_duration"}, - {"h3getoriginindexfromunidirectionaledge", "h3_get_origin_index_from_unidirectional_edge"}, - {"crc32", "crc32"}, - {"trimright", "trim_right"}, - {"trimleft", "trim_left"}, - {"dumpcolumnstructure", "dump_column_structure"}, - {"touuid", "to_uuid"}, - {"extractallgroupshorizontal", "extract_all_groups_horizontal"}, - {"uniqthetaunion", "uniq_theta_union"}, - {"s2cellsintersect", "s2_cells_intersect"}, - {"coalesce", "coalesce"}, - {"todateorzero", "to_date_or_zero"}, - {"initialqueryid", "initial_query_id"}, - {"toyearweek", "to_year_week"}, - {"detectlanguagemixed", "detect_language_mixed"}, - {"h3line", "h3_line"}, - {"atanh", "atanh"}, - {"wordshingleminhashutf8", "word_shingle_min_hash_utf8"}, - {"toint32ornull", "to_int32_or_null"}, - {"simplejsonextractuint", "simple_json_extract_uint"}, - {"h3hexring", "h3_hex_ring"}, - {"todecimal256", "to_decimal256"}, - {"ngramsearch", "ngram_search"}, - {"arraydifference", "array_difference"}, - {"arraypushback", "array_push_back"}, - {"h3unidirectionaledgeisvalid", "h3_unidirectional_edge_is_valid"}, - {"arraystringconcat", "array_string_concat"}, - {"repeat", "repeat"}, - {"stem", "stem"}, - {"totypename", "to_type_name"}, - {"todatetime64ornull", "to_datetime64_or_null"}, - {"reversednsquery", "reverse_dns_query"}, - {"splitbynonalpha", "split_by_non_alpha"}, - {"ignore", "ignore"}, - {"tostartofnanosecond", "to_start_of_nanosecond"}, - {"bittest", "bit_test"}, - {"tointervalhour", "to_interval_hour"}, - {"h3toparent", "h3_to_parent"}, - {"buildid", "build_id"}, - {"multisearchfirstposition", "multi_search_first_position"}, - {"dictgetuint64", "dict_get_uint64"}, - {"h3hexareakm2", "h3_hex_area_km2"}, - {"h3kring", "h3k_ring"}, - {"toint8ornull", "to_int8_or_null"}, - {"hypot", "hypot"}, - {"kostikconsistenthash", "kostik_consistent_hash"}, - {"globalnotnullinignoreset", "global_not_null_in_ignore_set"}, - {"detectlanguage", "detect_language"}, - {"tupleelement", "tuple_element"}, - {"notnullinignoreset", "not_null_in_ignore_set"}, - {"h3exactedgelengthrads", "h3_exact_edge_length_rads"}, - {"globalnotinignoreset", "global_not_in_ignore_set"}, - {"globalinignoreset", "global_in_ignore_set"}, - {"subtractmonths", "subtract_months"}, - {"inignoreset", "in_ignore_set"}, - {"bitshiftleft", "bit_shift_left"}, - {"notnullin", "not_null_in"}, - {"globalnullin", "global_null_in"}, - {"globalnotin", "global_not_in"}, - {"bitmaptransform", "bitmap_transform"}, - {"parsetimedelta", "parse_time_delta"}, - {"extractkeyvaluepairs", "extract_key_value_pairs"}, - {"in", "in"}, - {"h3getbasecell", "h3_get_base_cell"}, - {"errorcodetoname", "error_code_to_name"}, - {"randomfixedstring", "random_fixed_string"}, - {"tofloat32orzero", "to_float32_or_zero"}, - {"acos", "acos"}, - {"isconstant", "is_constant"}, - {"countsubstringscaseinsensitive", "count_substrings_case_insensitive"}, - {"emptyarraytosingle", "empty_array_to_single"}, - {"isipv6string", "is_ipv6_string"}, - {"addnanoseconds", "add_nanoseconds"}, - {"monotonic", "monotonic"}, - {"randexponential", "rand_exponential"}, - {"extractkeyvaluepairswithescaping", "extract_key_value_pairs_with_escaping"}, - {"polygonsunionspherical", "polygons_union_spherical"}, - {"polygonsunioncartesian", "polygons_union_cartesian"}, - {"isnullable", "is_nullable"}, - {"iszeroornull", "is_zero_or_null"}, - {"macstringtonum", "mac_string_to_num"}, - {"leftpadutf8", "left_pad_utf8"}, - {"lagbehind", "lag_behind"}, - {"multifuzzymatchanyindex", "multi_fuzzy_match_any_index"}, - {"lemmatize", "lemmatize"}, - {"isdecimaloverflow", "is_decimal_overflow"}, - {"multisearchallpositionscaseinsensitiveutf8", "multi_search_all_positions_case_insensitive_utf8"}, - {"lengthutf8", "length_utf8"}, - {"h3hexaream2", "h3_hex_area_m2"}, - {"tobool", "to_bool"}, - {"lessorequals", "less_or_equals"}, - {"multiplydecimal", "multiply_decimal"}, - {"wkt", "wkt"}, - {"filesystemunreserved", "filesystem_unreserved"}, - {"randnormal", "rand_normal"}, - {"abs", "abs"}, - {"and", "and"}, - {"arraymap", "array_map"}, - {"log1p", "log1p"}, - {"fromunixtimestamp64nano", "from_unix_timestamp64_nano"}, - {"todecimal32ordefault", "to_decimal32_or_default"}, - {"todatetime64ordefault", "to_datetime64_or_default"}, - {"greatcircledistance", "great_circle_distance"}, - {"reinterpretasfixedstring", "reinterpret_as_fixed_string"}, - {"dotproduct", "dot_product"}, - {"touint256orzero", "to_uint256_or_zero"}, - {"jsonextractfloat", "json_extract_float"}, - {"tofloat64ordefault", "to_float64_or_default"}, - {"toint256ordefault", "to_int256_or_default"}, - {"tuplenegate", "tuple_negate"}, - {"arrayflatten", "array_flatten"}, - {"materialize", "materialize"}, - {"toint8ordefault", "to_int8_or_default"}, - {"tostartofminute", "to_start_of_minute"}, - {"extract", "extract"}, - {"touint64ordefault", "to_uint64_or_default"}, - {"arrayenumerateuniq", "array_enumerate_uniq"}, - {"svg", "svg"}, - {"bitmaphasall", "bitmap_has_all"}, - {"h3ispentagon", "h3_is_pentagon"}, - {"mapupdate", "map_update"}, - {"proportionsztest", "proportions_ztest"}, - {"base58encode", "base58_encode"}, - {"h3isvalid", "h3_is_valid"}, - {"bitmasktolist", "bitmask_to_list"}, - {"mapvalues", "map_values"}, - {"positioncaseinsensitive", "position_case_insensitive"}, - {"mapcontains", "map_contains"}, - {"meilimatch", "meili_match"}, - {"snowflaketodatetime", "snowflake_to_datetime"}, - {"multisearchfirstpositioncaseinsensitive", "multi_search_first_position_case_insensitive"}, - {"minsamplesizeconversion", "min_sample_size_conversion"}, - {"divide", "divide"}, - {"modulolegacy", "modulo_legacy"}, - {"tojsonstring", "to_json_string"}, - {"isinfinite", "is_infinite"}, - {"mortondecode", "morton_decode"}, - {"enabledprofiles", "enabled_profiles"}, - {"grok", "grok"}, - {"mortonencode", "morton_encode"}, - {"randomprintableascii", "random_printable_ascii"}, - {"todatetimeordefault", "to_datetime_or_default"}, - {"timeslot", "time_slot"}, - {"formatreadabletimedelta", "format_readable_time_delta"}, - {"s2rectadd", "s2_rect_add"}, - {"runningaccumulate", "running_accumulate"}, - {"hasthreadfuzzer", "has_thread_fuzzer"}, - {"appendtrailingcharifabsent", "append_trailing_char_if_absent"}, - {"bitboolmaskor", "__bit_bool_mask_or"}, - {"multifuzzymatchany", "multi_fuzzy_match_any"}, - {"torelativeweeknum", "to_relative_week_num"}, - {"dictgethierarchy", "dict_get_hierarchy"}, - {"aesencryptmysql", "aes_encrypt_mysql"}, - {"intdivorzero", "int_div_or_zero"}, - {"rightpadutf8", "right_pad_utf8"}, - {"reverseutf8", "reverse_utf8"}, - {"leftpad", "left_pad"}, - {"translateutf8", "translate_utf8"}, - {"multimatchanyindex", "multi_match_any_index"}, - {"todecimal64ornull", "to_decimal64_or_null"}, - {"arrayfirstornull", "array_first_or_null"}, - {"addmonths", "add_months"}, - {"timeslots", "time_slots"}, - {"toipv4ordefault", "to_ipv4_or_default"}, - {"joinget", "join_get"}, - {"base64decode", "base64_decode"}, - {"atan2", "atan2"}, - {"toint16ordefault", "to_int16_or_default"}, - {"lpdistance", "lp_distance"}, - {"normalizeutf8nfkd", "normalize_utf8_nfkd"}, - {"multisearchallpositions", "multi_search_all_positions"}, - {"dictgetuint8", "dict_get_uint8"}, - {"accuratecastordefault", "accurate_cast_or_default"}, - {"file", "file"}, - {"normalizeutf8nfkc", "normalize_utf8_nfkc"}, - {"arraypushfront", "array_push_front"}, - {"normalizeutf8nfc", "normalize_utf8_nfc"}, - {"mapkeys", "map_keys"}, - {"todatetimeornull", "to_datetime_or_null"}, - {"encrypt", "encrypt"}, - {"arrayauc", "array_auc"}, - {"tostartofmonth", "to_start_of_month"}, - {"siphash64", "sip_hash64"}, - {"arrayelement", "array_element"}, - {"bitor", "bit_or"}, - {"formatdatetime", "format_datetime"}, - {"simplejsonextractraw", "simple_json_extract_raw"}, - {"subtractseconds", "subtract_seconds"}, - {"addresstosymbol", "address_to_symbol"}, - {"emitversion", "emit_version"}, - {"tostring", "to_string"}, - {"makedate32", "make_date32"}, - {"simplejsonextractbool", "simple_json_extract_bool"}, - {"bittestall", "bit_test_all"}, - {"reinterpretasdate", "reinterpret_as_date"}, - {"getoskernelversion", "get_os_kernel_version"}, - {"arraycount", "array_count"}, - {"evalmlmethod", "eval_ml_method"}, - {"addminutes", "add_minutes"}, - {"sin", "sin"}, - {"positioncaseinsensitiveutf8", "position_case_insensitive_utf8"}, - {"multisearchfirstindexcaseinsensitiveutf8", "multi_search_first_index_case_insensitive_utf8"}, - {"mapcast", "map_cast"}, - {"todatetime64orzero", "to_datetime64_or_zero"}, - {"timediff", "time_diff"}, - {"has", "has"}, - {"base64encode", "base64_encode"}, - {"s2rectcontains", "s2_rect_contains"}, - {"negate", "negate"}, - {"intdiv", "int_div"}, - {"lags", "lags"}, - {"replaceall", "replace_all"}, - {"farmhash64", "farm_hash64"}, - {"rightpad", "right_pad"}, - {"subtractweeks", "subtract_weeks"}, - {"totimezone", "to_timezone"}, - {"currentroles", "current_roles"}, - {"bin", "bin"}, - {"h3edgelengthkm", "h3_edge_length_km"}, - {"today", "today"}, - {"match", "match"}, - {"torelativemonthnum", "to_relative_month_num"}, - {"ngramminhashcaseinsensitiveutf8", "ngram_min_hash_case_insensitive_utf8"}, - {"arraycumsum", "array_cum_sum"}, - {"arrayfirst", "array_first"}, - {"emptyarraydatetime", "empty_array_datetime"}, - {"regiontotopcontinent", "region_to_top_continent"}, - {"globalnullinignoreset", "global_null_in_ignore_set"}, - {"emptyarraydate", "empty_array_date"}, - {"emptyarrayfloat64", "empty_array_float64"}, - {"h3getunidirectionaledgesfromhexagon", "h3_get_unidirectional_edges_from_hexagon"}, - {"emptyarrayfloat32", "empty_array_float32"}, - {"atan", "atan"}, - {"md4", "md4"}, - {"queryid", "query_id"}, - {"emptyarrayuint64", "empty_array_uint64"}, - {"now", "now"}, - {"subtractdays", "subtract_days"}, - {"json_query", "json_query"}, - {"todatetime32", "to_datetime32"}, - {"nullif", "null_if"}, - {"bitand", "bit_and"}, - {"ngramminhasharg", "ngram_min_hash_arg"}, - {"boottime", "boot_time"}, - {"torelativedaynum", "to_relative_day_num"}, - {"left", "left"}, - {"asin", "asin"}, - {"tosecond", "to_second"}, - {"roundtoexp2", "round_to_exp2"}, - {"parsedatetime", "parse_datetime"}, - {"readwktmultipolygon", "read_wkt_multi_polygon"}, - {"arrayenumerate", "array_enumerate"}, - {"plus", "plus"}, - {"dictgetint8ordefault", "dict_get_int8_or_default"}, - {"reinterpretasint128", "reinterpret_as_int128"}, - {"arrayconcat", "array_concat"}, - {"h3pointdistm", "h3_point_dist_m"}, - {"parsedatetime32besteffort", "parse_datetime32_best_effort"}, - {"randconstant", "rand_constant"}, - {"cityhash64", "city_hash64"}, - {"pointinellipses", "point_in_ellipses"}, - {"toconcretetype", "to_concrete_type"}, - {"murmurhash264", "murmur_hash2_64"}, - {"nullin", "null_in"}, - {"toint16orzero", "to_int16_or_zero"}, - {"multifuzzymatchallindices", "multi_fuzzy_match_all_indices"}, - {"polygonareaspherical", "polygon_area_spherical"}, - {"dictgetdate", "dict_get_date"}, - {"dictgetint64", "dict_get_int64"}, - {"e", "e"}, - {"bitwrapperfunc", "__bit_wrapper_func"}, - {"roundage", "round_age"}, - {"polygonperimeterspherical", "polygon_perimeter_spherical"}, - {"lgamma", "lgamma"}, - {"throwif", "throw_if"}, - {"h3pointdistkm", "h3_point_dist_km"}, - {"h3isresclassiii", "h3_is_res_class_iii"}, - {"randstudentt", "rand_student_t"}, - {"polygonsintersectionspherical", "polygons_intersection_spherical"}, - {"arraymax", "array_max"}, - {"serveruuid", "server_uuid"}, - {"polygonssymdifferencespherical", "polygons_sym_difference_spherical"}, - {"polygonssymdifferencecartesian", "polygons_sym_difference_cartesian"}, - {"polygonswithinspherical", "polygons_within_spherical"}, - {"tostartoffiveminutes", "to_start_of_five_minutes"}, - {"reinterpretasint32", "reinterpret_as_int32"}, - {"todecimal64ordefault", "to_decimal64_or_default"}, - {"arrayresize", "array_resize"}, - {"joingetornull", "join_get_or_null"}, - {"encodexmlcomponent", "encode_xml_component"}, - {"polygonsintersectioncartesian", "polygons_intersection_cartesian"}, - {"pow", "pow"}, - {"decrypt", "decrypt"}, - {"emptyarrayint64", "empty_array_int64"}, - {"addweeks", "add_weeks"}, - {"streamingneighbor", "__streaming_neighbor"}, - {"addtupleofintervals", "add_tuple_of_intervals"}, - {"toquarter", "to_quarter"}, - {"yesterday", "yesterday"}, - {"todateornull", "to_date_or_null"}, - {"positionutf8", "position_utf8"}, - {"getscalar", "__get_scalar"}, - {"ilike", "ilike"}, - {"touint256ordefault", "to_uint256_or_default"}, - {"ngramsearchcaseinsensitiveutf8", "ngram_search_case_insensitive_utf8"}, - {"subtracthours", "subtract_hours"}, - {"wordshingleminhashcaseinsensitiveutf8", "word_shingle_min_hash_case_insensitive_utf8"}, - {"pointinpolygon", "point_in_polygon"}, - {"dictgetuint8ordefault", "dict_get_uint8_or_default"}, - {"ngramsearchutf8", "ngram_search_utf8"}, - {"nullinignoreset", "null_in_ignore_set"}, - {"todayofmonth", "to_day_of_month"}, - {"mapadd", "map_add"}, - {"randpoisson", "rand_poisson"}, - {"randnegativebinomial", "rand_negative_binomial"}, - {"uuidnumtostring", "uuid_num_to_string"}, - {"convertcharset", "convert_charset"}, - {"randbinomial", "rand_binomial"}, - {"todecimal256ordefault", "to_decimal256_or_default"}, - {"randbernoulli", "rand_bernoulli"}, - {"randfisherf", "rand_fisher_f"}, - {"h3tostring", "h3_to_string"}, - {"arrayall", "array_all"}, - {"blockserializedsize", "block_serialized_size"}, - {"randchisquared", "rand_chi_squared"}, - {"arrayenumeratedense", "array_enumerate_dense"}, - {"multisearchallpositionscaseinsensitive", "multi_search_all_positions_case_insensitive"}, - {"rand64", "rand64"}, - {"tofloat32ordefault", "to_float32_or_default"}, - {"radians", "radians"}, - {"multisearchanycaseinsensitive", "multi_search_any_case_insensitive"}, - {"emptyarrayint32", "empty_array_int32"}, - {"randuniform", "rand_uniform"}, - {"tominute", "to_minute"}, - {"log2", "log2"}, - {"mapapply", "map_apply"}, - {"tuplecast", "tuple_cast"}, - {"ipv4stringtonumornull", "ipv4_string_to_num_or_null"}, - {"randomstringutf8", "random_string_utf8"}, - {"parsedatetime32besteffortorzero", "parse_datetime32_best_effort_or_zero"}, - {"mapcontainskeylike", "map_contains_key_like"}, - {"arrayreversefill", "array_reverse_fill"}, - {"reinterpretasstring", "reinterpret_as_string"}, - {"reinterpretasuuid", "reinterpret_as_uuid"}, - {"uuid", "uuid"}, - {"bitmasktoarray", "bitmask_to_array"}, - {"tostartofmicrosecond", "to_start_of_microsecond"}, - {"tostartofhour", "to_start_of_hour"}, - {"normalizedqueryhash", "normalized_query_hash"}, - {"reinterpretasdatetime", "reinterpret_as_datetime"}, - {"tuplehammingdistance", "tuple_hamming_distance"}, - {"touint8ordefault", "to_uint8_or_default"}, - {"reinterpretasfloat64", "reinterpret_as_float64"}, - {"tocolumntypename", "to_column_type_name"}, - {"reinterpretasfloat32", "reinterpret_as_float32"}, - {"nowinblock", "now_in_block"}, - {"sigmoid", "sigmoid"}, - {"format", "format"}, - {"emptyarrayint16", "empty_array_int16"}, - {"replaceregexpone", "replace_regexp_one"}, - {"reinterpretasint256", "reinterpret_as_int256"}, - {"fromunixtimestamp64micro", "from_unix_timestamp64_micro"}, - {"simplejsonextractstring", "simple_json_extract_string"}, - {"reinterpretasint64", "reinterpret_as_int64"}, - {"bitmaptoarray", "bitmap_to_array"}, - {"normalizedqueryhashkeepnames", "normalized_query_hash_keep_names"}, - {"reinterpretasint16", "reinterpret_as_int16"}, - {"xor", "xor"}, - {"addinterval", "add_interval"}, - {"reinterpretasuint128", "reinterpret_as_uint128"}, - {"intexp10", "int_exp10"}, - {"touint16ordefault", "to_uint16_or_default"}, - {"notin", "not_in"}, - {"randomstring", "random_string"}, - {"dicthas", "dict_has"}, - {"mapsubtract", "map_subtract"}, - {"linfnormalize", "linf_normalize"}, - {"hasany", "has_any"}, - {"tohour", "to_hour"}, - {"readwktpolygon", "read_wkt_polygon"}, - {"reinterpretasuint32", "reinterpret_as_uint32"}, - {"wordshingleminhashargcaseinsensitive", "word_shingle_min_hash_arg_case_insensitive"}, - {"simplejsonextractfloat", "simple_json_extract_float"}, - {"filesystemavailable", "filesystem_available"}, - {"readwktring", "read_wkt_ring"}, - {"addmilliseconds", "add_milliseconds"}, - {"cosinedistance", "cosine_distance"}, - {"minsamplesizecontinous", "min_sample_size_continous"}, - {"regexpquotemeta", "regexp_quote_meta"}, - {"emptyarrayuint32", "empty_array_uint32"}, - {"parsedatetimebesteffort", "parse_datetime_best_effort"}, - {"uptime", "uptime"}, - {"arraysort", "array_sort"}, - {"l1normalize", "l1_normalize"}, - {"arraydistinct", "array_distinct"}, - {"addquarters", "add_quarters"}, - {"ifnotfinite", "if_not_finite"}, - {"equals", "equals"}, - {"ifnull", "if_null"}, - {"regiontoarea", "region_to_area"}, - {"arrayjaccardindex", "array_jaccard_index"}, - {"right", "right"}, - {"dictgetall", "dict_get_all"}, - {"notequals", "not_equals"}, - {"s2capunion", "s2_cap_union"}, - {"factorial", "factorial"}, - {"tofloat32", "to_float32"}, - {"arraymin", "array_min"}, - {"h3getunidirectionaledgeboundary", "h3_get_unidirectional_edge_boundary"}, - {"multisearchfirstindexcaseinsensitive", "multi_search_first_index_case_insensitive"}, - {"revision", "revision"}, - {"visiblewidth", "visible_width"}, - {"synonyms", "synonyms"}, - {"randlognormal", "rand_log_normal"}, - {"multisearchfirstpositionutf8", "multi_search_first_position_utf8"}, - {"globalin", "global_in"}, - {"erf", "erf"}, - {"arraypopback", "array_pop_back"}, - {"s2rectunion", "s2_rect_union"}, - {"timezone", "timezone"}, - {"countequal", "count_equal"}, - {"isfinite", "is_finite"}, - {"emptyarrayint8", "empty_array_int8"}, - {"normalizequerykeepnames", "normalize_query_keep_names"}, - {"arrayexists", "array_exists"}, - {"shardnum", "shard_num"}, - {"hassubstr", "has_substr"}, - {"streamingnow", "__streaming_now"}, - {"touint16orzero", "to_uint16_or_zero"}, - {"multisearchfirstpositioncaseinsensitiveutf8", "multi_search_first_position_case_insensitive_utf8"}, - {"dictgetipv4", "dict_get_ipv4"}, - {"replaceregexpall", "replace_regexp_all"}, - {"like", "like"}, - {"tostartofmillisecond", "to_start_of_millisecond"}, - {"fromunixtimestampinjodasyntax", "from_unix_timestamp_in_joda_syntax"}, - {"tostartoffifteenminutes", "to_start_of_fifteen_minutes"}, - {"ngramdistanceutf8", "ngram_distance_utf8"}, - {"min2", "min2"}, - {"tostartofweek", "to_start_of_week"}, - {"toint32orzero", "to_int32_or_zero"}, - {"length", "length"}, - {"lpnorm", "lp_norm"}, - {"linfnorm", "linf_norm"}, - {"datetime64tosnowflake", "datetime64_to_snowflake"}, - {"touint128ornull", "to_uint128_or_null"}, - {"tupleminus", "tuple_minus"}, - {"validatenestedarraysizes", "validate_nested_array_sizes"}, - {"reinterpretasint8", "reinterpret_as_int8"}, - {"tolastdayofmonth", "to_last_day_of_month"}, - {"sign", "sign"}, - {"upper", "upper"}, - {"arrayintersect", "array_intersect"}, - {"notempty", "not_empty"}, - {"arraysplit", "array_split"}, - {"dictgetordefault", "dict_get_or_default"}, - {"tointervalday", "to_interval_day"}, - {"substringutf8", "substring_utf8"}, - {"parsedatetimebesteffortornull", "parse_datetime_best_effort_or_null"}, - {"toint256orzero", "to_int256_or_zero"}, - {"casewithexpr", "case_with_expr"}, - {"tanh", "tanh"}, - {"tostringcuttozero", "to_string_cut_to_zero"}, - {"arraywithconstant", "array_with_constant"}, - {"murmurhash232", "murmur_hash2_32"}, - {"erfc", "erfc"}, - {"frommodifiedjuliandayornull", "from_modified_julian_day_or_null"}, - {"replaceone", "replace_one"}, - {"multisearchallpositionsutf8", "multi_search_all_positions_utf8"}, - {"asinh", "asinh"}, - {"detecttonality", "detect_tonality"}, - {"bitxor", "bit_xor"}, - {"timezoneof", "timezone_of"}, - {"greaterorequals", "greater_or_equals"}, - {"jsonextractuint", "json_extract_uint"}, - {"h3getfaces", "h3_get_faces"}, - {"notinignoreset", "not_in_ignore_set"}, - {"jsonextractarray", "json_extract_array"}, - {"ngramminhashcaseinsensitive", "ngram_min_hash_case_insensitive"}, - {"arrayreduce", "array_reduce"}, - {"todayofyear", "to_day_of_year"}, - {"l2squarednorm", "l2_squared_norm"}, - {"h3tocenterchild", "h3_to_center_child"}, - {"tounixtimestamp", "to_unix_timestamp"}, - {"toint128ordefault", "to_int128_or_default"}, - {"degrees", "degrees"}, - {"tostartofyear", "to_start_of_year"}, - {"toisoweek", "to_iso_week"}, - {"regiontopopulation", "region_to_population"}, - {"geotos2", "geo_to_s2"}, - {"max2", "max2"}, - {"upperutf8", "upper_utf8"}, - {"torelativeminutenum", "to_relative_minute_num"}, - {"tolowcardinality", "to_low_cardinality"}, - {"parsedatetime64besteffortornull", "parse_datetime64_best_effort_or_null"}, - {"tounixtimestamp64milli", "to_unix_timestamp64_milli"}, - {"hostname", "hostname"}, - {"tomodifiedjuliandayornull", "to_modified_julian_day_or_null"}, - {"multiply", "multiply"}, - {"dictgetuint16ordefault", "dict_get_uint16_or_default"}, - {"splitbystring", "split_by_string"}, - {"pi", "pi"}, - {"version", "version"}, - {"linfdistance", "linf_distance"}, - {"torelativehournum", "to_relative_hour_num"}, - {"datediffwithin", "date_diff_within"}, - {"datediff", "date_diff"}, - {"toint64ordefault", "to_int64_or_default"}, - {"tounixtimestamp64nano", "to_unix_timestamp64_nano"}, - {"emptyarrayuint8", "empty_array_uint8"}, - {"multimatchallindices", "multi_match_all_indices"}, - {"toyyyymmddhhmmss", "to_yyyymmddhhmmss"}, - {"to_yyyymmddhhmmss", "to_yyyymmddhhmmss"}, - {"toint128orzero", "to_int128_or_zero"}, - {"tovalidutf8", "to_valid_utf8"}, - {"polygonswithincartesian", "polygons_within_cartesian"}, - {"arrayzip", "array_zip"}, - {"torelativeyearnum", "to_relative_year_num"}, - {"ngramsimhash", "ngram_sim_hash"}, - {"isipaddressinrange", "is_ip_address_in_range"}, - {"exp2", "exp2"}, - {"tcpport", "tcp_port"}, - {"arraylastornull", "array_last_or_null"}, - {"transform", "transform"}, - {"bitmapcontains", "bitmap_contains"}, - {"reinterpretasuint256", "reinterpret_as_uint256"}, - {"toipv6", "to_ipv6"}, - {"subtractmicroseconds", "subtract_microseconds"}, - {"defaultroles", "default_roles"}, - {"lag", "lag"}, - {"mapfilter", "map_filter"}, - {"bitmapcardinality", "bitmap_cardinality"}, - {"toyyyymmdd", "to_yyyymmdd"}, - {"to_yyyymmdd", "to_yyyymmdd"}, - {"lpnormalize", "lp_normalize"}, - {"l2squareddistance", "l2_squared_distance"}, - {"readwktpoint", "read_wkt_point"}, - {"trimboth", "trim_both"}, - {"s2rectintersection", "s2_rect_intersection"}, - {"greatest", "greatest"}, - {"l1distance", "l1_distance"}, - {"neighbor", "neighbor"}, - {"arrayreversesort", "array_reverse_sort"}, - {"trydecrypt", "try_decrypt"}, - {"tupledividebynumber", "tuple_divide_by_number"}, - {"touint64ornull", "to_uint64_or_null"}, - {"defaultvalueoftypename", "default_value_of_type_name"}, - {"h3distance", "h3_distance"}, - {"tgamma", "tgamma"}, - {"s2getneighbors", "s2_get_neighbors"}, - {"tupledivide", "tuple_divide"}, - {"arrayfirstindex", "array_first_index"}, - {"toint32ordefault", "to_int32_or_default"}, - {"addresstoline", "address_to_line"}, - {"assumenotnull", "assume_not_null"}, - {"simplejsonhas", "simple_json_has"}, - {"arrayjoin", "array_join"}, - {"bitmapandnotcardinality", "bitmap_andnot_cardinality"}, - {"detectprogramminglanguage", "detect_programming_language"}, - {"bitmapxor", "bitmap_xor"}, - {"gettypeserializationstreams", "get_type_serialization_streams"}, - {"reinterpretasuint8", "reinterpret_as_uint8"}, - {"timezoneoffset", "timezone_offset"}, - {"filesystemcapacity", "filesystem_capacity"}, - {"arraycast", "array_cast"}, - {"touint32ordefault", "to_uint32_or_default"}, - {"startswith", "starts_with"}, - {"tofloat", "to_float"}, - {"notilike", "not_ilike"}, - {"ngramdistance", "ngram_distance"}, - {"totime", "to_time"}, - {"multisearchanyutf8", "multi_search_any_utf8"}, - {"ngramdistancecaseinsensitive", "ngram_distance_case_insensitive"}, - {"ngramsearchcaseinsensitive", "ngram_search_case_insensitive"}, - {"arraycumsumnonnegative", "array_cum_sum_non_negative"}, - {"globalvariable", "global_variable"}, - {"tointervalweek", "to_interval_week"}, - {"indexof", "index_of"}, - {"translate", "translate"}, - {"h3numhexagons", "h3_num_hexagons"}, - {"sinh", "sinh"}, - {"parsedatetimeinjodasyntax", "parse_datetime_in_joda_syntax"}, - {"tointervalnanosecond", "to_interval_nanosecond"}, - {"extractall", "extract_all"}, - {"empty", "empty"}, - {"simplejsonextractint", "simple_json_extract_int"}, - {"todatetime", "to_datetime"}, - {"bar", "bar"}, - {"h3togeo", "h3_to_geo"}, - {"indexhint", "index_hint"}, - {"date_trunc", "date_trunc"}, - {"date_add", "date_add"}, - {"date_sub", "date_sub"}, - {"uniqthetanot", "uniq_theta_not"}, - {"ceil", "ceil"}, - {"dictgetuuidordefault", "dict_get_uuid_or_default"}, - {"utctimestamp", "utc_timestamp"}, - {"arraylast", "array_last"}, - {"l2distance", "l2_distance"}, - {"wordshingleminhash", "word_shingle_min_hash"}, - {"log10", "log10"}, - {"mappopulateseries", "map_populate_series"}, - {"todecimal256ornull", "to_decimal256_or_null"}, - {"arrayenumerateuniqranked", "array_enumerate_uniq_ranked"}, - {"makedatetime", "make_datetime"}, - {"shardcount", "shard_count"}, - {"h3cellarearads2", "h3_cell_area_rads2"}, - {"arrayfilter", "array_filter"}, - {"subtracttupleofintervals", "subtract_tuple_of_intervals"}, - {"bitnot", "bit_not"}, - {"jsonextractkeys", "json_extract_keys"}, - {"addresstolinewithinlines", "address_to_line_with_inlines"}, - {"l2norm", "l2_norm"}, - {"uniqthetaintersect", "uniq_theta_intersect"}, - {"hasall", "has_all"}, - {"reinterpretasuint64", "reinterpret_as_uint64"}, - {"tofixedstring", "to_fixed_string"}, - {"emptyarrayuint16", "empty_array_uint16"}, - {"tostartofinterval", "to_start_of_interval"}, - {"tostartofisoyear", "to_start_of_iso_year"}, - {"h3getindexesfromunidirectionaledge", "h3_get_indexes_from_unidirectional_edge"}, - {"arraypopfront", "array_pop_front"}, - {"reinterpretasuint16", "reinterpret_as_uint16"}, - {"dictgetipv6", "dict_get_ipv6"}, - {"arrayreversesplit", "array_reverse_split"}, - {"dictgetdescendants", "dict_get_descendants"}, - {"crc64", "crc64"}, - {"least", "least"}, - {"crc32ieee", "crc32_ieee"}, - {"todate32ordefault", "to_date32_or_default"}, - {"arrayavg", "array_avg"}, - {"isnull", "is_null"}, - {"tomonday", "to_monday"}, - {"range", "range"}, - {"toyyyymm", "to_yyyymm"}, - {"to_yyyymm", "to_yyyymm"}, - {"splitbychar", "split_by_char"}, - {"polygonconvexhullcartesian", "polygon_convex_hull_cartesian"}, - {"tuplemultiply", "tuple_multiply"}, - {"tupletonamevaluepairs", "tuple_to_name_value_pairs"}, - {"touuidordefault", "to_uuid_or_default"}, - {"greater", "greater"}, - {"arrayuniq", "array_uniq"}, - {"less", "less"}, - {"sha256", "sha256"}, - {"bittestany", "bit_test_any"}, - {"arrayreverse", "array_reverse"}, - {"earliesttimestamp", "earliest_timestamp"}, - {"tounixtimestamp64micro", "to_unix_timestamp64_micro"}, - {"arrayfill", "array_fill"}, - {"arrayproduct", "array_product"}, - /// case_insensitive_aggregate_functions - {"uniqueretract", "__unique_retract"}, - {"groupuniqarrayretract", "group_uniq_array_retract"}, - {"minkretract", "__min_k_retract"}, - {"maxkretract", "__max_k_retract"}, - {"minretract", "__min_retract"}, - {"maxretract", "__max_retract"}, - {"sumretract", "__sum_retract"}, - {"exponentialtimedecayedcount", "exponential_time_decayed_count"}, - {"denserank", "dense_rank"}, - {"rank", "rank"}, - {"exponentialmovingaverage", "exponential_moving_average"}, - {"intervallengthsum", "interval_length_sum"}, - {"singlevalueornull", "single_value_or_null"}, - {"nothing", "nothing"}, - {"meanztest", "mean_ztest"}, - {"rankcorr", "rank_corr"}, - {"categoricalinformationvalue", "categorical_information_value"}, - {"sumkahanretract", "__sum_kahan_retract"}, - {"grouparraymovingavg", "group_array_moving_avg"}, - {"grouparraymovingsum", "group_array_moving_sum"}, - {"simplelinearregression", "simple_linear_regression"}, - {"entropy", "entropy"}, - {"exponentialtimedecayedsum", "exponential_time_decayed_sum"}, - {"retention", "retention"}, - {"histogram", "histogram"}, - {"uniqueexactretract", "__unique_exact_retract"}, - {"stochasticlogisticregression", "stochastic_logistic_regression"}, - {"groupbitmapxor", "group_bitmap_xor"}, - {"groupbitmapor", "group_bitmap_or"}, - {"groupbitmap", "group_bitmap"}, - {"cramersvbiascorrected", "cramers_v_bias_corrected"}, - {"cramersv", "cramers_v"}, - {"grouparray", "group_array"}, - {"p99", "p99"}, - {"anyheavy", "any_heavy"}, - {"groupbitand", "group_bit_and"}, - {"sparkbar", "sparkbar"}, - {"groupbitor", "group_bit_or"}, - {"leadinframe", "lead_in_frame"}, - {"deltasumtimestamp", "delta_sum_timestamp"}, - {"covarpop", "covar_pop"}, - {"topkexact", "top_k_exact"}, - {"p95", "p95"}, - {"approxtopksum", "approx_top_k_sum"}, - {"anylast", "any_last"}, - {"uniquecombined64", "unique_combined64"}, - {"quantilesexactexclusive", "quantiles_exact_exclusive"}, - {"uniquetheta", "unique_theta"}, - {"unique", "unique"}, - {"laginframe", "lag_in_frame"}, - {"summapfilteredwithoverflow", "sum_map_filtered_with_overflow"}, - {"quantilestdigest", "quantiles_t_digest"}, - {"uniquecombined", "unique_combined"}, - {"exponentialtimedecayedmax", "exponential_time_decayed_max"}, - {"minmappedarrays", "min_mapped_arrays"}, - {"maxk", "max_k"}, - {"summappedarrays", "sum_mapped_arrays"}, - {"corr", "corr"}, - {"mannwhitneyutest", "mann_whitney_utest"}, - {"stddevpop", "stddev_pop"}, - {"stddevsamp", "stddev_samp"}, - {"corrstable", "corr_stable"}, - {"avgretract", "__avg_retract"}, - {"covarsampstable", "covar_samp_stable"}, - {"stddevpopstable", "stddev_pop_stable"}, - {"maxintersections", "max_intersections"}, - {"kurtpop", "kurt_pop"}, - {"stddevsampstable", "stddev_samp_stable"}, - {"aggthrow", "agg_throw"}, - {"varsampstable", "var_samp_stable"}, - {"lastvalue", "last_value"}, - {"xirr", "xirr"}, - {"latest", "latest"}, - {"summapfiltered", "sum_map_filtered"}, - {"any", "any"}, - {"groupuniqarray", "group_uniq_array"}, - {"skewpop", "skew_pop"}, - {"max", "max"}, - {"analysisofvariance", "analysis_of_variance"}, - {"quantilebfloat16weighted", "quantile_b_float16_weighted"}, - {"countretract", "__count_retract"}, - {"groupbitxor", "group_bit_xor"}, - {"quantilesbfloat16", "quantiles_b_float16"}, - {"boundingratio", "bounding_ratio"}, - {"skewsamp", "skew_samp"}, - {"p90", "p90"}, - {"windowfunnel", "window_funnel"}, - {"quantilestdigestweighted", "quantiles_t_digest_weighted"}, - {"quantilebfloat16", "quantile_b_float16"}, - {"topkexactweighted", "top_k_exact_weighted"}, - {"quantiletdigestweighted", "quantile_t_digest_weighted"}, - {"welchttest", "welch_ttest"}, - {"quantiletdigest", "quantile_t_digest"}, - {"quantilestimingweighted", "quantiles_timing_weighted"}, - {"contingency", "contingency"}, - {"deltasum", "delta_sum"}, - {"topkweighted", "top_k_weighted"}, - {"quantiletimingweighted", "quantile_timing_weighted"}, - {"uniqueexact", "unique_exact"}, - {"quantiletiming", "quantile_timing"}, - {"quantilesexactinclusive", "quantiles_exact_inclusive"}, - {"studentttest", "student_ttest"}, - {"groupbitmapand", "group_bitmap_and"}, - {"sequencecount", "sequence_count"}, - {"avg", "avg"}, - {"rownumber", "row_number"}, - {"theilsu", "theils_u"}, - {"quantilesexacthigh", "quantiles_exact_high"}, - {"varpopstable", "var_pop_stable"}, - {"sumwithoverflow", "sum_with_overflow"}, - {"quantileexactweighted", "quantile_exact_weighted"}, - {"sequencenextnode", "sequence_next_node"}, - {"quantileexacthigh", "quantile_exact_high"}, - {"quantilesexactlow", "quantiles_exact_low"}, - {"quantilesexactweighted", "quantiles_exact_weighted"}, - {"quantilestiming", "quantiles_timing"}, - {"grouparraysample", "group_array_sample"}, - {"uniquehll12", "unique_hll12"}, - {"summapwithoverflow", "sum_map_with_overflow"}, - {"sumcount", "sum_count"}, - {"earliest", "earliest"}, - {"quantilesdeterministic", "quantiles_deterministic"}, - {"sumwithoverflowretract", "__sum_with_overflow_retract"}, - {"min", "min"}, - {"varpop", "var_pop"}, - {"quantileexactlow", "quantile_exact_low"}, - {"quantiles", "quantiles"}, - {"sum", "sum"}, - {"kurtsamp", "kurt_samp"}, - {"grouparrayinsertat", "group_array_insert_at"}, - {"quantilesexact", "quantiles_exact"}, - {"approxtopk", "approx_top_k"}, - {"exponentialtimedecayedavg", "exponential_time_decayed_avg"}, - {"firstvalue", "first_value"}, - {"quantileexact", "quantile_exact"}, - {"covarpopstable", "covar_pop_stable"}, - {"sequencematch", "sequence_match"}, - {"quantilesbfloat16weighted", "quantiles_b_float16_weighted"}, - {"uniqueupto", "unique_up_to"}, - {"largesttrianglethreebuckets", "largest_triangle_three_buckets"}, - {"quantile", "quantile"}, - {"covarsamp", "covar_samp"}, - {"varsamp", "var_samp"}, - {"quantiledeterministic", "quantile_deterministic"}, - {"quantileexactinclusive", "quantile_exact_inclusive"}, - {"maxintersectionsposition", "max_intersections_position"}, - {"maxmappedarrays", "max_mapped_arrays"}, - {"mink", "min_k"}, - {"quantileexactexclusive", "quantile_exact_exclusive"}, - {"sumkahan", "sum_kahan"}, - {"stochasticlinearregression", "stochastic_linear_regression"}, - {"count", "count"}, - {"topk", "top_k"}, - {"avgweighted", "avg_weighted"}}; - -String ParserFunction::functionNameFromCamelToSnake(const String & name) const -{ - auto it = function_map.find(name); - if (it != function_map.end()) - return it->second; - - String lower_name = Poco::toLower(name); - it = case_insensitive_function_map.find(lower_name); - if (it != case_insensitive_function_map.end()) - return it->second; - - return name; -} -/// proton: ends - bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ maybe_unused ]] bool hint) { ParserIdentifier id_parser; @@ -2068,12 +807,11 @@ bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ String function_name_lowercase = Poco::toLower(function_name); /// proton: starts - if (thread_local_is_clickhouse_compatible) + if (isClickHouseCompatibleMode()) { - String tmp_name = functionNameFromCamelToSnake(function_name); - function_name = tmp_name; - auto * tmpnode = dynamic_cast(identifier.get()); - tmpnode->setShortName(function_name); + function_name = functionNameFromCamelToSnake(function_name); + if (auto * identifier_p = dynamic_cast(identifier.get()); identifier_p) + identifier_p->setShortName(function_name); } /// proton: ends @@ -2144,7 +882,7 @@ bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ ParserExpressionList contents(false, is_table_function); const char * contents_begin = pos->begin; - /// proton: starts. support session range comparision expression for table function `session` + /// proton: starts. support session range comparison expression for table function `session` if (is_table_function && function_name == "session") { if (!ParserList( @@ -2192,7 +930,7 @@ bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ /// proton: starts /// First determine whether need to be compatible with ClickHouse. Timeplus does not allow the use of syntax such as quantile(0.9)(x). /// The parametric aggregate function has two lists (parameters and arguments) in parentheses. Example: quantile(0.9)(x). - if (thread_local_is_clickhouse_compatible && allow_function_parameters && pos->type == TokenType::OpeningRoundBracket) + if (isClickHouseCompatibleMode() && allow_function_parameters && pos->type == TokenType::OpeningRoundBracket) { ++pos; @@ -2238,10 +976,6 @@ bool ParserFunction::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ } /// proton: ends - /// proton: starts. - /// proton: don't support parametric aggregation function any more. - /// proton: ends. - auto function_node = std::make_shared(); tryGetIdentifierNameInto(identifier, function_node->name); diff --git a/src/Parsers/ExpressionElementParsers_ClickHouse.cpp b/src/Parsers/ExpressionElementParsers_ClickHouse.cpp new file mode 100644 index 00000000000..2a143e04587 --- /dev/null +++ b/src/Parsers/ExpressionElementParsers_ClickHouse.cpp @@ -0,0 +1,1261 @@ +#include +#include + +#include + +namespace DB +{ +namespace +{ +/// When Timeplus registers a new function, the new function needs to be added to one of the following two maps. +const std::unordered_map function_map + = {{"cast", "cast"}, + {"encodeURLComponent", "encode_url_component"}, + {"decodeURLComponent", "decode_url_component"}, + {"URLHierarchy", "url_hierarchy"}, + {"URLPathHierarchy", "url_path_hierarchy"}, + {"extractURLParameterNames", "extract_url_parameter_names"}, + {"extractURLParameters", "extract_url_parameters"}, + {"generateUUIDv4", "generate_uuidv4"}, + {"toYYYYMMDDhhmmss", "to_YYYYMMDDhhmmss"}, + {"toYYYYMM", "to_YYYYMM"}, + {"to_YYYYMM", "to_YYYYMM"}, + {"BLAKE3", "blake3"}, + {"connectionId", "connection_id"}, + {"countMatches", "count_matches"}, + {"countMatchesCaseInsensitive", "count_matches_case_insensitive"}, + {"dateName", "date_name"}, + {"displayName", "display_name"}, + {"formatReadableDecimalSize", "format_readable_decimal_size"}, + {"FQDN", "fqdn"}, + {"hasToken", "has_token"}, + {"leftUTF8", "left_utf8"}, + {"position", "position"}, + {"rightUTF8", "right_utf8"}, + {"roundBankers", "round_bankers"}, + {"starts", "starts"}, + {"structureToCapnProtoSchema", "structure_to_capn_proto_schema"}, + {"structureToProtobufSchema", "structure_to_protobuf_schema"}, + {"xxh3", "xxh3"}}; + +const std::unordered_map case_insensitive_function_map + /// case_insensitive_functions + = {{"bithammingdistance", "bit_hamming_distance"}, + {"polygonsdistancespherical", "polygons_distance_spherical"}, + {"polygonsdistancecartesian", "polygons_distance_cartesian"}, + {"fuzzbits", "fuzz_bits"}, + {"initializeaggregation", "initialize_aggregation"}, + {"extractgroups", "extract_groups"}, + {"tostartofsecond", "to_start_of_second"}, + {"randomintype", "random_in_type"}, + {"jsonvalues", "json_values"}, + {"jsonexists", "json_exists"}, + {"rand", "rand"}, + {"tointervalmonth", "to_interval_month"}, + {"tointervalminute", "to_interval_minute"}, + {"tointervalsecond", "to_interval_second"}, + {"tointervalmillisecond", "to_interval_millisecond"}, + {"tointervalmicrosecond", "to_interval_microsecond"}, + {"parsedatetime64besteffortusornull", "parse_datetime64_best_effort_us_or_null"}, + {"parsedatetime64besteffortorzero", "parse_datetime64_best_effort_or_zero"}, + {"parsedatetime64besteffort", "parse_datetime64_best_effort"}, + {"parsedatetime32besteffortornull", "parse_datetime32_best_effort_or_null"}, + {"parsedatetimebesteffortusorzero", "parse_datetime_best_effort_us_or_zero"}, + {"parsedatetimebesteffortus", "parse_datetime_best_effort_us"}, + {"toipv6ornull", "to_ipv6_or_null"}, + {"toipv4ornull", "to_ipv4_or_null"}, + {"touuidornull", "to_uuid_or_null"}, + {"todecimal32ornull", "to_decimal32_or_null"}, + {"todate32ornull", "to_date32_or_null"}, + {"tofloat64ornull", "to_float64_or_null"}, + {"tofloat32ornull", "to_float32_or_null"}, + {"toint256ornull", "to_int256_or_null"}, + {"toint128ornull", "to_int128_or_null"}, + {"toint64ornull", "to_int64_or_null"}, + {"toint16ornull", "to_int16_or_null"}, + {"touint256ornull", "to_uint256_or_null"}, + {"touint32ornull", "to_uint32_or_null"}, + {"touint16ornull", "to_uint16_or_null"}, + {"touint8ornull", "to_uint8_or_null"}, + {"toipv6orzero", "to_ipv6_or_zero"}, + {"toipv4orzero", "to_ipv4_or_zero"}, + {"touuidorzero", "to_uuid_or_zero"}, + {"todecimal128orzero", "to_decimal128_or_zero"}, + {"todecimal64orzero", "to_decimal64_or_zero"}, + {"todecimal32orzero", "to_decimal32_or_zero"}, + {"todatetimeorzero", "to_datetime_or_zero"}, + {"todate32orzero", "to_date32_or_zero"}, + {"tofloat64orzero", "to_float64_or_zero"}, + {"toint64orzero", "to_int64_or_zero"}, + {"toint8orzero", "to_int8_or_zero"}, + {"parsedatetimebesteffortorzero", "parse_datetime_best_effort_or_zero"}, + {"touint128orzero", "to_uint128_or_zero"}, + {"touint64orzero", "to_uint64_or_zero"}, + {"touint32orzero", "to_uint32_or_zero"}, + {"touint8orzero", "to_uint8_or_zero"}, + {"toipv4", "to_ipv4"}, + {"todatetime64", "to_datetime64"}, + {"todate", "to_date"}, + {"todate16", "to_date16"}, + {"todecimal128", "to_decimal128"}, + {"todecimal64", "to_decimal64"}, + {"todecimal32", "to_decimal32"}, + {"toint256", "to_int256"}, + {"toint128", "to_int128"}, + {"toint64", "to_int64"}, + {"toint32", "to_int32"}, + {"touint256", "to_uint256"}, + {"touint128", "to_uint128"}, + {"touint64", "to_uint64"}, + {"touint32", "to_uint32"}, + {"touint16", "to_uint16"}, + {"touint8", "to_uint8"}, + {"blocksize", "block_size"}, + {"isnotnull", "is_not_null"}, + {"rounddown", "round_down"}, + {"trunc", "trunc"}, + {"floor", "floor"}, + {"round", "round"}, + {"weakhash32", "weak_hash32"}, + {"wyhash64", "wy_hash64"}, + {"xxhash64", "xx_hash64"}, + {"xxhash32", "xx_hash32"}, + {"gccmurmurhash", "gcc_murmur_hash"}, + {"murmurhash3128", "murmur_hash3_128"}, + {"murmurhash364", "murmur_hash3_64"}, + {"todecimal256orzero", "to_decimal256_or_zero"}, + {"murmurhash332", "murmur_hash3_32"}, + {"hivehash", "hive_hash"}, + {"javahashutf16le", "java_hash_utf16_le"}, + {"javahash", "java_hash"}, + {"urlhash", "url_hash"}, + {"inthash64", "int_hash64"}, + {"inthash32", "int_hash32"}, + {"metrohash64", "metro_hash64"}, + {"farmfingerprint64", "farm_fingerprint64"}, + {"siphash128", "sip_hash128"}, + {"sha512", "sha512"}, + {"sha384", "sha384"}, + {"uuidstringtonum", "uuid_string_to_num"}, + {"sha224", "sha224"}, + {"sha1", "sha1"}, + {"todecimal", "to_decimal"}, + {"md5", "md5"}, + {"halfmd5", "half_md5"}, + {"lowcardinalityindices", "low_cardinality_indices"}, + {"logtrace", "log_trace"}, + {"edition", "edition"}, + {"stringtoh3", "string_to_h3"}, + {"toint16", "to_int16"}, + {"jsonextractkeysandvaluesraw", "json_extract_keys_and_values_raw"}, + {"jsonextractarrayraw", "json_extract_array_raw"}, + {"jsonextractraw", "json_extract_raw"}, + {"jsonextractkeysandvalues", "json_extract_keys_and_values"}, + {"jsonextract", "json_extract"}, + {"jsonextractstring", "json_extract_string"}, + {"jsonextractbool", "json_extract_bool"}, + {"jsonextractint", "json_extract_int"}, + {"jsontype", "json_type"}, + {"jsonlength", "json_length"}, + {"isvalidjson", "is_valid_json"}, + {"char", "char"}, + {"cbrt", "cbrt"}, + {"s2togeo", "s2_to_geo"}, + {"sleepeachrow", "sleep_each_row"}, + {"regiontoname", "region_to_name"}, + {"regionin", "region_in"}, + {"regiontocountry", "region_to_country"}, + {"regiontodistrict", "region_to_district"}, + {"adddays", "add_days"}, + {"countsubstringscaseinsensitiveutf8", "count_substrings_case_insensitive_utf8"}, + {"makedatetime64", "make_datetime64"}, + {"date", "date"}, + {"makedate", "make_date"}, + {"subtractnanoseconds", "subtract_nanoseconds"}, + {"ipv6stringtonumornull", "ipv6_string_to_num_or_null"}, + {"ipv6stringtonumordefault", "ipv6_string_to_num_or_default"}, + {"ipv6stringtonum", "ipv6_string_to_num"}, + {"ipv6numtostring", "ipv6_num_to_string"}, + {"ipv4stringtonumordefault", "ipv4_string_to_num_or_default"}, + {"ipv4stringtonum", "ipv4_string_to_num"}, + {"ipv4numtostringclassc", "ipv4_num_to_string_class_c"}, + {"isipv4string", "is_ipv4_string"}, + {"ipv4cidrtorange", "ipv4_cidr_to_range"}, + {"ipv6cidrtorange", "ipv6_cidr_to_range"}, + {"macstringtooui", "mac_string_to_oui"}, + {"macnumtostring", "mac_num_to_string"}, + {"ipv4toipv6", "ipv4_to_ipv6"}, + {"cutipv6", "cut_ipv6"}, + {"snowflaketodatetime64", "snowflake_to_datetime64"}, + {"subtractmilliseconds", "subtract_milliseconds"}, + {"getserverport", "get_server_port"}, + {"regiontocity", "region_to_city"}, + {"multisearchany", "multi_search_any"}, + {"bitmaphasany", "bitmap_has_any"}, + {"bitmapandnot", "bitmap_andnot"}, + {"parsedatetime64besteffortus", "parse_datetime64_best_effort_us"}, + {"bitmapand", "bitmap_and"}, + {"detectcharset", "detect_charset"}, + {"bitmapxorcardinality", "bitmap_xor_cardinality"}, + {"h3getpentagonindexes", "h3_get_pentagon_indexes"}, + {"arraylastindex", "array_last_index"}, + {"bitmaporcardinality", "bitmap_or_cardinality"}, + {"subbitmap", "sub_bitmap"}, + {"runningconcurrency", "running_concurrency"}, + {"bitmapsubsetlimit", "bitmap_subset_limit"}, + {"bitmapsubsetinrange", "bitmap_subset_in_range"}, + {"bitmapbuild", "bitmap_build"}, + {"extracttextfromhtml", "extract_text_from_html"}, + {"monthname", "month_name"}, + {"splitbyregexp", "split_by_regexp"}, + {"isnan", "is_nan"}, + {"geohashencode", "geohash_encode"}, + {"torelativequarternum", "to_relative_quarter_num"}, + {"or", "or"}, + {"dictgetchildren", "dict_get_children"}, + {"dictisin", "dict_is_in"}, + {"todecimal128ornull", "to_decimal128_or_null"}, + {"dictgetstringordefault", "dict_get_string_or_default"}, + {"dictgetipv6ordefault", "dict_get_ipv6_or_default"}, + {"dictgetdatetimeordefault", "dict_get_datetime_or_default"}, + {"datetimetosnowflake", "datetime_to_snowflake"}, + {"todateordefault", "to_date_or_default"}, + {"dictgetdateordefault", "dict_get_date_or_default"}, + {"dictgetfloat64ordefault", "dict_get_float64_or_default"}, + {"h3getresolution", "h3_get_resolution"}, + {"exp", "exp"}, + {"dictgetfloat32ordefault", "dict_get_float32_or_default"}, + {"addseconds", "add_seconds"}, + {"dictgetint64ordefault", "dict_get_int64_or_default"}, + {"toint", "to_int"}, + {"dictgetint16ordefault", "dict_get_int16_or_default"}, + {"dictgetuint64ordefault", "dict_get_uint64_or_default"}, + {"emptyarraystring", "empty_array_string"}, + {"dictgetuint32ordefault", "dict_get_uint32_or_default"}, + {"h3cellaream2", "h3_cell_area_m2"}, + {"date_diff", "date_diff"}, + {"dictgetstring", "dict_get_string"}, + {"dictgetuuid", "dict_get_uuid"}, + {"dictgetfloat64", "dict_get_float64"}, + {"tuplemultiplybynumber", "tuple_multiply_by_number"}, + {"tomonth", "to_month"}, + {"dictgetint16", "dict_get_int16"}, + {"dictgetint8", "dict_get_int8"}, + {"dictgetuint32", "dict_get_uint32"}, + {"multisearchanycaseinsensitiveutf8", "multi_search_any_case_insensitive_utf8"}, + {"cosh", "cosh"}, + {"dictgetuint16", "dict_get_uint16"}, + {"sleep", "sleep"}, + {"dictget", "dict_get"}, + {"replicate", "replicate"}, + {"tomodifiedjulianday", "to_modified_julian_day"}, + {"h3getunidirectionaledge", "h3_get_unidirectional_edge"}, + {"regiontocontinent", "region_to_continent"}, + {"hascolumnintable", "has_column_in_table"}, + {"detectlanguageunknown", "detect_language_unknown"}, + {"arrayslice", "array_slice"}, + {"todecimal128ordefault", "to_decimal128_or_default"}, + {"partitionid", "partition_id"}, + {"formatdatetimeinjodasyntax", "format_datetime_in_joda_syntax"}, + {"dictgetornull", "dict_get_or_null"}, + {"tostartofquarter", "to_start_of_quarter"}, + {"multisearchfirstindex", "multi_search_first_index"}, + {"bytesize", "byte_size"}, + {"geohashdecode", "geohash_decode"}, + {"polygonsequalscartesian", "polygons_equals_cartesian"}, + {"jsonkey", "json_key"}, + {"bitmapmax", "bitmap_max"}, + {"tid", "tid"}, + {"bitcount", "bit_count"}, + {"tointervalyear", "to_interval_year"}, + {"not", "not"}, + {"formatrow", "format_row"}, + {"arrayreduceinranges", "array_reduce_in_ranges"}, + {"addmicroseconds", "add_microseconds"}, + {"geotoh3", "geo_to_h3"}, + {"bitmapmin", "bitmap_min"}, + {"normalizequery", "normalize_query"}, + {"if", "if"}, + {"defaultprofiles", "default_profiles"}, + {"countsubstrings", "count_substrings"}, + {"ngramdistancecaseinsensitiveutf8", "ngram_distance_case_insensitive_utf8"}, + {"acosh", "acosh"}, + {"accuratecastornull", "accurate_cast_or_null"}, + {"h3indexesareneighbors", "h3_indexes_are_neighbors"}, + {"accuratecast", "accurate_cast"}, + {"cast", "cast"}, + {"notlike", "not_like"}, + {"aesdecryptmysql", "aes_decrypt_mysql"}, + {"toint8", "to_int8"}, + {"dictgetfloat32", "dict_get_float32"}, + {"arraycompact", "array_compact"}, + {"dictgetint32", "dict_get_int32"}, + {"bitslice", "bit_slice"}, + {"bitrotateright", "bit_rotate_right"}, + {"toweek", "to_week"}, + {"hashid", "hashid"}, + {"h3edgelengthm", "h3_edge_length_m"}, + {"bitshiftright", "bit_shift_right"}, + {"tan", "tan"}, + {"substring", "substring"}, + {"tostartofday", "to_start_of_day"}, + {"addhours", "add_hours"}, + {"ipv4numtostring", "ipv4_num_to_string"}, + {"randcanonical", "rand_canonical"}, + {"h3togeoboundary", "h3_to_geo_boundary"}, + {"blocknumber", "block_number"}, + {"l2normalize", "l2_normalize"}, + {"reverse", "reverse"}, + {"multisearchfirstindexutf8", "multi_search_first_index_utf8"}, + {"torelativesecondnum", "to_relative_second_num"}, + {"greatcircleangle", "great_circle_angle"}, + {"subtractyears", "subtract_years"}, + {"isvalidutf8", "is_valid_utf8"}, + {"arrayfold", "array_fold"}, + {"casewithexpression", "case_with_expression"}, + {"addyears", "add_years"}, + {"tointervalquarter", "to_interval_quarter"}, + {"tonullable", "to_nullable"}, + {"intexp2", "int_exp2"}, + {"wordshingleminhashargutf8", "word_shingle_min_hash_arg_utf8"}, + {"fromunixtimestamp", "from_unix_timestamp"}, + {"dictgetint32ordefault", "dict_get_int32_or_default"}, + {"wordshingleminhashcaseinsensitive", "word_shingle_min_hash_case_insensitive"}, + {"rownumberinblock", "row_number_in_block"}, + {"splitbywhitespace", "split_by_whitespace"}, + {"wordshingleminhasharg", "word_shingle_min_hash_arg"}, + {"s2capcontains", "s2_cap_contains"}, + {"ngramminhashargcaseinsensitiveutf8", "ngram_min_hash_arg_case_insensitive_utf8"}, + {"extractallgroupsvertical", "extract_all_groups_vertical"}, + {"globalnotnullin", "global_not_null_in"}, + {"ngramminhashargutf8", "ngram_min_hash_arg_utf8"}, + {"ngramminhashargcaseinsensitive", "ngram_min_hash_arg_case_insensitive"}, + {"ngramminhashutf8", "ngram_min_hash_utf8"}, + {"ngramminhash", "ngram_min_hash"}, + {"wordshinglesimhashutf8", "word_shingle_sim_hash_utf8"}, + {"jsonvalue", "json_value"}, + {"wordshinglesimhashcaseinsensitive", "word_shingle_sim_hash_case_insensitive"}, + {"getmacro", "get_macro"}, + {"wordshinglesimhash", "word_shingle_sim_hash"}, + {"ngramsimhashcaseinsensitiveutf8", "ngram_sim_hash_case_insensitive_utf8"}, + {"ngramsimhashutf8", "ngram_sim_hash_utf8"}, + {"wordshingleminhashargcaseinsensitiveutf8", "word_shingle_min_hash_arg_case_insensitive_utf8"}, + {"h3pointdistrads", "h3_point_dist_rads"}, + {"runningdifferencestartingwithfirstvalue", "running_difference_starting_with_first_value"}, + {"ngramsimhashcaseinsensitive", "ngram_sim_hash_case_insensitive"}, + {"base58decode", "base58_decode"}, + {"moduloorzero", "modulo_or_zero"}, + {"normalizeutf8nfd", "normalize_utf8_nfd"}, + {"currentdatabase", "current_database"}, + {"streamingnow64", "__streaming_now64"}, + {"identity", "identity"}, + {"ascii", "ascii"}, + {"currentprofiles", "current_profiles"}, + {"lowerutf8", "lower_utf8"}, + {"polygonperimetercartesian", "polygon_perimeter_cartesian"}, + {"positivemodulo", "positive_modulo"}, + {"bitpositionstoarray", "bit_positions_to_array"}, + {"dictgetipv4ordefault", "dict_get_ipv4_or_default"}, + {"jsonhas", "json_has"}, + {"currentuser", "current_user"}, + {"tofloat64", "to_float64"}, + {"age", "age"}, + {"regionhierarchy", "region_hierarchy"}, + {"reinterpret", "reinterpret"}, + {"todayofweek", "to_day_of_week"}, + {"unbin", "unbin"}, + {"h3edgeangle", "h3_edge_angle"}, + {"modulo", "modulo"}, + {"toipv6ordefault", "to_ipv6_or_default"}, + {"cos", "cos"}, + {"unhex", "unhex"}, + {"hex", "hex"}, + {"gcd", "gcd"}, + {"jumpconsistenthash", "jump_consistent_hash"}, + {"defaultvalueofargumenttype", "default_value_of_argument_type"}, + {"subtractminutes", "subtract_minutes"}, + {"frommodifiedjulianday", "from_modified_julian_day"}, + {"concat", "concat"}, + {"demangle", "demangle"}, + {"log", "log"}, + {"alphatokens", "alpha_tokens"}, + {"l1norm", "l1_norm"}, + {"dividedecimal", "divide_decimal"}, + {"h3tochildren", "h3_to_children"}, + {"fullhostname", "full_host_name"}, + {"getsetting", "get_setting"}, + {"bitboolmaskand", "__bit_bool_mask_and"}, + {"tupleplus", "tuple_plus"}, + {"minus", "minus"}, + {"sqrt", "sqrt"}, + {"casewithoutexpr", "case_without_expr"}, + {"bitrotateleft", "bit_rotate_left"}, + {"getsizeofenumtype", "get_size_of_enum_type"}, + {"endswith", "ends_with"}, + {"wordshinglesimhashcaseinsensitiveutf8", "word_shingle_sim_hash_case_insensitive_utf8"}, + {"streamingrownumber", "__streaming_row_number"}, + {"formatreadablesize", "format_readable_size"}, + {"countdigits", "count_digits"}, + {"subtractquarters", "subtract_quarters"}, + {"polygonareacartesian", "polygon_area_cartesian"}, + {"trybase58decode", "try_base58_decode"}, + {"exp10", "exp10"}, + {"bitswaplasttwo", "__bit_swap_last_two"}, + {"lowcardinalitykeys", "low_cardinality_keys"}, + {"subtractinterval", "subtract_interval"}, + {"finalizeaggregation", "finalize_aggregation"}, + {"trybase64decode", "try_base64_decode"}, + {"tokens", "tokens"}, + {"ngrams", "ngrams"}, + {"geohashesinbox", "geohashes_in_box"}, + {"runningdifference", "running_difference"}, + {"arrayenumeratedenseranked", "array_enumerate_dense_ranked"}, + {"flattentuple", "flatten_tuple"}, + {"bitmapor", "bitmap_or"}, + {"concatassumeinjective", "concat_assume_injective"}, + {"lcm", "lcm"}, + {"mapextractkeylike", "map_extract_key_like"}, + {"formatreadablequantity", "format_readable_quantity"}, + {"formatrownonewline", "format_row_no_newline"}, + {"casewithoutexpression", "case_without_expression"}, + {"multiif", "multi_if"}, + {"fromunixtimestamp64milli", "from_unix_timestamp64_milli"}, + {"hastokencaseinsensitive", "has_token_case_insensitive"}, + {"geodistance", "geo_distance"}, + {"h3getres0indexes", "h3_get_res0_indexes"}, + {"toyear", "to_year"}, + {"decodexmlcomponent", "decode_xml_component"}, + {"now64", "now64"}, + {"multimatchany", "multi_match_any"}, + {"h3exactedgelengthkm", "h3_exact_edge_length_km"}, + {"arraysum", "array_sum"}, + {"toisoyear", "to_iso_year"}, + {"enabledroles", "enabled_roles"}, + {"parsedatetimebesteffortusornull", "parse_datetime_best_effort_us_or_null"}, + {"tostartoftenminutes", "to_start_of_ten_minutes"}, + {"lower", "lower"}, + {"h3exactedgelengthm", "h3_exact_edge_length_m"}, + {"bitmapandcardinality", "bitmap_and_cardinality"}, + {"dictgetdatetime", "dict_get_datetime"}, + {"totime", "__to_time"}, + {"h3getdestinationindexfromunidirectionaledge", "h3_get_destination_index_from_unidirectional_edge"}, + {"roundduration", "round_duration"}, + {"h3getoriginindexfromunidirectionaledge", "h3_get_origin_index_from_unidirectional_edge"}, + {"crc32", "crc32"}, + {"trimright", "trim_right"}, + {"trimleft", "trim_left"}, + {"dumpcolumnstructure", "dump_column_structure"}, + {"touuid", "to_uuid"}, + {"extractallgroupshorizontal", "extract_all_groups_horizontal"}, + {"uniqthetaunion", "uniq_theta_union"}, + {"s2cellsintersect", "s2_cells_intersect"}, + {"coalesce", "coalesce"}, + {"todateorzero", "to_date_or_zero"}, + {"initialqueryid", "initial_query_id"}, + {"toyearweek", "to_year_week"}, + {"detectlanguagemixed", "detect_language_mixed"}, + {"h3line", "h3_line"}, + {"atanh", "atanh"}, + {"wordshingleminhashutf8", "word_shingle_min_hash_utf8"}, + {"toint32ornull", "to_int32_or_null"}, + {"simplejsonextractuint", "simple_json_extract_uint"}, + {"h3hexring", "h3_hex_ring"}, + {"todecimal256", "to_decimal256"}, + {"ngramsearch", "ngram_search"}, + {"arraydifference", "array_difference"}, + {"arraypushback", "array_push_back"}, + {"h3unidirectionaledgeisvalid", "h3_unidirectional_edge_is_valid"}, + {"arraystringconcat", "array_string_concat"}, + {"repeat", "repeat"}, + {"stem", "stem"}, + {"totypename", "to_type_name"}, + {"todatetime64ornull", "to_datetime64_or_null"}, + {"reversednsquery", "reverse_dns_query"}, + {"splitbynonalpha", "split_by_non_alpha"}, + {"ignore", "ignore"}, + {"tostartofnanosecond", "to_start_of_nanosecond"}, + {"bittest", "bit_test"}, + {"tointervalhour", "to_interval_hour"}, + {"h3toparent", "h3_to_parent"}, + {"buildid", "build_id"}, + {"multisearchfirstposition", "multi_search_first_position"}, + {"dictgetuint64", "dict_get_uint64"}, + {"h3hexareakm2", "h3_hex_area_km2"}, + {"h3kring", "h3k_ring"}, + {"toint8ornull", "to_int8_or_null"}, + {"hypot", "hypot"}, + {"kostikconsistenthash", "kostik_consistent_hash"}, + {"globalnotnullinignoreset", "global_not_null_in_ignore_set"}, + {"detectlanguage", "detect_language"}, + {"tupleelement", "tuple_element"}, + {"notnullinignoreset", "not_null_in_ignore_set"}, + {"h3exactedgelengthrads", "h3_exact_edge_length_rads"}, + {"globalnotinignoreset", "global_not_in_ignore_set"}, + {"globalinignoreset", "global_in_ignore_set"}, + {"subtractmonths", "subtract_months"}, + {"inignoreset", "in_ignore_set"}, + {"bitshiftleft", "bit_shift_left"}, + {"notnullin", "not_null_in"}, + {"globalnullin", "global_null_in"}, + {"globalnotin", "global_not_in"}, + {"bitmaptransform", "bitmap_transform"}, + {"parsetimedelta", "parse_time_delta"}, + {"extractkeyvaluepairs", "extract_key_value_pairs"}, + {"in", "in"}, + {"h3getbasecell", "h3_get_base_cell"}, + {"errorcodetoname", "error_code_to_name"}, + {"randomfixedstring", "random_fixed_string"}, + {"tofloat32orzero", "to_float32_or_zero"}, + {"acos", "acos"}, + {"isconstant", "is_constant"}, + {"countsubstringscaseinsensitive", "count_substrings_case_insensitive"}, + {"emptyarraytosingle", "empty_array_to_single"}, + {"isipv6string", "is_ipv6_string"}, + {"addnanoseconds", "add_nanoseconds"}, + {"monotonic", "monotonic"}, + {"randexponential", "rand_exponential"}, + {"extractkeyvaluepairswithescaping", "extract_key_value_pairs_with_escaping"}, + {"polygonsunionspherical", "polygons_union_spherical"}, + {"polygonsunioncartesian", "polygons_union_cartesian"}, + {"isnullable", "is_nullable"}, + {"iszeroornull", "is_zero_or_null"}, + {"macstringtonum", "mac_string_to_num"}, + {"leftpadutf8", "left_pad_utf8"}, + {"lagbehind", "lag_behind"}, + {"multifuzzymatchanyindex", "multi_fuzzy_match_any_index"}, + {"lemmatize", "lemmatize"}, + {"isdecimaloverflow", "is_decimal_overflow"}, + {"multisearchallpositionscaseinsensitiveutf8", "multi_search_all_positions_case_insensitive_utf8"}, + {"lengthutf8", "length_utf8"}, + {"h3hexaream2", "h3_hex_area_m2"}, + {"tobool", "to_bool"}, + {"lessorequals", "less_or_equals"}, + {"multiplydecimal", "multiply_decimal"}, + {"wkt", "wkt"}, + {"filesystemunreserved", "filesystem_unreserved"}, + {"randnormal", "rand_normal"}, + {"abs", "abs"}, + {"and", "and"}, + {"arraymap", "array_map"}, + {"log1p", "log1p"}, + {"fromunixtimestamp64nano", "from_unix_timestamp64_nano"}, + {"todecimal32ordefault", "to_decimal32_or_default"}, + {"todatetime64ordefault", "to_datetime64_or_default"}, + {"greatcircledistance", "great_circle_distance"}, + {"reinterpretasfixedstring", "reinterpret_as_fixed_string"}, + {"dotproduct", "dot_product"}, + {"touint256orzero", "to_uint256_or_zero"}, + {"jsonextractfloat", "json_extract_float"}, + {"tofloat64ordefault", "to_float64_or_default"}, + {"toint256ordefault", "to_int256_or_default"}, + {"tuplenegate", "tuple_negate"}, + {"arrayflatten", "array_flatten"}, + {"materialize", "materialize"}, + {"toint8ordefault", "to_int8_or_default"}, + {"tostartofminute", "to_start_of_minute"}, + {"extract", "extract"}, + {"touint64ordefault", "to_uint64_or_default"}, + {"arrayenumerateuniq", "array_enumerate_uniq"}, + {"svg", "svg"}, + {"bitmaphasall", "bitmap_has_all"}, + {"h3ispentagon", "h3_is_pentagon"}, + {"mapupdate", "map_update"}, + {"proportionsztest", "proportions_ztest"}, + {"base58encode", "base58_encode"}, + {"h3isvalid", "h3_is_valid"}, + {"bitmasktolist", "bitmask_to_list"}, + {"mapvalues", "map_values"}, + {"positioncaseinsensitive", "position_case_insensitive"}, + {"mapcontains", "map_contains"}, + {"meilimatch", "meili_match"}, + {"snowflaketodatetime", "snowflake_to_datetime"}, + {"multisearchfirstpositioncaseinsensitive", "multi_search_first_position_case_insensitive"}, + {"minsamplesizeconversion", "min_sample_size_conversion"}, + {"divide", "divide"}, + {"modulolegacy", "modulo_legacy"}, + {"tojsonstring", "to_json_string"}, + {"isinfinite", "is_infinite"}, + {"mortondecode", "morton_decode"}, + {"enabledprofiles", "enabled_profiles"}, + {"grok", "grok"}, + {"mortonencode", "morton_encode"}, + {"randomprintableascii", "random_printable_ascii"}, + {"todatetimeordefault", "to_datetime_or_default"}, + {"timeslot", "time_slot"}, + {"formatreadabletimedelta", "format_readable_time_delta"}, + {"s2rectadd", "s2_rect_add"}, + {"runningaccumulate", "running_accumulate"}, + {"hasthreadfuzzer", "has_thread_fuzzer"}, + {"appendtrailingcharifabsent", "append_trailing_char_if_absent"}, + {"bitboolmaskor", "__bit_bool_mask_or"}, + {"multifuzzymatchany", "multi_fuzzy_match_any"}, + {"torelativeweeknum", "to_relative_week_num"}, + {"dictgethierarchy", "dict_get_hierarchy"}, + {"aesencryptmysql", "aes_encrypt_mysql"}, + {"intdivorzero", "int_div_or_zero"}, + {"rightpadutf8", "right_pad_utf8"}, + {"reverseutf8", "reverse_utf8"}, + {"leftpad", "left_pad"}, + {"translateutf8", "translate_utf8"}, + {"multimatchanyindex", "multi_match_any_index"}, + {"todecimal64ornull", "to_decimal64_or_null"}, + {"arrayfirstornull", "array_first_or_null"}, + {"addmonths", "add_months"}, + {"timeslots", "time_slots"}, + {"toipv4ordefault", "to_ipv4_or_default"}, + {"joinget", "join_get"}, + {"base64decode", "base64_decode"}, + {"atan2", "atan2"}, + {"toint16ordefault", "to_int16_or_default"}, + {"lpdistance", "lp_distance"}, + {"normalizeutf8nfkd", "normalize_utf8_nfkd"}, + {"multisearchallpositions", "multi_search_all_positions"}, + {"dictgetuint8", "dict_get_uint8"}, + {"accuratecastordefault", "accurate_cast_or_default"}, + {"file", "file"}, + {"normalizeutf8nfkc", "normalize_utf8_nfkc"}, + {"arraypushfront", "array_push_front"}, + {"normalizeutf8nfc", "normalize_utf8_nfc"}, + {"mapkeys", "map_keys"}, + {"todatetimeornull", "to_datetime_or_null"}, + {"encrypt", "encrypt"}, + {"arrayauc", "array_auc"}, + {"tostartofmonth", "to_start_of_month"}, + {"siphash64", "sip_hash64"}, + {"arrayelement", "array_element"}, + {"bitor", "bit_or"}, + {"formatdatetime", "format_datetime"}, + {"simplejsonextractraw", "simple_json_extract_raw"}, + {"subtractseconds", "subtract_seconds"}, + {"addresstosymbol", "address_to_symbol"}, + {"emitversion", "emit_version"}, + {"tostring", "to_string"}, + {"makedate32", "make_date32"}, + {"simplejsonextractbool", "simple_json_extract_bool"}, + {"bittestall", "bit_test_all"}, + {"reinterpretasdate", "reinterpret_as_date"}, + {"getoskernelversion", "get_os_kernel_version"}, + {"arraycount", "array_count"}, + {"evalmlmethod", "eval_ml_method"}, + {"addminutes", "add_minutes"}, + {"sin", "sin"}, + {"positioncaseinsensitiveutf8", "position_case_insensitive_utf8"}, + {"multisearchfirstindexcaseinsensitiveutf8", "multi_search_first_index_case_insensitive_utf8"}, + {"mapcast", "map_cast"}, + {"todatetime64orzero", "to_datetime64_or_zero"}, + {"timediff", "time_diff"}, + {"has", "has"}, + {"base64encode", "base64_encode"}, + {"s2rectcontains", "s2_rect_contains"}, + {"negate", "negate"}, + {"intdiv", "int_div"}, + {"lags", "lags"}, + {"replaceall", "replace_all"}, + {"farmhash64", "farm_hash64"}, + {"rightpad", "right_pad"}, + {"subtractweeks", "subtract_weeks"}, + {"totimezone", "to_timezone"}, + {"currentroles", "current_roles"}, + {"bin", "bin"}, + {"h3edgelengthkm", "h3_edge_length_km"}, + {"today", "today"}, + {"match", "match"}, + {"torelativemonthnum", "to_relative_month_num"}, + {"ngramminhashcaseinsensitiveutf8", "ngram_min_hash_case_insensitive_utf8"}, + {"arraycumsum", "array_cum_sum"}, + {"arrayfirst", "array_first"}, + {"emptyarraydatetime", "empty_array_datetime"}, + {"regiontotopcontinent", "region_to_top_continent"}, + {"globalnullinignoreset", "global_null_in_ignore_set"}, + {"emptyarraydate", "empty_array_date"}, + {"emptyarrayfloat64", "empty_array_float64"}, + {"h3getunidirectionaledgesfromhexagon", "h3_get_unidirectional_edges_from_hexagon"}, + {"emptyarrayfloat32", "empty_array_float32"}, + {"atan", "atan"}, + {"md4", "md4"}, + {"queryid", "query_id"}, + {"emptyarrayuint64", "empty_array_uint64"}, + {"now", "now"}, + {"subtractdays", "subtract_days"}, + {"json_query", "json_query"}, + {"todatetime32", "to_datetime32"}, + {"nullif", "null_if"}, + {"bitand", "bit_and"}, + {"ngramminhasharg", "ngram_min_hash_arg"}, + {"boottime", "boot_time"}, + {"torelativedaynum", "to_relative_day_num"}, + {"left", "left"}, + {"asin", "asin"}, + {"tosecond", "to_second"}, + {"roundtoexp2", "round_to_exp2"}, + {"parsedatetime", "parse_datetime"}, + {"readwktmultipolygon", "read_wkt_multi_polygon"}, + {"arrayenumerate", "array_enumerate"}, + {"plus", "plus"}, + {"dictgetint8ordefault", "dict_get_int8_or_default"}, + {"reinterpretasint128", "reinterpret_as_int128"}, + {"arrayconcat", "array_concat"}, + {"h3pointdistm", "h3_point_dist_m"}, + {"parsedatetime32besteffort", "parse_datetime32_best_effort"}, + {"randconstant", "rand_constant"}, + {"cityhash64", "city_hash64"}, + {"pointinellipses", "point_in_ellipses"}, + {"toconcretetype", "to_concrete_type"}, + {"murmurhash264", "murmur_hash2_64"}, + {"nullin", "null_in"}, + {"toint16orzero", "to_int16_or_zero"}, + {"multifuzzymatchallindices", "multi_fuzzy_match_all_indices"}, + {"polygonareaspherical", "polygon_area_spherical"}, + {"dictgetdate", "dict_get_date"}, + {"dictgetint64", "dict_get_int64"}, + {"e", "e"}, + {"bitwrapperfunc", "__bit_wrapper_func"}, + {"roundage", "round_age"}, + {"polygonperimeterspherical", "polygon_perimeter_spherical"}, + {"lgamma", "lgamma"}, + {"throwif", "throw_if"}, + {"h3pointdistkm", "h3_point_dist_km"}, + {"h3isresclassiii", "h3_is_res_class_iii"}, + {"randstudentt", "rand_student_t"}, + {"polygonsintersectionspherical", "polygons_intersection_spherical"}, + {"arraymax", "array_max"}, + {"serveruuid", "server_uuid"}, + {"polygonssymdifferencespherical", "polygons_sym_difference_spherical"}, + {"polygonssymdifferencecartesian", "polygons_sym_difference_cartesian"}, + {"polygonswithinspherical", "polygons_within_spherical"}, + {"tostartoffiveminutes", "to_start_of_five_minutes"}, + {"reinterpretasint32", "reinterpret_as_int32"}, + {"todecimal64ordefault", "to_decimal64_or_default"}, + {"arrayresize", "array_resize"}, + {"joingetornull", "join_get_or_null"}, + {"encodexmlcomponent", "encode_xml_component"}, + {"polygonsintersectioncartesian", "polygons_intersection_cartesian"}, + {"pow", "pow"}, + {"decrypt", "decrypt"}, + {"emptyarrayint64", "empty_array_int64"}, + {"addweeks", "add_weeks"}, + {"streamingneighbor", "__streaming_neighbor"}, + {"addtupleofintervals", "add_tuple_of_intervals"}, + {"toquarter", "to_quarter"}, + {"yesterday", "yesterday"}, + {"todateornull", "to_date_or_null"}, + {"positionutf8", "position_utf8"}, + {"getscalar", "__get_scalar"}, + {"ilike", "ilike"}, + {"touint256ordefault", "to_uint256_or_default"}, + {"ngramsearchcaseinsensitiveutf8", "ngram_search_case_insensitive_utf8"}, + {"subtracthours", "subtract_hours"}, + {"wordshingleminhashcaseinsensitiveutf8", "word_shingle_min_hash_case_insensitive_utf8"}, + {"pointinpolygon", "point_in_polygon"}, + {"dictgetuint8ordefault", "dict_get_uint8_or_default"}, + {"ngramsearchutf8", "ngram_search_utf8"}, + {"nullinignoreset", "null_in_ignore_set"}, + {"todayofmonth", "to_day_of_month"}, + {"mapadd", "map_add"}, + {"randpoisson", "rand_poisson"}, + {"randnegativebinomial", "rand_negative_binomial"}, + {"uuidnumtostring", "uuid_num_to_string"}, + {"convertcharset", "convert_charset"}, + {"randbinomial", "rand_binomial"}, + {"todecimal256ordefault", "to_decimal256_or_default"}, + {"randbernoulli", "rand_bernoulli"}, + {"randfisherf", "rand_fisher_f"}, + {"h3tostring", "h3_to_string"}, + {"arrayall", "array_all"}, + {"blockserializedsize", "block_serialized_size"}, + {"randchisquared", "rand_chi_squared"}, + {"arrayenumeratedense", "array_enumerate_dense"}, + {"multisearchallpositionscaseinsensitive", "multi_search_all_positions_case_insensitive"}, + {"rand64", "rand64"}, + {"tofloat32ordefault", "to_float32_or_default"}, + {"radians", "radians"}, + {"multisearchanycaseinsensitive", "multi_search_any_case_insensitive"}, + {"emptyarrayint32", "empty_array_int32"}, + {"randuniform", "rand_uniform"}, + {"tominute", "to_minute"}, + {"log2", "log2"}, + {"mapapply", "map_apply"}, + {"tuplecast", "tuple_cast"}, + {"ipv4stringtonumornull", "ipv4_string_to_num_or_null"}, + {"randomstringutf8", "random_string_utf8"}, + {"parsedatetime32besteffortorzero", "parse_datetime32_best_effort_or_zero"}, + {"mapcontainskeylike", "map_contains_key_like"}, + {"arrayreversefill", "array_reverse_fill"}, + {"reinterpretasstring", "reinterpret_as_string"}, + {"reinterpretasuuid", "reinterpret_as_uuid"}, + {"uuid", "uuid"}, + {"bitmasktoarray", "bitmask_to_array"}, + {"tostartofmicrosecond", "to_start_of_microsecond"}, + {"tostartofhour", "to_start_of_hour"}, + {"normalizedqueryhash", "normalized_query_hash"}, + {"reinterpretasdatetime", "reinterpret_as_datetime"}, + {"tuplehammingdistance", "tuple_hamming_distance"}, + {"touint8ordefault", "to_uint8_or_default"}, + {"reinterpretasfloat64", "reinterpret_as_float64"}, + {"tocolumntypename", "to_column_type_name"}, + {"reinterpretasfloat32", "reinterpret_as_float32"}, + {"nowinblock", "now_in_block"}, + {"sigmoid", "sigmoid"}, + {"format", "format"}, + {"emptyarrayint16", "empty_array_int16"}, + {"replaceregexpone", "replace_regexp_one"}, + {"reinterpretasint256", "reinterpret_as_int256"}, + {"fromunixtimestamp64micro", "from_unix_timestamp64_micro"}, + {"simplejsonextractstring", "simple_json_extract_string"}, + {"reinterpretasint64", "reinterpret_as_int64"}, + {"bitmaptoarray", "bitmap_to_array"}, + {"normalizedqueryhashkeepnames", "normalized_query_hash_keep_names"}, + {"reinterpretasint16", "reinterpret_as_int16"}, + {"xor", "xor"}, + {"addinterval", "add_interval"}, + {"reinterpretasuint128", "reinterpret_as_uint128"}, + {"intexp10", "int_exp10"}, + {"touint16ordefault", "to_uint16_or_default"}, + {"notin", "not_in"}, + {"randomstring", "random_string"}, + {"dicthas", "dict_has"}, + {"mapsubtract", "map_subtract"}, + {"linfnormalize", "linf_normalize"}, + {"hasany", "has_any"}, + {"tohour", "to_hour"}, + {"readwktpolygon", "read_wkt_polygon"}, + {"reinterpretasuint32", "reinterpret_as_uint32"}, + {"wordshingleminhashargcaseinsensitive", "word_shingle_min_hash_arg_case_insensitive"}, + {"simplejsonextractfloat", "simple_json_extract_float"}, + {"filesystemavailable", "filesystem_available"}, + {"readwktring", "read_wkt_ring"}, + {"addmilliseconds", "add_milliseconds"}, + {"cosinedistance", "cosine_distance"}, + {"minsamplesizecontinous", "min_sample_size_continous"}, + {"regexpquotemeta", "regexp_quote_meta"}, + {"emptyarrayuint32", "empty_array_uint32"}, + {"parsedatetimebesteffort", "parse_datetime_best_effort"}, + {"uptime", "uptime"}, + {"arraysort", "array_sort"}, + {"l1normalize", "l1_normalize"}, + {"arraydistinct", "array_distinct"}, + {"addquarters", "add_quarters"}, + {"ifnotfinite", "if_not_finite"}, + {"equals", "equals"}, + {"ifnull", "if_null"}, + {"regiontoarea", "region_to_area"}, + {"arrayjaccardindex", "array_jaccard_index"}, + {"right", "right"}, + {"dictgetall", "dict_get_all"}, + {"notequals", "not_equals"}, + {"s2capunion", "s2_cap_union"}, + {"factorial", "factorial"}, + {"tofloat32", "to_float32"}, + {"arraymin", "array_min"}, + {"h3getunidirectionaledgeboundary", "h3_get_unidirectional_edge_boundary"}, + {"multisearchfirstindexcaseinsensitive", "multi_search_first_index_case_insensitive"}, + {"revision", "revision"}, + {"visiblewidth", "visible_width"}, + {"synonyms", "synonyms"}, + {"randlognormal", "rand_log_normal"}, + {"multisearchfirstpositionutf8", "multi_search_first_position_utf8"}, + {"globalin", "global_in"}, + {"erf", "erf"}, + {"arraypopback", "array_pop_back"}, + {"s2rectunion", "s2_rect_union"}, + {"timezone", "timezone"}, + {"countequal", "count_equal"}, + {"isfinite", "is_finite"}, + {"emptyarrayint8", "empty_array_int8"}, + {"normalizequerykeepnames", "normalize_query_keep_names"}, + {"arrayexists", "array_exists"}, + {"shardnum", "shard_num"}, + {"hassubstr", "has_substr"}, + {"streamingnow", "__streaming_now"}, + {"touint16orzero", "to_uint16_or_zero"}, + {"multisearchfirstpositioncaseinsensitiveutf8", "multi_search_first_position_case_insensitive_utf8"}, + {"dictgetipv4", "dict_get_ipv4"}, + {"replaceregexpall", "replace_regexp_all"}, + {"like", "like"}, + {"tostartofmillisecond", "to_start_of_millisecond"}, + {"fromunixtimestampinjodasyntax", "from_unix_timestamp_in_joda_syntax"}, + {"tostartoffifteenminutes", "to_start_of_fifteen_minutes"}, + {"ngramdistanceutf8", "ngram_distance_utf8"}, + {"min2", "min2"}, + {"tostartofweek", "to_start_of_week"}, + {"toint32orzero", "to_int32_or_zero"}, + {"length", "length"}, + {"lpnorm", "lp_norm"}, + {"linfnorm", "linf_norm"}, + {"datetime64tosnowflake", "datetime64_to_snowflake"}, + {"touint128ornull", "to_uint128_or_null"}, + {"tupleminus", "tuple_minus"}, + {"validatenestedarraysizes", "validate_nested_array_sizes"}, + {"reinterpretasint8", "reinterpret_as_int8"}, + {"tolastdayofmonth", "to_last_day_of_month"}, + {"sign", "sign"}, + {"upper", "upper"}, + {"arrayintersect", "array_intersect"}, + {"notempty", "not_empty"}, + {"arraysplit", "array_split"}, + {"dictgetordefault", "dict_get_or_default"}, + {"tointervalday", "to_interval_day"}, + {"substringutf8", "substring_utf8"}, + {"parsedatetimebesteffortornull", "parse_datetime_best_effort_or_null"}, + {"toint256orzero", "to_int256_or_zero"}, + {"casewithexpr", "case_with_expr"}, + {"tanh", "tanh"}, + {"tostringcuttozero", "to_string_cut_to_zero"}, + {"arraywithconstant", "array_with_constant"}, + {"murmurhash232", "murmur_hash2_32"}, + {"erfc", "erfc"}, + {"frommodifiedjuliandayornull", "from_modified_julian_day_or_null"}, + {"replaceone", "replace_one"}, + {"multisearchallpositionsutf8", "multi_search_all_positions_utf8"}, + {"asinh", "asinh"}, + {"detecttonality", "detect_tonality"}, + {"bitxor", "bit_xor"}, + {"timezoneof", "timezone_of"}, + {"greaterorequals", "greater_or_equals"}, + {"jsonextractuint", "json_extract_uint"}, + {"h3getfaces", "h3_get_faces"}, + {"notinignoreset", "not_in_ignore_set"}, + {"jsonextractarray", "json_extract_array"}, + {"ngramminhashcaseinsensitive", "ngram_min_hash_case_insensitive"}, + {"arrayreduce", "array_reduce"}, + {"todayofyear", "to_day_of_year"}, + {"l2squarednorm", "l2_squared_norm"}, + {"h3tocenterchild", "h3_to_center_child"}, + {"tounixtimestamp", "to_unix_timestamp"}, + {"toint128ordefault", "to_int128_or_default"}, + {"degrees", "degrees"}, + {"tostartofyear", "to_start_of_year"}, + {"toisoweek", "to_iso_week"}, + {"regiontopopulation", "region_to_population"}, + {"geotos2", "geo_to_s2"}, + {"max2", "max2"}, + {"upperutf8", "upper_utf8"}, + {"torelativeminutenum", "to_relative_minute_num"}, + {"tolowcardinality", "to_low_cardinality"}, + {"parsedatetime64besteffortornull", "parse_datetime64_best_effort_or_null"}, + {"tounixtimestamp64milli", "to_unix_timestamp64_milli"}, + {"hostname", "hostname"}, + {"tomodifiedjuliandayornull", "to_modified_julian_day_or_null"}, + {"multiply", "multiply"}, + {"dictgetuint16ordefault", "dict_get_uint16_or_default"}, + {"splitbystring", "split_by_string"}, + {"pi", "pi"}, + {"version", "version"}, + {"linfdistance", "linf_distance"}, + {"torelativehournum", "to_relative_hour_num"}, + {"datediffwithin", "date_diff_within"}, + {"datediff", "date_diff"}, + {"toint64ordefault", "to_int64_or_default"}, + {"tounixtimestamp64nano", "to_unix_timestamp64_nano"}, + {"emptyarrayuint8", "empty_array_uint8"}, + {"multimatchallindices", "multi_match_all_indices"}, + {"toyyyymmddhhmmss", "to_yyyymmddhhmmss"}, + {"to_yyyymmddhhmmss", "to_yyyymmddhhmmss"}, + {"toint128orzero", "to_int128_or_zero"}, + {"tovalidutf8", "to_valid_utf8"}, + {"polygonswithincartesian", "polygons_within_cartesian"}, + {"arrayzip", "array_zip"}, + {"torelativeyearnum", "to_relative_year_num"}, + {"ngramsimhash", "ngram_sim_hash"}, + {"isipaddressinrange", "is_ip_address_in_range"}, + {"exp2", "exp2"}, + {"tcpport", "tcp_port"}, + {"arraylastornull", "array_last_or_null"}, + {"transform", "transform"}, + {"bitmapcontains", "bitmap_contains"}, + {"reinterpretasuint256", "reinterpret_as_uint256"}, + {"toipv6", "to_ipv6"}, + {"subtractmicroseconds", "subtract_microseconds"}, + {"defaultroles", "default_roles"}, + {"lag", "lag"}, + {"mapfilter", "map_filter"}, + {"bitmapcardinality", "bitmap_cardinality"}, + {"toyyyymmdd", "to_yyyymmdd"}, + {"to_yyyymmdd", "to_yyyymmdd"}, + {"lpnormalize", "lp_normalize"}, + {"l2squareddistance", "l2_squared_distance"}, + {"readwktpoint", "read_wkt_point"}, + {"trimboth", "trim_both"}, + {"s2rectintersection", "s2_rect_intersection"}, + {"greatest", "greatest"}, + {"l1distance", "l1_distance"}, + {"neighbor", "neighbor"}, + {"arrayreversesort", "array_reverse_sort"}, + {"trydecrypt", "try_decrypt"}, + {"tupledividebynumber", "tuple_divide_by_number"}, + {"touint64ornull", "to_uint64_or_null"}, + {"defaultvalueoftypename", "default_value_of_type_name"}, + {"h3distance", "h3_distance"}, + {"tgamma", "tgamma"}, + {"s2getneighbors", "s2_get_neighbors"}, + {"tupledivide", "tuple_divide"}, + {"arrayfirstindex", "array_first_index"}, + {"toint32ordefault", "to_int32_or_default"}, + {"addresstoline", "address_to_line"}, + {"assumenotnull", "assume_not_null"}, + {"simplejsonhas", "simple_json_has"}, + {"arrayjoin", "array_join"}, + {"bitmapandnotcardinality", "bitmap_andnot_cardinality"}, + {"detectprogramminglanguage", "detect_programming_language"}, + {"bitmapxor", "bitmap_xor"}, + {"gettypeserializationstreams", "get_type_serialization_streams"}, + {"reinterpretasuint8", "reinterpret_as_uint8"}, + {"timezoneoffset", "timezone_offset"}, + {"filesystemcapacity", "filesystem_capacity"}, + {"arraycast", "array_cast"}, + {"touint32ordefault", "to_uint32_or_default"}, + {"startswith", "starts_with"}, + {"tofloat", "to_float"}, + {"notilike", "not_ilike"}, + {"ngramdistance", "ngram_distance"}, + {"totime", "to_time"}, + {"multisearchanyutf8", "multi_search_any_utf8"}, + {"ngramdistancecaseinsensitive", "ngram_distance_case_insensitive"}, + {"ngramsearchcaseinsensitive", "ngram_search_case_insensitive"}, + {"arraycumsumnonnegative", "array_cum_sum_non_negative"}, + {"globalvariable", "global_variable"}, + {"tointervalweek", "to_interval_week"}, + {"indexof", "index_of"}, + {"translate", "translate"}, + {"h3numhexagons", "h3_num_hexagons"}, + {"sinh", "sinh"}, + {"parsedatetimeinjodasyntax", "parse_datetime_in_joda_syntax"}, + {"tointervalnanosecond", "to_interval_nanosecond"}, + {"extractall", "extract_all"}, + {"empty", "empty"}, + {"simplejsonextractint", "simple_json_extract_int"}, + {"todatetime", "to_datetime"}, + {"bar", "bar"}, + {"h3togeo", "h3_to_geo"}, + {"indexhint", "index_hint"}, + {"date_trunc", "date_trunc"}, + {"date_add", "date_add"}, + {"date_sub", "date_sub"}, + {"uniqthetanot", "uniq_theta_not"}, + {"ceil", "ceil"}, + {"dictgetuuidordefault", "dict_get_uuid_or_default"}, + {"utctimestamp", "utc_timestamp"}, + {"arraylast", "array_last"}, + {"l2distance", "l2_distance"}, + {"wordshingleminhash", "word_shingle_min_hash"}, + {"log10", "log10"}, + {"mappopulateseries", "map_populate_series"}, + {"todecimal256ornull", "to_decimal256_or_null"}, + {"arrayenumerateuniqranked", "array_enumerate_uniq_ranked"}, + {"makedatetime", "make_datetime"}, + {"shardcount", "shard_count"}, + {"h3cellarearads2", "h3_cell_area_rads2"}, + {"arrayfilter", "array_filter"}, + {"subtracttupleofintervals", "subtract_tuple_of_intervals"}, + {"bitnot", "bit_not"}, + {"jsonextractkeys", "json_extract_keys"}, + {"addresstolinewithinlines", "address_to_line_with_inlines"}, + {"l2norm", "l2_norm"}, + {"uniqthetaintersect", "uniq_theta_intersect"}, + {"hasall", "has_all"}, + {"reinterpretasuint64", "reinterpret_as_uint64"}, + {"tofixedstring", "to_fixed_string"}, + {"emptyarrayuint16", "empty_array_uint16"}, + {"tostartofinterval", "to_start_of_interval"}, + {"tostartofisoyear", "to_start_of_iso_year"}, + {"h3getindexesfromunidirectionaledge", "h3_get_indexes_from_unidirectional_edge"}, + {"arraypopfront", "array_pop_front"}, + {"reinterpretasuint16", "reinterpret_as_uint16"}, + {"dictgetipv6", "dict_get_ipv6"}, + {"arrayreversesplit", "array_reverse_split"}, + {"dictgetdescendants", "dict_get_descendants"}, + {"crc64", "crc64"}, + {"least", "least"}, + {"crc32ieee", "crc32_ieee"}, + {"todate32ordefault", "to_date32_or_default"}, + {"arrayavg", "array_avg"}, + {"isnull", "is_null"}, + {"tomonday", "to_monday"}, + {"range", "range"}, + {"toyyyymm", "to_yyyymm"}, + {"to_yyyymm", "to_yyyymm"}, + {"splitbychar", "split_by_char"}, + {"polygonconvexhullcartesian", "polygon_convex_hull_cartesian"}, + {"tuplemultiply", "tuple_multiply"}, + {"tupletonamevaluepairs", "tuple_to_name_value_pairs"}, + {"touuidordefault", "to_uuid_or_default"}, + {"greater", "greater"}, + {"arrayuniq", "array_uniq"}, + {"less", "less"}, + {"sha256", "sha256"}, + {"bittestany", "bit_test_any"}, + {"arrayreverse", "array_reverse"}, + {"earliesttimestamp", "earliest_timestamp"}, + {"tounixtimestamp64micro", "to_unix_timestamp64_micro"}, + {"arrayfill", "array_fill"}, + {"arrayproduct", "array_product"}, + /// case_insensitive_aggregate_functions + {"uniqueretract", "__unique_retract"}, + {"groupuniqarrayretract", "group_uniq_array_retract"}, + {"minkretract", "__min_k_retract"}, + {"maxkretract", "__max_k_retract"}, + {"minretract", "__min_retract"}, + {"maxretract", "__max_retract"}, + {"sumretract", "__sum_retract"}, + {"exponentialtimedecayedcount", "exponential_time_decayed_count"}, + {"denserank", "dense_rank"}, + {"rank", "rank"}, + {"exponentialmovingaverage", "exponential_moving_average"}, + {"intervallengthsum", "interval_length_sum"}, + {"singlevalueornull", "single_value_or_null"}, + {"nothing", "nothing"}, + {"meanztest", "mean_ztest"}, + {"rankcorr", "rank_corr"}, + {"categoricalinformationvalue", "categorical_information_value"}, + {"sumkahanretract", "__sum_kahan_retract"}, + {"grouparraymovingavg", "group_array_moving_avg"}, + {"grouparraymovingsum", "group_array_moving_sum"}, + {"simplelinearregression", "simple_linear_regression"}, + {"entropy", "entropy"}, + {"exponentialtimedecayedsum", "exponential_time_decayed_sum"}, + {"retention", "retention"}, + {"histogram", "histogram"}, + {"uniqueexactretract", "__unique_exact_retract"}, + {"stochasticlogisticregression", "stochastic_logistic_regression"}, + {"groupbitmapxor", "group_bitmap_xor"}, + {"groupbitmapor", "group_bitmap_or"}, + {"groupbitmap", "group_bitmap"}, + {"cramersvbiascorrected", "cramers_v_bias_corrected"}, + {"cramersv", "cramers_v"}, + {"grouparray", "group_array"}, + {"p99", "p99"}, + {"anyheavy", "any_heavy"}, + {"groupbitand", "group_bit_and"}, + {"sparkbar", "sparkbar"}, + {"groupbitor", "group_bit_or"}, + {"leadinframe", "lead_in_frame"}, + {"deltasumtimestamp", "delta_sum_timestamp"}, + {"covarpop", "covar_pop"}, + {"topkexact", "top_k_exact"}, + {"p95", "p95"}, + {"approxtopksum", "approx_top_k_sum"}, + {"anylast", "any_last"}, + {"uniquecombined64", "unique_combined64"}, + {"quantilesexactexclusive", "quantiles_exact_exclusive"}, + {"uniquetheta", "unique_theta"}, + {"unique", "unique"}, + {"laginframe", "lag_in_frame"}, + {"summapfilteredwithoverflow", "sum_map_filtered_with_overflow"}, + {"quantilestdigest", "quantiles_t_digest"}, + {"uniquecombined", "unique_combined"}, + {"exponentialtimedecayedmax", "exponential_time_decayed_max"}, + {"minmappedarrays", "min_mapped_arrays"}, + {"maxk", "max_k"}, + {"summappedarrays", "sum_mapped_arrays"}, + {"corr", "corr"}, + {"mannwhitneyutest", "mann_whitney_utest"}, + {"stddevpop", "stddev_pop"}, + {"stddevsamp", "stddev_samp"}, + {"corrstable", "corr_stable"}, + {"avgretract", "__avg_retract"}, + {"covarsampstable", "covar_samp_stable"}, + {"stddevpopstable", "stddev_pop_stable"}, + {"maxintersections", "max_intersections"}, + {"kurtpop", "kurt_pop"}, + {"stddevsampstable", "stddev_samp_stable"}, + {"aggthrow", "agg_throw"}, + {"varsampstable", "var_samp_stable"}, + {"lastvalue", "last_value"}, + {"xirr", "xirr"}, + {"latest", "latest"}, + {"summapfiltered", "sum_map_filtered"}, + {"any", "any"}, + {"groupuniqarray", "group_uniq_array"}, + {"skewpop", "skew_pop"}, + {"max", "max"}, + {"analysisofvariance", "analysis_of_variance"}, + {"quantilebfloat16weighted", "quantile_b_float16_weighted"}, + {"countretract", "__count_retract"}, + {"groupbitxor", "group_bit_xor"}, + {"quantilesbfloat16", "quantiles_b_float16"}, + {"boundingratio", "bounding_ratio"}, + {"skewsamp", "skew_samp"}, + {"p90", "p90"}, + {"windowfunnel", "window_funnel"}, + {"quantilestdigestweighted", "quantiles_t_digest_weighted"}, + {"quantilebfloat16", "quantile_b_float16"}, + {"topkexactweighted", "top_k_exact_weighted"}, + {"quantiletdigestweighted", "quantile_t_digest_weighted"}, + {"welchttest", "welch_ttest"}, + {"quantiletdigest", "quantile_t_digest"}, + {"quantilestimingweighted", "quantiles_timing_weighted"}, + {"contingency", "contingency"}, + {"deltasum", "delta_sum"}, + {"topkweighted", "top_k_weighted"}, + {"quantiletimingweighted", "quantile_timing_weighted"}, + {"uniqueexact", "unique_exact"}, + {"quantiletiming", "quantile_timing"}, + {"quantilesexactinclusive", "quantiles_exact_inclusive"}, + {"studentttest", "student_ttest"}, + {"groupbitmapand", "group_bitmap_and"}, + {"sequencecount", "sequence_count"}, + {"avg", "avg"}, + {"rownumber", "row_number"}, + {"theilsu", "theils_u"}, + {"quantilesexacthigh", "quantiles_exact_high"}, + {"varpopstable", "var_pop_stable"}, + {"sumwithoverflow", "sum_with_overflow"}, + {"quantileexactweighted", "quantile_exact_weighted"}, + {"sequencenextnode", "sequence_next_node"}, + {"quantileexacthigh", "quantile_exact_high"}, + {"quantilesexactlow", "quantiles_exact_low"}, + {"quantilesexactweighted", "quantiles_exact_weighted"}, + {"quantilestiming", "quantiles_timing"}, + {"grouparraysample", "group_array_sample"}, + {"uniquehll12", "unique_hll12"}, + {"summapwithoverflow", "sum_map_with_overflow"}, + {"sumcount", "sum_count"}, + {"earliest", "earliest"}, + {"quantilesdeterministic", "quantiles_deterministic"}, + {"sumwithoverflowretract", "__sum_with_overflow_retract"}, + {"min", "min"}, + {"varpop", "var_pop"}, + {"quantileexactlow", "quantile_exact_low"}, + {"quantiles", "quantiles"}, + {"sum", "sum"}, + {"kurtsamp", "kurt_samp"}, + {"grouparrayinsertat", "group_array_insert_at"}, + {"quantilesexact", "quantiles_exact"}, + {"approxtopk", "approx_top_k"}, + {"exponentialtimedecayedavg", "exponential_time_decayed_avg"}, + {"firstvalue", "first_value"}, + {"quantileexact", "quantile_exact"}, + {"covarpopstable", "covar_pop_stable"}, + {"sequencematch", "sequence_match"}, + {"quantilesbfloat16weighted", "quantiles_b_float16_weighted"}, + {"uniqueupto", "unique_up_to"}, + {"largesttrianglethreebuckets", "largest_triangle_three_buckets"}, + {"quantile", "quantile"}, + {"covarsamp", "covar_samp"}, + {"varsamp", "var_samp"}, + {"quantiledeterministic", "quantile_deterministic"}, + {"quantileexactinclusive", "quantile_exact_inclusive"}, + {"maxintersectionsposition", "max_intersections_position"}, + {"maxmappedarrays", "max_mapped_arrays"}, + {"mink", "min_k"}, + {"quantileexactexclusive", "quantile_exact_exclusive"}, + {"sumkahan", "sum_kahan"}, + {"stochasticlinearregression", "stochastic_linear_regression"}, + {"count", "count"}, + {"topk", "top_k"}, + {"avgweighted", "avg_weighted"}}; +} + +String ParserFunction::functionNameFromCamelToSnake(const String & name) const +{ + if (auto it = function_map.find(name); it != function_map.end()) + return it->second; + + String lower_name = Poco::toLower(name); + if (auto it = case_insensitive_function_map.find(lower_name); it != case_insensitive_function_map.end()) + return it->second; + + return name; +} + +} diff --git a/src/Parsers/ParserDataType.cpp b/src/Parsers/ParserDataType.cpp index bec373239ef..8484ad0d48a 100644 --- a/src/Parsers/ParserDataType.cpp +++ b/src/Parsers/ParserDataType.cpp @@ -5,8 +5,9 @@ #include #include #include + ///proton: starts -#include +#include ///proton: ends @@ -61,7 +62,7 @@ bool ParserDataType::parseImpl(Pos & pos, ASTPtr & node, Expected & expected, [[ tryGetIdentifierNameInto(identifier, type_name); /// proton: starts - if (thread_local_is_clickhouse_compatible) + if (isClickHouseCompatibleMode()) { String type_name_lower = Poco::toLower(type_name); /// There are special type that cannot be directly changed to lowercase and need handle specially. diff --git a/src/Parsers/tests/gtest_compatible_clickhouse_datatype_function.cpp b/src/Parsers/tests/gtest_compatible_clickhouse_datatype_function.cpp index 5bbbe1c604b..3282696d57e 100644 --- a/src/Parsers/tests/gtest_compatible_clickhouse_datatype_function.cpp +++ b/src/Parsers/tests/gtest_compatible_clickhouse_datatype_function.cpp @@ -6,7 +6,7 @@ #include #include -#include +#include #include @@ -15,7 +15,7 @@ using namespace DB; /// clickhouse datatype TEST(ParserDataTypeNameTest, TestDatatypeInt8) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Int8);"; ParserFunction parser; @@ -28,11 +28,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeInt8) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int8"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeUInt8) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS UInt8);"; ParserFunction parser; @@ -45,11 +46,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeUInt8) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint8"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeInt16) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Int16);"; ParserFunction parser; @@ -62,11 +64,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeInt16) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int16"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeUInt16) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS UInt16);"; ParserFunction parser; @@ -79,11 +82,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeUInt16) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint16"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeInt32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Int32);"; ParserFunction parser; @@ -96,11 +100,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeInt32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int32"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeUInt32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS UInt32);"; ParserFunction parser; @@ -113,11 +118,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeUInt32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint32"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeInt64) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Int64);"; ParserFunction parser; @@ -130,11 +136,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeInt64) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int64"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeUInt64) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS UInt64);"; ParserFunction parser; @@ -147,11 +154,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeUInt64) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint64"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeInt128) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Int128);"; ParserFunction parser; @@ -164,11 +172,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeInt128) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int128"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeUInt128) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS UInt128);"; ParserFunction parser; @@ -181,11 +190,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeUInt128) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint128"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeInt256) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Int256);"; ParserFunction parser; @@ -198,11 +208,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeInt256) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int256"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeUInt256) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS UInt256);"; ParserFunction parser; @@ -215,12 +226,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeUInt256) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint256"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeFloat32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Float32);"; ParserFunction parser; @@ -233,11 +244,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeFloat32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "float32"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeFloat64) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Float64);"; ParserFunction parser; @@ -250,12 +262,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeFloat64) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "float64"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeString) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS String);"; ParserFunction parser; @@ -268,12 +280,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeString) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "string"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeDate) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Date);"; ParserFunction parser; @@ -286,11 +298,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDate) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "date"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeDate32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Date32);"; ParserFunction parser; @@ -303,11 +316,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDate32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "date32"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeDateTime) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS DateTime);"; ParserFunction parser; @@ -320,12 +334,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDateTime) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "datetime"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeBool) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Bool);"; ParserFunction parser; @@ -338,12 +352,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeBool) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "bool"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeUUID) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS UUID);"; ParserFunction parser; @@ -356,12 +370,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeUUID) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uuid"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeIPv4) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS IPv4);"; ParserFunction parser; @@ -374,11 +388,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeIPv4) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "ipv4"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatypeIPv6) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS IPv6);"; ParserFunction parser; @@ -391,12 +406,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeIPv6) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "ipv6"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeJSON) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS JSON);"; ParserFunction parser; @@ -409,12 +424,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeJSON) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "json"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeNullable) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Nullable(String));"; ParserFunction parser; @@ -427,12 +442,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeNullable) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "nullable(string)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeDecimal) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Decimal(10, 3));"; ParserFunction parser; @@ -445,12 +460,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDecimal) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal(10, 3)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeDecimal32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Decimal32(3));"; ParserFunction parser; @@ -463,12 +478,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDecimal32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal32(3)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeDecimal64) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Decimal64(8));"; ParserFunction parser; @@ -481,12 +496,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDecimal64) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal64(8)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeDecimal128) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Decimal128(8));"; ParserFunction parser; @@ -499,12 +514,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDecimal128) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal128(8)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeDecimal256) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Decimal256(8));"; ParserFunction parser; @@ -517,12 +532,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDecimal256) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal256(8)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeFixedString) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS FixedString(8));"; ParserFunction parser; @@ -535,12 +550,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeFixedString) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "fixed_string(8)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeDateTime_TimeZone) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS DateTime('Asia/Istanbul'));"; ParserFunction parser; @@ -553,12 +568,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDateTime_TimeZone) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "datetime('Asia/Istanbul')"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeDateTime64_Precision) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS DateTime64(3));"; ParserFunction parser; @@ -571,12 +586,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDateTime64_Precision) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "datetime64(3)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeDateTime64_Precision_TimeZone) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS DateTime64(3, 'Asia/Istanbul'));"; ParserFunction parser; @@ -589,12 +604,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeDateTime64_Precision_TimeZone) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "datetime64(3, 'Asia/Istanbul')"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeEnum) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Enum('One' = 1, 'Two' = 2, 'Three' = 3));"; ParserFunction parser; @@ -607,12 +622,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeEnum) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "enum('One' = 1, 'Two' = 2, 'Three' = 3)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeArray) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Array(Int32));"; ParserFunction parser; @@ -625,12 +640,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeArray) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "array(int32)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeMap) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Map(String, Int32));"; ParserFunction parser; @@ -643,12 +658,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeMap) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "map(string, int32)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeTuple) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Tuple(String, Int32, String));"; ParserFunction parser; @@ -661,13 +676,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeTuple) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "tuple(string, int32, string)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeLowCardinality) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS LowCardinality(String));"; ParserFunction parser; @@ -680,13 +694,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeLowCardinality) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "low_cardinality(string)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeNested1) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Nullable(Map(String, Tuple(Array(Nullable(String), Nullable(Int32), Nullable(FixedString(10)), Nullable(DateTime64(3, 'UTC')), LowCardinality(Nullable(Float32)))))));"; ParserFunction parser; @@ -699,13 +712,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeNested1) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "nullable(map(string, tuple(array(nullable(string), nullable(int32), nullable(fixed_string(10)), nullable(datetime64(3, 'UTC')), low_cardinality(nullable(float32))))))"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeNested2) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Nullable(Array(Tuple(Nullable(Int32), Nullable(String)))));"; ParserFunction parser; @@ -718,13 +730,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeNested2) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "nullable(array(tuple(nullable(int32), nullable(string))))"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeNested3) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Tuple(Nullable(String), Nullable(Int32), Nullable(DateTime64(3, 'UTC'))));"; ParserFunction parser; @@ -737,13 +748,12 @@ TEST(ParserDataTypeNameTest, TestDatatypeNested3) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "tuple(nullable(string), nullable(int32), nullable(datetime64(3, 'UTC')))"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatypeNested4) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Map(String, Tuple(Nullable(Int32), Nullable(String))))"; ParserFunction parser; @@ -756,13 +766,13 @@ TEST(ParserDataTypeNameTest, TestDatatypeNested4) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "map(string, tuple(nullable(int32), nullable(string)))"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } /// timeplus datatype TEST(ParserDataTypeNameTest, TestDatatype_int8) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS int8);"; ParserFunction parser; @@ -775,11 +785,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_int8) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int8"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_uint8) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS uint8);"; ParserFunction parser; @@ -792,11 +803,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_uint8) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint8"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_int16) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS int16);"; ParserFunction parser; @@ -809,11 +821,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_int16) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int16"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_uint16) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS uint16);"; ParserFunction parser; @@ -826,11 +839,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_uint16) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint16"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_int32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS Int32);"; ParserFunction parser; @@ -843,11 +857,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_int32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int32"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_uint32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS uint32);"; ParserFunction parser; @@ -860,11 +875,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_uint32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint32"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_int64) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS int64);"; ParserFunction parser; @@ -877,11 +893,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_int64) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int64"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_uint64) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS uint64);"; ParserFunction parser; @@ -894,11 +911,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_uint64) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint64"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_int128) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS int128);"; ParserFunction parser; @@ -911,11 +929,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_int128) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int128"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_uint128) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS uint128);"; ParserFunction parser; @@ -928,11 +947,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_uint128) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint128"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_int256) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS int256);"; ParserFunction parser; @@ -945,11 +965,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_int256) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "int256"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_uint256) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS uint256);"; ParserFunction parser; @@ -962,12 +983,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_uint256) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uint256"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_float32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS float32);"; ParserFunction parser; @@ -980,11 +1001,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_float32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "float32"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_float64) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS float64);"; ParserFunction parser; @@ -997,12 +1019,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_float64) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "float64"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_string) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS string);"; ParserFunction parser; @@ -1015,12 +1037,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_string) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "string"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_date) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS date);"; ParserFunction parser; @@ -1033,11 +1055,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_date) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "date"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_date32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS date32);"; ParserFunction parser; @@ -1050,11 +1073,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_date32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "date32"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_dateTime) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS datetime);"; ParserFunction parser; @@ -1067,12 +1091,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_dateTime) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "datetime"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_bool) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS bool);"; ParserFunction parser; @@ -1085,12 +1109,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_bool) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "bool"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_uuid) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS uuid);"; ParserFunction parser; @@ -1103,12 +1127,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_uuid) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "uuid"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_ipv4) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS ipv4);"; ParserFunction parser; @@ -1121,11 +1145,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_ipv4) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "ipv4"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } + TEST(ParserDataTypeNameTest, TestDatatype_ipv6) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS ipv6);"; ParserFunction parser; @@ -1138,12 +1163,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_ipv6) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "ipv6"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_json) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS json);"; ParserFunction parser; @@ -1156,12 +1181,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_json) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "json"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_nullable) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS nullable(string));"; ParserFunction parser; @@ -1174,12 +1199,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_nullable) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "nullable(string)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_decimal) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS decimal(10, 3));"; ParserFunction parser; @@ -1192,12 +1217,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_decimal) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal(10, 3)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_decimal32) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS decimal32(3));"; ParserFunction parser; @@ -1210,12 +1235,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_decimal32) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal32(3)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_decimal64) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS decimal64(8));"; ParserFunction parser; @@ -1228,12 +1253,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_decimal64) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal64(8)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_decimal128) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS decimal128(8));"; ParserFunction parser; @@ -1246,12 +1271,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_decimal128) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal128(8)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_decimal256) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS decimal256(8));"; ParserFunction parser; @@ -1264,12 +1289,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_decimal256) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "decimal256(8)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_fixed_string) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS fixed_string(8));"; ParserFunction parser; @@ -1282,12 +1307,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_fixed_string) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "fixed_string(8)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_datetime_timezone) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS datetime('Asia/Istanbul'));"; ParserFunction parser; @@ -1300,12 +1325,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_datetime_timezone) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "datetime('Asia/Istanbul')"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_datetime64_precision) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS datetime64(3));"; ParserFunction parser; @@ -1318,12 +1343,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_datetime64_precision) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "datetime64(3)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_datetime64_precision_timezone) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS datetime64(3, 'Asia/Istanbul'));"; ParserFunction parser; @@ -1336,12 +1361,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_datetime64_precision_timezone) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "datetime64(3, 'Asia/Istanbul')"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_enum) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS enum('One' = 1, 'Two' = 2, 'Three' = 3));"; ParserFunction parser; @@ -1354,12 +1379,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_enum) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "enum('One' = 1, 'Two' = 2, 'Three' = 3)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_array) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS array(Int32));"; ParserFunction parser; @@ -1372,12 +1397,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_array) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "array(int32)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_map) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS map(string, int32));"; ParserFunction parser; @@ -1390,12 +1415,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_map) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "map(string, int32)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_tuple) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS tuple(string, int32, string));"; ParserFunction parser; @@ -1408,13 +1433,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_tuple) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "tuple(string, int32, string)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_low_cardinality) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS low_cardinality(string));"; ParserFunction parser; @@ -1427,13 +1451,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_low_cardinality) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "low_cardinality(string)"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_nested1) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS nullable(map(string, tuple(array(nullable(string), nullable(int32), nullable(fixed_string(10)), nullable(datetime64(3, 'UTC')), low_cardinality(nullable(float32)))))));"; ParserFunction parser; @@ -1446,13 +1469,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_nested1) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "nullable(map(string, tuple(array(nullable(string), nullable(int32), nullable(fixed_string(10)), nullable(datetime64(3, 'UTC')), low_cardinality(nullable(float32))))))"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_nested2) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS nullable(array(tuple(nullable(int32), nullable(string)))));"; ParserFunction parser; @@ -1465,13 +1487,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_nested2) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "nullable(array(tuple(nullable(int32), nullable(string))))"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_nested3) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS tuple(nullable(string), nullable(int32), nullable(datetime64(3, 'UTC'))));"; ParserFunction parser; @@ -1484,13 +1505,12 @@ TEST(ParserDataTypeNameTest, TestDatatype_nested3) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "tuple(nullable(string), nullable(int32), nullable(datetime64(3, 'UTC')))"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserDataTypeNameTest, TestDatatype_nested4) { - - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "CAST(id AS map(string, tuple(nullable(int32), nullable(string))))"; ParserFunction parser; @@ -1503,14 +1523,14 @@ TEST(ParserDataTypeNameTest, TestDatatype_nested4) EXPECT_EQ(arg1->name(), "id"); ASTLiteral * arg2 = function->arguments->children[1]->as(); EXPECT_EQ(arg2->value, "map(string, tuple(nullable(int32), nullable(string)))"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } /// clickhouse function name TEST(ParserFunctionNameTest, TestFunction_toUInt16) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "toUInt16('123')"; ParserFunction parser; @@ -1518,12 +1538,12 @@ TEST(ParserFunctionNameTest, TestFunction_toUInt16) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "to_uint16"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_encodeURLComponent) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "encodeURLComponent('Hello world! How are you?')"; ParserFunction parser; @@ -1531,12 +1551,12 @@ TEST(ParserFunctionNameTest, TestFunction_encodeURLComponent) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "encode_url_component"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_todAte) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "todAte(now())"; ParserFunction parser; @@ -1544,12 +1564,12 @@ TEST(ParserFunctionNameTest, TestFunction_todAte) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "to_date"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_generateUUIDv4) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "generateUUIDv4(1)"; ParserFunction parser; @@ -1557,12 +1577,12 @@ TEST(ParserFunctionNameTest, TestFunction_generateUUIDv4) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "generate_uuidv4"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_stddevSamp) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "stddevSamp(v)"; ParserFunction parser; @@ -1570,12 +1590,12 @@ TEST(ParserFunctionNameTest, TestFunction_stddevSamp) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "stddev_samp"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_ifNull) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "ifNull(value, 0)"; ParserFunction parser; @@ -1583,13 +1603,13 @@ TEST(ParserFunctionNameTest, TestFunction_ifNull) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "if_null"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } /// timeplus function name TEST(ParserFunctionNameTest, TestFunction_to_uint16) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "to_uint16('123')"; ParserFunction parser; @@ -1597,12 +1617,12 @@ TEST(ParserFunctionNameTest, TestFunction_to_uint16) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "to_uint16"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_encode_url_component) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "encode_url_component('Hello world! How are you?')"; ParserFunction parser; @@ -1610,12 +1630,12 @@ TEST(ParserFunctionNameTest, TestFunction_encode_url_component) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "encode_url_component"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_to_date) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "to_date(now())"; ParserFunction parser; @@ -1623,12 +1643,12 @@ TEST(ParserFunctionNameTest, TestFunction_to_date) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "to_date"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_generate_uuidv4) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "generate_uuidv4(1)"; ParserFunction parser; @@ -1636,12 +1656,12 @@ TEST(ParserFunctionNameTest, TestFunction_generate_uuidv4) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "generate_uuidv4"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_stddev_samp) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "stddev_samp(v)"; ParserFunction parser; @@ -1649,12 +1669,12 @@ TEST(ParserFunctionNameTest, TestFunction_stddev_samp) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "stddev_samp"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } TEST(ParserFunctionNameTest, TestFunction_if_null) { - thread_local_is_clickhouse_compatible = true; + setClickHouseCompatibleMode(true); String input = "if_null(value, 0)"; ParserFunction parser; @@ -1662,5 +1682,5 @@ TEST(ParserFunctionNameTest, TestFunction_if_null) ASTFunction * function = ast->as(); EXPECT_EQ(function->name, "if_null"); - thread_local_is_clickhouse_compatible = false; + setClickHouseCompatibleMode(false); } diff --git a/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp b/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp index f8da63e24ad..ada0e446d30 100644 --- a/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp +++ b/src/Processors/Formats/Impl/TabSeparatedRowOutputFormat.cpp @@ -44,8 +44,12 @@ void TabSeparatedRowOutputFormat::writePrefix() if (with_types) { /// proton: starts. - writeLine(header.getDataTypeNames(format_settings.is_clickhouse_compatible)); + if (format_settings.is_clickhouse_compatible) + writeLine(header.getClickHouseDataTypeNames()); + else + writeLine(header.getDataTypeNames()); /// proton: ends. + writeRowBetweenDelimiter(); } } diff --git a/src/Server/HTTPHandlerFactory.cpp b/src/Server/HTTPHandlerFactory.cpp index 6baa136558f..5a6f796f7aa 100644 --- a/src/Server/HTTPHandlerFactory.cpp +++ b/src/Server/HTTPHandlerFactory.cpp @@ -181,7 +181,7 @@ HTTPRequestHandlerFactoryPtr createMetaStoreHandlerFactory(IServer & server, con auto factory = std::make_shared(name); for (const auto * prefix : {"timeplusd", "proton"}) { - auto rest_handler = std::make_shared>(server, "metastore"); + auto rest_handler = std::make_shared>(server, "metastore", false, false); rest_handler->attachNonStrictPath(fmt::format("/{}/metastore", prefix)); factory->addHandler(rest_handler); } @@ -206,28 +206,36 @@ void addCommonDefaultHandlersFactory(HTTPRequestHandlerFactoryMain & factory, IS } /// proton: starts -void addDefaultHandlersFactory(HTTPRequestHandlerFactoryMain & factory, IServer & server, AsynchronousMetrics & async_metrics, bool snapshot_mode_, bool is_clickhouse_compatible_) -/// proton: ends +void addDefaultHandlersFactory( + HTTPRequestHandlerFactoryMain & factory, + IServer & server, + AsynchronousMetrics & async_metrics, + bool snapshot_mode_, + bool is_clickhouse_compatible_mode_) { addCommonDefaultHandlersFactory(factory, server); - /// proton: start. Add rest request process handler { - auto rest_handler = std::make_shared>(server, "proton"); + bool snapshot_mode_copy = snapshot_mode_; + bool is_clickhouse_compatible_mode_copy = is_clickhouse_compatible_mode_; + auto rest_handler = std::make_shared>( + server, "proton", std::move(snapshot_mode_copy), std::move(is_clickhouse_compatible_mode_copy)); rest_handler->attachNonStrictPath("/proton"); factory.addHandler(rest_handler); } { - auto rest_handler = std::make_shared>(server, "timeplusd"); + bool snapshot_mode_copy = snapshot_mode_; + bool is_clickhouse_compatible_mode_copy = is_clickhouse_compatible_mode_; + auto rest_handler = std::make_shared>( + server, "timeplusd", std::move(snapshot_mode_copy), std::move(is_clickhouse_compatible_mode_copy)); rest_handler->attachNonStrictPath("/timeplusd"); factory.addHandler(rest_handler); } - /// proton: end. - - /// proton: starts - auto query_handler = std::make_shared>(server, "query", std::move(snapshot_mode_), std::move(is_clickhouse_compatible_)); + auto query_handler = std::make_shared>( + server, "query", std::move(snapshot_mode_), std::move(is_clickhouse_compatible_mode_)); /// proton: ends + query_handler->allowPostAndGetParamsAndOptionsRequest(); factory.addHandler(query_handler); diff --git a/src/Server/RestHTTPRequestHandler.cpp b/src/Server/RestHTTPRequestHandler.cpp index bf371dc5d65..02df6810f64 100644 --- a/src/Server/RestHTTPRequestHandler.cpp +++ b/src/Server/RestHTTPRequestHandler.cpp @@ -419,6 +419,12 @@ void RestHTTPRequestHandler::processQuery( request.get("x-timeplus-query-id", request.get("x-proton-request-id", request.get("x-proton-query-id", ""))))); response.add("x-timeplus-query-id", context->getCurrentQueryId()); + if (is_snapshot_mode) + context->setSetting("query_mode", Field("table")); + + if (is_clickhouse_compatible_mode) + context->setSetting("is_clickhouse_compatible", Field(true)); + /// Setup idempotent key if it is passed by user String idem_key = request.get("x-timeplus-idempotent-id", request.get("x-proton-idempotent-id", "")); if (!idem_key.empty()) @@ -451,8 +457,13 @@ void RestHTTPRequestHandler::processQuery( LOG_DEBUG(log, "End of processing query_id={} user={}", context->getCurrentQueryId(), context->getUserName()); } -RestHTTPRequestHandler::RestHTTPRequestHandler(IServer & server_, const String & name) - : server(server_), default_settings(server.context()->getSettingsRef()), log(&Poco::Logger::get(name)) +RestHTTPRequestHandler::RestHTTPRequestHandler( + IServer & server_, const String & name, bool is_snapshot_mode_, bool is_clickhouse_compatible_mode_) + : server(server_) + , default_settings(server.context()->getSettingsRef()) + , is_snapshot_mode(is_snapshot_mode_) + , is_clickhouse_compatible_mode(is_clickhouse_compatible_mode_) + , log(&Poco::Logger::get(name)) { } diff --git a/src/Server/RestHTTPRequestHandler.h b/src/Server/RestHTTPRequestHandler.h index 1d8e6068bc5..02a5172c988 100644 --- a/src/Server/RestHTTPRequestHandler.h +++ b/src/Server/RestHTTPRequestHandler.h @@ -19,7 +19,7 @@ class Session; class RestHTTPRequestHandler final : public HTTPRequestHandler { public: - RestHTTPRequestHandler(IServer & server_, const String & name); + RestHTTPRequestHandler(IServer & server_, const String & name, bool is_snapshot_mode_, bool is_clickhouse_compatible_mode_); void handleRequest(HTTPServerRequest & request, HTTPServerResponse & response) override; @@ -29,6 +29,10 @@ class RestHTTPRequestHandler final : public HTTPRequestHandler /// Those settings are used only to extract a http request's parameters. /// See settings http_max_fields, http_max_field_name_size, http_max_field_value_size in HTMLForm. const Settings & default_settings; + + bool is_snapshot_mode = false; + bool is_clickhouse_compatible_mode = false; + Poco::Logger * log; // session is reset at the end of each request/response.