ClickHouse · tavplubix · Jan 22, 2024 · Jul 3, 2022 · Jul 15, 2022 · Jul 22, 2022
diff --git a/docs/en/sql-reference/statements/alter/partition.md b/docs/en/sql-reference/statements/alter/partition.md
@@ -112,7 +112,7 @@ Note that:
 For the query to run successfully, the following conditions must be met:
 
 - Both tables must have the same structure.
-- Both tables must have the same partition key, the same order by key and the same primary key.
+- Both tables must have the same order by key and the same primary key.
 - Both tables must have the same indices and projections.
 - Both tables must have the same storage policy.
 

diff --git a/src/Interpreters/MonotonicityCheckVisitor.h b/src/Interpreters/MonotonicityCheckVisitor.h
@@ -1,13 +1,17 @@
 #pragma once
 
 #include <AggregateFunctions/AggregateFunctionFactory.h>
+#include <Core/Range.h>
 #include <DataTypes/DataTypeFactory.h>
+#include <DataTypes/FieldToDataType.h>
 #include <Functions/FunctionFactory.h>
 #include <IO/WriteHelpers.h>
-#include <Interpreters/InDepthNodeVisitor.h>
 #include <Interpreters/IdentifierSemantic.h>
+#include <Interpreters/InDepthNodeVisitor.h>
+#include <Interpreters/applyFunction.h>
 #include <Parsers/ASTFunction.h>
 #include <Parsers/ASTIdentifier.h>
+#include <Parsers/ASTLiteral.h>
 #include <Parsers/ASTOrderByElement.h>
 #include <Parsers/ASTTablesInSelectQuery.h>
 #include <Parsers/IAST.h>
@@ -33,6 +37,8 @@ class MonotonicityCheckMatcher
         ASTIdentifier * identifier = nullptr;
         DataTypePtr arg_data_type = {};
 
+        Range range = Range::createWholeUniverse();
+
         void reject() { monotonicity.is_monotonic = false; }
         bool isRejected() const { return !monotonicity.is_monotonic; }
 
@@ -97,13 +103,30 @@ class MonotonicityCheckMatcher
         if (data.isRejected())
             return;
 
-        /// TODO: monotonicity for functions of several arguments
-        if (!ast_function.arguments || ast_function.arguments->children.size() != 1)
+        /// Monotonicity check only works for functions that contain at most two arguments and one of them must be a constant.
+        if (!ast_function.arguments)
         {
             data.reject();
             return;
         }
 
+        auto arguments_size = ast_function.arguments->children.size();
+
+        if (arguments_size == 0 || arguments_size > 2)
+        {
+            data.reject();
+            return;
+        }
+        else if (arguments_size == 2)
+        {
+            /// If the function has two arguments, then one of them must be a constant.
+            if (!ast_function.arguments->children[0]->as<ASTLiteral>() && !ast_function.arguments->children[1]->as<ASTLiteral>())
+            {
+                data.reject();
+                return;
+            }
+        }
+
         if (!data.canOptimize(ast_function))
         {
             data.reject();
@@ -124,14 +147,33 @@ class MonotonicityCheckMatcher
             return;
         }
 
