Kusto-phase3: rebase v23.10.5.20-stable

Author: kothiga

src/Client/ClientBase.cpp

@@ -352,7 +352,10 @@ ASTPtr ClientBase::parseQuery(const char *& pos, const char * end, bool allow_mu
     if (is_interactive || ignore_error)
     {
         String message;
-        res = tryParseQuery(*parser, pos, end, message, true, "", allow_multi_statements, max_length, settings.max_parser_depth);
+        if (dialect == Dialect::kusto)
+            res = tryParseKQLQuery(*parser, pos, end, message, true, "", allow_multi_statements, max_length, settings.max_parser_depth);
+        else
+            res = tryParseQuery(*parser, pos, end, message, true, "", allow_multi_statements, max_length, settings.max_parser_depth);
 
         if (!res)
         {
@@ -362,7 +365,10 @@ ASTPtr ClientBase::parseQuery(const char *& pos, const char * end, bool allow_mu
     }
     else
     {
-        res = parseQueryAndMovePosition(*parser, pos, end, "", allow_multi_statements, max_length, settings.max_parser_depth);
+        if (dialect == Dialect::kusto)
+            res = parseKQLQueryAndMovePosition(*parser, pos, end, "", allow_multi_statements, max_length, settings.max_parser_depth);
+        else
+            res = parseQueryAndMovePosition(*parser, pos, end, "", allow_multi_statements, max_length, settings.max_parser_depth);
     }
 
     if (is_interactive)

src/DataTypes/IDataType.h

@@ -388,7 +388,7 @@ struct WhichDataType
     constexpr bool isDateOrDate32() const { return isDate() || isDate32(); }
     constexpr bool isDateTime() const { return idx == TypeIndex::DateTime; }
     constexpr bool isDateTime64() const { return idx == TypeIndex::DateTime64; }
-    constexpr bool isDateOrDate32() const { return isDate() || isDate32(); }
+    constexpr bool isDateTimeOrDateTime64() const { return isDateTime() || isDateTime64(); }
     constexpr bool isDateOrDate32OrDateTimeOrDateTime64() const { return isDate() || isDate32() || isDateTime() || isDateTime64(); }
 
     constexpr bool isString() const { return idx == TypeIndex::String; }

src/Functions/CMakeLists.txt

@@ -116,9 +116,6 @@ list (APPEND OBJECT_LIBS $<TARGET_OBJECTS:clickhouse_functions_url>)
 add_subdirectory(array)
 list (APPEND OBJECT_LIBS $<TARGET_OBJECTS:clickhouse_functions_array>)
 
-add_subdirectory(Kusto)
-list (APPEND OBJECT_LIBS $<TARGET_OBJECTS:clickhouse_functions_kusto>)
-
 if (TARGET ch_contrib::datasketches)
     add_subdirectory(UniqTheta)
     list (APPEND OBJECT_LIBS $<TARGET_OBJECTS:clickhouse_functions_uniqtheta>)

src/Functions/Kusto/kqlIndexOfRegex.cpp

@@ -7,7 +7,14 @@
 #include <Functions/FunctionHelpers.h>
 #include <Functions/IFunction.h>
 
+#ifdef __clang__
+#  pragma clang diagnostic push
+#  pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
+#endif
 #include <re2/re2.h>
+#ifdef __clang__
+#  pragma clang diagnostic pop
+#endif
 
 namespace DB::ErrorCodes
 {

src/Functions/byteSwap.cpp

@@ -36,7 +36,8 @@ template <typename T>
 struct ByteSwapImpl
 {
     using ResultType = T;
-    static constexpr const bool allow_string_or_fixed_string = false;
+    static const constexpr bool allow_interval = true;
+    static const constexpr bool allow_string_or_fixed_string = false;
     static T apply(T x) { return byteSwap<T>(x); }
 
 #if USE_EMBEDDED_COMPILER

src/Functions/extract.cpp

@@ -83,7 +83,7 @@ struct KqlExtractImpl
         res_data.reserve(data.size() / 5);
         res_offsets.resize(offsets.size());
 
-        const Regexps::Regexp regexp = Regexps::createRegexp<false, false, false>(pattern);
+        const OptimizedRegularExpression regexp = Regexps::createRegexp<false, false, false>(pattern);
 
         OptimizedRegularExpression::MatchVec matches;
         matches.reserve(capture + 1);

src/Functions/toStartOfInterval.cpp

@@ -453,15 +453,12 @@ class FunctionToStartOfInterval : public IFunction
         return return_type;
     }
 
-    bool useDefaultImplementationForConstants() const override { return true; }
-    ColumnNumbers getArgumentsThatAreAlwaysConstant() const override { return {1, 2}; }
-
     ColumnPtr executeImpl(const ColumnsWithTypeAndName & arguments, const DataTypePtr & result_type, const size_t) const override
     {
         const auto & time_column = arguments[0];
         const auto & interval_column = arguments[1];
         const auto & time_zone = extractTimeZoneFromFunctionArguments(arguments, 2, 0);
-        return dispatchForColumns(time_column, interval_column, result_type, time_zone);
+        return dispatchForTimeColumn(time_column, interval_column, result_type, time_zone);
     }
 
 private:

src/Interpreters/executeQuery.cpp

@@ -711,7 +711,7 @@ static std::tuple<ASTPtr, BlockIO> executeQueryImpl(
         {
             ParserKQLStatement parser;
             /// TODO: parser should fail early when max_query_size limit is reached.
-            ast = parseQuery(parser, begin, end, "", max_query_size, settings.max_parser_depth);
+            ast = parseKQLQuery(parser, begin, end, "", max_query_size, settings.max_parser_depth);
         }
         else if (settings.dialect == Dialect::prql && !internal)
         {

src/Parsers/ExpressionElementParsers.cpp

@@ -105,70 +105,62 @@ bool ParserSubquery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
     ParserSelectWithUnionQuery select;
     ParserExplainQuery explain;
+
+    if (pos->type != TokenType::OpeningRoundBracket)
+        return false;
+    ++pos;
+
     ASTPtr result_node = nullptr;
-    ParserKeyword s_kql("KQL");
 
-    if (s_kql.ignore(pos, expected))
+    if (ASTPtr select_node; select.parse(pos, select_node, expected))
     {
-        if (KQLContext kql_context; !ParserKQLTableFunction(kql_context).parse(pos, result_node, expected))
-            return false;
+        result_node = std::move(select_node);
     }
-    else
+    else if (ASTPtr explain_node; explain.parse(pos, explain_node, expected))
     {
-        if (pos->type != TokenType::OpeningRoundBracket)
-            return false;
-        ++pos;
-
-        if (ASTPtr select_node; select.parse(pos, select_node, expected))
-        {
-            result_node = std::move(select_node);
-        }
-        else if (ASTPtr explain_node; explain.parse(pos, explain_node, expected))
-        {
-            const auto & explain_query = explain_node->as<const ASTExplainQuery &>();
+        const auto & explain_query = explain_node->as<const ASTExplainQuery &>();
 
-            if (explain_query.getTableFunction() || explain_query.getTableOverride())
-                throw Exception(ErrorCodes::BAD_ARGUMENTS, "EXPLAIN in a subquery cannot have a table function or table override");
+        if (explain_query.getTableFunction() || explain_query.getTableOverride())
+            throw Exception(ErrorCodes::BAD_ARGUMENTS, "EXPLAIN in a subquery cannot have a table function or table override");
 
-            /// Replace subquery `(EXPLAIN <kind> <explain_settings> SELECT ...)`
-            /// with `(SELECT * FROM viewExplain("<kind>", "<explain_settings>", SELECT ...))`
+        /// Replace subquery `(EXPLAIN <kind> <explain_settings> SELECT ...)`
+        /// with `(SELECT * FROM viewExplain("<kind>", "<explain_settings>", SELECT ...))`
 
-            String kind_str = ASTExplainQuery::toString(explain_query.getKind());
+        String kind_str = ASTExplainQuery::toString(explain_query.getKind());
 
-            String settings_str;
-            if (ASTPtr settings_ast = explain_query.getSettings())
-            {
-                if (!settings_ast->as<ASTSetQuery>())
-                    throw Exception(ErrorCodes::BAD_ARGUMENTS, "EXPLAIN settings must be a SET query");
-                settings_str = queryToString(settings_ast);
-            }
+        String settings_str;
+        if (ASTPtr settings_ast = explain_query.getSettings())
+        {
+            if (!settings_ast->as<ASTSetQuery>())
+                throw Exception(ErrorCodes::BAD_ARGUMENTS, "EXPLAIN settings must be a SET query");
+            settings_str = queryToString(settings_ast);
+        }
 
-            const ASTPtr & explained_ast = explain_query.getExplainedQuery();
-            if (explained_ast)
-            {
-                auto view_explain = makeASTFunction("viewExplain",
-                    std::make_shared<ASTLiteral>(kind_str),
-                    std::make_shared<ASTLiteral>(settings_str),
-                    explained_ast);
-                result_node = buildSelectFromTableFunction(view_explain);
-            }
-            else
-            {
-                auto view_explain = makeASTFunction("viewExplain",
-                    std::make_shared<ASTLiteral>(kind_str),
-                    std::make_shared<ASTLiteral>(settings_str));
-                result_node = buildSelectFromTableFunction(view_explain);
-            }
+        const ASTPtr & explained_ast = explain_query.getExplainedQuery();
+        if (explained_ast)
+        {
+            auto view_explain = makeASTFunction("viewExplain",
+                std::make_shared<ASTLiteral>(kind_str),
+                std::make_shared<ASTLiteral>(settings_str),
+                explained_ast);
+            result_node = buildSelectFromTableFunction(view_explain);
         }
         else
         {
-            return false;
+            auto view_explain = makeASTFunction("viewExplain",
+                std::make_shared<ASTLiteral>(kind_str),
+                std::make_shared<ASTLiteral>(settings_str));
+            result_node = buildSelectFromTableFunction(view_explain);
         }
-
-        if (pos->type != TokenType::ClosingRoundBracket)
-            return false;
-        ++pos;
     }
+    else
+    {
+        return false;
+    }
+
+    if (pos->type != TokenType::ClosingRoundBracket)
+        return false;
+    ++pos;
 
     node = std::make_shared<ASTSubquery>();
     node->children.push_back(result_node);
@@ -178,16 +170,6 @@ bool ParserSubquery::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 
 bool ParserIdentifier::parseImpl(Pos & pos, ASTPtr & node, Expected & expected)
 {
-    /// 'kql(' is used for subuquery in Kusto, should not be treated as an identifier if kql followed by (
-    ParserKeyword s_kql("KQL");
-    if (s_kql.ignore(pos, expected))
-    {
-        if (pos->type == TokenType::OpeningRoundBracket)
-        {   --pos;
-            return false;
-        }
-        --pos;
-    }
     /// Identifier in backquotes or in double quotes
     if (pos->type == TokenType::QuotedIdentifier)
     {

src/Parsers/ExpressionListParsers.cpp

@@ -2170,7 +2170,7 @@ class KustoLayer : public Layer
         {
             ASTPtr query;
             --pos;
-            if (!ParserKQLTableFunction().parse(pos, query, expected))
+            if (KQLContext kql_context; !ParserKQLTableFunction(kql_context).parse(pos, query, expected))
                 return false;
             --pos;
             pushResult(query);
@@ -2234,9 +2234,13 @@ std::unique_ptr<Layer> getFunctionLayer(ASTPtr identifier, bool is_table_functio
     const auto function_name = getIdentifierName(identifier);
     const auto function_name_lowercase = Poco::toLower(function_name);
 
-    if (is_table_function
-        && (function_name_lowercase == "getschema" || function_name_lowercase == "view" || function_name_lowercase == "viewifpermitted"))
-        return std::make_unique<ViewLayer>(function_name_lowercase);
+    if (is_table_function)
+    {
+        if (function_name_lowercase == "getschema" || function_name_lowercase == "view" || function_name_lowercase == "viewifpermitted")
+            return std::make_unique<ViewLayer>(function_name_lowercase);
+        if (function_name_lowercase == "kql")
+            return std::make_unique<KustoLayer>();
+    }
 
     if (function_name == "tuple")
         return std::make_unique<TupleLayer>();
@@ -2644,7 +2648,7 @@ Action ParserExpressionImpl::tryParseOperand(Layers & layers, IParser::Pos & pos
     {
         layers.back()->pushOperand(std::move(tmp));
     }
-    else if (pos->type == TokenType::OpeningRoundBracket)
+    else if (pos->type == TokenType::OpeningRoundBracket || String(pos->begin , pos->end) == "kql")
     {
 
         if (subquery_parser.parse(pos, tmp, expected))