-        ColumnsWithTypeAndName args;
-        args.emplace_back(data.arg_data_type, "tmp");
-        auto function_base = function->build(args);
+        auto function_arguments = getFunctionArguments(ast_function, data);
+
+        auto function_base = function->build(function_arguments);
 
         if (function_base && function_base->hasInformationAboutMonotonicity())
         {
             bool is_positive = data.monotonicity.is_positive;
-            data.monotonicity = function_base->getMonotonicityForRange(*data.arg_data_type, Field(), Field());
+            data.monotonicity = function_base->getMonotonicityForRange(*data.arg_data_type, data.range.left, data.range.right);
+
+            auto & key_range = data.range;
+
+            /// If we apply function to open interval, we can get empty intervals in result.
+            /// E.g. for ('2020-01-03', '2020-01-20') after applying 'toYYYYMM' we will get ('202001', '202001').
+            /// To avoid this we make range left and right included.
+            /// Any function that treats NULL specially is not monotonic.
+            /// Thus we can safely use isNull() as an -Inf/+Inf indicator here.
+            if (!key_range.left.isNull())
+            {
+                key_range.left = applyFunction(function_base, data.arg_data_type, key_range.left);
+                key_range.left_included = true;
+            }
+
+            if (!key_range.right.isNull())
+            {
+                key_range.right = applyFunction(function_base, data.arg_data_type, key_range.right);
+                key_range.right_included = true;
+            }
 
             if (!is_positive)
                 data.monotonicity.is_positive = !data.monotonicity.is_positive;
@@ -143,13 +185,53 @@ class MonotonicityCheckMatcher
 
     static bool needChildVisit(const ASTPtr & parent, const ASTPtr &)
     {
-        /// Currently we check monotonicity only for single-argument functions.
-        /// Although, multi-argument functions with all but one constant arguments can also be monotonic.
+        /// Multi-argument functions with all but one constant arguments can be monotonic.
         if (const auto * func = typeid_cast<const ASTFunction *>(parent.get()))
-            return func->arguments->children.size() < 2;
+            return func->arguments->children.size() <= 2;
 
         return true;
     }
+
+    static ColumnWithTypeAndName extractLiteralColumnAndTypeFromAstLiteral(const ASTLiteral * literal)
+    {
+        ColumnWithTypeAndName result;
+
+        result.type = applyVisitor(FieldToDataType(), literal->value);
+        result.column = result.type->createColumnConst(0, literal->value);
+
+        return result;
+    }
+
+    static ColumnsWithTypeAndName getFunctionArguments(const ASTFunction & ast_function, const Data & data)
+    {
+        ColumnsWithTypeAndName args;
+
+        auto arguments_size = ast_function.arguments->children.size();
+
+        chassert(arguments_size == 1 || arguments_size == 2);
+
+        if (arguments_size == 2)
+        {
+            if (ast_function.arguments->children[0]->as<ASTLiteral>())
+            {
+                const auto * literal = ast_function.arguments->children[0]->as<ASTLiteral>();
+                args.push_back(extractLiteralColumnAndTypeFromAstLiteral(literal));
+                args.emplace_back(data.arg_data_type, "tmp");
+            }
+            else
+            {
+                const auto * literal = ast_function.arguments->children[1]->as<ASTLiteral>();
+                args.emplace_back(data.arg_data_type, "tmp");
+                args.push_back(extractLiteralColumnAndTypeFromAstLiteral(literal));
+            }
+        }
+        else
+        {
+            args.emplace_back(data.arg_data_type, "tmp");
+        }
+
+        return args;
+    }
 };
 
 using MonotonicityCheckVisitor = ConstInDepthNodeVisitor<MonotonicityCheckMatcher, false>;

diff --git a/src/Interpreters/applyFunction.cpp b/src/Interpreters/applyFunction.cpp
@@ -0,0 +1,43 @@
+#include <Interpreters/applyFunction.h>
+
+#include <Core/Range.h>
+#include <Functions/IFunction.h>
+
+namespace DB
+{
+
+static Field applyFunctionForField(const FunctionBasePtr & func, const DataTypePtr & arg_type, const Field & arg_value)
+{
+    ColumnsWithTypeAndName columns{
+        {arg_type->createColumnConst(1, arg_value), arg_type, "x"},
+    };
+
+    auto col = func->execute(columns, func->getResultType(), 1);
+    return (*col)[0];
+}
+
+FieldRef applyFunction(const FunctionBasePtr & func, const DataTypePtr & current_type, const FieldRef & field)
+{
+    /// Fallback for fields without block reference.
+    if (field.isExplicit())
+        return applyFunctionForField(func, current_type, field);
+
+    String result_name = "_" + func->getName() + "_" + toString(field.column_idx);
+    const auto & columns = field.columns;
+    size_t result_idx = columns->size();
+
+    for (size_t i = 0; i < result_idx; ++i)
+        if ((*columns)[i].name == result_name)
+            result_idx = i;
+
+    if (result_idx == columns->size())
+    {
+        ColumnsWithTypeAndName args{(*columns)[field.column_idx]};
+        field.columns->emplace_back(ColumnWithTypeAndName{nullptr, func->getResultType(), result_name});
+        (*columns)[result_idx].column = func->execute(args, (*columns)[result_idx].type, columns->front().column->size());
+    }
+
+    return {field.columns, field.row_idx, result_idx};
+}
+
+}
diff --git a/src/Interpreters/applyFunction.h b/src/Interpreters/applyFunction.h
@@ -0,0 +1,16 @@
+#pragma once
+
+#include <memory>
+
+namespace DB
+{
+struct FieldRef;
+
+class IFunctionBase;
+class IDataType;
+
+using DataTypePtr = std::shared_ptr<const IDataType>;
+using FunctionBasePtr = std::shared_ptr<const IFunctionBase>;
+
+FieldRef applyFunction(const FunctionBasePtr & func, const DataTypePtr & current_type, const FieldRef & field);
+}
diff --git a/src/Parsers/queryToString.cpp b/src/Parsers/queryToString.cpp
@@ -3,6 +3,11 @@
 
 namespace DB
 {
+    String queryToStringNullable(const ASTPtr & query)
+    {
+        return query ? queryToString(query) : "";
+    }
+
     String queryToString(const ASTPtr & query)
     {
         return queryToString(*query);

diff --git a/src/Parsers/queryToString.h b/src/Parsers/queryToString.h
@@ -6,4 +6,5 @@ namespace DB
 {
     String queryToString(const ASTPtr & query);
     String queryToString(const IAST & query);
+    String queryToStringNullable(const ASTPtr & query);
 }
diff --git a/src/Storages/MergeTree/IMergeTreeDataPart.cpp b/src/Storages/MergeTree/IMergeTreeDataPart.cpp
@@ -81,6 +81,7 @@ void IMergeTreeDataPart::MinMaxIndex::load(const MergeTreeData & data, const Par
     auto minmax_column_types = data.getMinMaxColumnsTypes(partition_key);
     size_t minmax_idx_size = minmax_column_types.size();
 
+    hyperrectangle.clear();
     hyperrectangle.reserve(minmax_idx_size);
     for (size_t i = 0; i < minmax_idx_size; ++i)
     {
@@ -104,6 +105,39 @@ void IMergeTreeDataPart::MinMaxIndex::load(const MergeTreeData & data, const Par
     initialized = true;
 }
 
+Block IMergeTreeDataPart::MinMaxIndex::getBlock(const MergeTreeData & data) const
+{
+    if (!initialized)
+        throw Exception(ErrorCodes::LOGICAL_ERROR, "Attempt to get block from uninitialized MinMax index.");
+
+    Block block;
+
+    const auto metadata_snapshot = data.getInMemoryMetadataPtr();
+    const auto & partition_key = metadata_snapshot->getPartitionKey();
+
+    const auto minmax_column_names = data.getMinMaxColumnsNames(partition_key);
+    const auto minmax_column_types = data.getMinMaxColumnsTypes(partition_key);
+    const auto minmax_idx_size = minmax_column_types.size();
+
+    for (size_t i = 0; i < minmax_idx_size; ++i)
+    {
+        const auto & data_type = minmax_column_types[i];
+        const auto & column_name = minmax_column_names[i];
+
+        const auto column = data_type->createColumn();
+
+        const auto min_val = hyperrectangle.at(i).left;
+        const auto max_val = hyperrectangle.at(i).right;
+
+        column->insert(min_val);
+        column->insert(max_val);
+
+        block.insert(ColumnWithTypeAndName(column->getPtr(), data_type, column_name));
+    }
+
+    return block;
+}
+
 IMergeTreeDataPart::MinMaxIndex::WrittenFiles IMergeTreeDataPart::MinMaxIndex::store(
     const MergeTreeData & data, IDataPartStorage & part_storage, Checksums & out_checksums) const
 {
@@ -185,8 +219,7 @@ void IMergeTreeDataPart::MinMaxIndex::merge(const MinMaxIndex & other)
 
     if (!initialized)
     {
-        hyperrectangle = other.hyperrectangle;
-        initialized = true;
+        *this = other;
     }
     else
     {

diff --git a/src/Storages/MergeTree/IMergeTreeDataPart.h b/src/Storages/MergeTree/IMergeTreeDataPart.h
@@ -336,6 +336,7 @@ class IMergeTreeDataPart : public std::enable_shared_from_this<IMergeTreeDataPar
         }
 
         void load(const MergeTreeData & data, const PartMetadataManagerPtr & manager);
+        Block getBlock(const MergeTreeData & data) const;
 
         using WrittenFiles = std::vector<std::unique_ptr<WriteBufferFromFileBase>>;
-Original file line number
+Diff line change
@@ Expand Up @@
             }
             void load(const MergeTreeData & data, const PartMetadataManagerPtr & manager);
+            Block getBlock(const MergeTreeData & data) const;
             using WrittenFiles = std::vector<std::unique_ptr<WriteBufferFromFileBase>>;
@@ Expand Down @@